CelanturSDKInterface.h

#pragma once
 
#include <filesystem>
#include <opencv4/opencv2/core/types.hpp>
#include "CelanturDetection.h"
#include "CommonParameters.h"
 
namespace celantur {
    class Processor;
}
 
namespace CelanturSDK {
class Processor;
 
struct AdditionalProcessorParams {
    int context_width = 1280;
    int context_height = 1280;
};
 
 
struct ModelCompilerParams {
    std::filesystem::path inference_plugin;
};
 
class License {
friend class Processor;
public:
    License(std::filesystem::path license_path);
    License(const License& other);
    License& operator=(const License& other);
    License(License&& other) noexcept;
    License& operator=(License&& other) noexcept;
    ~License();
public:
    void* _pimpl;
};
 
class Anonymiser {
public:
    Anonymiser(
        std::filesystem::path license_path,
        celantur::PerTypeProcessingConfig config
    );
    Anonymiser(const Anonymiser& other);
    Anonymiser& operator=(const Anonymiser& other);
    Anonymiser(Anonymiser&& other) noexcept;
    Anonymiser& operator=(Anonymiser&& other) noexcept;
    ~Anonymiser() = default;
    
    void anonymise(cv::Mat &mat, const celantur::CelanturDetection& det);
 
    void anonymise(cv::Mat &mat, const std::vector<celantur::CelanturDetection>& dets);
 
    void anonymise(cv::Mat &mat, const celantur::CelanturDetection& det, const celantur::PerTypeProcessingConfig& config);
 
private:
    celantur::PerTypeProcessingConfig config_;
    License license_;
};
 
 
class Tracker {
public:
    Tracker(
        std::filesystem::path license_path,
        float min_iou_threshold = 0.3f, 
        float high_score_threshold = 0.7f
    );
 
    Tracker(const Tracker& other) = delete;
    Tracker& operator=(const Tracker& other) = delete;
    Tracker(Tracker&& other) noexcept;
    Tracker& operator=(Tracker&& other) noexcept;
    ~Tracker();
 
    void update(const std::vector<celantur::CelanturDetection>& detections);
 
    std::vector<celantur::CelanturDetection> get_lost_detections() const;
 
    void reset();
 
    void init_logging();
 
private:
    void* pimpl_;
    License license_;
};
 
class ModelCompiler {
public:
    ModelCompiler(std::filesystem::path license, ModelCompilerParams params);
    ModelCompiler(const ModelCompiler& other);
    ModelCompiler& operator=(const ModelCompiler& other);
    ModelCompiler(ModelCompiler&& other) noexcept;
    ModelCompiler& operator=(ModelCompiler&& other) noexcept;
    ~ModelCompiler();
 
    celantur::InferenceEnginePluginCompileSettings preload_model(std::filesystem::path model_path);
 
    void compile_model(celantur::InferenceEnginePluginCompileSettings settings, std::filesystem::path output_path);
private:
    License _license;
    void* _pimpl;
};
 
 
class Processor {
public:
    Processor(celantur::ProcessorParams params, std::filesystem::path license_path);
    Processor(const Processor& other);
    Processor& operator=(const Processor& other);
    Processor(Processor&& other);
    Processor& operator=(Processor&& other);
    
    celantur::InferenceEnginePluginSettings get_inference_settings(std::filesystem::path model_path);
 
    void load_inference_model(celantur::InferenceEnginePluginSettings settings, AdditionalProcessorParams params = AdditionalProcessorParams());
 
    [[deprecated("Using this method does not allow for model-specific settings that are needed for OpenVINO and TensorRT plugins\n \
                  use celantur::InferenceEnginePluginSettings get_inference_settings(std::filesystem::path model_path instead\n \
                  To get better access to the new features for all inference plugins")]]
    celantur::InferenceEnginePluginSettings get_inference_settings();
 
    [[deprecated("Using this method does not allow for model-specific settings that are needed for OpenVINO and TensorRT plugins\n \
                  use celantur::InferenceEnginePluginSettings get_inference_settings(std::filesystem::path model_path instead\n \
                  To get better access to the new features for all inference plugins")]]
    void load_inference_model(std::filesystem::path model_path, celantur::InferenceEnginePluginSettings settings = celantur::InferenceEnginePluginSettings{});
 
    ~Processor();
 
    void process(cv::Mat mat);
 
    cv::Mat get_result();
    
    std::vector<celantur::CelanturDetection> get_detections();
 
private:
    void* _pimpl;
    License _license;
};
} // namespace CelanturSDK