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 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
//