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 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};
    };
 
    typedef std::map<CelanturClassId, DetectionProcessingConfig> PerTypeProcessingConfig;
 
    const PerTypeProcessingConfig DEFAULT_PER_TYPE_PROCESSING_CONFIG
    (
        {
            {CelanturClassId::LicensePlate, DetectionProcessingConfig{
 
                BlurType::BBox_Rectangle,
                0.3f,
                0.0f,
                1.0f,
                true
            }},
            {CelanturClassId::Person, {BlurType::None}},
            {CelanturClassId::Face, {
                BlurType::BBox_Oval,
                0.3f,
                0.0f,
                0.2f,
                true
            }},
            {CelanturClassId::Vehicle, {BlurType::None}},
        }
    );
 
    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;
    };
} // namespace celantur
 
 
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::CelanturClassId& id);
std::istream& operator>>(std::istream& os, celantur::CelanturClassId& id);