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): image(image), offset(offset), position(position) {
            }
            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 /* ConscienceDetectorEngine_hpp */