Denoising3D.h

#pragma once

 
#include "DefinitionsThreeDim.h"
#include "AlgorithmFeature3D_SO_DO.h"

namespace FLImaging
{
    namespace ThreeDim
    {
        class CInternalDenoising3D;

        class FL_EXPORT CDenoising3D : public CAlgorithmFeature3D_SO_DO
        {
        public:

            CDenoising3D();

            CDenoising3D(const CDenoising3D& Denoising3D);

            CDenoising3D(const CDenoising3D* pDenoising3D);

            virtual ~CDenoising3D();

            const CDenoising3D& operator=(const CDenoising3D& Denoising3D);

            virtual const CResult Assign(const CDenoising3D& Denoising3D);

            virtual const CResult Assign(const CDenoising3D* pDenoising3D);

            virtual const CResult Execute() override;

            virtual const CResult Clear() override;

            virtual const CResult SetLambda(float f32Lambda = 0.1f);

            virtual float GetLambda() const;

            virtual const CResult SetNormalVectorDistanceThreshold(float f32Threshold);

            virtual float GetNormalVectorDistanceThreshold() const;

            virtual const CResult SetNeighborCount(int32_t i32Count = 40);

            virtual int32_t GetNeighborCount() const;

            virtual const CResult SetIteration(int32_t i32Iteration = 30);

            virtual int32_t GetIteration() const;

            virtual const CResult SetSpatialDistanceThreshold(float f32DistanceThreshold);

            virtual float GetSpatialDistanceThreshold() const;

            virtual const CResult SetSpatialDistanceThresholdCoefficient(float f32Coefficient = 3);

            virtual float GetSpatialDistanceThresholdCoefficient() const;

            virtual const CResult EnableAutoSpatialDistanceThresholdCalculation(bool bAutoSpatialDistance = true);

            virtual bool IsAutoSpatialDistanceThresholdCalculationEnabled() const;

            virtual const CResult SetViewPoint(const Base::TPoint3<float>& tp3ViewPoint = Base::TPoint3<float>(0, 0, 1));

            virtual Base::TPoint3<float> GetViewPoint() const;

            virtual const CResult EnableNormalVectorInclusion(bool bNormal = true);

            virtual bool IsNormalVectorInclusionEnabled() const;
 
            virtual bool IsLicenseAvailable() const override;
 
            DeclareGetClassType();
            SupportToDuplicateObject(CDenoising3D, *this);
 
        protected:

            float m_f32Lambda;

            float m_f32NormalVectorDistanceThreshold;

            float m_f32SpatialDistanceThreshold;

            int32_t m_i32Iteration;

            int32_t m_i32NeighborCount;

            bool m_bIncludeResultNormalVector;

            Base::TPoint3<float> m_tp3ViewPoint;
 
        protected:
            CInternalDenoising3D* m_pInternal;
            friend class CInternalDenoising3D;
        };
    }
}