LeastSquares3D.h

#pragma once
#include "FLFigureForwardDeclaration.h"
#include "DefinitionsMathematics.h"
 
namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class CInternalLeastSquares3D;
 
        template<typename T>
        class FL_EXPORT CLeastSquares3D : public Base::CFLBase
        {
        public:
            CLeastSquares3D();
 
            virtual ~CLeastSquares3D();
 
            const CResult Clear();
 
            const CResult Set(const Base::TPoint3<T>* pTpArrXYZ, int32_t i32Count);
 
            const CResult Set(const Base::CFLArray<Base::TPoint3<T>>& flaData);
 
            const CResult Set(const Base::CFLArray<Base::TPoint3<T>>* pFlaData);
 
            const CResult Set(T* pTArrX, T* pTArrY, T* pTArrZ, int32_t i32Count);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint3<double>>& flaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint3<float>>& flaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint3<int64_t>>& flaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint3<int32_t>>& flaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint3<double>>* pFlaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint3<float>>* pFlaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint3<int64_t>>* pFlaData);
 
            const CResult Assign(const Base::CFLArray<Base::TPoint3<int32_t>>* pFlaData);
 
            const CResult Assign(int32_t* pI32X, int32_t* pI32Y, int32_t* pI32Z, int32_t i32Count);
 
            const CResult Assign(int64_t* pI64X, int64_t* pI64Y, int64_t* pI64Z, int32_t i32Count);
 
            const CResult Assign(float* pF32X, float* pF32Y, float* pF32Z, int32_t i32Count);
 
            const CResult Assign(double* pF64X, double* pF64Y, double* pF64Z, int32_t i32Count);
 
            const CResult Assign(const CFLPoint3<float>* pData, int32_t i32Count);
 
            const CResult Assign(const CFLPoint3<double>* pData, int32_t i32Count);
 
            const CResult Add(int32_t i32X, int32_t i32Y, int32_t i32Z);
 
            const CResult Add(int64_t i64X, int64_t i64Y, int64_t i64Z);
 
            const CResult Add(float f32X, float f32Y, float f32Z);
 
            const CResult Add(double f64X, double f64Y, double f64Z);
 
            const CResult Add(const CFLPoint3<double>& flpData);
 
            const CResult Add(const CFLPoint3<float>& flpData);
 
            const CResult Add(const CFLPoint3<double>* pFlpData);
 
            const CResult Add(const CFLPoint3<float>* pFlpData);
 
            const CResult Add(const Base::TPoint3<double>& tpData);
 
            const CResult Add(const Base::TPoint3<float>& tpData);
 
            const CResult Add(const Base::TPoint3<int64_t>& tpData);
 
            const CResult Add(const Base::TPoint3<int32_t>& tpData);
 
            const CResult Add(const Base::TPoint3<double>* pTpData);
 
            const CResult Add(const Base::TPoint3<float>* pTpData);
 
            const CResult Add(const Base::TPoint3<int64_t>* pTpData);
 
            const CResult Add(const Base::TPoint3<int32_t>* pTpData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint3<double>>& flaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint3<float>>& flaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint3<int64_t>>& flaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint3<int32_t>>& flaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint3<double>>* pFlaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint3<float>>* pFlaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint3<int64_t>>* pFlaData);
 
            const CResult Add(const Base::CFLArray<Base::TPoint3<int32_t>>* pFlaData);
 
            const CResult Add(double* pArrX, double* pArrY, double* pArrZ, int32_t i32Count);
 
            const CResult Add(float* pArrX, float* pArrY, float* pArrZ, int32_t i32Count);
 
            const CResult Add(int64_t* pArrX, int64_t* pArrY, int64_t* pArrZ, int32_t i32Count);
 
            const CResult Add(int32_t* pArrX, int32_t* pArrY, int32_t* pArrZ, int32_t i32Count);
 
            Base::TPoint3<T>* Get(size_t stIndex) const;
 
            const CResult Get(size_t stIndex, T** ppTArrX, T** ppTArrY, T** ppTArrZ) const;
 
            size_t GetCount();
 
            const CResult GetPlane(T& tA, T& tB, T& tC, T& tD, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            const CResult GetSphere(T& tU, T& tV, T& tW, T& tR, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            const CResult GetLine(CFLPoint3<T>& flpDirectionVector, CFLPoint3<T>& flpBasePosition, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            const CResult GetLine(CFLPoint3<T>* pFlpDirectionVector, CFLPoint3<T>* pFlpBasePosition, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3.) const;
 
            SupportToDuplicateObject(CLeastSquares3D, *this);
            DeclareGetClassType();
 
        private:
            CInternalLeastSquares3D<T>* m_pInternal;
        };
 
        typedef CLeastSquares3D<float> CLeastSquares3DF;
        typedef CLeastSquares3D<double> CLeastSquares3DD;
    }
}