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 tIoU;
            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,
            };
 
            enum ETruthLabelMode
            {
                ETruthLabelMode_Rect = 0,
                ETruthLabelMode_Angle,
                ETruthLabelMode_MERAngle,
                ETruthLabelMode_Region,
            };
 
        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;
 
            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, std::vector<T>& vctResultPrecisionPerClass, std::vector<T>& vctResultRecallPerClass, std::vector<T>& vctResultAPClass);
 
            static const CResult CalculateEvaluation(const std::vector<CDetectionInfo<T>>& vctDetectionInfo, const int64_t* pI64TruthClassesCount, int64_t i64UniqueTruthCount, int64_t i64ClassCount, Base::CFLArray<uint8_t>& flaResultCorrectness, Base::CFLArray<double>& flaResultIoU, Base::CFLArray<int64_t>& flaFalseNegativeTargetIndexes);
 
            static const CResult MakeDetectionInfo(const Foundation::CFLFigureArray& flfa2Figure, const Base::CFLArray<Base::CFLArray<int32_t>>& fla2ClassNum, const Base::CFLArray<Base::CFLArray<double>>& fla2Score, const Foundation::CFLFigureArray& flfa2Target, int64_t i64TotalClass, T tIoUThrehsold, std::vector<CDetectionInfo<T>>& vctResultDetectionInfoFlatten, std::vector<int64_t>& vctResultTruthClassesCountFlatten, int64_t& i64ResultUniqueTruthTotal, ETruthLabelMode eTruthLabelMode = ETruthLabelMode::ETruthLabelMode_Region);
 
            virtual const CResult SetTruthLabelMode(ETruthLabelMode eTruthLabelMode);
            virtual ETruthLabelMode GetTruthLabelModel() const;
 
            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;
 
            virtual const CResult EnableSingleLabel(bool bSingleLabel);
            virtual bool IsSingleLabelEnable() const;
 
            virtual const std::vector<T>& GetRecallPerClass() const;
            virtual const std::vector<T>& GetPrecisionPerClass() const;
            virtual const std::vector<T>& GetAPPerClass() const;
 
            virtual const int64_t* GetTruthClassesCount() const;
            virtual const std::vector< CDetectionInfo<T>>& GetDetectionInstances();
            virtual int64_t GetUniqueTruthCount() 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;
            int64_t m_i64UniqueTruthCount;
            T* m_pTAvgIoUPerClass;
 
            EModel m_eModel;
            ETruthLabelMode m_eTruthLabelMode;
 
            bool m_bIOUThresholdUpdate;
            bool m_bAngleReflection;
            bool m_bSingleLabel;
            std::vector<std::vector<std::vector<std::tuple<CObjectBox<T>, T, int64_t>>>>& m_vct3BoxResult;
 
            std::vector<T>& m_vctPrecisionPerClass;
            std::vector<T>& m_vctRecallPerClass;
            std::vector<T>& m_vctAPPerClass;
            std::vector<CDetectionInfo<T>>& m_vctDetectionInstances;
        };
 
 
        typedef CValidatorForObjectDetection<float> CValidatorForObjectDetectionF;
        typedef CValidatorForObjectDetection<double> CValidatorForObjectDetectionD;
    }
}
 
#endif