Point.h

Go to the documentation of this file.

 
#pragma once
 
#include <iostream>
#include <string>
#include <iomanip>
#include <limits>
#include <cmath>
#include <sstream>
#include <type_traits>
 
#include "../Types.h"
#include "../String.h"
 
namespace Gorgon {
    namespace Geometry {
 
        template <class T_>
        class basic_Point {
        public:
            typedef T_ BaseType;
            
            basic_Point() { }
 
            basic_Point(const T_ &X, const T_ &Y) : X(X), Y(Y) { }
 
            template <class O_>
            basic_Point(const basic_Point<O_> &point) : X((T_)point.X), Y((T_)point.Y) { }
            
            explicit basic_Point(const std::string &str) : X(0), Y(0) {
                T_ x = 0, y = 0;
                auto s=str.begin();
 
                if(s==str.end())
                    return;
 
                while(*s==' ' || *s=='\t') s++;
 
                if(s==str.end())
                    return;
 
                if(*s=='(') s++;
 
                if(s==str.end())
                    return;
 
                x=String::To<T_>(&str[s-str.begin()]);
                
                while(s!=str.end() && *s!=',') s++;
 
                if(s==str.end())
                    return;
                
                if(*s==',') s++;
 
                if(s==str.end())
                    return;
 
                y=String::To<T_>(&str[s-str.begin()]);
 
                X = x;
                Y = y;
            }
 
            template <class O_>
            basic_Point& operator =(const basic_Point<O_> &point) { 
                X=T_(point.X); 
                Y=T_(point.Y); 
                return *this; 
            }
            
            explicit operator std::string() const {
                std::string ret;
                ret.push_back('(');
                ret += String::From(X);
                ret.push_back(',');
                ret.push_back(' ');
                ret += String::From(Y);
                ret.push_back(')');
                
                return ret;
            }
 
            template <class O_>
            static basic_Point FromVector(Float magnitute, Float angle, const basic_Point<O_> &origin={0,0}) {
                return{T_(origin.X+magnitute*std::cos(angle)), T_(origin.Y+magnitute*std::sin(angle))};
            }
            
            static basic_Point Parse(const std::string &str, bool require_parenthesis=false) {
                basic_Point p;
                
                auto s=str.begin();
                
                size_t par=-1;
                
                while(s!=str.end() && (*s==' ' || *s=='\t')) s++;
                
                if(s!=str.end() && *s=='(') {
                    par=s-str.begin();
                    s++;
                }
                
                if(par==-1 && require_parenthesis) {
                    throw String::ParseError(110006, "Missing parenthesis");
                }
 
                if(s==str.end()) {
                    throw String::ParseError(110007, std::string("Missing operand"));
                }
                
                char *endptr;
                p.X = T_(strtod(&*s, &endptr));
                if(endptr==&*s) {
                    throw String::IllegalTokenError(0, 110001);
                }
                s+=endptr-&*s;
                
                while(s!=str.end() && (*s==' ' || *s=='\t')) s++;
                if(s==str.end() || *s!=',') {
                    throw String::IllegalTokenError(s-str.begin(), 111002, std::string("Illegal token: ")+*s);
                }
                s++;
                
 
                if(s==str.end()) {
                    throw String::ParseError(110007, std::string("Missing operand"));
                }
                p.Y=T_(strtod(&*s, &endptr));           
                if(endptr==&*s) {
                    throw String::IllegalTokenError(s-str.begin(), 111003);
                }
                s+=endptr-&*s;
 
                //eat white space + a single )
                while(s!=str.end() && (*s==' ' || *s=='\t')) s++;
                if(s!=str.end() && *s==')') {
                    if(par!=-1) {
                        s++;
                        par=-1;
                    }
                    else {
                        throw String::IllegalTokenError(s-str.begin(), 111005, "Unmatched parenthesis");
                    }
                }
                while(s!=str.end() && (*s==' ' || *s=='\t')) s++;
 
                if(s!=str.end()) {
                    throw String::IllegalTokenError(s-str.begin(), 111004, std::string("Illegal token: ")+*s);
                }
                
                if(par>0) {
                    throw String::IllegalTokenError(par, 111005, "Unmatched parenthesis");
                }
                
                return p;
            }
 
            basic_Point operator - (const basic_Point &point) const {
                return basic_Point(X-point.X, Y-point.Y);
            }
 
            basic_Point operator -() const {
                return{-X, -Y};
            }
 
            basic_Point operator + (const basic_Point &point) const {
                return{X+point.X, Y+point.Y};
            }
 
            template <class O_>
            basic_Point operator * (O_ value) const {
                return{T_(X*value), T_(Y*value)};
            }
 
            T_ operator *(const basic_Point<T_> &value) const {
                return X*value.X + Y*value.Y;
            }
 
            template <class O_>
            basic_Point operator / (O_ value) const {
                return{T_(X/value), T_(Y/value)};
            }
 
            basic_Point &operator -= (const basic_Point &point) {
                X-=point.X;
                Y-=point.Y;
 
                return *this;
            }
 
            basic_Point &operator += (const basic_Point &point) {
                X+=point.X;
                Y+=point.Y;
 
                return *this;
            }
 
            template <class O_>
            basic_Point &operator *= (O_ value) {
                X=T_(X*value);
                Y=T_(Y*value);
 
                return *this;
            }
 
            template <class O_>
            basic_Point &operator /= (O_ value) {
                X=T_(X/value);
                Y=T_(Y/value);
 
                return *this;
            }
 
            T_ CrossProduct(const basic_Point<T_> &value) const {
                return X*value.Y - Y*value.X;
            }
 
            T_ DotProduct(const basic_Point<T_> &value) const {
                return X*value.X + Y*value.Y;
            }
 
 
            Float Distance(const basic_Point &target) const {
                Float xdif = (Float)(X - target.X);
                Float ydif = (Float)(Y - target.Y);
                return std::sqrt((xdif*xdif) + (ydif*ydif));
            }
            Float EuclideanSquare(const basic_Point &target) const {
                Float xdif = (Float)(target.X - X);
                Float ydif = (Float)(target.Y - Y);
                return (xdif * xdif) + (ydif * ydif);
            }
            Float Distance() const {
                return std::sqrt( Float(X*X) + Float(Y*Y) );
            }
 
            Float EuclideanSquare() const {
                return Float(X * X) + Float(Y * Y);
            }
            Float ManhattanDistance(const basic_Point &target) const {
                return (Float)(std::abs(X-target.X) + std::abs(Y-target.Y));
            }
 
            Float ManhattanDistance() const {
                return (Float)(std::abs(X) + std::abs(Y));
            }
            
            basic_Point Normalize() const {
                return (*this)/Distance();
            }
            
            basic_Point Perpendicular() const {
                return {-Y, X};
            }
 
            Float Angle(const basic_Point &origin) const {
                return (Float)atan2(Y-origin.Y, X-origin.X);
            }
 
            Float Angle() const {
                return (Float)atan2(Y, X);
            }
 
            Float Slope(const basic_Point &point) const {
                return (Float)(Y-point.Y)/(X-point.X);
            }
 
            Float Slope() const {
                return (Float)Y/X;
            }
 
            bool Compare(const basic_Point &point) const {
                return X==point.X && Y==point.Y;
            }
 
            bool operator == (const basic_Point &point) const {
                return Compare(point);
            }
 
            bool operator !=(const basic_Point &point) const {
                return !Compare(point);
            }
 
            void Move(const T_ &x, const T_ &y) {
                X=x;
                Y=y;
            }
 
            union {
                struct {
                    T_ X;
                    
                    T_ Y;
                };
                
                T_ Vector[2];
            };
                
        };
 
        template <class T_>
        std::ostream &operator << (std::ostream &out, const basic_Point<T_> &point) {
            out<<"("<<point.X<<", "<<point.Y<<")";
 
            return out;
        }
 
 
        template <class T_>
        std::istream &operator >> (std::istream &in, basic_Point<T_> &point) {
            while(in.peek()==' ' || in.peek()=='\t')
                in.ignore(1);
            
            bool par=false;
            if(in.peek()=='(') {
                par=true;
                in.ignore(1);
            }
 
            std::string s;
 
            while(in.peek()!=',' && !in.eof())
                s.push_back((char)in.get());
 
            if(in.eof()) {
                in.setstate(in.failbit);
                return in;
            }
            in.ignore(1);
 
            auto x = String::To<T_>(s);
 
            s="";
 
            while(in.peek()==' ' || in.peek()=='\t')
                in.ignore(1);
 
            while(in.peek()!=')' && in.peek()!=' ' && in.peek()!='\t' && in.peek()!='\n' && in.peek()!='\r' && !in.eof())
                s.push_back(in.get());
            
            if(in.bad()) return in;
 
            point.X = x;
            point.Y = String::To<T_>(s);
 
            if(par) {
                while(in.peek()==' ' || in.peek()=='\t')
                in.ignore(1);
            }
            
            if(in.peek()==')')
                in.ignore(1);
 
            return in;
        }
 
 
        template<class T_, class O_>
        void Translate(basic_Point<T_> &point, O_ x, O_ y) {
            point.X=T_(point.X+x);
            point.Y=T_(point.Y+y);
        }
 
        template<class T_>
        void Translate(basic_Point<T_> &point, const basic_Point<T_> &other) {
            point.X+=other.X;
            point.Y+=other.Y;
        }
 
        template <class T_, class O_>
        void Scale(basic_Point<T_> &point, const O_ &size) {
            point.X = T_(point.X*size);
            point.Y = T_(point.Y*size);
        }
 
        template <class T_, class O1_, class O2_>
        void Scale(basic_Point<T_> &point, const O1_ &sizex, const O2_ &sizey) {
            point.X = T_(point.X*sizex);
            point.Y = T_(point.Y*sizey);
        }
 
        template <class T_, class O_>
        void Scale(basic_Point<T_> &point, const O_ &size, const basic_Point<T_> &origin) {
            point.X = T_((point.X-origin.X)*size+origin.X);
            point.Y = T_((point.Y-origin.Y)*size+origin.Y);
        }
 
        template <class T_, class O1_, class O2_>
        void Scale(basic_Point<T_> &point, const O1_ &sizex, const O2_ &sizey, const basic_Point<T_> &origin) {
            point.X = T_((point.X-origin.X)*sizex+origin.X);
            point.Y = T_((point.Y-origin.Y)*sizey+origin.Y);
        }
 
 
        template<class T_>
        void Rotate(basic_Point<T_> &point, Float angle) {
            T_ new_x;
            Float cosa=std::cos(angle), sina=std::sin(angle);
            new_x       = T_(point.X*cosa - point.Y*sina);
            point.Y     = T_(point.X*sina + point.Y*cosa);
 
            point.X     = new_x;
        }
 
        template<class T_>
        void Rotate(basic_Point<T_> &point, Float angle, const basic_Point<T_> &origin) {
            Float cosa=std::cos(angle), sina=std::sin(angle);
 
            basic_Point<T_> temp=point-origin;
 
            point.X   = T_(temp.X*cosa - temp.Y*sina);
            point.Y   = T_(temp.X*sina + temp.Y*cosa);
 
            point += origin;
        }
 
        template <class T_, class O_>
        void SkewX(basic_Point<T_> &point, const O_ &rate) {
            point.X += T_(point.Y*rate);
        }
 
        template <class T_, class O_>
        void SkewY(basic_Point<T_> &point, const O_ &rate) {
            point.Y += T_(point.X*rate);
        }
 
        template <class T_, class O_>
        void SkewX(basic_Point<T_> &point, const O_ &rate, const basic_Point<T_> &origin) {
            point.X += T_((point.Y-origin.Y)*rate);
        }
 
        template <class T_, class O_>
        void SkewY(basic_Point<T_> &point, const O_ &rate, const basic_Point<T_> &origin) {
            point.Y += T_((point.X-origin.X)*rate);
        }
 
        template<class T_>
        void ReflectX(basic_Point<T_> &point) {
            point.Y = -point.Y;
        }
 
        template<class T_>
        void ReflectY(basic_Point<T_> &point) {
            point.X = -point.X;
        }
 
        template<class T_>
        void HorizontalMirror(basic_Point<T_> &point) {
            ReflectX(point);
        }
 
        template<class T_>
        void VerticalMirror(basic_Point<T_> &point) {
            ReflectY(point);
        }
 
        template<class T_>
        void ReflectX(basic_Point<T_> &point, const basic_Point<T_> &origin) {
            point.Y = -point.Y+origin.Y*2;
        }
 
        template<class T_>
        void ReflectY(basic_Point<T_> &point, const basic_Point<T_> &origin) {
            point.X = -point.X+origin.X*2;
        }
 
        template<class T_>
        void HorizontalMirror(basic_Point<T_> &point, const basic_Point<T_> &origin) {
            ReflectX(point, origin);
        }
 
        template<class T_>
        void VerticalMirror(basic_Point<T_> &point, const basic_Point<T_> &origin) {
            ReflectY(point, origin);
        }
 
        using Point = basic_Point<int>;
 
        using Pointf = basic_Point<Float>;
 
        inline Pointf Round(Pointf num) {
            return{
                std::floor(num.X+Float(0.5)), 
                std::floor(num.Y+Float(0.5))
            };
        }
 
    } 
}