FLImagingAdvancedFunctions/PatternMatch.h

#pragma once

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

namespace FLImaging
{
    namespace AdvancedFunctions
    {
        class CInternalPatternMatch;

        class FL_EXPORT CPatternMatch : 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> 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 ESearchAccuracy
            {
                ESearchAccuracy_Fast = 0x00,

                ESearchAccuracy_Normal = 0x01,

                ESearchAccuracy_Accurate = 0x02,
            };

            CPatternMatch();

            CPatternMatch(const CPatternMatch& pmr);

            CPatternMatch(const CPatternMatch* pPmr);

            virtual ~CPatternMatch();

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

            virtual const CResult Assign(const CPatternMatch& aib);

            virtual const CResult Assign(const CPatternMatch* 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 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 SetAccuracy(double f64Accuracy = 0.5);

            virtual double GetAccuracy() const;

            virtual const CResult SetSearchAccuracy(const ESearchAccuracy eSearchAccuracy);

            virtual const ESearchAccuracy GetSearchAccuracy() const;

            virtual const CResult EnableInterpolation(bool bEnable = true);

            virtual bool IsInterpolationEnabled() const;

            virtual const CResult SetContrastOption(EMatchContrastOption eOption = EMatchContrastOption_Normal);

            virtual const EMatchContrastOption GetContrastOption() const;

            virtual const CResult SetFilterItem(CPatternMatch::EFilterItem eFilterItem, double f64Value, const Base::ELogicalCondition eFilterCondition);
            virtual const CResult AddFilterItem(CPatternMatch::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(CPatternMatch::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(CPatternMatch::EFilterItem eSortItem, CPatternMatch::EOrder eOrder);
            virtual const CResult AddSortItem(CPatternMatch::EFilterItem eSortItem, CPatternMatch::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(CPatternMatch::EFilterItem& eSortItem, CPatternMatch::EOrder& eOrder) const;
            virtual const CResult GetSortItem(Base::CFLArray<int32_t>& flaItem, Base::CFLArray<int32_t>& flaOrder) const;

            virtual const CResult SetSortClusterMode(CPatternMatch::ESortClusterModeMethod eMethod, double f64Coefficient);
            virtual bool GetSortClusterMode(CPatternMatch::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, CPatternMatch::SResult* pSResults) const;

            virtual const CResult GetResult(int64_t i64Index, CPatternMatch::SResult& sResults) const;

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

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

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

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

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

            virtual const CResult GetResultPivot(int64_t i64Index, Foundation::CFLPoint<double>& flpResultPivot) const;
 
            virtual const CResult ReportToCSV(const Foundation::CReportDescriptor* pWrd) const override;

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

            virtual const CResult  ReportToCSV(const CReportDescriptorForMatch* pWrd) const;
 
            virtual Foundation::EProcessingUnitFeatures GetOptimalProcessingUnit() const override;

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

            double m_f64MinimumDetectionScore;

            double m_f64ScaleMin;

            double m_f64ScaleMax;

            double m_f64AngleBias;

            double m_f64AngleTolerance;

            double m_f64Accuracy;

            bool m_bInterpolation;

            EMatchContrastOption m_eContrastOption;

            ESearchAccuracy m_eSearchAccuracy;

            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;

            CPatternMatch::ESortClusterModeMethod m_eSortClusterMethod;

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