Rectangle.h

Go to the documentation of this file.

 
#pragma once
 
#include <iostream>
#include <string>
#include <sstream>
 
#include "../Types.h"
#include "Point.h"
#include "Size.h"
#include "Bounds.h"
 
namespace Gorgon { namespace Geometry {
 
    template <class T_>
    class basic_Rectangle {
    public:
        typedef T_ BaseType;
 
        
        basic_Rectangle() {}
 
        basic_Rectangle(const T_ &left, const T_ &top, const T_ &width, const T_ &height) : 
            X(left), Y(top), Width(width), Height(height)
        { }
 
        basic_Rectangle(const basic_Point<T_> &position, const basic_Size<T_> &size) : 
            X(position.X), Y(position.Y), Width(size.Width), Height(size.Height)
        { }
 
        basic_Rectangle(const T_ &left, const T_ &top, const basic_Size<T_> &size) : 
        X(left), Y(top), Width(size.Width), Height(size.Height)
        { }
            
        basic_Rectangle(const basic_Point<T_> &position, T_ width, T_ height) : 
            X(position.X), Y(position.Y), Width(width), Height(height)
        { }
        
        basic_Rectangle(const basic_Point<T_> &topleft, const basic_Point<T_> &bottomright) :
            X(topleft.X), Y(topleft.Y),
            Width(bottomright.X-topleft.X), Height(bottomright.Y-topleft.Y)
        { }
 
        template <class O_>
        basic_Rectangle(const basic_Rectangle<O_> &rect) : 
            X(T_(rect.X)), Y(T_(rect.Y)), Width(T_(rect.Width)), Height(T_(rect.Height))
        { }
 
        template <class O_>
        basic_Rectangle(const basic_Bounds<O_> &bounds) : X(T_(bounds.Left)), Y(T_(bounds.Top)), 
            Width(T_(bounds.Right-bounds.Left)), Height(T_(bounds.Bottom-bounds.Top))
        { }     
            
        explicit basic_Rectangle(const std::string &str) {
            auto s=str.begin();
            
            while(*s==' ' || *s=='\t') s++;
            
            if(*s=='<') s++;
            
            X=String::To<T_>(&str[s-str.begin()]);
            
            while(*s!=',' && s!=str.end()) s++;
            
            if(*s==',') s++;
            
            Y=String::To<T_>(&str[s-str.begin()]);
            
            while(*s!=' ' && s!=str.end()) s++;
            while(*s==' ' || *s=='\t') s++;
            
            Width=String::To<T_>(&str[s-str.begin()]);
            
            while(*s!='x' && s!=str.end()) s++;
            
            if(*s=='x') s++;
            
            Height=String::To<T_>(&str[s-str.begin()]);
        }
 
        static basic_Rectangle Parse(std::string s) {
            static char tospace[] = ",<>x";
 
            std::string::size_type pos;
            while((pos=s.find_first_of(tospace)) != std::string::npos) {
                s[pos]=' ';
            }
 
            basic_Rectangle ret;
 
            std::istringstream is(s);
            is>>ret.Left;
            is>>ret.Top;
            is>>ret.Width;
            is>>ret.Height;
 
            if(is.fail()) {
                throw std::runtime_error("Input string is not properly formatted");
            }
 
            return ret;
        }
 
        template <class O_>
        operator basic_Bounds<O_>() const {
            return{TopLeft(), GetSize()};
        }
        
        explicit operator std::string() const {
            std::string str;
            
            str.push_back('<');
            str += String::From(X);
            str.push_back(',');
            str += String::From(Y);
            str.push_back(' ');
            str += String::From(Width);
            str.push_back('x');
            str += String::From(Height);
            str.push_back('>');
            
            return str;
        }
 
        T_ Right() const { return Width +X; }
 
        T_ Bottom() const { return Height+Y;  }
 
        void SetRight(const T_ &right) { 
            if(right>X) 
                Width=right-X; 
            else {
                Width=X-right;
                X=right;
            }
        }
 
        void SetBottom(const T_ &bottom) {
            if(bottom>Y) 
                Height=bottom-Y; 
            else {
                Height=Y-bottom;
                Y=bottom;
            }
        }
 
        void Resize(const T_ &w, const T_ &h) { 
            Width=w;
            Height=h;
        }
 
        void Resize(const basic_Size<T_> &s) { 
            Width=s.Width;
            Height=s.Height;
        }
 
        void Move(const basic_Point<T_> &p) {
            X  = p.X;
            Y  = p.Y;
        }
        
        void Move(const T_ &x, const T_ &y) {
            X=x;
            Y=y;
        }
 
        basic_Point<T_> Center() const {
            return{X+Width/2, Y+Height/2};
        }
 
        basic_Point<T_> TopLeft() const {
            return{X, Y};
        }
 
        basic_Point<T_> TopRight() const {
            return{X+Width, Y};
        }
 
        basic_Point<T_> BottomLeft() const {
            return{X, Y+Height};
        }
 
        basic_Point<T_> BottomRight() const {
            return{X+Width, Y+Height};
        }
 
        basic_Size<T_> GetSize() const {
            return{Width, Height};
        }
 
        bool operator ==(const basic_Rectangle &r) const {
            return X==r.X && Y==r.Y && Width==r.Width && Height==r.Height;
        }
 
        bool operator !=(const basic_Rectangle &r) const {
            return X!=r.X || Y!=r.Y || Width!=r.Width || Height!=r.Height;
        }
 
        basic_Rectangle operator +(const basic_Point<T_> &amount) const {
            return{X+amount.X, Y+amount.Y, Width, Height};
        }
 
        basic_Rectangle operator +(const basic_Size<T_> &amount) const {
            return{X, Y, Width+amount.Width, Height+amount.Height};
        }
 
        basic_Rectangle operator -(const basic_Point<T_> &amount) const {
            return{X-amount.X, Y-amount.Y, Width, Height};
        }
 
        basic_Rectangle operator -(const basic_Size<T_> &amount) const {
            return{X, Y, Width-amount.Width, Height-amount.Height};
        }
        
        template<class O_>
        basic_Rectangle operator *(const basic_Size<O_> &amount) const {
            return {X, Y, T_(Width*amount.Width), T_(Height*amount.Height)};
        }
        
        template<class O_>
        basic_Rectangle operator /(const basic_Size<O_> &amount) const {
            return {X, Y, T_(Width/amount.Width), T_(Height/amount.Height)};
        }
        
        template<class O_>
        basic_Rectangle operator *(const O_ &amount) const {
            return {X, Y, Width*amount, Height*amount};
        }
        
        template<class O_>
        basic_Rectangle operator /(const O_ &amount) const {
            return {X, Y, Width/amount, Height/amount};
        }
 
        
        basic_Rectangle &operator +=(const basic_Point<T_> &amount) {
            X+=amount.X;
            Y+=amount.Y;
 
            return *this;
        }
 
        basic_Rectangle &operator +=(const basic_Size<T_> &amount) {
            Width +=amount.Width;
            Height+=amount.Height;
 
            return *this;
        }
 
        basic_Rectangle &operator -=(const basic_Point<T_> &amount) {
            X-=amount.X;
            Y -=amount.Y;
 
            return *this;
        }
 
        basic_Rectangle &operator -=(const basic_Size<T_> &amount) {
            Width -=amount.Width;
            Height-=amount.Height;
 
            return *this;
        }
        
        template<class O_>
        basic_Rectangle &operator *=(const basic_Size<O_> &amount) {
            Width  =T_(Width *amount.Width);
            Height =T_(Height*amount.Height);
 
            return *this;
        }
        
        template<class O_>
        basic_Rectangle &operator /=(const basic_Size<O_> &amount) {
            Width  =T_(Width /amount.Width);
            Height =T_(Height/amount.Height);
 
            return *this;
        }
        
        template<class O_>
        basic_Rectangle &operator *=(const O_ &amount) {
            Width  =T_(Width *amount);
            Height =T_(Height*amount);
 
            return *this;
        }
        
        template<class O_>
        basic_Rectangle &operator /=(const O_ &amount) {
            Width  =T_(Width /amount);
            Height =T_(Height/amount);
 
            return *this;
        }
 
        T_ X;
        
        T_ Y;
        
        T_ Width;
 
        T_ Height;
    };
 
    template <class T_>
    std::ostream &operator << (std::ostream &out, const basic_Rectangle<T_> &Rectangle) {
        out<<"<"<<Rectangle.X<<","<<Rectangle.Y<<" "<<Rectangle.Width<<"x"<<Rectangle.Height<<">";
 
        return out;
    }
    
    template <class T_>
    std::istream &operator >> (std::istream &in, basic_Rectangle<T_> &rect) {
        while(in.peek()==' ' || in.peek()=='<')
            in.ignore(1);
 
        std::string s;
        std::stringstream ss;
 
        while(in.peek()!=',' && !in.eof())
            s.append(1, (char)in.get());
 
        in.ignore(1);
 
        ss.str(s);
        ss>>rect.Left;
 
        s="";
 
        while(in.peek()==' ' || in.peek()=='\t')
            in.ignore(1);
 
        while(in.peek()!=',' && !in.eof())
            s.append(1, (char)in.get());
 
        in.ignore(1);
 
        ss.str(s);
        ss.clear();
        ss>>rect.Top;
 
        s="";
 
        while(in.peek()==' ' || in.peek()=='\t')
            in.ignore(1);
 
        while(in.peek()!=',' && in.peek()!='x' && !in.eof())
            s.append(1, (char)in.get());
 
        in.ignore(1);
 
        ss.str(s);
        ss.clear();
        ss>>rect.Width;
 
        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.append(1, in.get());
 
 
        ss.str(s);
        ss.clear();
        ss>>rect.Height;
 
        if(in.peek()=='>')
            in.ignore(1);
 
        return in;
    }
 
    template<class T_>
    bool IsInside(const basic_Rectangle<T_> &r, const basic_Point<T_> &p) {
        return p.X>=r.X && p.Y>=r.Y && p.X<r.Right() && p.Y<r.Bottom();
    }
 
    typedef basic_Rectangle<Float> Rectanglef;
 
    typedef basic_Rectangle<int> Rectangle;
 
} }