FLPoint3.h

#pragma once
 
#include "FLFigure3.h"
#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 CMatrix;
 
        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 CFLFigure3
        {
        public:
            Ty x;

            Ty y;

            Ty z;

            CFLPoint3();

            virtual ~CFLPoint3();

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

            virtual double GetMagnitude() const;

            virtual double GetSquareMagnitude() const;
 
            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 f64ScaleX, double f64ScaleY, double f64ScaleZ, double f64PivotX, double f64PivotY, double f64PivotZ) 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 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);
 
            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 Reflect(double pivotX, double pivotY, double pivotZ);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            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);

            virtual const CResult MatMul(const CMatrix<float>& mat4x4);

            virtual const CResult MatMul(const CMatrix<double>& mat4x4);

            virtual const CResult MatMul(const CMatrix<float>* pMat4x4);

            virtual const CResult MatMul(const CMatrix<double>* pMat4x4);

            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;

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

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

            virtual const CResult GetOrthogonalBasis(CFLPoint3<double>& flpU) const;

            virtual const CResult GetOrthogonalBasis(CFLPoint3<float>& flpU) const;

            virtual const CResult GetOrthogonalBasis(CFLPoint3<double>& flpU, CFLPoint3<double>& flpV) const;

            virtual const CResult GetOrthogonalBasis(CFLPoint3<float>& flpU, CFLPoint3<float>& flpV) const;

            virtual const CResult GetOrthogonalBasis(CFLPoint3<double>* pFlpU, CFLPoint3<double>* pFlpV = nullptr) const;

            virtual const CResult GetOrthogonalBasis(CFLPoint3<float>* pFlpU, CFLPoint3<float>* pFlpV = nullptr) 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 EFigureTemplateType GetTemplateType() 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;

            CFLPoint3<Ty> operator-() const;
 
            //Friend operator
            // Arithmetic operator

            friend CFLPoint3<double> operator+(const int32_t& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t += value;
                return t;
            }

            friend CFLPoint3<double> operator+(const int64_t& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t += value;
                return t;
            }

            friend CFLPoint3<double> operator+(const float& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t += value;
                return t;
            }

            friend CFLPoint3<double> operator+(const double& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t += value;
                return t;
            }

            friend CFLPoint3<double> operator-(const int32_t& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLPoint3<double> operator-(const int64_t& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLPoint3<double> operator-(const float& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLPoint3<double> operator-(const double& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLPoint3<double> operator*(const int32_t& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t *= value;
                return t;
            }

            friend CFLPoint3<double> operator*(const int64_t& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t *= value;
                return t;
            }

            friend CFLPoint3<double> operator*(const float& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t *= value;
                return t;
            }

            friend CFLPoint3<double> operator*(const double& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t(point);
                t *= value;
                return t;
            }

            friend CFLPoint3<double> operator/(const int32_t& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t((double)value / (double)point.x, (double)value / (double)point.y, (double)value / (double)point.z);
                return t;
            }

            friend CFLPoint3<double> operator/(const int64_t& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t((double)value / (double)point.x, (double)value / (double)point.y, (double)value / (double)point.z);
                return t;
            }

            friend CFLPoint3<double> operator/(const float& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t((double)value / (double)point.x, (double)value / (double)point.y, (double)value / (double)point.z);
                return t;
            }

            friend CFLPoint3<double> operator/(const double& value, const CFLPoint3<Ty>& point)
            {
                CFLPoint3<double> t((double)value / (double)point.x, (double)value / (double)point.y, (double)value / (double)point.z);
                return t;
            }

            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);
 
        protected:
            virtual CFLPoint<double> GetCenterOfGravity() const override;
 
            SupportToDuplicateObject(CFLPoint3<Ty>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLPoint3<float> CFLPoint3F;
        typedef CFLPoint3<double> CFLPoint3D;
    }
}