Integral.h

#pragma once

 
#include "AlgorithmFeature_SR_DI_BAT.h"
 

namespace FLImaging
{
    namespace ImageProcessing
    {
        class CInternalIntegral;

        class FL_EXPORT CIntegral : public CAlgorithmFeature_SR_DI_BAT
        {
        public:

            enum EDataType
            {
                EDataType_Uint32 = 0,

                EDataType_Int32,

                EDataType_Uint64,

                EDataType_Int64,

                EDataType_Float32,

                EDataType_Float64,
            };

            enum ECalculationMode
            {
                ECalculationMode_Sum = 0,

                ECalculationMode_SquareSum,

                ECalculationMode_SquareAndSum,

                ECalculationMode_Polynomial,
            };

            enum EDirection
            {
                EDirection_XY = 0,

                EDirection_X,

                EDirection_Y,
            };

            CIntegral();

            CIntegral(const CIntegral& Integral);

            CIntegral(const CIntegral* pIntegral);

            virtual ~CIntegral();

            const CIntegral& operator=(const CIntegral& Integral);

            virtual const CResult Assign(const CIntegral& Integral);

            virtual const CResult Assign(const CIntegral* pIntegral);

            virtual const CResult Execute();

            virtual const CResult Clear() override;

            virtual const CResult SetDataType(EDataType eDataType = EDataType_Uint64);
            
            virtual EDataType GetDataType();

            virtual const CResult SetCalculationMode(ECalculationMode eCalculationMode = ECalculationMode_Sum);

            virtual ECalculationMode GetCalculationMode() const;

            virtual const CResult SetDirection(EDirection eDirection = EDirection_XY);

            virtual EDirection GetDirection() const;

            virtual const CResult SetCoefficients(double f64QuadraticTerm = 1.0, double f64LinearTerm = 1.0, double f64Constant = 1.0);

            virtual const CResult SetCoefficients(const Base::CMultiVar<double>& mvCoefficients = Base::CMultiVar<double>(1, 1, 1));

            virtual const Base::CMultiVar<double> GetCoefficients() const;
 
            virtual Foundation::EProcessingUnitFeatures GetOptimalProcessingUnit() const override;
            virtual bool IsLicenseAvailable() const override;
 
 
            DeclareGetClassType();
            SupportToDuplicateObject(CIntegral, *this);
 
        protected:

            EDataType m_eDataType;

            ECalculationMode m_eCalculationMode;

            EDirection m_eDirection;

            Base::CMultiVar<double> m_mvCoefficients;
 
        protected:
            friend class CInternalIntegral;     
            CInternalIntegral* m_pInternal;
        };
    };
}