FLPoint3.h

#pragma once
 
#include "FLPoint.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename Ty>
        class FL_EXPORT CFLGeometry3DVector;
 
        template<typename Ty>
        class FL_EXPORT CFLGeometry3DDirection;
 
        template<typename Ty>
        class FL_EXPORT CMatrixFor3D;
 
        template<typename Ty>
        class FL_EXPORT CMatrixFor3DTransform;
 
        template<typename Ty>
        class FL_EXPORT CFLGeometry3DAxis;
 
        template<typename Ty>
        class FL_EXPORT CFLGeometry3DCoordinateSystemRH;

        template<typename Ty>
        class FL_EXPORT CFLPoint3 : public CFLPoint<Ty>
        {
        public:
            Ty z;

            CFLPoint3();

            virtual ~CFLPoint3();

            virtual void Get(Ty& tX, Ty& tY, Ty& tZ) const;

            virtual double GetMagnitude() const;

            virtual double GetSquareMagnitude() const;

            virtual const CResult Offset(double x, double y, double z);

            virtual const CResult Offset(float x, float y, float z);

            virtual const CResult Offset(int32_t x, int32_t y, int32_t z);

            virtual const CResult Offset(int64_t x, int64_t y, int64_t z);

            virtual const CResult Offset(const CFLPoint3<double>& flp3);

            virtual const CResult Offset(const CFLPoint3<float>& flp3);

            virtual const CResult Offset(const CFLPoint3<double>* pFlp3);

            virtual const CResult Offset(const CFLPoint3<float>* pFlp3);

            virtual const CResult Add(const CFLPoint3<Ty>& rhs);

            virtual const CResult Add(Ty tX, Ty tY, Ty tZ);

            virtual const CResult Subtract(const CFLPoint3<Ty>& rhs);

            virtual const CResult Subtract(Ty tX, Ty tY, Ty tZ);

            virtual const CResult Multiply(double f64MulX, double f64MulY, double f64MulZ);

            virtual const CResult Multiply(float f32MulX, float f32MulY, float f32MulZ);

            virtual const CResult Multiply(int32_t i32MulX, int32_t i32MulY, int32_t i32MulZ);

            virtual const CResult Multiply(int64_t i64MulX, int64_t i64MulY, int64_t i64MulZ);

            virtual const CResult Multiply(const CFLPoint3<double>& flp3);

            virtual const CResult Multiply(const CFLPoint3<float>& flp3);

            virtual const CResult Multiply(const CFLPoint3<double>* pFlp3);

            virtual const CResult Multiply(const CFLPoint3<float>* pFlp3);

            virtual const CResult Multiply(double f64Scalar);

            virtual const CResult Multiply(float f32Scalar);

            virtual const CResult Multiply(int32_t i32Scalar);

            virtual const CResult Multiply(int64_t i64Scalar);

            virtual const CResult MatMul(const CMatrixFor3D<float>& mat3D);

            virtual const CResult MatMul(const CMatrixFor3D<double>& mat3D);

            virtual const CResult MatMul(const CMatrixFor3D<float>* pMat3D);

            virtual const CResult MatMul(const CMatrixFor3D<double>* pMat3D);
 
            operator CFLPoint<float>()
            {
                return CFLPoint<float>(this);
            }
 
            operator CFLPoint<double>()
            {
                return CFLPoint<double>(this);
            }

            const CFLPoint3<Ty>& operator*=(const CMatrixFor3D<float>& mat3D);

            const CFLPoint3<Ty>& operator*=(const CMatrixFor3D<double>& mat3D);

            const CFLPoint3<Ty>& operator*=(const CMatrixFor3D<float>* pMat3D);

            const CFLPoint3<Ty>& operator*=(const CMatrixFor3D<double>* pMat3D);

            CFLPoint3<Ty> operator*(const CMatrixFor3D<float>& mat3D) const;

            CFLPoint3<Ty> operator*(const CMatrixFor3D<double>& mat3D) const;

            CFLPoint3<Ty> operator*(const CMatrixFor3D<float>* pMat3D) const;

            CFLPoint3<Ty> operator*(const CMatrixFor3D<double>* pMat3D) const;

            virtual const CResult Divide(double f64Scalar);

            virtual const CResult Divide(float f32Scalar);

            virtual const CResult Divide(int32_t i32Scalar);

            virtual const CResult Divide(int64_t i64Scalar);

            virtual const CResult Cross(float f32X, float f32Y, float f32Z);

            virtual const CResult Cross(double f64X, double f64Y, double f64Z);

            virtual const CResult Cross(int32_t i32X, int32_t i32Y, int32_t i32Z);

            virtual const CResult Cross(int64_t i64X, int64_t i64Y, int64_t i64Z);

            virtual const CResult Cross(const CFLPoint3<float>& rhs);

            virtual const CResult Cross(const CFLPoint3<double>& rhs);

            virtual const CResult Cross(const CFLPoint3<float>* pRhs);

            virtual const CResult Cross(const CFLPoint3<double>* pRhs);

            virtual double Dot(float f32X, float f32Y, float f32Z) const;

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

            virtual double Dot(int32_t i32X, int32_t i32Y, int32_t i32Z) const;

            virtual double Dot(int64_t i64X, int64_t i64Y, int64_t i64Z) const;

            virtual double Dot(const CFLPoint3<float>& rhs) const;

            virtual double Dot(const CFLPoint3<double>& rhs) const;

            virtual double Dot(const CFLPoint3<float>* pRhs) const;

            virtual double Dot(const CFLPoint3<double>* pRhs) const;

            virtual const CResult Scale(double f64PivotX, double f64PivotY, double f64PivotZ, double f64RatioX, double f64RatioY, double f64RatioZ);

            virtual const CResult Scale(float f32PivotX, float f32PivotY, float f32PivotZ, float f32RatioX, float f32RatioY, float f32RatioZ);

            virtual const CResult Scale(const CFLPoint3<double>& flp3Pivot, double f64RatioX, double f64RatioY, double f64RatioZ);

            virtual const CResult Scale(const CFLPoint3<float>& flp3Pivot, float f32RatioX, float f32RatioY, float f32RatioZ);

            virtual const CResult Scale(const CFLPoint3<double>* pFlp3Pivot, double f64RatioX, double f64RatioY, double f64RatioZ);

            virtual const CResult Scale(const CFLPoint3<float>* pFlp3Pivot, float f32RatioX, float f32RatioY, float f32RatioZ);

            virtual const CResult Scale(const CFLPoint3<double>& flp3Pivot, double f64Ratio);

            virtual const CResult Scale(const CFLPoint3<float>& flp3Pivot, float f32Ratio);

            virtual const CResult Scale(const CFLPoint3<double>* pFlp3Pivot, double f64Ratio);

            virtual const CResult Scale(const CFLPoint3<float>* pFlp3Pivot, float f32Ratio);

            virtual const CResult Mirror(double pivotX, double pivotY, double pivotZ);

            virtual const CResult Mirror(float pivotX, float pivotY, float pivotZ);

            virtual const CResult Mirror(int32_t pivotX, int32_t pivotY, int32_t pivotZ);

            virtual const CResult Mirror(int64_t pivotX, int64_t pivotY, int64_t pivotZ);

            virtual const CResult Mirror(const CFLPoint3<double>& flp3Pivot);

            virtual const CResult Mirror(const CFLPoint3<float>& flp3Pivot);

            virtual const CResult Mirror(const CFLPoint3<double>* pFlp3Pivot);

            virtual const CResult Mirror(const CFLPoint3<float>* pFlp3Pivot);

            virtual const CResult Mirror(const CFLGeometry3DAxis<double>& axis3Pivot);

            virtual const CResult Mirror(const CFLGeometry3DAxis<float>& axis3Pivot);

            virtual const CResult Mirror(const CFLGeometry3DAxis<double>* pAxis3Pivot);

            virtual const CResult Mirror(const CFLGeometry3DAxis<float>* pAxis3Pivot);

            virtual const CResult Mirror(const CFLGeometry3DCoordinateSystemRH<double>& coordSysRHPlane);

            virtual const CResult Mirror(const CFLGeometry3DCoordinateSystemRH<float>& coordSysRHPlane);

            virtual const CResult Mirror(const CFLGeometry3DCoordinateSystemRH<double>* pCoordSysRHPlane);

            virtual const CResult Mirror(const CFLGeometry3DCoordinateSystemRH<float>* pCoordSysRHPlane);

            virtual const CResult Rotate(const CFLGeometry3DAxis<double>& axis, double f64Angle);

            virtual const CResult Rotate(const CFLGeometry3DAxis<float>& axis, double f64Angle);

            virtual const CResult Rotate(const CFLGeometry3DAxis<double>* pAxis, double f64Angle);

            virtual const CResult Rotate(const CFLGeometry3DAxis<float>* pAxis, double f64Angle);

            virtual const CResult Transform(const CMatrixFor3DTransform<double>& transform);

            virtual const CResult Transform(const CMatrixFor3DTransform<float>& transform);

            virtual const CResult Transform(const CMatrixFor3DTransform<double>* pTransform);

            virtual const CResult Transform(const CMatrixFor3DTransform<float>* pTransform);

            virtual double GetDistance(const CFLPoint3<double>& flp3) const;

            virtual double GetDistance(const CFLPoint3<float>& flp3) const;

            virtual double GetDistance(const CFLPoint3<double>* pFlp3) const;

            virtual double GetDistance(const CFLPoint3<float>* pFlp3) const;

            virtual const CResult Normalize();

            CFLPoint3<double> GetUnitVector() const;

            CFLPoint3<double> GetUnitVector(const CFLPoint3<double>& flp3Target) const;

            virtual CFLPoint3<double> GetUnitVector(const CFLPoint3<double>* pFlp3Target) const;

            virtual const CResult SetLinearInterpolation(const CFLPoint3<Ty>& flp3Start, const CFLPoint3<Ty>& flp3End, double f64T);
 
            virtual void Clear() override;
 
            virtual EFigureDeclType GetDeclType() const override;
 
            virtual bool IsValid() const override;
            virtual bool IsFigureValid() const override;
 
            virtual const CResult MakeFigureInvalid() override;
 
            using CFLFigure::IsSpecEqual;
            virtual bool IsSpecEqual(const CFLFigure* pFlfRhs, EFigureSpecCompareType eSpecType = EFigureSpecCompareType_Coordinates) const override;

            const CFLPoint3<Ty>& operator=(const CFLPoint3<Ty>& flp3);

            const CFLPoint3<Ty>& operator=(const Base::TPoint3<Ty>& tp3);

            bool operator==(const CFLPoint3<double>& flp3) const;

            bool operator!=(const CFLPoint3<double>& flp3) const;

            const CFLPoint3<Ty>& operator+=(const double& value);

            const CFLPoint3<Ty>& operator+=(const CFLPoint3<double>& flp3);

            const CFLPoint3<Ty>& operator-=(const double& value);

            const CFLPoint3<Ty>& operator-=(const CFLPoint3<double>& flp3);

            const CFLPoint3<Ty>& operator*=(const double& value);

            const CFLPoint3<Ty>& operator*=(const float& value);

            const CFLPoint3<Ty>& operator*=(const int32_t& value);

            const CFLPoint3<Ty>& operator*=(const int64_t& value);

            const CFLPoint3<Ty>& operator*=(const CFLPoint3<double>& flp3);

            const CFLPoint3<Ty>& operator/=(const double& value);

            const CFLPoint3<Ty>& operator/=(const CFLPoint3<double>& flp3);

            CFLPoint3<double> operator+(const double& value) const;

            CFLPoint3<double> operator+(const CFLPoint3<double>& flp3) const;

            CFLPoint3<double> operator-(const double& value) const;

            CFLPoint3<double> operator-(const CFLPoint3<double>& flp3) const;

            CFLPoint3<double> operator*(const double& value) const;

            CFLPoint3<double> operator*(const CFLPoint3<double>& flp3) const;

            CFLPoint3<double> operator/(const double& value) const;

            CFLPoint3<double> operator/(const CFLPoint3<double>& flp3) const;
 

            virtual const CResult Assign(const CFLPoint3<Ty>& flp3);

            virtual const CResult Assign(const Base::TPoint3<Ty>& tp3);

            // Set
 
            virtual const CResult Set(const CFLFigure& flf) override;
            virtual const CResult Set(const CFLFigure* pFlf) override;

            virtual const CResult Set(double x, double y, double z);

            virtual const CResult Set(float x, float y, float z);

            virtual const CResult Set(int32_t x, int32_t y, int32_t z);

            virtual const CResult Set(int64_t x, int64_t y, int64_t z);

            virtual const CResult Set(const CFLPoint<double>& flp, double z = 0.);

            virtual const CResult Set(const CFLPoint<float>& flp, float z = 0.);

            virtual const CResult Set(const CFLPoint<int32_t>& flp, int32_t z = 0.);

            virtual const CResult Set(const CFLPoint<int64_t>& flp, int64_t z = 0.);

            virtual const CResult Set(const CFLPoint<double>* pFlp, double z = 0.);

            virtual const CResult Set(const CFLPoint<float>* pFlp, float z = 0.);

            virtual const CResult Set(const CFLPoint<int32_t>* pFlp, int32_t z = 0.);

            virtual const CResult Set(const CFLPoint<int64_t>* pFlp, int64_t z = 0.);

            virtual const CResult Set(const CFLPoint3<double>& flp3);

            virtual const CResult Set(const CFLPoint3<float>& flp3);

            virtual const CResult Set(const CFLPoint3<double>* pFlp3);

            virtual const CResult Set(const CFLPoint3<float>* pFlp3);

            virtual const CResult Set(const Base::TPoint3<double>& tp3);

            virtual const CResult Set(const Base::TPoint3<float>& tp3);

            virtual const CResult Set(const Base::TPoint3<double>* pTp3);

            virtual const CResult Set(const Base::TPoint3<float>* pTp3);

            virtual const CResult Set(const CFLGeometry3DVector<double>& vec3);

            virtual const CResult Set(const CFLGeometry3DVector<float>& vec3);
 

            virtual const CResult Set(const CFLGeometry3DVector<double>* pVec3);

            virtual const CResult Set(const CFLGeometry3DVector<float>* pVec3);
 

            virtual const CResult Set(const CFLGeometry3DDirection<double>& dir);

            virtual const CResult Set(const CFLGeometry3DDirection<float>& dir);
 

            virtual const CResult Set(const CFLGeometry3DDirection<double>* pDir);

            virtual const CResult Set(const CFLGeometry3DDirection<float>* pDir);
 
 

            // Constructor

            CFLPoint3(const CFLFigure& flf);

            CFLPoint3(const CFLFigure* pFlf);

            CFLPoint3(double x, double y, double z);

            CFLPoint3(float x, float y, float z);

            CFLPoint3(int32_t x, int32_t y, int32_t z);

            CFLPoint3(int64_t x, int64_t y, int64_t z);

            CFLPoint3(const CFLPoint<double>& flp, double z = 0.);

            CFLPoint3(const CFLPoint<float>& flp, float z = 0.);

            CFLPoint3(const CFLPoint<int32_t>& flp, int32_t z = 0.);

            CFLPoint3(const CFLPoint<int64_t>& flp, int64_t z = 0.);

            CFLPoint3(const CFLPoint<double>* pFlp, double z = 0.);

            CFLPoint3(const CFLPoint<float>* pFlp, float z = 0.);

            CFLPoint3(const CFLPoint<int32_t>* pFlp, int32_t z = 0.);

            CFLPoint3(const CFLPoint<int64_t>* pFlp, int64_t z = 0.);

            CFLPoint3(const CFLPoint3<double>& flp3);

            CFLPoint3(const CFLPoint3<float>& flp3);

            CFLPoint3(const CFLPoint3<double>* pFlp3);

            CFLPoint3(const CFLPoint3<float>* pFlp3);

            CFLPoint3(const Base::TPoint3<double>& tp3);

            CFLPoint3(const Base::TPoint3<float>& tp3);

            CFLPoint3(const Base::TPoint3<double>* pTp3);

            CFLPoint3(const Base::TPoint3<float>* pTp3);

            CFLPoint3(const CFLGeometry3DVector<double>& vec3);

            CFLPoint3(const CFLGeometry3DVector<float>& vec3);

            CFLPoint3(const CFLGeometry3DVector<double>* pVec3);

            CFLPoint3(const CFLGeometry3DVector<float>* pVec3);
 

            CFLPoint3(const CFLGeometry3DDirection<double>& dir);

            CFLPoint3(const CFLGeometry3DDirection<float>& dir);
 

            CFLPoint3(const CFLGeometry3DDirection<double>* pDir);

            CFLPoint3(const CFLGeometry3DDirection<float>* pDir);
 
            SupportToDuplicateObject(CFLPoint3<Ty>, *this);
            DeclareGetClassType();
 
 
        private:
            using CFLPoint<Ty>::GetDistance;
        };
 
        typedef CFLPoint3<float> CFLPoint3F;
        typedef CFLPoint3<double> CFLPoint3D;
    }
}