GeometricMatch.h

#pragma once

 
#include "DefinitionsAdvancedFunctions.h"
#include "AlgorithmFeature_SR_LI_LR_LP.h"

namespace FLImaging
{
    namespace AdvancedFunctions
    {
        class CInternalGeometricMatch;
        class CReportDescriptorForGeometricMatch;

        class FL_EXPORT CGeometricMatch : public CAlgorithmFeature_SR_LI_LR_LP
        {
        public:
            struct FL_EXPORT SResult
            {
                SResult();

                virtual ~SResult();

                SResult(const SResult& pmr);

                SResult(const SResult* pPmr);

                const SResult& operator=(const SResult& pmr);

                virtual const CResult Assign(const SResult& pmr);

                virtual const CResult Assign(const SResult* pPmr);

                virtual const CResult Clear();

                float f32Score;

                float f32Angle;

                float f32Scale;

                Foundation::CFLFigure* pFlfRegion;

                Foundation::CFLPoint<double> flpLocation;

                Foundation::CFLPoint<double> flpPivot;
            };

            enum EFilterItem
            {
                EFilterItem_Unselected = 0,

                EFilterItem_Score,

                EFilterItem_Scale,

                EFilterItem_Angle,

                EFilterItem_RegionCenterX,

                EFilterItem_RegionCenterY,

                EFilterItem_PivotX,

                EFilterItem_PivotY,
            };

            enum EOrder
            {
                EOrder_Ascending = 0,

                EOrder_Descending,
            };

            enum ESortClusterModeMethod
            {
                ESortClusterModeMethod_RegionCenter_Y_Asc_X_Asc = 0x100,

                ESortClusterModeMethod_RegionCenter_Y_Asc_X_Desc = 0x101,

                ESortClusterModeMethod_RegionCenter_Y_Desc_X_Asc = 0x102,

                ESortClusterModeMethod_RegionCenter_Y_Desc_X_Desc = 0x103,

                ESortClusterModeMethod_RegionCenter_X_Asc_Y_Asc = 0x110,

                ESortClusterModeMethod_RegionCenter_X_Asc_Y_Desc = 0x111,

                ESortClusterModeMethod_RegionCenter_X_Desc_Y_Asc = 0x112,

                ESortClusterModeMethod_RegionCenter_X_Desc_Y_Desc = 0x113,

                ESortClusterModeMethod_Pivot_Y_Asc_X_Asc = 0x200,

                ESortClusterModeMethod_Pivot_Y_Asc_X_Desc = 0x201,

                ESortClusterModeMethod_Pivot_Y_Desc_X_Asc = 0x202,

                ESortClusterModeMethod_Pivot_Y_Desc_X_Desc = 0x203,

                ESortClusterModeMethod_Pivot_X_Asc_Y_Asc = 0x210,

                ESortClusterModeMethod_Pivot_X_Asc_Y_Desc = 0x211,

                ESortClusterModeMethod_Pivot_X_Desc_Y_Asc = 0x212,

                ESortClusterModeMethod_Pivot_X_Desc_Y_Desc = 0x213,
            };

            enum EOptimizationOption
            {
                EOptimizationOption_Fast = 0x00,

                EOptimizationOption_Normal = 0x01,

                EOptimizationOption_Accurate = 0x02,
            };

            enum ECandidateExtraction
            {
                ECandidateExtraction_Fast = 0x00,

                ECandidateExtraction_Normal = 0x01,

                ECandidateExtraction_Accurate = 0x02,
            };

            enum EScoreMode
            {
                EScoreMode_Model = 0x00,

                EScoreMode_Target = 0x01,
            };

            enum EReductionMode
            {
                EReductionMode_NearestNeighbor = 0x00,

                EReductionMode_Area = 0x01,
            };

            enum EJudgementLevel
            {
                EJudgementLevel_Tight = 0x00,

                EJudgementLevel_Normal = 0x01,

                EJudgementLevel_Rough = 0x02,
            };

            CGeometricMatch();

            CGeometricMatch(const CGeometricMatch& pg);

            CGeometricMatch(const CGeometricMatch* pPg);

            virtual ~CGeometricMatch();

            const CGeometricMatch& operator=(const CGeometricMatch& pm);

            virtual const CResult Assign(const CGeometricMatch& aib);

            virtual const CResult Assign(const CGeometricMatch* pAib);

            virtual const CResult Clear();

            virtual const CResult ClearLearnedData();

            virtual const CResult GetLearnedImage(Base::CFLImage& fliImage, bool bIncludeFigure = false) const;

            virtual const CResult GetLearnedImageRaw(Base::CFLImage& fliImage) const;

            virtual const CResult SetFeatureCount(int64_t i64FeatureCount = 2048);

            virtual int64_t GetFeatureCount() const;

            virtual const CResult SetFeatureFiltering(double f64FeatureFilter = 0.5);

            virtual double GetFeatureFiltering() const;

            virtual const CResult SetLearnThresholdCoefficient(double f64ThresCoeff = 1.0);

            virtual double GetLearnThresholdCoefficient() const;
            
            virtual const CResult SetLearnReductionMode(EReductionMode eReductionMode = EReductionMode_NearestNeighbor);

            virtual EReductionMode GetLearnReductionMode() const;

            virtual const CResult SetLearnReductionLevel(int32_t i32Level = 0);

            virtual int32_t GetLearnReductionLevel() const;

            virtual const int64_t GetLearnWeightROICount() const;

            virtual const CResult AddLearnWeightROI(Foundation::CFLFigure* pFlfWeightROI, double f64Weight = 1.);

            virtual const CResult AddLearnWeightROI(Foundation::CFLFigure& flfaWeightROI, double f64Weight = 1.);

            virtual const CResult GetLearnWeightROI(Foundation::CFLFigureArray* pFlfaWeightROI, double& f64Weight, int64_t i64Index = 0)  const;

            virtual const CResult GetLearnWeightROI(Foundation::CFLFigureArray& flfaWeightROI, double& f64Weight, int64_t i64Index = 0)  const;

            virtual const CResult DeleteLearnWeightROI(int64_t i64Index = 0);

            virtual const CResult ClearLearnWeightROI();

            virtual const CResult GetLearnedWeightROI(Foundation::CFLFigureArray* pFlfaWeightROI, double& f64Weight, int64_t i64Index = 0)  const;

            virtual const CResult GetLearnedWeightROI(Foundation::CFLFigureArray& flfaWeightROI, double& f64Weight, int64_t i64Index = 0)  const;

            virtual const CResult ClearLearnGuideShape();

            virtual const int64_t GetLearnGuideShapeCount() const;

            virtual const CResult AddLearnGuideShape(Foundation::CFLFigure* pFlfCustomRegion, double f64Weight = 1, double f64Tolerance = 5);

            virtual const CResult AddLearnGuideShape(Foundation::CFLFigure& flfCustomRegion, double f64Weight = 1, double f64Tolerance = 5);

            virtual const CResult DeleteLearnGuideShape(int64_t i64Index = 0);

            virtual const CResult GetLearnGuideShape(Foundation::CFLFigureArray* pFlfaGuideShape, double& f64Weight, double& f64Tolerance, int64_t i64Index = 0)  const;

            virtual const CResult GetLearnGuideShape(Foundation::CFLFigureArray& flfaGuideShape, double& f64Weight, double& f64Tolerance, int64_t i64Index = 0)  const;

            virtual const Foundation::CFLFigureArray GetLearnGuideShape() const;

            virtual const int64_t GetLearnedGuideShapeCount() const;

            virtual const CResult GetLearnedGuideShape(Foundation::CFLFigureArray* pFlfaGuideShape, double& f64Weight, double& f64Tolerance, int64_t i64Index = 0)  const;

            virtual const CResult GetLearnedGuideShape(Foundation::CFLFigureArray& flfaGuideShape, double& f64Weight, double& f64Tolerance, int64_t i64Index = 0)  const;

            virtual const Foundation::CFLFigureArray GetLearnedGuideShape() const;

            virtual const CResult SetMaxObject(int64_t i64MaxObject = 1);

            virtual int64_t GetMaxObject() const;

            virtual const CResult SetMinimumDetectionScore(double f64Score = .5);

            virtual double GetMinimumDetectionScore() const;

            virtual const CResult SetScaleRange(double f64ScaleMin = 1., double f64ScaleMax = 1.);

            virtual const CResult GetScaleRange(double& f64ScaleMin, double& f64ScaleMax) const;

            virtual const CResult SetAngleBias(double f64AngleBias = .0);

            virtual double GetAngleBias() const;

            virtual const CResult SetAngleTolerance(double f64AngleTolerance = .0);

            virtual double GetAngleTolerance() const;

            virtual const CResult EnableInterpolation(bool bUse = true);

            virtual bool IsInterpolationEnabled() const;

            virtual const CResult SetOptimizationOption(EOptimizationOption eOption = CGeometricMatch::EOptimizationOption_Fast);

            virtual EOptimizationOption GetOptimizationOption() const;

            virtual const CResult SetCandidateExtraction(ECandidateExtraction eOption = CGeometricMatch::ECandidateExtraction_Normal);

            virtual CGeometricMatch::ECandidateExtraction GetCandidateExtraction() const;

            virtual const CResult SetContrastOption(EMatchContrastOption eOption = EMatchContrastOption_Normal);

            virtual const EMatchContrastOption GetContrastOption() const;

            virtual const CResult SetScoreMode(EScoreMode eMode = EScoreMode_Model);

            virtual const EScoreMode GetScoreMode() const;

            virtual const CResult SetJudgementLevel(EJudgementLevel eJudgementLevel = EJudgementLevel_Normal);

            virtual EJudgementLevel GetJudgementLevel() const;

            virtual const CResult SetInvisibleRegionEstimation(double f64InvisibleRatio = 1.25);

            virtual double GetInvisibleRegionEstimation() const;

            virtual const CResult SetFindThresholdCoefficient(double f64ThresCoeff = 1.0);

            virtual double GetFindThresholdCoefficient() const;

            virtual const CResult SetObjectOverlap(double f64Overlap = 0.5);

            virtual double GetObjectOverlap() const;

            virtual const CResult SetFilterItem(CGeometricMatch::EFilterItem eFilterItem, double f64Value, const Base::ELogicalCondition eFilterCondition);
            virtual const CResult AddFilterItem(CGeometricMatch::EFilterItem eFilterItem, double f64Value, const Base::ELogicalCondition eFilterCondition);
            virtual const CResult SetFilterItem(const Base::CFLArray<int32_t>& flaFilterItem, const Base::CFLArray<double>& flaValue, const Base::CFLArray<int32_t>& flaFilterCondition);
            virtual const CResult AddFilterItem(const Base::CFLArray<int32_t>& flaFilterItem, const Base::CFLArray<double>& flaValue, const Base::CFLArray<int32_t>& flaFilterCondition);

            virtual const CResult GetFilterItem(CGeometricMatch::EFilterItem& eFilterItem, double& f64Value, Base::ELogicalCondition& eFilterCondition) const;
            virtual const CResult GetFilterItem(Base::CFLArray<int32_t>& flaFilterItem, Base::CFLArray<double>& flaValue, Base::CFLArray<int32_t>& flaFilterCondition) const;

            virtual const CResult ClearFilterItem();

            virtual const CResult SetSortItem(CGeometricMatch::EFilterItem eSortItem, CGeometricMatch::EOrder eOrder);
            virtual const CResult AddSortItem(CGeometricMatch::EFilterItem eSortItem, CGeometricMatch::EOrder eOrder);
            virtual const CResult SetSortItem(const Base::CFLArray<int32_t>& flaItem, const Base::CFLArray<int32_t>& flaOrder);
            virtual const CResult AddSortItem(const Base::CFLArray<int32_t>& flaItem, const Base::CFLArray<int32_t>& flaOrder);
            virtual const CResult GetSortItem(CGeometricMatch::EFilterItem& eSortItem, CGeometricMatch::EOrder& eOrder) const;
            virtual const CResult GetSortItem(Base::CFLArray<int32_t>& flaItem, Base::CFLArray<int32_t>& flaOrder) const;

            virtual const CResult SetSortClusterMode(CGeometricMatch::ESortClusterModeMethod eMethod, double f64Coefficient);
            virtual bool GetSortClusterMode(CGeometricMatch::ESortClusterModeMethod& eMethod, double& f64Coefficient) const;

            virtual const CResult ClearSortItem();

            virtual bool IsLearned() const;

            virtual const CResult Learn();

            virtual const CResult Execute();

            virtual const CResult Filter(EFilterItem eItem, double f64Value, Base::ELogicalCondition eCondition);

            virtual const CResult Sort(EFilterItem eItem = EFilterItem_Unselected, EOrder eOrder = EOrder_Descending);

            virtual const CResult Sort(const Base::CFLArray<int32_t>& flaItem, const Base::CFLArray<int32_t>& flaOrder);

            virtual const CResult SortClusterMode(ESortClusterModeMethod eMethod, double f64Coefficient = .5);

            virtual const CResult Load(const Base::CFLString<wchar_t>& strPatternFile);

            virtual const CResult Save(const Base::CFLString<wchar_t>& strPatternFile);
            
            virtual const CResult ClearResultData();

            virtual int64_t GetResultCount() const;

            virtual const CResult GetResult(int64_t i64Index, CGeometricMatch::SResult& sResult) const;

            virtual const CResult GetResultForScore(int64_t i64Index, float& f32ResultScore) const;

            virtual const CResult GetResultForAngle(int64_t i64Index, float& f32ResultAngle) const;

            virtual const CResult GetResultForScale(int64_t i64Index, float& f32ResultScale) const;

            virtual const CResult GetResultForRegion(int64_t i64Index, Foundation::CFLFigureArray* pFlfaResultRegion) const;

            virtual const CResult GetResultForRegion(int64_t i64Index, Foundation::CFLFigureArray& flfaResultRegion) const;

            virtual const CResult GetResultForRegionLocation(int64_t i64Index, Foundation::CFLPoint<double>& flpResultLocation) const;

            virtual const CResult GetResultForPivot(int64_t i64Index, Foundation::CFLPoint<double>& flpResultPivot) const;

            virtual const CResult GetLearnedFeature(Foundation::CFLFigureArray& flfaFeaturePoints) const;

            virtual const CResult GetLearnedFeature(Foundation::CFLFigureArray* pFlfaFeaturePoints) const;

            virtual const CResult GetResultForDetectedFeature(int64_t i64Index, Foundation::CFLFigureArray& flfaResultFeaturePoints) const;

            virtual const CResult GetResultForDetectedFeature(int64_t i64Index, Foundation::CFLFigureArray* pFlfaResultFeaturePoints) const;

            virtual const CResult GetResultForDetectedValidFeature(int64_t i64Index, Foundation::CFLFigureArray& flfaResultFeaturePoints) const;

            virtual const CResult GetResultForDetectedValidFeature(int64_t i64Index, Foundation::CFLFigureArray* pFlfaResultFeaturePoints) const;

            virtual const CResult GetResultForDetectedInvalidFeature(int64_t i64Index, Foundation::CFLFigureArray& flfaResultFeaturePoints) const;

            virtual const CResult GetResultForDetectedInvalidFeature(int64_t i64Index, Foundation::CFLFigureArray* pFlfaResultFeaturePoints) const;
 
            virtual const CResult ReportToCSV(const Foundation::CReportDescriptor* pWrd) const override;

            virtual const CResult ReportToCSV(const CReportDescriptorForGeometricMatch& wrd) const;

            virtual const CResult ReportToCSV(const CReportDescriptorForGeometricMatch* pWrd) const;

            static const CResult GetLearnedFileVersion(Base::CFLString<wchar_t> strPatternFile, int32_t& i32MajorVer, int32_t& i32MinorVer);
 
            virtual bool IsLicenseAvailable() const override;
 
 
            DeclareGetClassType();
            SupportToDuplicateObject(CGeometricMatch, *this);
 
        protected:
            int64_t m_i64FeatureCount;

            double m_f64FeatureFilter;

            double m_f64LearnThreshold;

            int64_t m_i64MaxObject;

            double m_f64MinimumDetectionScore;

            double m_f64ScaleMin;

            double m_f64ScaleMax;

            double m_f64AngleBias;

            double m_f64AngleTolerance;

            double m_f64InvisibleRatio;

            double m_f64FindThreshold;

            double m_f64Overlap;

            bool m_bInterpolation;

            EOptimizationOption m_eOptimizationOption;

            ECandidateExtraction m_eCandidateExtraction;

            EMatchContrastOption m_eContrastOption;

            EScoreMode m_eScoreMode;

            Foundation::CFLFigureArray m_flfaGuideShapes;

            Base::CFLArray<double> m_arrGuideWeight;

            Base::CFLArray<double> m_arrGuideTolerance;

            EReductionMode m_eReductionMode;

            int32_t m_i32ReduceLevel;

            EJudgementLevel m_eJudgementLevel;

            Base::CFLArray<int32_t> m_flaFilterItem;

            Base::CFLArray<double> m_flaFilterValue;

            Base::CFLArray<int32_t> m_flaFilterCondition;

            Base::CFLArray<int32_t> m_flaSortItem;

            Base::CFLArray<int32_t> m_flaSortOrder;

            bool m_bSortClusterMode;

            CGeometricMatch::ESortClusterModeMethod m_eSortClusterMethod;

            double m_f64SortClusterCoefficient;
 
 
        protected:
            friend class CInternalGeometricMatch;
 
            CInternalGeometricMatch* m_pInternal;
        };
    }
}