CommonParameters.h

#pragma once
#include <filesystem>
#include "CPUInfo.h"
#include <opencv4/opencv2/core.hpp>
// Ignore the warning for the unused include, it is here for the backward compatibility
#include <variant>
#include "CompilationParams.h"
#include "CelanturExceptions.h"
 
namespace celantur {
enum class DetectionType {
    Auto = 0,
    None = 1,
    BBox = 2,
    Segmentation = 3,
};
 
enum class BlurType {
    None = 0,
    BBox_Oval = 1,
    BBox_Rectangle = 2,
    Segmentation = 3,
};
 
enum class CelanturClassId {
    LicensePlate = 101,
    Person = 102,
    Face = 103,
    Vehicle = 104,
};
 
 
struct DetectionProcessingConfig {
    BlurType blur_type{BlurType::BBox_Rectangle};
    float gradient_start{0.3};
 
    float gradient_stop{0.0};
    float kernel_size{0.2f};
 
    bool beautify_blur{true};
 
    DetectionType detection_type{DetectionType::Auto};
};
 
typedef std::map<CelanturClassId, DetectionProcessingConfig> PerTypeProcessingConfig;
 
const PerTypeProcessingConfig FACE_LICENSE_PLATE_PROCESSING_CONFIG =
{
    {
        CelanturClassId::LicensePlate,
        DetectionProcessingConfig {
            BlurType::BBox_Rectangle,
            0.3f,
            0.0f,
            1.0f,
            true,
            DetectionType::BBox
        }
    },
    {
        CelanturClassId::Person,
        {
            DetectionProcessingConfig {
                BlurType::None,
                0.3f,
                0.0f,
                0.2f,
                false,
                DetectionType::None
            }
        }
    },
    {
        CelanturClassId::Face,
        DetectionProcessingConfig {
            BlurType::BBox_Oval,
            0.3f,
            0.0f,
            0.2f,
            true,
            DetectionType::BBox,
        }
    },
    {
        CelanturClassId::Vehicle,
        {
            DetectionProcessingConfig {
                BlurType::None,
                0.3f,
                0.0f,
                0.2f,
                false,
                DetectionType::None
            }
        }
    },
};
 
const PerTypeProcessingConfig DEFAULT_PER_TYPE_PROCESSING_CONFIG = FACE_LICENSE_PLATE_PROCESSING_CONFIG;
const PerTypeProcessingConfig PERSON_VEHICLE_PROCESSING_CONFIG = {
    {
        CelanturClassId::LicensePlate,
        DetectionProcessingConfig {
            BlurType::None,
            0.3f,
            0.0f,
            1.0f,
            true,
            DetectionType::None
        }
    },
    {
        CelanturClassId::Person,
        DetectionProcessingConfig {
            BlurType::Segmentation,
            0.3f,
            0.0f,
            0.2f,
            false,
            DetectionType::Segmentation
        }
    },
    {
        CelanturClassId::Face,
        DetectionProcessingConfig {
            BlurType::None,
            0.3f,
            0.0f,
            0.2f,
            true,
            DetectionType::None,
        }
    },
    {
        CelanturClassId::Vehicle,
        DetectionProcessingConfig {
            BlurType::Segmentation,
            0.3f,
            0.0f,
            0.2f,
            false,
            DetectionType::Segmentation
        }
    },
};
 
const PerTypeProcessingConfig DETECT_ONLY_CONFIG = {
    {
        CelanturClassId::LicensePlate,
        DetectionProcessingConfig {
            BlurType::None,
            0.3f,
            0.0f,
            1.0f,
            true,
            DetectionType::BBox,
        }
    },
    {
        CelanturClassId::Person,
        DetectionProcessingConfig {
            BlurType::None,
            0.3f,
            0.0f,
            0.2f,
            false,
            DetectionType::Segmentation
        }
    },
    {
        CelanturClassId::Face,
        DetectionProcessingConfig {
            BlurType::None,
            0.3f,
            0.0f,
            0.2f,
            true,
            DetectionType::BBox,
        }
    },
    {
        CelanturClassId::Vehicle,
        DetectionProcessingConfig {
            BlurType::None,
            0.3f,
            0.0f,
            0.2f,
            false,
            DetectionType::Segmentation
        }
 
    },
};
 
struct ProcessorParams {
    std::filesystem::path inference_plugin;
    int n_tiles_x{1};
    int n_tiles_y{1};
    float ol_x{0.0f};
    float ol_y{0.0f};
    bool swapRB{false};
    cv::Rect_<float> roi{0.0f, 0.0f, 1.0f, 1.0f};
    ModelThresholds thresholds;
    float nms_threshold{0.5f};
    int queue_size{std::numeric_limits<int>::max()};
    PerTypeProcessingConfig per_type_processing_config{DEFAULT_PER_TYPE_PROCESSING_CONFIG};
};
 
 
enum class Rotation {
    None = 0,
    Rotated90Clockwise = 1,
    Rotated180 = 2,
    Rotated90CounterClockwise = 3
};
struct ImageMetadata {
 
}; 
 
struct FrameMetadata {
    int frame_number{-1};
    int source_id{0};
    bool vertical_flip{false};
    bool horizontal_flip{false};
    Rotation rotation{Rotation::None};
};
 
struct MatContainer {
    cv::Mat mat;
    std::variant<ImageMetadata, FrameMetadata> metadata;
};
std::ostream& operator<<(std::ostream& os, const celantur::BlurType& blur_type);
std::istream& operator>>(std::istream& os, celantur::BlurType& blur_type);
 
std::ostream& operator<<(std::ostream& os, const celantur::DetectionType& blur_type);
std::istream& operator>>(std::istream& os, celantur::DetectionType& blur_type);
 
std::ostream& operator<<(std::ostream& os, const celantur::CelanturClassId& id);
std::istream& operator>>(std::istream& os, celantur::CelanturClassId& id);
} // namespace celantur