FLPoint.h

#pragma once

 
#include "FLFigure.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLPoint : public CFLFigure
        {
        public:
            T x;

            T y;
 
            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;
 
 
            using CFLFigure::GetBoundaryRect;
            virtual const CResult GetBoundaryRect(double& left, double& top, double& right, double& bottom) const override;
 
            using CFLFigure::Offset;
            virtual const CResult Offset(double x, double y) override;
 
            using CFLFigure::Multiply;
            virtual const CResult Multiply(double f64MulX, double f64MulY) override;
 
            using CFLFigure::Scale;
            virtual const CResult Scale(double f64PivotX, double f64PivotY, double f64RatioX, double f64RatioY) override;
 
            using CFLFigure::Rotate;
            virtual const CResult Rotate(double f64Angle, double f64PivotX, double f64PivotY) override;
 
            using CFLFigure::GetCenter;
            virtual const CResult GetCenter(double& x, double& y) const override;
 
            using CFLFigure::GetCenterOfGravity;
            virtual const CResult GetCenterOfGravity(double& x, double& y) const override;
 
            using CFLFigure::Flip;
            virtual const CResult Flip(EFigureFlipDirection eDirection, double f64PivotX, double f64PivotY) override;
 
            using CFLFigure::Warp;
            virtual const CResult Warp(const CFLQuad<double>* pFlqSourceRegion, const CFLQuad<double>* pFlqTargetRegion, CFLFigureArray* pFlfaResult, EWarpingType eWarpingType = EWarpingType_Bilinear) const override;
            virtual const CResult Warp(const CFLPointArray* pFlpaSource, const CFLPointArray* pFlpaTarget, CFLFigureArray* pFlfaResult, EWarpingType eWarpingType = EWarpingType_Bicubic, int32_t i32Extension = 2) const override;
 
            using CFLFigure::Swap;
            virtual const CResult Swap(CFLFigure* pFlfRight) override;
 
            using CFLFigure::GetMinimumEnclosingRectangle;
            virtual const CResult GetMinimumEnclosingRectangle(CFLQuad<double>* pQuad) const override;
 
            using CFLFigure::GetMinimumDistance;
            using CFLFigure::GetMaximumDistance;
 
            using CFLFigure::GetPointsOfMinimumDistance;
            virtual const CResult GetPointsOfMinimumDistance(const CFLFigure* pFlfTarget, CFLPointArray* pFlpaResult) const override;
 
            using CFLFigure::GetPointsOfMaximumDistance;
            virtual const CResult GetPointsOfMaximumDistance(const CFLFigure* pFlfTarget, CFLPointArray* pFlpaResult) const override;
 
            using CFLFigure::GetRasterRegion;
            virtual const CResult GetRasterRegion(CFLFigureArray* pFlfaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TRect<int32_t>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TRect<int64_t>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TRect<float>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TRect<double>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TPoint3<int32_t>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
 
 
 
            virtual double GetWidth() const override;
            virtual double GetHeight() const override;
            virtual double GetArea() const override;
            virtual double GetAngle() const override;
            virtual double GetPerimeter() const override;
            virtual double GetLength() const override;
            virtual uint64_t GetVertexCountRecursive(EIncludingRegionType eType = EIncludingRegionType_All) const;
            virtual const CResult GetVertexCount(CFLFigureArray& flfaResult, EIncludingRegionType eType = EIncludingRegionType_All, bool bRecursive = true) const override;
            virtual const CResult GetVertexCount(CFLFigureArray* pFlfaResult, EIncludingRegionType eType = EIncludingRegionType_All, bool bRecursive = true) const override;
 
            virtual const CResult MeasureThickness(double& f64Thickness, double f64SamplingStep = 1.) const override;
            virtual const CResult MeasureThickness(double* pF64Thickness, double f64SamplingStep = 1.) const override;
 

            virtual EWindingDirection GetWindingDirection(double f64BeginPtX, double f64BeginPtY, double f64MidPtX, double f64MidPtY) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLPoint<int32_t>& flpBegin, const CFLPoint<int32_t>& flpMid) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLPoint<int32_t>* pFlpBegin, const CFLPoint<int32_t>* pFlpMid) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLPoint<int64_t>& flpBegin, const CFLPoint<int64_t>& flpMid) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLPoint<int64_t>* pFlpBegin, const CFLPoint<int64_t>* pFlpMid) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLPoint<float>& flpBegin, const CFLPoint<float>& flpMid) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLPoint<float>* pFlpBegin, const CFLPoint<float>* pFlpMid) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLPoint<double>& flpBegin, const CFLPoint<double>& flpMid) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLPoint<double>* pFlpBegin, const CFLPoint<double>* pFlpMid) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLLine<int32_t>& fllBegin) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLLine<int32_t>* pFllBegin) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLLine<int64_t>& fllBegin) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLLine<int64_t>* pFllBegin) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLLine<float>& fllBegin) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLLine<float>* pFllBegin) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLLine<double>& fllBegin) const sealed;

            virtual EWindingDirection GetWindingDirection(const CFLLine<double>* pFllBegin) const sealed;
 
 
 
            using CFLFigure::IsCollision;
            virtual bool IsCollision(const CFLPoint<double>* pPoint) const override;
            virtual bool IsCollision(const CFLLine<double>* pLine) const override;
            virtual bool IsCollision(const CFLRect<double>* pRect) const override;
            virtual bool IsCollision(const CFLRoundRect<double>* pRect) const override;
            virtual bool IsCollision(const CFLQuad<double>* pQuad) const override;
            virtual bool IsCollision(const CFLCircle<double>* pRect) const override;
            virtual bool IsCollision(const CFLEllipse<double>* pEll) const override;
            virtual bool IsCollision(const CFLDoughnut<double>* pDoughnut) const override;
            virtual bool IsCollision(const CFLCubicSpline* pFlcs) const override;
            virtual bool IsCollision(const CFLBezierCubicCurve* pFlbc3) const override;
            virtual bool IsCollision(const CFLBezierQuadraticCurve* pFlbc2) const override;
            virtual bool IsCollision(const CFLRegion* pFlrg) const override;
            virtual bool IsCollision(const CFLComplexRegion* pFlcr) const override;
            virtual bool IsCollision(const CFLFigureArray* pFlfa) const override;
            virtual bool IsCollision(const CFLPointArray* pFlpa) const override;
 
 

            virtual double GetDistance(const CFLPoint<int32_t>& point) const;

            virtual double GetDistance(const CFLPoint<int32_t>* pPoint) const;

            virtual double GetDistance(const CFLPoint<int64_t>& point) const;

            virtual double GetDistance(const CFLPoint<int64_t>* pPoint) const;

            virtual double GetDistance(const CFLPoint<float>& point) const;

            virtual double GetDistance(const CFLPoint<float>* pPoint) const;

            virtual double GetDistance(const CFLPoint<double>& point) const;

            virtual double GetDistance(const CFLPoint<double>* pPoint) const;

            virtual double GetOrthogonalDistance(const CFLLine<int32_t>& line) const sealed;

            virtual double GetOrthogonalDistance(const CFLLine<int32_t>* pLine) const sealed;

            virtual double GetOrthogonalDistance(const CFLLine<int64_t>& line) const sealed;

            virtual double GetOrthogonalDistance(const CFLLine<int64_t>* pLine) const sealed;

            virtual double GetOrthogonalDistance(const CFLLine<float>& line) const sealed;

            virtual double GetOrthogonalDistance(const CFLLine<float>* pLine) const sealed;

            virtual double GetOrthogonalDistance(const CFLLine<double>& line) const sealed;

            virtual double GetOrthogonalDistance(const CFLLine<double>* pLine) const sealed;

            virtual double GetAngle(const CFLPoint<int32_t>& point) const sealed;

            virtual double GetAngle(const CFLPoint<int32_t>* pPoint) const sealed;

            virtual double GetAngle(const CFLPoint<int64_t>& point) const sealed;

            virtual double GetAngle(const CFLPoint<int64_t>* pPoint) const sealed;

            virtual double GetAngle(const CFLPoint<float>& point) const sealed;

            virtual double GetAngle(const CFLPoint<float>* pPoint) const sealed;

            virtual double GetAngle(const CFLPoint<double>& point) const sealed;

            virtual double GetAngle(const CFLPoint<double>* pPoint) const sealed;

            virtual double GetInteriorAngle(const CFLPoint<int32_t>& firstPoint, const CFLPoint<int32_t>& thirdPoint) const sealed;

            virtual double GetInteriorAngle(const CFLPoint<int32_t>* pFirstPoint, const CFLPoint<int32_t>* pThirdPoint) const sealed;

            virtual double GetInteriorAngle(const CFLPoint<int64_t>& firstPoint, const CFLPoint<int64_t>& thirdPoint) const sealed;

            virtual double GetInteriorAngle(const CFLPoint<int64_t>* pFirstPoint, const CFLPoint<int64_t>* pThirdPoint) const sealed;

            virtual double GetInteriorAngle(const CFLPoint<float>& firstPoint, const CFLPoint<float>& thirdPoint) const sealed;

            virtual double GetInteriorAngle(const CFLPoint<float>* pFirstPoint, const CFLPoint<float>* pThirdPoint) const sealed;

            virtual double GetInteriorAngle(const CFLPoint<double>& firstPoint, const CFLPoint<double>& thirdPoint) const sealed;

            virtual double GetInteriorAngle(const CFLPoint<double>* pFirstPoint, const CFLPoint<double>* pThirdPoint) const sealed;

            virtual CFLPoint<double> GetCircumcenter(const CFLPoint<int32_t>& point1, const CFLPoint<int32_t>& point2) const sealed;

            virtual CFLPoint<double> GetCircumcenter(const CFLPoint<int32_t>* pPoint1, const CFLPoint<int32_t>* pPoint2) const sealed;

            virtual CFLPoint<double> GetCircumcenter(const CFLPoint<int64_t>& point1, const CFLPoint<int64_t>& point2) const sealed;

            virtual CFLPoint<double> GetCircumcenter(const CFLPoint<int64_t>* pPoint1, const CFLPoint<int64_t>* pPoint2) const sealed;

            virtual CFLPoint<double> GetCircumcenter(const CFLPoint<float>& point1, const CFLPoint<float>& point2) const sealed;

            virtual CFLPoint<double> GetCircumcenter(const CFLPoint<float>* pPoint1, const CFLPoint<float>* pPoint2) const sealed;

            virtual CFLPoint<double> GetCircumcenter(const CFLPoint<double>& point1, const CFLPoint<double>& point2) const sealed;

            virtual CFLPoint<double> GetCircumcenter(const CFLPoint<double>* pPoint1, const CFLPoint<double>* pPoint2) const sealed;

            virtual CFLPoint<double> GetUnitVector(const CFLPoint<int32_t>& flpTarget) const sealed;

            virtual CFLPoint<double> GetUnitVector(const CFLPoint<int32_t>* pFlpTarget) const sealed;

            virtual CFLPoint<double> GetUnitVector(const CFLPoint<int64_t>& flpTarget) const sealed;

            virtual CFLPoint<double> GetUnitVector(const CFLPoint<int64_t>* pFlpTarget) const sealed;

            virtual CFLPoint<double> GetUnitVector(const CFLPoint<float>& flpTarget) const sealed;

            virtual CFLPoint<double> GetUnitVector(const CFLPoint<float>* pFlpTarget) const sealed;

            virtual CFLPoint<double> GetUnitVector(const CFLPoint<double>& flpTarget) const sealed;

            virtual CFLPoint<double> GetUnitVector(const CFLPoint<double>* pFlpTarget) const sealed;

            virtual CFLPoint<double> GetNormalVector(const CFLPoint<int32_t>& flpTarget) const sealed;

            virtual CFLPoint<double> GetNormalVector(const CFLPoint<int32_t>* pFlpTarget) const sealed;

            virtual CFLPoint<double> GetNormalVector(const CFLPoint<int64_t>& flpTarget) const sealed;

            virtual CFLPoint<double> GetNormalVector(const CFLPoint<int64_t>* pFlpTarget) const sealed;

            virtual CFLPoint<double> GetNormalVector(const CFLPoint<float>& flpTarget) const sealed;

            virtual CFLPoint<double> GetNormalVector(const CFLPoint<float>* pFlpTarget) const sealed;

            virtual CFLPoint<double> GetNormalVector(const CFLPoint<double>& flpTarget) const sealed;

            virtual CFLPoint<double> GetNormalVector(const CFLPoint<double>* pFlpTarget) const sealed;

            virtual CFLFigureArray MakeCrossHair(double f64LineLength = 1., bool bDiagonal = false) const sealed;

            virtual const CResult MakeCrossHair(const CFLFigureArray& flfaResult, double f64LineLength = 1., bool bDiagonal = false) const sealed;

            virtual const CResult MakeCrossHair(CFLFigureArray* pFlfaResult, double f64LineLength = 1., bool bDiagonal = false) const sealed;
 
            virtual const CResult GetRasterContour(Base::CFLArray<Base::TPoint<int32_t>>* pFlaResult, bool bExcludeSingleDelta = false) const override;
            virtual const CResult GetRasterContour(CFLFigureArray* pFlfaResult, bool bExcludeSingleDelta = false) const override;
            virtual const CResult GetRasterContour(CFLPointArray* pFlpaResult, bool bExcludeSingleDelta = false) const override;
 
            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, CFLPointArray& flpaResult) const override;
            virtual const CResult GetSamplingPointsOnSegment(double f64SamplingDistance, CFLPointArray* pFlpaResult) const override;
 
            virtual const CResult GetSamplingVectorOnSegment(double f64SamplingDistance, CFLFigureArray& flfaResult) const override;
            virtual const CResult GetSamplingVectorOnSegment(double f64SamplingDistance, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetSamplingVectorOnSegment(double f64SamplingDistance, CFLPointArray& flpaResult) const override;
            virtual const CResult GetSamplingVectorOnSegment(double f64SamplingDistance, CFLPointArray* pFlpaResult) const override;
 
 
            virtual const CResult Set(const Base::CFLImage& fli) override;
            virtual const CResult Set(const Base::CFLImage* pFli) override;
            virtual const CResult Set(const Base::CFLImagePage& fli) override;
            virtual const CResult Set(const Base::CFLImagePage* pFli) override;
            virtual const CResult Set(const CFLFigure& flf) override;
            virtual const CResult Set(const CFLFigure* pFlf) override;

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

            virtual const CResult Set(int32_t x, int64_t y) sealed;

            virtual const CResult Set(int32_t x, float y) sealed;

            virtual const CResult Set(int32_t x, double y) sealed;

            virtual const CResult Set(int64_t x, int32_t y) sealed;

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

            virtual const CResult Set(int64_t x, float y) sealed;

            virtual const CResult Set(int64_t x, double y) sealed;

            virtual const CResult Set(float x, int32_t y) sealed;

            virtual const CResult Set(float x, int64_t y) sealed;

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

            virtual const CResult Set(float x, double y) sealed;

            virtual const CResult Set(double x, int32_t y) sealed;

            virtual const CResult Set(double x, int64_t y) sealed;

            virtual const CResult Set(double x, float y) sealed;

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

            virtual const CResult Set(const Base::TPoint<int32_t>& point) sealed;

            virtual const CResult Set(const Base::TPoint<int32_t>* pPoint) sealed;

            virtual const CResult Set(const Base::TPoint<int64_t>& point) sealed;

            virtual const CResult Set(const Base::TPoint<int64_t>* pPoint) sealed;

            virtual const CResult Set(const Base::TPoint<float>& point) sealed;

            virtual const CResult Set(const Base::TPoint<float>* pPoint) sealed;

            virtual const CResult Set(const Base::TPoint<double>& point) sealed;

            virtual const CResult Set(const Base::TPoint<double>* pPoint) sealed;

            virtual const CResult Set(const CFLPoint<int32_t>& point) sealed;

            virtual const CResult Set(const CFLPoint<int32_t>* pPoint) sealed;

            virtual const CResult Set(const CFLPoint<int64_t>& point) sealed;

            virtual const CResult Set(const CFLPoint<int64_t>* pPoint) sealed;

            virtual const CResult Set(const CFLPoint<float>& point) sealed;

            virtual const CResult Set(const CFLPoint<float>* pPoint) sealed;

            virtual const CResult Set(const CFLPoint<double>& point) sealed;

            virtual const CResult Set(const CFLPoint<double>* pPoint) sealed;

            virtual const CResult Set(const CFLFigureText<int32_t>& flft) sealed;

            virtual const CResult Set(const CFLFigureText<int32_t>* pFlft) sealed;

            virtual const CResult Set(const CFLFigureText<int64_t>& flft) sealed;

            virtual const CResult Set(const CFLFigureText<int64_t>* pFlft) sealed;

            virtual const CResult Set(const CFLFigureText<float>& flft) sealed;

            virtual const CResult Set(const CFLFigureText<float>* pFlft) sealed;

            virtual const CResult Set(const CFLFigureText<double>& flft) sealed;

            virtual const CResult Set(const CFLFigureText<double>* pFlft) sealed;
 

            CFLPoint();

            virtual ~CFLPoint();

            CFLPoint(const Base::CFLImage& fli);

            CFLPoint(const Base::CFLImage* pFli);

            CFLPoint(const Base::CFLImagePage& flip);

            CFLPoint(const Base::CFLImagePage* pFlip);

            // Copy constructor

            CFLPoint(int32_t x, int32_t y);

            CFLPoint(int32_t x, int64_t y);

            CFLPoint(int32_t x, float y);

            CFLPoint(int32_t x, double y);

            CFLPoint(int64_t x, int32_t y);

            CFLPoint(int64_t x, int64_t y);

            CFLPoint(int64_t x, float y);

            CFLPoint(int64_t x, double y);

            CFLPoint(float x, int32_t y);

            CFLPoint(float x, int64_t y);

            CFLPoint(float x, float y);

            CFLPoint(float x, double y);

            CFLPoint(double x, int32_t y);

            CFLPoint(double x, int64_t y);

            CFLPoint(double x, float y);

            CFLPoint(double x, double y);

            CFLPoint(const Base::TPoint<int32_t>& point);

            CFLPoint(const Base::TPoint<int32_t>* pPoint);

            CFLPoint(const Base::TPoint<int64_t>& point);

            CFLPoint(const Base::TPoint<int64_t>* pPoint);

            CFLPoint(const Base::TPoint<float>& point);

            CFLPoint(const Base::TPoint<float>* pPoint);

            CFLPoint(const Base::TPoint<double>& point);

            CFLPoint(const Base::TPoint<double>* pPoint);

            CFLPoint(const CFLFigure& flf);

            CFLPoint(const CFLFigure* pFlf);
 
            CFLPoint(const CFLPoint<T>& flpRhs);
            CFLPoint(const CFLPoint<T>* pFlpRhs);
 
            CFLPoint(const CFLFigureText<T>& flft);
            CFLPoint(const CFLFigureText<T>* pFlft);
 
            CFLPoint(int32_t x, int32_t y, const wchar_t* pWcsName);
            CFLPoint(int64_t x, int64_t y, const wchar_t* pWcsName);
            CFLPoint(float x, float y, const wchar_t* pWcsName);
            CFLPoint(double x, double  y, const wchar_t* pWcsName);

 

            // Assignment operator

            const CFLPoint<T>& operator=(const Base::TPoint<int32_t>& point);

            const CFLPoint<T>& operator=(const Base::TPoint<int64_t>& point);

            const CFLPoint<T>& operator=(const Base::TPoint<float>& point);

            const CFLPoint<T>& operator=(const Base::TPoint<double>& point);

            const CFLPoint<T>& operator=(const CFLFigure& flf);

            const CFLPoint<T>& operator=(const CFLPoint<T>& flp);

 

            // Comparison operator

            bool operator==(const Base::TPoint<int32_t>& point) const;

            bool operator==(const Base::TPoint<int64_t>& point) const;

            bool operator==(const Base::TPoint<float>& point) const;

            bool operator==(const Base::TPoint<double>& point) const;

            bool operator==(const CFLPoint<int32_t>& point) const;

            bool operator==(const CFLPoint<int64_t>& point) const;

            bool operator==(const CFLPoint<float>& point) const;

            bool operator==(const CFLPoint<double>& point) const;

            bool operator!=(const Base::TPoint<int32_t>& point) const;

            bool operator!=(const Base::TPoint<int64_t>& point) const;

            bool operator!=(const Base::TPoint<float>& point) const;

            bool operator!=(const Base::TPoint<double>& point) const;

            bool operator!=(const CFLPoint<int32_t>& point) const;

            bool operator!=(const CFLPoint<int64_t>& point) const;

            bool operator!=(const CFLPoint<float>& point) const;

            bool operator!=(const CFLPoint<double>& point) const;
 

            // Arithmetic and assignment operator

            const CFLPoint<T>& operator+=(const int32_t& value);

            const CFLPoint<T>& operator+=(const int64_t& value);

            const CFLPoint<T>& operator+=(const float& value);

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

            const CFLPoint<T>& operator+=(const Base::TPoint<int32_t>& point);

            const CFLPoint<T>& operator+=(const Base::TPoint<int64_t>& point);

            const CFLPoint<T>& operator+=(const Base::TPoint<float>& point);

            const CFLPoint<T>& operator+=(const Base::TPoint<double>& point);

            const CFLPoint<T>& operator+=(const CFLPoint<int32_t>& point);

            const CFLPoint<T>& operator+=(const CFLPoint<int64_t>& point);

            const CFLPoint<T>& operator+=(const CFLPoint<float>& point);

            const CFLPoint<T>& operator+=(const CFLPoint<double>& point);

            const CFLPoint<T>& operator-=(const int32_t& value);

            const CFLPoint<T>& operator-=(const int64_t& value);

            const CFLPoint<T>& operator-=(const float& value);

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

            const CFLPoint<T>& operator-=(const Base::TPoint<int32_t>& point);

            const CFLPoint<T>& operator-=(const Base::TPoint<int64_t>& point);

            const CFLPoint<T>& operator-=(const Base::TPoint<float>& point);

            const CFLPoint<T>& operator-=(const Base::TPoint<double>& point);

            const CFLPoint<T>& operator-=(const CFLPoint<int32_t>& point);

            const CFLPoint<T>& operator-=(const CFLPoint<int64_t>& point);

            const CFLPoint<T>& operator-=(const CFLPoint<float>& point);

            const CFLPoint<T>& operator-=(const CFLPoint<double>& point);

            const CFLPoint<T>& operator*=(const int32_t& value);

            const CFLPoint<T>& operator*=(const int64_t& value);

            const CFLPoint<T>& operator*=(const float& value);

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

            const CFLPoint<T>& operator*=(const Base::TPoint<int32_t>& point);

            const CFLPoint<T>& operator*=(const Base::TPoint<int64_t>& point);

            const CFLPoint<T>& operator*=(const Base::TPoint<float>& point);

            const CFLPoint<T>& operator*=(const Base::TPoint<double>& point);

            const CFLPoint<T>& operator*=(const CFLPoint<int32_t>& point);

            const CFLPoint<T>& operator*=(const CFLPoint<int64_t>& point);

            const CFLPoint<T>& operator*=(const CFLPoint<float>& point);

            const CFLPoint<T>& operator*=(const CFLPoint<double>& point);

            const CFLPoint<T>& operator/=(const int32_t& value);

            const CFLPoint<T>& operator/=(const int64_t& value);

            const CFLPoint<T>& operator/=(const float& value);

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

            const CFLPoint<T>& operator/=(const Base::TPoint<int32_t>& point);

            const CFLPoint<T>& operator/=(const Base::TPoint<int64_t>& point);

            const CFLPoint<T>& operator/=(const Base::TPoint<float>& point);

            const CFLPoint<T>& operator/=(const Base::TPoint<double>& point);

            const CFLPoint<T>& operator/=(const CFLPoint<int32_t>& point);

            const CFLPoint<T>& operator/=(const CFLPoint<int64_t>& point);

            const CFLPoint<T>& operator/=(const CFLPoint<float>& point);

            const CFLPoint<T>& operator/=(const CFLPoint<double>& point);
 

            // Arithmetic operator
            CFLPoint<double> operator+(const int32_t& value) const;

            CFLPoint<double> operator+(const int64_t& value) const;

            CFLPoint<double> operator+(const float& value) const;

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

            CFLPoint<double> operator+(const Base::TPoint<int32_t>& point) const;

            CFLPoint<double> operator+(const Base::TPoint<int64_t>& point) const;

            CFLPoint<double> operator+(const Base::TPoint<float>& point) const;

            CFLPoint<double> operator+(const Base::TPoint<double>& point) const;

            CFLPoint<double> operator+(const CFLPoint<int32_t>& point) const;

            CFLPoint<double> operator+(const CFLPoint<int64_t>& point) const;

            CFLPoint<double> operator+(const CFLPoint<float>& point) const;

            CFLPoint<double> operator+(const CFLPoint<double>& point) const;

            CFLPoint<double> operator-(const int32_t& value) const;

            CFLPoint<double> operator-(const int64_t& value) const;

            CFLPoint<double> operator-(const float& value) const;

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

            CFLPoint<double> operator-(const Base::TPoint<int32_t>& point) const;

            CFLPoint<double> operator-(const Base::TPoint<int64_t>& point) const;

            CFLPoint<double> operator-(const Base::TPoint<float>& point) const;

            CFLPoint<double> operator-(const Base::TPoint<double>& point) const;

            CFLPoint<double> operator-(const CFLPoint<int32_t>& point) const;

            CFLPoint<double> operator-(const CFLPoint<int64_t>& point) const;

            CFLPoint<double> operator-(const CFLPoint<float>& point) const;

            CFLPoint<double> operator-(const CFLPoint<double>& point) const;

            CFLPoint<double> operator*(const int32_t& value) const;

            CFLPoint<double> operator*(const int64_t& value) const;

            CFLPoint<double> operator*(const float& value) const;

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

            CFLPoint<double> operator*(const Base::TPoint<int32_t>& point) const;

            CFLPoint<double> operator*(const Base::TPoint<int64_t>& point) const;

            CFLPoint<double> operator*(const Base::TPoint<float>& point) const;

            CFLPoint<double> operator*(const Base::TPoint<double>& point) const;

            CFLPoint<double> operator*(const CFLPoint<int32_t>& point) const;

            CFLPoint<double> operator*(const CFLPoint<int64_t>& point) const;

            CFLPoint<double> operator*(const CFLPoint<float>& point) const;

            CFLPoint<double> operator*(const CFLPoint<double>& point) const;

            CFLPoint<double> operator/(const int32_t& value) const;

            CFLPoint<double> operator/(const int64_t& value) const;

            CFLPoint<double> operator/(const float& value) const;

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

            CFLPoint<double> operator/(const Base::TPoint<int32_t>& point) const;

            CFLPoint<double> operator/(const Base::TPoint<int64_t>& point) const;

            CFLPoint<double> operator/(const Base::TPoint<float>& point) const;

            CFLPoint<double> operator/(const Base::TPoint<double>& point) const;

            CFLPoint<double> operator/(const CFLPoint<int32_t>& point) const;

            CFLPoint<double> operator/(const CFLPoint<int64_t>& point) const;

            CFLPoint<double> operator/(const CFLPoint<float>& point) const;

            CFLPoint<double> operator/(const CFLPoint<double>& point) const;
 
            //Friend operator
            // Arithmetic operator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            friend CFLPoint<double> operator/(const double& value, const CFLPoint<T>& point)
            {
                CFLPoint<double> t((double)value / (double)point.x, (double)value / (double)point.y);
                return t;
            }
 
            operator Base::TPoint<int32_t>() const;
            operator Base::TRect<int32_t>() const;
 
 
 
            SupportToDuplicateObject(CFLPoint<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLPoint<int32_t> CFLPointL;
        typedef CFLPoint<int64_t> CFLPointLL;
        typedef CFLPoint<float> CFLPointF;
        typedef CFLPoint<double> CFLPointD;
    }
}