RectangleGauge.h

#pragma once
 
#include "DefinitionsAdvancedFunctions.h"

 

namespace FLImaging
{
    namespace AdvancedFunctions
    {
        class CInternalRectangleGauge;

        class FL_EXPORT CRectangleGauge : public ImageProcessing::CAlgorithmFeature_SR
        {
        public:

            enum ETransitionType
            {
                ETransitionType_DarkToBright = 0x01,

                ETransitionType_BrightToDark = 0x02,

                ETransitionType_DarkToBrightOrBrightToDark = 0x04,

                ETransitionType_DarkToBrightToDark = 0x08,

                ETransitionType_BrightToDarkToBright = 0x10,

                ETransitionType_DarkToBrightToDarkOrBrightToDarkToBright = 0x20,
            };

            enum ETransitionChoice
            {
                ETransitionChoice_Begin = 0x10000,

                ETransitionChoice_End = 0x20000,

                ETransitionChoice_Closest = 0x40000,

                ETransitionChoice_LargestAmplitude = 0x80000,

                ETransitionChoice_LargestArea = 0x100000,
            };

            enum ESearchDirection
            {
                ESearchDirection_InsideToOutside = 0,

                ESearchDirection_OutsideToInside,
            };

            enum EMargin
            {
                EMargin_TopSide_Left = 0x0001,

                EMargin_TopSide_Right = 0x0002,

                EMargin_TopSide_Both = EMargin_TopSide_Left | EMargin_TopSide_Right,

                EMargin_RightSide_Top = 0x0004,

                EMargin_RightSide_Bottom = 0x0008,

                EMargin_RightSide_Both = EMargin_RightSide_Top | EMargin_RightSide_Bottom,

                EMargin_BottomSide_Right = 0x0010,

                EMargin_BottomSide_Left = 0x0020,

                EMargin_BottomSide_Both = EMargin_BottomSide_Right | EMargin_BottomSide_Left,

                EMargin_LeftSide_Bottom = 0x0040,

                EMargin_LeftSide_Top = 0x0080,

                EMargin_LeftSide_Both = EMargin_LeftSide_Bottom | EMargin_LeftSide_Top,

                EMargin_All = EMargin_TopSide_Both | EMargin_RightSide_Both | EMargin_BottomSide_Both | EMargin_LeftSide_Both,
            };

            enum ETolerance
            {
                ETolerance_TopSide_Top = 0x0001,

                ETolerance_TopSide_Bottom = 0x0002,

                ETolerance_TopSide_Both = ETolerance_TopSide_Top | ETolerance_TopSide_Bottom,

                ETolerance_RightSide_Right = 0x0004,

                ETolerance_RightSide_Left = 0x0008,

                ETolerance_RightSide_Both = ETolerance_RightSide_Left | ETolerance_RightSide_Right,

                ETolerance_BottomSide_Bottom = 0x0010,

                ETolerance_BottomSide_Top = 0x0020,

                ETolerance_BottomSide_Both = ETolerance_BottomSide_Top | ETolerance_BottomSide_Bottom,

                ETolerance_LeftSide_Left = 0x0040,

                ETolerance_LeftSide_Right = 0x0080,

                ETolerance_LeftSide_Both = ETolerance_LeftSide_Left | ETolerance_LeftSide_Right,

                ETolerance_All = ETolerance_TopSide_Both | ETolerance_RightSide_Both | ETolerance_BottomSide_Both | ETolerance_LeftSide_Both,
            };

            CRectangleGauge();

            CRectangleGauge(const CRectangleGauge& rg);

            CRectangleGauge(const CRectangleGauge* pRg);

            virtual ~CRectangleGauge();

            const CRectangleGauge& operator=(const CRectangleGauge& rg);

            virtual const CResult Assign(const CRectangleGauge& aib);

            virtual const CResult Assign(const CRectangleGauge* pAib);

            virtual const CResult Execute();

            virtual const CResult Clear();

            virtual const CResult SetMeasurementRegion(const Foundation::CFLPoint<int32_t>& flpCenter, double f64Width, double f64Height, double f64Tolerance = 40., double f64Angle = 0.0);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLPoint<int32_t>* pFlpCenter, double f64Width, double f64Height, double f64Tolerance = 40., double f64Angle = 0.0);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLPoint<int64_t>& flpCenter, double f64Width, double f64Height, double f64Tolerance = 40., double f64Angle = 0.0);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLPoint<int64_t>* pFlpCenter, double f64Width, double f64Height, double f64Tolerance = 40., double f64Angle = 0.0);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLPoint<float>& flpCenter, double f64Width, double f64Height, double f64Tolerance = 40., double f64Angle = 0.0);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLPoint<float>* pFlpCenter, double f64Width, double f64Height, double f64Tolerance = 40., double f64Angle = 0.0);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLPoint<double>& flpCenter, double f64Width, double f64Height, double f64Tolerance = 40., double f64Angle = 0.0);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLPoint<double>* pFlpCenter, double f64Width, double f64Height, double f64Tolerance = 40., double f64Angle = 0.0);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLRect<int32_t>& flrRegion, double f64Tolerance = 40.);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLRect<int32_t>* pFlrRegion, double f64Tolerance = 40.);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLRect<int64_t>& flrRegion, double f64Tolerance = 40.);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLRect<int64_t>* pFlrRegion, double f64Tolerance = 40.);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLRect<float>& flrRegion, double f64Tolerance = 40.);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLRect<float>* pFlrRegion, double f64Tolerance = 40.);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLRect<double>& flrRegion, double f64Tolerance = 40.);

            virtual const CResult SetMeasurementRegion(const Foundation::CFLRect<double>* pFlrRegion, double f64Tolerance = 40.);

            virtual const Foundation::CFLRect<double> GetMeasurementRegion() const;

            virtual const CResult SetTolerance(double f64Tolerance = 40., ETolerance eTolerance = ETolerance_All);

            virtual const Base::CFLArray<double> GetTolerance() const;

            virtual const CResult SetMeasurementMarginRatio(double f64Ratio = 0., EMargin eMargin = EMargin_All);

            virtual const Base::CFLArray<double> GetMeasurementMarginRatio() const;

            virtual const CResult SetTransitionType(ETransitionType eTransitionType = ETransitionType_DarkToBrightOrBrightToDark);

            virtual ETransitionType GetTransitionType() const;

            virtual const CResult SetTransitionChoice(ETransitionChoice eTransitionChoice = ETransitionChoice_LargestAmplitude);

            virtual ETransitionChoice GetTransitionChoice() const;

            virtual const CResult SetSearchDirection(ESearchDirection eSearchDirection = ESearchDirection_InsideToOutside);

            virtual ESearchDirection GetSearchDirection() const;

            virtual const CResult SetThreshold(double f64Threshold = 20);

            virtual double GetThreshold() const;

            virtual const CResult SetMinimumAmplitude(double f64MinimumAmplitude = 10);

            virtual double GetMinimumAmplitude() const;

            virtual const CResult SetSamplingStep(double f64SamplingStep = 5.);

            virtual double GetSamplingStep() const;

            virtual const CResult EnableClusterMode(bool bEnable = true);

            virtual bool IsClusterModeEnabled() const;

            virtual const CResult SetOutlierFilteringMode(EGaugeOutlierFilteringMode eOutlierFilteringMode = EGaugeOutlierFilteringMode_Manual);
            virtual EGaugeOutlierFilteringMode GetOutlierFilteringMode() const;

            virtual const CResult SetOutliersThreshold(double f64OutliersThreshold = 3.);

            virtual double GetOutliersThreshold() const;

            virtual const CResult SetOutliersThresholdCount(int64_t i64OutliersThresholdCount = 3);

            virtual int64_t GetOutliersThresholdCount() const;

            virtual const CResult SetThickness(int64_t i64Thickness = 1);

            virtual int64_t GetThickness() const;

            virtual const CResult EnableRegression(bool bEnable = true);

            virtual const bool IsRegressionEnabled();

            virtual const CResult EnableOptimalFitting(bool bEnable = true);

            virtual const bool IsOptimalFittingEnabled() const;

            virtual const CResult EnableAccurateMode(bool bAccurateMode = false);

            virtual bool IsAccurateModeEnabled() const;

            virtual const Foundation::CFLRect<double> GetMeasuredObject(int64_t i64Index = 0) const;

            virtual const CResult GetMeasuredObject(Foundation::CFLRect<double>& flrMeasuredObject, int64_t i64Index = 0) const;

            virtual const CResult GetMeasuredObject(Foundation::CFLRect<double>* pFlrMeasuredObject, int64_t i64Index = 0) const;

            virtual const CResult GetMeasuredValidPoints(Foundation::CFLFigureArray& flfaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredValidPoints(Foundation::CFLFigureArray* pFlfaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredValidPoints(Foundation::CFLPointArray& flpaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredValidPoints(Foundation::CFLPointArray* pFlpaResult, int64_t i64Index = 0) const;

            const CResult GetMeasuredTransitionOfValidPoints(Base::CFLArray<int32_t>& flaResult, int64_t i64Index = 0) const;
            const CResult GetMeasuredTransitionOfValidPoints(Base::CFLArray<int32_t>* pFlaResult, int64_t i64Index = 0) const;

            virtual const CResult GetMeasuredInvalidPoints(Foundation::CFLFigureArray& flfaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredInvalidPoints(Foundation::CFLFigureArray* pFlfaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredInvalidPoints(Foundation::CFLPointArray& flpaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredInvalidPoints(Foundation::CFLPointArray* pFlpaResult, int64_t i64Index = 0) const;

            const CResult GetMeasuredTransitionOfInvalidPoints(Base::CFLArray<int32_t>& flaResult, int64_t i64Index = 0) const;
            const CResult GetMeasuredTransitionOfInvalidPoints(Base::CFLArray<int32_t>* pFlaResult, int64_t i64Index = 0) const;

            virtual const CResult GetMeasuredPoints(Foundation::CFLFigureArray& flfaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredPoints(Foundation::CFLFigureArray* pFlfaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredPoints(Foundation::CFLPointArray& flpaResult, int64_t i64Index = 0) const;
            virtual const CResult GetMeasuredPoints(Foundation::CFLPointArray* pFlpaResult, int64_t i64Index = 0) const;

            const CResult GetMeasuredTransition(Base::CFLArray<int32_t>& flaResult, int64_t i64Index = 0) const;
            const CResult GetMeasuredTransition(Base::CFLArray<int32_t>* pFlaResult, int64_t i64Index = 0) const;

            virtual const CResult GetMeasuredScore(double* pF64Score, int64_t i64Index = 0) const;

            virtual const CResult GetMeasuredScore(double& f64Score, int64_t i64Index = 0) const;

            virtual const Foundation::CFLFigureArray GetActualMeasurementRegion();

            virtual const CResult GetMeasuredProfile(Base::CFLArray<double>& flaProfile, Base::CFLArray<double>& flaDerivative, double& f64MeasuredAverageDistance);
 
            virtual bool IsLicenseAvailable() const override;
 
 
            DeclareGetClassType();
            SupportToDuplicateObject(CRectangleGauge, *this);
 
        protected:
            double m_f64Threshold;

            double m_f64MinimumAmplitude;

            double m_f64SamplingStep;

            double m_f64OutliersThreshold;

            int64_t m_i64OutliersThresholdCount;

            int64_t m_i64Thickness;

            Foundation::CFLRect<double> m_flrMeasurementRect;

            Base::CFLArray<double> m_arrF64Tolerance;

            Base::CFLArray<double> m_arrF64MarginRatio;

            EGaugeOutlierFilteringMode m_eOutlierFilteringMode;

            ETransitionType m_eTransitionType;

            ETransitionChoice m_eTransitionChoice;

            bool m_bClusterMode;

            bool m_bEnable;

            ESearchDirection m_eSearchDirection;

            bool m_bOptimalFitting;

            bool m_bAccurateMode;
 
        protected:
            friend class CInternalRectangleGauge;
 
            CInternalRectangleGauge* m_pInternal;
        };
    }
}