TPoint.h

#pragma once

 
#include <stdint.h>
#include <type_traits>
#include <typeinfo>
 
#include "FLLibTags.h"

namespace FLImaging
{
    namespace Base
    {
        #pragma pack(push, 1)
        template <typename T>
        class FL_EXPORT TPoint
        {
        public:
            T x;
            T y;
 
 
            TPoint()
            {
            }
 
            TPoint(const TPoint<int8_t>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<int8_t>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<uint8_t>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<uint8_t>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<int16_t>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<int16_t>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<uint16_t>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<uint16_t>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<int32_t>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<int32_t>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<uint32_t>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<uint32_t>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<int64_t>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<int64_t>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<uint64_t>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<uint64_t>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<float>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<float>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
            TPoint(const TPoint<double>& tp) : x((T)tp.x), y((T)tp.y)
            {
            }
 
            TPoint(const TPoint<double>* pTp) : x((T)pTp->x), y((T)pTp->y)
            {
            }
 
 
            TPoint(int8_t x, int8_t y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(uint8_t x, uint8_t y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(int16_t x, int16_t y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(uint16_t x, uint16_t y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(int32_t x, int32_t y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(uint32_t x, uint32_t y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(int64_t x, int64_t y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(uint64_t x, uint64_t y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(float x, float y) : x((T)x), y((T)y)
            {
            }
 
            TPoint(double x, double y) : x((T)x), y((T)y)
            {
            }
 
            void Set(const TPoint<int8_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<int8_t>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<uint8_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<uint8_t>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<int16_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<int16_t>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<uint16_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<uint16_t>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<int32_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<int32_t>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<uint32_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<uint32_t>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<int64_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<int64_t>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<uint64_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<uint64_t>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<float>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<float>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(const TPoint<double>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
            }
 
            void Set(const TPoint<double>* pTp)
            {
                x = (T)pTp->x;
                y = (T)pTp->y;
            }
 
            void Set(int8_t x, int8_t y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(uint8_t x, uint8_t y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(int16_t x, int16_t y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(uint16_t x, uint16_t y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(int32_t x, int32_t y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(uint32_t x, uint32_t y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(int64_t x, int64_t y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(uint64_t x, uint64_t y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(float x, float y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            void Set(double x, double y)
            {
                this->x = (T)x;
                this->y = (T)y;
            }
 
            const TPoint<T>& operator=(int32_t value)
            {
                x = y = (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator=(int64_t value)
            {
                x = y = (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator=(float value)
            {
                x = y = (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator=(double value)
            {
                x = y = (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator=(const TPoint<int32_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator=(const TPoint<int64_t>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator=(const TPoint<float>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator=(const TPoint<double>& tp)
            {
                x = (T)tp.x;
                y = (T)tp.y;
 
                return *this;
            }
 
            bool operator==(const TPoint<int32_t>& tp) const
            {
                return x == (T)tp.x && y == (T)tp.y;
            }
 
            bool operator==(const TPoint<int64_t>& tp) const
            {
                return x == (T)tp.x && y == (T)tp.y;
            }
 
            bool operator==(const TPoint<float>& tp) const
            {
                return x == (T)tp.x && y == (T)tp.y;
            }
 
            bool operator==(const TPoint<double>& tp) const
            {
                return x == (T)tp.x && y == (T)tp.y;
            }
 
            bool operator!=(const TPoint<int32_t>& tp) const
            {
                return x != (T)tp.x || y != (T)tp.y;
            }
 
            bool operator!=(const TPoint<int64_t>& tp) const
            {
                return x != (T)tp.x || y != (T)tp.y;
            }
 
            bool operator!=(const TPoint<float>& tp) const
            {
                return x != (T)tp.x || y != (T)tp.y;
            }
 
            bool operator!=(const TPoint<double>& tp) const
            {
                return x != (T)tp.x || y != (T)tp.y;
            }
 
            const TPoint<T>& operator+=(int32_t value)
            {
                x += (T)value;
                y += (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator+=(int64_t value)
            {
                x += (T)value;
                y += (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator+=(float value)
            {
                x += (T)value;
                y += (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator+=(double value)
            {
                x += (T)value;
                y += (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator+=(const TPoint<int32_t>& tp)
            {
                x += (T)tp.x;
                y += (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator+=(const TPoint<int64_t>& tp)
            {
                x += (T)tp.x;
                y += (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator+=(const TPoint<float>& tp)
            {
                x += (T)tp.x;
                y += (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator+=(const TPoint<double>& tp)
            {
                x += (T)tp.x;
                y += (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator-=(int32_t value)
            {
                x -= (T)value;
                y -= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator-=(int64_t value)
            {
                x -= (T)value;
                y -= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator-=(float value)
            {
                x -= (T)value;
                y -= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator-=(double value)
            {
                x -= (T)value;
                y -= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator-=(const TPoint<int32_t>& tp)
            {
                x -= (T)tp.x;
                y -= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator-=(const TPoint<int64_t>& tp)
            {
                x -= (T)tp.x;
                y -= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator-=(const TPoint<float>& tp)
            {
                x -= (T)tp.x;
                y -= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator-=(const TPoint<double>& tp)
            {
                x -= (T)tp.x;
                y -= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator*=(int32_t value)
            {
                x *= (T)value;
                y *= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator*=(int64_t value)
            {
                x *= (T)value;
                y *= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator*=(float value)
            {
                x *= (T)value;
                y *= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator*=(double value)
            {
                x *= (T)value;
                y *= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator*=(const TPoint<int32_t>& tp)
            {
                x *= (T)tp.x;
                y *= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator*=(const TPoint<int64_t>& tp)
            {
                x *= (T)tp.x;
                y *= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator*=(const TPoint<float>& tp)
            {
                x *= (T)tp.x;
                y *= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator*=(const TPoint<double>& tp)
            {
                x *= (T)tp.x;
                y *= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator/=(int32_t value)
            {
                x /= (T)value;
                y /= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator/=(int64_t value)
            {
                x /= (T)value;
                y /= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator/=(float value)
            {
                x /= (T)value;
                y /= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator/=(double value)
            {
                x /= (T)value;
                y /= (T)value;
 
                return *this;
            }
 
            const TPoint<T>& operator/=(const TPoint<int32_t>& tp)
            {
                x /= (T)tp.x;
                y /= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator/=(const TPoint<int64_t>& tp)
            {
                x /= (T)tp.x;
                y /= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator/=(const TPoint<float>& tp)
            {
                x /= (T)tp.x;
                y /= (T)tp.y;
 
                return *this;
            }
 
            const TPoint<T>& operator/=(const TPoint<double>& tp)
            {
                x /= (T)tp.x;
                y /= (T)tp.y;
 
                return *this;
            }
 
            TPoint<T> operator+(int32_t value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x + (T)value;
                tpReturn.y = y + (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator+(int64_t value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x + (T)value;
                tpReturn.y = y + (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator+(float value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x + (T)value;
                tpReturn.y = y + (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator+(double value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x + (T)value;
                tpReturn.y = y + (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator+(const TPoint<int32_t>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x + (T)tp.x;
                tpReturn.y = y + (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator+(const TPoint<int64_t>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x + (T)tp.x;
                tpReturn.y = y + (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator+(const TPoint<float>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x + (T)tp.x;
                tpReturn.y = y + (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator+(const TPoint<double>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x + (T)tp.x;
                tpReturn.y = y + (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator-(int32_t value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x - (T)value;
                tpReturn.y = y - (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator-(int64_t value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x - (T)value;
                tpReturn.y = y - (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator-(float value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x - (T)value;
                tpReturn.y = y - (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator-(double value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x - (T)value;
                tpReturn.y = y - (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator-(const TPoint<int32_t>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x - (T)tp.x;
                tpReturn.y = y - (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator-(const TPoint<int64_t>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x - (T)tp.x;
                tpReturn.y = y - (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator-(const TPoint<float>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x - (T)tp.x;
                tpReturn.y = y - (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator-(const TPoint<double>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x - (T)tp.x;
                tpReturn.y = y - (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator*(int32_t value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x * (T)value;
                tpReturn.y = y * (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator*(int64_t value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x * (T)value;
                tpReturn.y = y * (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator*(float value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x * (T)value;
                tpReturn.y = y * (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator*(double value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x * (T)value;
                tpReturn.y = y * (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator*(const TPoint<int32_t>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x * (T)tp.x;
                tpReturn.y = y * (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator*(const TPoint<int64_t>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x * (T)tp.x;
                tpReturn.y = y * (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator*(const TPoint<float>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x * (T)tp.x;
                tpReturn.y = y * (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator*(const TPoint<double>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x * (T)tp.x;
                tpReturn.y = y * (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator/(int32_t value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x / (T)value;
                tpReturn.y = y / (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator/(int64_t value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x / (T)value;
                tpReturn.y = y / (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator/(float value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x / (T)value;
                tpReturn.y = y / (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator/(double value) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x / (T)value;
                tpReturn.y = y / (T)value;
                return tpReturn;
            }
 
            TPoint<T> operator/(const TPoint<int32_t>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x / (T)tp.x;
                tpReturn.y = y / (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator/(const TPoint<int64_t>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x / (T)tp.x;
                tpReturn.y = y / (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator/(const TPoint<float>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x / (T)tp.x;
                tpReturn.y = y / (T)tp.y;
                return tpReturn;
            }
 
            TPoint<T> operator/(const TPoint<double>& tp) const
            {
                TPoint<T> tpReturn;
                tpReturn.x = x / (T)tp.x;
                tpReturn.y = y / (T)tp.y;
                return tpReturn;
            }
 
            friend TPoint<T> operator+(int32_t value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value + tp.x, (T)value + tp.y);
            }
            friend TPoint<T> operator+(int64_t value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value + tp.x, (T)value + tp.y);
            }
            friend TPoint<T> operator+(float value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value + tp.x, (T)value + tp.y);
            }
            friend TPoint<T> operator+(double value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value + tp.x, (T)value + tp.y);
            }
 
            friend TPoint<T> operator-(int32_t value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value - tp.x, (T)value - tp.y);
            }
            friend TPoint<T> operator-(int64_t value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value - tp.x, (T)value - tp.y);
            }
            friend TPoint<T> operator-(float value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value - tp.x, (T)value - tp.y);
            }
            friend TPoint<T> operator-(double value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value - tp.x, (T)value - tp.y);
            }
 
            friend TPoint<T> operator*(int32_t value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value * tp.x, (T)value * tp.y);
            }
            friend TPoint<T> operator*(int64_t value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value * tp.x, (T)value * tp.y);
            }
            friend TPoint<T> operator*(float value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value * tp.x, (T)value * tp.y);
            }
            friend TPoint<T> operator*(double value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value * tp.x, (T)value * tp.y);
            }
 
            friend TPoint<T> operator/(int32_t value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value / tp.x, (T)value / tp.y);
            }
            friend TPoint<T> operator/(int64_t value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value / tp.x, (T)value / tp.y);
            }
            friend TPoint<T> operator/(float value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value / tp.x, (T)value / tp.y);
            }
            friend TPoint<T> operator/(double value, const TPoint<T>& tp)
            {
                return TPoint<T>((T)value / tp.x, (T)value / tp.y);
            }
        };
        #pragma pack(pop)
 
        typedef TPoint<int8_t> TPointC;
        typedef TPoint<uint8_t> TPointUC;
        typedef TPoint<int16_t> TPointS;
        typedef TPoint<uint16_t> TPointUS;
        typedef TPoint<int32_t> TPointL;
        typedef TPoint<uint32_t> TPointUL;
        typedef TPoint<int64_t> TPointLL;
        typedef TPoint<uint64_t> TPointULL;
        typedef TPoint<float> TPointF;
        typedef TPoint<double> TPointD;
    }
}