FLLine3.h

#pragma once

 
#include "FLFigure3.h"
#include "FLPoint3.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLPointArray3;

        template<typename T>
        class FL_EXPORT CFLLine3 : public CFLFigure3
        {
        public:
            CFLPoint3<T> flpPoints[2];

            CFLLine3();

            virtual ~CFLLine3();

            CFLLine3(const CFLLine3<float>& rhs);

            CFLLine3(const CFLLine3<double>& rhs);

            CFLLine3(const CFLLine3<float>* pRhs);

            CFLLine3(const CFLLine3<double>* pRhs);

            CFLLine3(const Base::TLine3<float>& rhs);

            CFLLine3(const Base::TLine3<double>& rhs);

            CFLLine3(const Base::TLine3<float>* pRhs);

            CFLLine3(const Base::TLine3<double>* pRhs);

            CFLLine3(const Base::TLine<float>& rhs);

            CFLLine3(const Base::TLine<double>& rhs);

            CFLLine3(const Base::TLine<float>* pRhs);

            CFLLine3(const Base::TLine<double>* pRhs);

            CFLLine3(const CFLPoint3<float>& flp0, const CFLPoint3<float>& flp1);

            CFLLine3(const CFLPoint3<double>& flp0, const CFLPoint3<double>& flp1);

            CFLLine3(const CFLPoint3<float>* pFlp0, const CFLPoint3<float>* pFlp1);

            CFLLine3(const CFLPoint3<double>* pFlp0, const CFLPoint3<double>* pFlp1);

            CFLLine3(const Base::TPoint3<float>& tp0, const Base::TPoint3<float>& tp1);

            CFLLine3(const Base::TPoint3<double>& tp0, const Base::TPoint3<double>& tp1);

            CFLLine3(const Base::TPoint3<float>* pTp0, const Base::TPoint3<float>* pTp1);

            CFLLine3(const Base::TPoint3<double>* pTp0, const Base::TPoint3<double>* pTp1);

            CFLLine3(double x0, double y0, double z0, double x1, double y1, double z1);

            CFLLine3(float x0, float y0, float z0, float x1, float y1, float z1);

            CFLLine3(int64_t x0, int64_t y0, int64_t z0, int64_t x1, int64_t y1, int64_t z1);

            CFLLine3(int32_t x0, int32_t y0, int32_t z0, int32_t x1, int32_t y1, int32_t z1);

            CFLLine3(const CFLPointArray3<double>& flpa3);

            CFLLine3(const CFLPointArray3<float>& flpa3);

            CFLLine3(const CFLPointArray3<double>* pFlpa3);

            CFLLine3(const CFLPointArray3<float>* pFlpa3);

            CFLLine3(const CFLFigure& flf);

            CFLLine3(const CFLFigure* pFlf);

            virtual const CResult Set(const CFLLine3<float>& rhs);

            virtual const CResult Set(const CFLLine3<double>& rhs);

            virtual const CResult Set(const CFLLine3<float>* pRhs);

            virtual const CResult Set(const CFLLine3<double>* pRhs);

            virtual const CResult Set(const Base::TLine3<float>& rhs);

            virtual const CResult Set(const Base::TLine3<double>& rhs);

            virtual const CResult Set(const Base::TLine3<float>* pRhs);

            virtual const CResult Set(const Base::TLine3<double>* pRhs);

            virtual const CResult Set(const Base::TLine<float>& rhs);

            virtual const CResult Set(const Base::TLine<double>& rhs);

            virtual const CResult Set(const Base::TLine<float>* pRhs);

            virtual const CResult Set(const Base::TLine<double>* pRhs);

            virtual const CResult Set(const CFLPoint3<float>& flp0, const CFLPoint3<float>& flp1);

            virtual const CResult Set(const CFLPoint3<double>& flp0, const CFLPoint3<double>& flp1);

            virtual const CResult Set(const CFLPoint3<float>* pFlp0, const CFLPoint3<float>* pFlp1);

            virtual const CResult Set(const CFLPoint3<double>* pFlp0, const CFLPoint3<double>* pFlp1);

            virtual const CResult Set(const Base::TPoint3<float>& tp0, const Base::TPoint3<float>& tp1);

            virtual const CResult Set(const Base::TPoint3<double>& tp0, const Base::TPoint3<double>& tp1);

            virtual const CResult Set(const Base::TPoint3<float>* pTp0, const Base::TPoint3<float>* pTp1);

            virtual const CResult Set(const Base::TPoint3<double>* pTp0, const Base::TPoint3<double>* pTp1);

            virtual const CResult Set(double x0, double y0, double z0, double x1, double y1, double z1);

            virtual const CResult Set(float x0, float y0, float z0, float x1, float y1, float z1);

            virtual const CResult Set(int64_t x0, int64_t y0, int64_t z0, int64_t x1, int64_t y1, int64_t z1);

            virtual const CResult Set(int32_t x0, int32_t y0, int32_t z0, int32_t x1, int32_t y1, int32_t z1);

            virtual const CResult Set(const CFLPointArray3<double>& flpa3);

            virtual const CResult Set(const CFLPointArray3<float>& flpa3);

            virtual const CResult Set(const CFLPointArray3<double>* pFlpa3);

            virtual const CResult Set(const CFLPointArray3<float>* pFlpa3);
 
            virtual const CResult Set(const CFLFigure& flf) override;
            virtual const CResult Set(const CFLFigure* pFlf) override;

            virtual const CResult Fit(const Base::CFLArray<Base::TPoint3<double>>& flaPoints, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3., Base::CFLArray<int64_t>* pFlaOutlierIndices = nullptr);

            virtual const CResult Fit(const Base::CFLArray<Base::TPoint3<float>>& flaPoints, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3., Base::CFLArray<int64_t>* pFlaOutlierIndices = nullptr);

            virtual const CResult Fit(const Base::CFLArray<Base::TPoint3<double>>* pFlaPoints, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3., Base::CFLArray<int64_t>* pFlaOutlierIndices = nullptr);

            virtual const CResult Fit(const Base::CFLArray<Base::TPoint3<float>>* pFlaPoints, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3., Base::CFLArray<int64_t>* pFlaOutlierIndices = nullptr);

            virtual const CResult Fit(const CFLPointArray3<double>& flpaPoints, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3., Base::CFLArray<int64_t>* pFlaOutlierIndices = nullptr);

            virtual const CResult Fit(const CFLPointArray3<float>& flpaPoints, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3., Base::CFLArray<int64_t>* pFlaOutlierIndices = nullptr);

            virtual const CResult Fit(const CFLPointArray3<double>* pFlpaPoints, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3., Base::CFLArray<int64_t>* pFlaOutlierIndices = nullptr);

            virtual const CResult Fit(const CFLPointArray3<float>* pFlpaPoints, int64_t i64OutlierThresholdCount = 0, double f64OutlierThreshold = 3., Base::CFLArray<int64_t>* pFlaOutlierIndices = nullptr);
 
            virtual void Clear() override;
 
            virtual EFigureDeclType GetDeclType() const override;
            virtual EFigureTemplateType GetTemplateType() const override;
 
            using CFLFigure::IsSpecEqual;
            virtual bool IsSpecEqual(const CFLFigure* pFlfRhs, EFigureSpecCompareType eSpecType = EFigureSpecCompareType_Coordinates) const override;
 
            using CFLFigure::Swap;
            virtual const CResult Swap(CFLFigure* pFlfRight) override;
 
            virtual double GetLength() const override;
 
            using CFLFigure3::Offset;
            virtual const CResult Offset(double x, double y, double z) override;
 
            using CFLFigure3::Multiply;
            virtual const CResult Multiply(double x, double y, double z) override;
 
            virtual CFLPoint3<double> GetCenter3D() const override;
 
            using CFLFigure3::GetCenterOfGravity;
            virtual const CResult GetCenterOfGravity(double& x, double& y, double& z) const override;
 
            using CFLFigure3::GetCenterOfVertices;
            virtual const CResult GetCenterOfVertices(double& x, double& y, double& z) const override;
 
            using CFLFigure3::Rotate;
            virtual const CResult Rotate(const CFLGeometry3DQuaternion<float>* pQuat, const CFLPoint3<float>* pFlp3Pivot = nullptr) override;
            virtual const CResult Rotate(const CFLGeometry3DQuaternion<double>* pQuat, const CFLPoint3<double>* pFlp3Pivot = nullptr) override;
 
            using CFLFigure3::Scale;
            virtual const CResult Scale(double f64PivotX, double f64PivotY, double f64PivotZ, double f64ScaleX, double f64ScaleY, double f64ScaleZ) override;
 
            using CFLFigure3::Transform;
            virtual const CResult Transform(const CMatrix<float>* pMatTransform) override;
            virtual const CResult Transform(const CMatrix<double>* pMatTransform) override;
 
            using CFLFigure3::GetBoundingBox;
            virtual const CResult GetBoundingBox(double& f64MinX, double& f64MinY, double& f64MinZ, double& f64MaxX, double& f64MaxY, double& f64MaxZ) const override;
            virtual const CResult GetBoundingBox(float& f32MinX, float& f32MinY, float& f32MinZ, float& f32MaxX, float& f32MaxY, float& f32MaxZ) const override;

            virtual CFLPoint3<T> GetUnitVector() const;
 
            virtual const CResult GetSamplingPointsOnSegment(double f64SamplingDistance, CFLFigureArray& flfaResult) const override;
            virtual const CResult GetSamplingPointsOnSegment(double f64SamplingDistance, CFLFigureArray* pFlfaResult) const override;

            virtual const CResult GetSamplingPointsOnSegment(double f64SamplingDistance, CFLPointArray3<T>& flpaResult) const;

            virtual const CResult GetSamplingPointsOnSegment(double f64SamplingDistance, CFLPointArray3<T>* pFlpaResult) const;

            virtual CFLPoint3<T> GetPointOnLine(double f64T) const;

            virtual const CResult GetPositionOnLine(double f64X, double f64Y, double f64Z, double& f64T) const;

            virtual const CResult GetPositionOnLine(const CFLPoint3<T>& flp, double& f64T) const;

            virtual const CResult GetPositionOnLine(const CFLPoint3<T>* pFlp, double& f64T) const;

            virtual double GetPositionOnLine(double f64X, double f64Y, double f64Z) const;

            virtual double GetPositionOnLine(const CFLPoint3<T>& flp) const;

            virtual double GetPositionOnLine(const CFLPoint3<T>* pFlp) const;
 

            bool operator==(const CFLLine3<float>& flsp) const;

            bool operator==(const CFLLine3<double>& flsp) const;

            bool operator!=(const CFLLine3<float>& flsp) const;

            bool operator!=(const CFLLine3<double>& flsp) const;

            const CFLLine3<T>& operator=(const CFLLine3<float>& rhs);

            const CFLLine3<T>& operator=(const CFLLine3<double>& rhs);

            const CFLLine3<T>& operator+=(const double& value);

            const CFLLine3<T>& operator+=(const CFLPoint3<float>& flpPoint);

            const CFLLine3<T>& operator+=(const CFLPoint3<double>& flpPoint);

            const CFLLine3<T>& operator+=(const Base::TPoint3<float>& tpPoint);

            const CFLLine3<T>& operator+=(const Base::TPoint3<double>& tpPoint);

            const CFLLine3<T>& operator-=(const double& value);

            const CFLLine3<T>& operator-=(const CFLPoint3<float>& flpPoint);

            const CFLLine3<T>& operator-=(const CFLPoint3<double>& flpPoint);

            const CFLLine3<T>& operator-=(const Base::TPoint3<float>& tpPoint);

            const CFLLine3<T>& operator-=(const Base::TPoint3<double>& tpPoint);

            const CFLLine3<T>& operator*=(const double& value);

            const CFLLine3<T>& operator*=(const CFLPoint3<float>& flpPoint);

            const CFLLine3<T>& operator*=(const CFLPoint3<double>& flpPoint);

            const CFLLine3<T>& operator*=(const Base::TPoint3<float>& tpPoint);

            const CFLLine3<T>& operator*=(const Base::TPoint3<double>& tpPoint);

            const CFLLine3<T>& operator/=(const double& value);

            const CFLLine3<T>& operator/=(const CFLPoint3<float>& flpPoint);

            const CFLLine3<T>& operator/=(const CFLPoint3<double>& flpPoint);

            const CFLLine3<T>& operator/=(const Base::TPoint3<float>& tpPoint);

            const CFLLine3<T>& operator/=(const Base::TPoint3<double>& tpPoint);

            CFLLine3<T> operator+(const double& value) const;

            CFLLine3<T> operator+(const Base::TPoint3<float>& tpPoint) const;

            CFLLine3<T> operator+(const Base::TPoint3<double>& tpPoint) const;

            CFLLine3<T> operator+(const CFLPoint3<float>& flpPoint) const;

            CFLLine3<T> operator+(const CFLPoint3<double>& flpPoint) const;

            CFLLine3<T> operator-(const double& value) const;

            CFLLine3<T> operator-(const Base::TPoint3<float>& tpPoint) const;

            CFLLine3<T> operator-(const Base::TPoint3<double>& tpPoint) const;

            CFLLine3<T> operator-(const CFLPoint3<float>& flpPoint) const;

            CFLLine3<T> operator-(const CFLPoint3<double>& flpPoint) const;

            CFLLine3<T> operator*(const double& value) const;

            CFLLine3<T> operator*(const Base::TPoint3<float>& tpPoint) const;

            CFLLine3<T> operator*(const Base::TPoint3<double>& tpPoint) const;

            CFLLine3<T> operator*(const CFLPoint3<float>& flpPoint) const;

            CFLLine3<T> operator*(const CFLPoint3<double>& flpPoint) const;

            CFLLine3<T> operator/(const double& value) const;

            CFLLine3<T> operator/(const Base::TPoint3<float>& tpPoint) const;

            CFLLine3<T> operator/(const Base::TPoint3<double>& tpPoint) const;

            CFLLine3<T> operator/(const CFLPoint3<float>& flpPoint) const;

            CFLLine3<T> operator/(const CFLPoint3<double>& flpPoint) const;

            CFLLine3<T> operator-() const;

            friend CFLLine3<T> operator+(const double& value, const CFLLine3<T>& fll)
            {
                CFLLine3<T> t(fll);
                t += value;
                return t;
            }

            friend CFLLine3<T> operator-(const double& value, const CFLLine3<T>& fll)
            {
                CFLLine3<T> t(fll);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLLine3<T> operator*(const double& value, const CFLLine3<T>& fll)
            {
                CFLLine3<T> t(fll);
                t *= value;
                return t;
            }

            friend CFLLine3<T> operator/(const double& value, const CFLLine3<T>& fll)
            {
                CFLLine3<T> t(fll);
                t.flpPoints[0] = value / fll.flpPoints[0];
                t.flpPoints[1] = value / fll.flpPoints[1];
                return t;
            }
 
 
        private:
            using CFLFigure::GetSamplingVectorOnSegment;
 
        protected:
            virtual CFLPoint<double> GetCenterOfGravity() const override;
 
            SupportToDuplicateObject(CFLLine3<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLLine3<float> CFLLine3F;
        typedef CFLLine3<double> CFLLine3D;
    }
}