Registration3D.h

#pragma once

 
#include "DefinitionsThreeDim.h"
#include "AlgorithmFeature3D_LR_SR_LP_LO_SO.h"

namespace FLImaging
{
    namespace ThreeDim
    {
        class CInternalRegistration3D;

        class FL_EXPORT CRegistration3D : public CAlgorithmFeature3D_LR_SR_LP_LO_SO
        {
        public:

            enum EDescriptorType
            {
                EDescriptorType_SHOT352 = 0,

                EDescriptorType_FPFH,
            };

            enum ERefinementMethod
            {
                ERefinementMethod_None = 0,

                ERefinementMethod_Fast,
            };

            CRegistration3D();

            CRegistration3D(const CRegistration3D& Registration3D);

            CRegistration3D(const CRegistration3D* pRegistration3D);

            virtual ~CRegistration3D();

            const CRegistration3D& operator=(const CRegistration3D& Registration3D);

            virtual const CResult Assign(const CRegistration3D& Registration3D);

            virtual const CResult Assign(const CRegistration3D* pRegistration3D);

            virtual const CResult Execute();

            virtual const CResult Clear() override;

            virtual const CResult SetSamplingDistance(float f32SamplingDistance = 0.03f);

            virtual float GetSamplingDistance() const;

            virtual const CResult SetDescriptorType(EDescriptorType eType);

            virtual const EDescriptorType GetDescriptorType() const;

            virtual const CResult SetRefinementMethod(ERefinementMethod eMethod);

            virtual const ERefinementMethod GetRefinementMethod() const;
            
            virtual const CResult EnableNormalEstimationAutoRadius(bool bEnableAutoRadius = true);

            virtual bool IsNormalEstimationAutoRadiusEnabled() const;

            virtual const CResult EnableSHOTLRFAutoRadius(bool bEnableAutoRadius = true);

            virtual bool IsSHOTLRFAutoRadiusEnabled() const;

            virtual const CResult EnableSHOTAutoRadius(bool bEnableAutoRadius = true);

            virtual bool IsSHOTAutoRadiusEnabled() const;

            virtual const CResult SetNormalEstimationCoefficient(float f32Coefficient = 3);

            virtual float GetNormalEstimationCoefficient() const;

            virtual const CResult SetSHOTLRFCoefficient(float f32Coefficient = 2);

            virtual float GetSHOTLRFCoefficient() const;

            virtual const CResult SetSHOTCoefficient(float f32Coefficient = 4);

            virtual float GetSHOTCoefficient() const;

            virtual const CResult SetNormalEstimationRadius(float f32Radius = 0.01f);

            virtual float GetNormalEstimationRadius() const;

            virtual const CResult SetSHOTLRFRadius(float f32Radius = 0.05f);

            virtual float GetSHOTLRFRadius() const;

            virtual const CResult SetSHOTRadius(float f32Radius = 0.1f);

            virtual float GetSHOTRadius() const;

            virtual const CResult GetResultPoseMatrix(Foundation::CMatrix<float>& matPoseMatrix) const;

            virtual const CResult GetResultPoseMatrix(Foundation::CMatrixFor3DTransform<float>& matPoseMatrix) const;

            virtual const CResult GetResultRotationVector(Base::CFLArray<float>& flaResultRotationVector) const;

            virtual const CResult GetResultRotationVector(Base::CFLArray<float>* pFlaResultRotationVector) const;

            virtual const CResult GetResultEulerAngle(Foundation::EEulerSequence eEulerSequence, Base::CFLArray<float>& flaResultEulerAngle) const;

            virtual const CResult GetResultEulerAngle(Foundation::EEulerSequence eEulerSequence, Base::CFLArray<float>* pFlaResultEulerAngle) const;

            virtual const CResult GetResultTranslationVector(Base::CFLArray<float>& flaResultTranslationVector) const;

            virtual const CResult GetResultTranslationVector(Base::CFLArray<float>* pFlaResultTranslationVector) const;

            virtual const CResult GetMergedResult3DObject(bool bLearnRecoloring = true, bool bSourceRecoloring = true, const Base::TPoint3<uint8_t>* pTp3LearnColor = nullptr, const Base::TPoint3<uint8_t>* pTp3SourceColor = nullptr, Foundation::CFL3DObject* pFloMergedResult = nullptr);
 
            virtual bool IsLicenseAvailable() const override;
 
            DeclareGetClassType();
            SupportToDuplicateObject(CRegistration3D, *this);
 
        protected:

            float m_f32NormalEstimationCoefficient;

            float m_f32SHOTLRFCoefficient;

            float m_f32SHOTCoefficient;

            float m_f32NormalEstimationRadius;

            float m_f32SHOTLRFRadius;

            float m_f32SHOTRadius;

            float m_f32SamplingDistance;

            ERefinementMethod m_eRefinementMethod;

            bool m_bAutoNormalEstimationRadius;

            bool m_bAutoSHOTLRFRadius;

            bool m_bAutoSHOTRadius;

            EDescriptorType m_eDescriptorType;
 
        protected:
            CInternalRegistration3D* m_pInternal;
            friend class CInternalRegistration3D;
        };
    }
}