CscDetectorEngineYoloV4.h

Go to the documentation of this file.

#ifndef CscDetectorEngineYoloV4_h
#define CscDetectorEngineYoloV4_h
 
#include "DetectorEngine/CscDetectorEngine.h"
#include "DetectorEngine/CscDNNPool.h"
#include "DetectorEngine/CscDetectorEngineYoloV8.h"
 
using std::ostream;
 
namespace conscience_core::detector_engine {
 
using SafeNeuralNetwork = CscDNNPool::SafeNeuralNetwork;
 
class CscDetectorEngineYoloV4 : public CscDetectorEngine {
public:
    CscDetectorEngineYoloV4(ptr<CscDNNPool> dnnPool, map<DetectableObjectClassId, const DetectableObjectClass> detectedObjectClasses, bool drawPredictionOnImage, const string &name);
 
    CscDetectorEngineYoloV4(ptr<CscDNNPool> dnnPool,
                            map<DetectableObjectClassId, const DetectableObjectClass> detectedObjectClasses, const fs::path modelConfigurationPath, const fs::path modelWeightsPath, bool drawPredictionOnImage, const string &name);
 
    ptr<DetectionResult> detectOnImage(
        const DetectorSourceImage &image, ptr<DetectionParameters> parameters) override;
 
    CscDetectorEngineYoloV4 *setDetectedRectanglesColor(const cv::Scalar &detectedRectanglesColor) {
        this->detectedRectanglesColor = detectedRectanglesColor;
        return this;
    }
 
    CscDetectorEngineYoloV4 *setTilingEnabled(bool tilingEnabled) {
        this->tilingEnabled = tilingEnabled;
        return this;
    }
 
    CscDetectorEngineYoloV4 *setMinConfidenceThreshold(float minConfidenceThreshold) {
        this->minConfidenceThreshold = minConfidenceThreshold;
        return this;
    }
 
    CscDetectorEngineYoloV4 *setCropImage(bool cropImage) {
        this->cropImage = cropImage;
        return this;
    }
 
    virtual bool equals(CscDetectorEngine *) const override;
 
private:
    float minConfidenceThreshold = 0.7;
    bool cropImage = false;
 
    // this scale factor allows conversion of colors bytes from 0-255 to float 0-1
    const double SCALE_FACTOR = 1 / 255.0;
 
    int netInputWidth = 0;
    int netInputHeight = 0;
 
    ptr<SafeNeuralNetwork> neuralNetwork;
 
    bool tilingEnabled = false;
    const bool drawPredictionOnImage;
    const map<DetectableObjectClassId, const DetectableObjectClass> detectedObjectClasses;
 
    cv::Scalar detectedRectanglesColor = cv::Scalar(255, 178, 50);
 
    std::unique_ptr<CscLogger> logger;
 
    void readNetInputSizeFromCfg(fs::path cfgFilePath);
 
    const fs::path modelConfigurationPath;
    const fs::path modelWeightsPath;
 
    class Tile {
    private:
        Mat *image;
 
        cv::Point offset;
 
        cv::Point position;
 
    public:
        Tile(const Mat &image, const cv::Point &offset, const cv::Point &position);
        ~Tile();
        Mat &getImage() {
            return *image;
        }
        cv::Point &getOffset() {
            return offset;
        }
        cv::Point &getPosition() {
            return position;
        }
    };
 
    class TileResultsCollector {
    public:
        vector<DetectableObjectClassId> classIds;
        vector<float> confidences;
        vector<cv::Rect> rectangles;
    };
 
    void processTile(ptr<Tile> tile, TileResultsCollector &resultsCollector);
 
    vector<ptr<Tile>> splitInTiles(const Mat &image);
 
    ptr<DetectionResult> reconcileResults(Mat &image, TileResultsCollector &tileResults);
};
}
 
#endif