ValidatorForObjectDetection.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "ValidatorBase.h"
 
namespace FLImaging
{
    namespace AI
    {
        template<typename T>
        class CObjectBox;
 
        template <typename T>
        class CDetectionInfo
        {
        public:
            int64_t i64UniqueTruthIndex;
            int64_t i64TruthFlag;
            int64_t i64ClassId;
            T tScore;
 
        public:
            CDetectionInfo();
        };
 
        template <typename T>
        class CPrecisionRecall
        {
        public:
            int64_t i64TP;
            int64_t i64FP;
            int64_t i64FN;
            T tScore;
            double f64Precision;
            double f64Recall;
 
        public:
            CPrecisionRecall();
        };
 
        template <typename T>
        class FL_EXPORT CValidatorForObjectDetection : public CValidatorBase<T>
        {
        public:
            enum EModel
            {
                EModel_RFLNet = 0,
    /*          EModel_Yolo_V4 = 1000,*/
            };
 
        public:
            CValidatorForObjectDetection();
            CValidatorForObjectDetection(const CValidatorForObjectDetection<T>& validator);
            CValidatorForObjectDetection(const CValidatorForObjectDetection<T>* pValidator);
            virtual ~CValidatorForObjectDetection();
 
            const CValidatorForObjectDetection<T>& operator=(const CValidatorForObjectDetection<T>& validator);
 
            virtual const CResult Assign(const CValidatorForObjectDetection<T>& validator);
            virtual const CResult Assign(const CValidatorForObjectDetection<T>* pValidator);
 
            virtual const CResult Clear() override;
            virtual const CResult ClearResultBox();
 
            virtual const CResult SetNumOfClasses(int64_t i64ClassCount);
            virtual int64_t GetNumOfClasses() const;
 
            virtual const CResult SetNonMaximumSuppressionType(ENonMaximumSuppressionType eNMS = ENonMaximumSuppressionType_Greedy);
            virtual ENonMaximumSuppressionType GetNonMaximumSuppressionType() const;
            virtual const CResult SetBetaNMS(T tBetaNMS = .6);
            virtual T GetBetaNMS() const;
            virtual const CResult SetNMSIoUThreshold(T tNMSIoUThreshold = 0.45);
            virtual T GetNMSIoUThreshold() const;
            virtual const CResult SetObjectnessThreshold(T tObjectnessThreshold = .005);
            virtual T GetObjectnessThreshold() const;
 
            virtual const CResult SetIoUThreshold(T tIoUThreshold = .5);
            virtual T GetIoUThreshold() const;
            virtual const CResult SetAverageIoUThreshold(T tCalcAvgIoUThreshold = .25);
            virtual T GetAverageIoUThreshold() const;
 
            // 실제 유효한 class 개수가 label class num 과 다른 경우를 위해 존재
            virtual const CResult SetRealClassIdToValidClassId(const std::vector<int64_t>& vctRealClassId);
            virtual const CResult GetRealClassIdToValidClassId(std::vector<int64_t>& vctRealClassId);
 
            virtual const std::vector<std::vector<std::vector<std::tuple<CObjectBox<T>, T, int64_t>>>>* GetResultBox() const;
 
            virtual T Validate(int32_t* pI32IterationFeedback = nullptr) override;
 
            static T CalculateMap(std::vector<CDetectionInfo<T>>& vctDetectionInfo, const int64_t* pI64TruthClassesCount, int64_t i64UniqueTruthCount, int64_t i64ClassCount);
 
            virtual const CResult SetModel(EModel eModel);
            virtual EModel GetModel() const;
 
            virtual const CResult EnableIOUThresholdUpdate(bool bIOUThresholdUpdate = true);
            virtual bool IsIOUThresholdUpdateEnabled() const;
 
            virtual const CResult EnableAngleReflection(bool bAngleReflection = false);
            virtual bool IsAngleReflectionEnabled() const;
 
            DeclareGetClassType();
            SupportToDuplicateObject(CValidatorForObjectDetection<T>, *this);
 
        protected:
            virtual const CResult ResetComputationPerClass();
            virtual const CResult SetModelParams();
            virtual const CResult SetModelParams(const Base::CFLData& fldData);
            virtual const CResult BackupModelParams(Base::CFLData& fldData);
 
            std::vector<int64_t>& m_vctRealClassIdToValidClassId;
 
            ENonMaximumSuppressionType m_eValidationNMS;
            T m_tValidationBetaNMS;
            T m_tValidationNMSIoUThreshold;
            T m_tValidationObjectnessThreshold;
 
            T m_tValidationIoUThreshold;
            T m_tValidationCalcAvgIoUThreshold;
            T m_tLastValidation;
 
            int64_t m_i64TruthLabelSize;
            T* m_pTTruthLabels;
 
            int64_t m_i64ClassCount;
            int64_t* m_pI64TruthClassesCount;
            int64_t* m_pI64TPForThresholdPerClass;
            int64_t* m_pI64FPForThresholdPerClass;
            T* m_pTAvgIoUPerClass;
 
            EModel m_eModel;
 
            bool m_bIOUThresholdUpdate;
            bool m_bAngleReflection;
            std::vector<std::vector<std::vector<std::tuple<CObjectBox<T>, T, int64_t>>>>& m_vct3BoxResult;
        };
 
 
        typedef CValidatorForObjectDetection<float> CValidatorForObjectDetectionF;
        typedef CValidatorForObjectDetection<double> CValidatorForObjectDetectionD;
    }
}
 
#endif