LeastSquares.h

#pragma once
#include "FLFigureForwardDeclaration.h"
#include "DefinitionsMathematics.h"
 
namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class CInternalLeastSquares;
 
        enum ELeastSqauresAccuracy
        {
            ELeastSqauresAccuracy_TemplateType = 0,
 
            ELeastSqauresAccuracy_Bits128,
 
            ELeastSqauresAccuracy_Bits256,
        };
 
        template<typename T>
        class FL_EXPORT CLeastSquares : public Base::CFLBase
        {
        public:
            CLeastSquares();
 
            virtual ~CLeastSquares();
 
            const CResult Clear();
 
            const CResult Set(const Base::TPoint<T>* pTpArrXY, int32_t i32Count);
 
            const CResult Set(const Base::CFLArray<Base::TPoint<T>>& flaData);
 
            const CResult Set(const Base::CFLArray<Base::TPoint<T>>* pFlaData);
 
            const CResult Set(T* pTArrX, T* pTArrY, int32_t i32Count);
 
            const CResult Assign(const CFLFigureArray& flfaData);
 
            const CResult Assign(const CFLFigureArray* pFlfaData);
 
            const CResult Assign(const CFLPointArray& flpaData);
 
            const CResult Assign(const CFLPointArray* pFlpaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint<double>>& flaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint<float>>& flaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint<int64_t>>& flaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint<int32_t>>& flaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint<double>>* pFlaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint<float>>* pFlaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint<int64_t>>* pFlaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint<int32_t>>* pFlaData);
 
            const CResult Assign(int32_t* pI32X, int32_t* pI32Y, int32_t i32Count);
 
            const CResult Assign(int64_t* pI64X, int64_t* pI64Y, int32_t i32Count);
 
            const CResult Assign(float* pF32X, float* pF32Y, int32_t i32Count);
 
            const CResult Assign(double* pF64X, double* pF64Y, int32_t i32Count);
 
            const CResult Assign(int32_t* pArr2I32XY, int32_t i32Count);
 
            const CResult Assign(int64_t* pArr2I64XY, int32_t i32Count);
 
            const CResult Assign(float* pArr2F32XY, int32_t i32Count);
 
            const CResult Assign(double* pArr2F64XY, int32_t i32Count);
 
            const CResult Assign(const CFLPoint<int32_t>* pData, int32_t i32Count);
 
            const CResult Assign(const CFLPoint<int64_t>* pData, int32_t i32Count);
 
            const CResult Assign(const CFLPoint<float>* pData, int32_t i32Count);
 
            const CResult Assign(const CFLPoint<double>* pData, int32_t i32Count);
 
            const CResult Add(int32_t i32X, int32_t i32Y);
 
            const CResult Add(int64_t i64X, int64_t i64Y);
 
            const CResult Add(float f32X, float f32Y);
 
            const CResult Add(double f64X, double f64Y);
 
            const CResult Add(const CFLPoint<double>& flpData);
 
            const CResult Add(const CFLPoint<float>& flpData);
 
            const CResult Add(const CFLPoint<int64_t>& flpData);
 
            const CResult Add(const CFLPoint<int32_t>& flpData);
 
            const CResult Add(const CFLPoint<double>* pFlpData);
 
            const CResult Add(const CFLPoint<float>* pFlpData);
 
            const CResult Add(const CFLPoint<int64_t>* pFlpData);
 
            const CResult Add(const CFLPoint<int32_t>* pFlpData);
 
            const CResult Add(const Base::TPoint<double>& tpData);
 
            const CResult Add(const Base::TPoint<float>& tpData);
 
            const CResult Add(const Base::TPoint<int64_t>& tpData);
 
            const CResult Add(const Base::TPoint<int32_t>& tpData);
 
            const CResult Add(const Base::TPoint<double>* pTpData);
 
            const CResult Add(const Base::TPoint<float>* pTpData);
 
            const CResult Add(const Base::TPoint<int64_t>* pTpData);
 
            const CResult Add(const Base::TPoint<int32_t>* pTpData);
 
            const CResult Add(const CFLFigureArray& flfaData);
 
            const CResult Add(const CFLFigureArray* pFlfaData);
 
            const CResult Add(const CFLPointArray& flpaData);
 
            const CResult Add(const CFLPointArray* pFlpaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint<double>>& flaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint<float>>& flaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint<int64_t>>& flaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint<int32_t>>& flaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint<double>>* pFlaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint<float>>* pFlaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint<int64_t>>* pFlaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint<int32_t>>* pFlaData);
 
            const CResult Add(double* pArrX, double* pArrY, int32_t i32Count);
 
            const CResult Add(float* pArrX, float* pArrY, int32_t i32Count);
 
            const CResult Add(int64_t* pArrX, int64_t* pArrY, int32_t i32Count);
 
            const CResult Add(int32_t* pArrX, int32_t* pArrY, int32_t i32Count);
 
            Base::TPoint<T>* Get(size_t stIndex) const;
 
            const CResult Get(size_t stIndex, T** ppTArrX, T** ppTArrY) const;
 
            size_t GetCount();
 
            const CResult GetPoly(int32_t i32Degree, T* pTResult, T* pTRSquare = nullptr, ECoefficientOrder eOrder = ECoefficientOrder_Descending, ELeastSqauresAccuracy eAccuracy = ELeastSqauresAccuracy_TemplateType);
 
            const CResult GetPoly(int32_t i32Degree, Base::CFLArray<T>& flaResult, T* pTRSquare = nullptr, ECoefficientOrder eOrder = ECoefficientOrder_Descending, ELeastSqauresAccuracy eAccuracy = ELeastSqauresAccuracy_TemplateType);
 
            const CResult GetPoly(int32_t i32Degree, Base::CFLArray<T>* pFlaResult, T* pTRSquare = nullptr, ECoefficientOrder eOrder = ECoefficientOrder_Descending, ELeastSqauresAccuracy eAccuracy = ELeastSqauresAccuracy_TemplateType);
 
            const CResult GetCircle(CFLCircle<T>& flcResult, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            const CResult GetCircle(CFLCircle<T>* pFlcResult, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            const CResult GetEllipse(CFLEllipse<T>& fleResult, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            const CResult GetEllipse(CFLEllipse<T>* pFleResult, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            const CResult GetLine(CFLLine<T>& fllResult, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            const CResult GetLine(CFLLine<T>* pFllResult, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
 
            SupportToDuplicateObject(CLeastSquares, *this);
            DeclareGetClassType();
 
        private:
            CInternalLeastSquares<T>* m_pInternal;
        };
 
        typedef CLeastSquares<float> CLeastSquaresF;
        typedef CLeastSquares<double> CLeastSquaresD;
    }
}