Integral.h

#pragma once

 
#include "AlgorithmFeature_SR_DI_BAT.h"
 

namespace FLImaging
{
    namespace ImageProcessing
    {
        class CInternalIntegralImage;

        class FL_EXPORT CIntegralImage : public CAlgorithmFeature_SR_DI_BAT
        {
        public:

            enum EDataType
            {
                EDataType_Uint32 = 0,

                EDataType_Int32,

                EDataType_Uint64,

                EDataType_Int64,

                EDataType_Float32,

                EDataType_Float64,
            };

            enum ECalculationMode
            {
                ECalculationMode_Linear = 0,

                ECalculationMode_LinearConstant,

                ECalculationMode_Squared,

                ECalculationMode_SquaredLinear,

                ECalculationMode_SquaredLinearConstant,
            };

            enum EDirection
            {
                EDirection_XY = 0,

                EDirection_X,

                EDirection_Y,
            };

            CIntegralImage();

            CIntegralImage(const CIntegralImage& Integral);

            CIntegralImage(const CIntegralImage* pIntegral);

            virtual ~CIntegralImage();

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

            virtual const CResult Assign(const CIntegralImage& Integral);

            virtual const CResult Assign(const CIntegralImage* 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_Linear);

            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(CIntegralImage, *this);
 
        protected:

            EDataType m_eDataType;

            ECalculationMode m_eCalculationMode;

            EDirection m_eDirection;

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