Moire3D.h

#pragma once
 
#include "DefinitionsThreeDim.h"
#include "AlgorithmFeature3D_SI_DHI_LI_DO.h"


namespace FLImaging
{
    namespace ThreeDim
    {
        class CInternalMoire3D;

        class FL_EXPORT CMoire3D : public CAlgorithmFeature3D_SI_DHI_LI_DO
        {
        public:

            enum EPatternType
            {
                EPatternType_SineWave = 0,

                EPatternType_SquareWave,
            };

            enum EBinProcessingType
            {
                EBinProcessingType_Auto = 0,

                EBinProcessingType_Manual,
            };

            CMoire3D();

            CMoire3D(const CMoire3D& Moire3D);

            CMoire3D(const CMoire3D* pMoire3D);

            virtual ~CMoire3D();

            const CMoire3D& operator=(const CMoire3D& Moire3D);

            virtual const CResult Assign(const CMoire3D& Moire3D);

            virtual const CResult Assign(const CMoire3D* pMoire3D);

            virtual const CResult Calibrate();

            virtual const CResult Execute();

            virtual const CResult SetLearnImage(Base::CFLImage& fliLearn) override;

            virtual const CResult SetLearnImage(Base::CFLImage* pFliLearn) override;

            virtual const CResult SetSourceImage(Base::CFLImage& fliSource) override;

            virtual const CResult SetSourceImage(Base::CFLImage* pFliSource) override;

            virtual const CResult SetLearnImage(Base::CFLArray<Base::CFLImage*>& flaImages);

            virtual const CResult SetLearnImage(Base::CFLArray<Base::CFLImage*>* pFlaImages);

            virtual const CResult SetSourceImage(Base::CFLArray<Base::CFLImage*>& flaImages);

            virtual const CResult SetSourceImage(Base::CFLArray<Base::CFLImage*>* pFlaImages);

            virtual const CResult AddLearnImage(Base::CFLImage& fliLearnImage);

            virtual const CResult AddLearnImage(Base::CFLImage* pFliLearnImage);

            virtual const CResult AddSourceImage(Base::CFLImage& fliSourceImage);

            virtual const CResult AddSourceImage(Base::CFLImage* pFliSourceImage);

            virtual const Base::CFLImage* GetLearnImage() const override;

            virtual const Base::CFLArray<Base::CFLImage*>* GetLearnImages() const;

            virtual const Base::CFLImage* GetSourceImage() const override;

            virtual const Base::CFLArray<Base::CFLImage*>* GetSourceImages() const;

            virtual const CResult SetWorkingDistance(double f64WorkingDistanceMM);

            virtual const CResult SetFieldOfView(double f64FieldOfViewMM);

            virtual const CResult SetAngleOfProjector(Base::CMultiVar<double> mvF64AngleOfProjector);

            virtual const CResult SetBinInterval(Base::CMultiVar<double> mvF64BinInterval);

            virtual const CResult SetBinProcessingType(EBinProcessingType eBinProcessingType = EBinProcessingType_Auto);
            

            virtual const CResult SetPatternType(EPatternType ePatternType = EPatternType_SquareWave);
 

            virtual const CResult EnableNoiseReduction(bool bNoiseReduction = true);

            virtual double GetWorkingDistance() const;

            virtual Base::CMultiVar<double> GetAngleOfProjector() const;

            virtual double GetFieldOfView() const;

            virtual Base::CMultiVar<double> GetBinInterval() const;

            virtual EBinProcessingType GetBinProcessingType() const;

            virtual EPatternType GetPatternType() const;

            virtual bool IsNoiseReductionEnabled() const;

            virtual bool IsCalibrated(int64_t i64Index = 0) const;

            virtual const CResult Clear() override;
 
            virtual bool IsLicenseAvailable() const override;
 
 
            DeclareGetClassType();
            SupportToDuplicateObject(CMoire3D, *this);
 
        protected:

 
            bool m_bCalibrated;

            double m_f64WorkingDistanceMM;

            Base::CMultiVar<double> m_mvF64AngleOfProjector;

            double m_f64FieldOfViewMM;

            EPatternType m_ePatternType;

            EBinProcessingType m_eBinProcessingType;

            bool m_bNoiseReduction;

            Base::CMultiVar<double> m_mvF64BinInterval;

            Base::CFLArray<Base::CFLImage*>* m_pFlaPFliLearnImageOrg;
            Base::CFLArray<Base::CFLImage> m_flaFliLearnImage;

            Base::CFLArray<Base::CFLImage*>* m_pFlaPFliSourceImageOrg;
            Base::CFLArray<Base::CFLImage> m_flaFliSourceImage;
 
        protected:
 
            friend class CInternalMoire3D;
            CInternalMoire3D* m_pInternal;
 
            virtual const CResult LockImageParameters() override;
            virtual const CResult UnlockImageParameters() override;
            Base::CFLArray<int64_t> m_flaBoolSrcLock;
            Base::CFLArray<int64_t> m_flaBoolLearnLock;
        };
    }
}