Bounds.h

Go to the documentation of this file.

 
#pragma once
 
#include <iostream>
#include <ostream>
#include <string>
#include <iomanip>
#include <limits>
#include <sstream>
 
#include "Point.h"
#include "Size.h"
#include "../String.h"
 
 
namespace Gorgon { namespace Geometry {
 
    template <class T_>
    class basic_Bounds {
    public:
        typedef T_ BaseType;
        
        basic_Bounds() { }
 
        basic_Bounds(const T_ &left, const T_ &top, const T_ &right, const T_ &bottom) : Left(left), Top(top), 
        Right(right), Bottom(bottom) {
            Normalize();
        }
 
        basic_Bounds(const basic_Point<T_> &topleft, const basic_Point<T_> &bottomright) : Left(topleft.X), Top(topleft.Y), 
        Right(bottomright.X), Bottom(bottomright.Y) {
            Normalize();
        }
 
        basic_Bounds(const basic_Point<T_> &topleft, const basic_Size<T_> &size) : Left(topleft.X), Top(topleft.Y), 
        Right(topleft.X+size.Width), Bottom(topleft.Y+size.Height) {
            Normalize();
        }
 
        basic_Bounds(const T_ &left, const T_ &top, const basic_Size<T_> &size) : Left(left), Top(top),
        Right(TopLeft().X+size.Width), Bottom(TopLeft().Y+size.Height) {
            Normalize();
        }
 
        basic_Bounds(const basic_Point<T_> &topleft, const T_ &width, const T_ &height) :
        Left(topleft.X), Top(topleft.Y), Right(topleft.X+width), Bottom(topleft.Y+height) {
            Normalize();
        }
 
        template<class O_>
        explicit basic_Bounds(const basic_Bounds<O_> &r) : Left((T_)r.Left), Top((T_)r.Top), 
        Right((T_)r.Right), Bottom((T_)r.Bottom) {
        }
        
        explicit basic_Bounds(const std::string &str) {
            auto s=str.begin();
            
            while(s!=str.end() && *s==' ')
                s++;
            
            //todo finish parsing....
        }
        
        explicit operator std::string() const {
            return std::string("[")+String::From(Left)+" - "+String::From(Right)+", "+String::From(Top)+" - "+String::From(Bottom)+"]";
        }
 
        bool operator ==(const basic_Bounds &other) const {
            return Left==other.Left && Right==other.Right && Top==other.Top && Bottom==other.Bottom;
        }
 
        bool operator !=(const basic_Bounds &other) {
            return !this->operator==(other);
        }
 
        void Normalize() {
            using std::swap;
            
            if(Left>Right) swap(Left,Right);
            if(Top>Bottom) swap(Top,Bottom);
        }
 
        basic_Point<T_> TopLeft() const {
            return{Left, Top};
        }
 
        basic_Point<T_> TopRight() const {
            return{Right, Top};
        }
 
        basic_Point<T_> Center() const {
            return{Left+Width()/2, Top+Height()/2};
        }
 
        basic_Point<T_> BottomLeft() const {
            return{Left, Bottom};
        }
 
        basic_Point<T_> BottomRight() const {
            return{Right, Bottom};
        }
 
        T_ Width() const { 
            return Right-Left;
        }
 
        T_ Height() const { 
            return Bottom-Top;
        }
 
 
        basic_Size<T_> GetSize() const {
            return{Width(), Height()};
        }
        
        void Resize(const basic_Size<T_> &size) {
            Right  = Left+size.Width;
            Bottom = Top +size.Height;
        }
 
        basic_Bounds operator |(const basic_Bounds &r) const {
            return{
                Left  < r.Left  ? Left  : r.Left,
                Top   < r.Top   ? Top   : r.Top,
                Right > r.Right ? Right : r.Right,
                Bottom> r.Bottom? Bottom: r.Bottom
            };
        }
 
        basic_Bounds operator &(const basic_Bounds &r) const {
            basic_Bounds<T_> b;
            Left  = Left  > Left  ? Left  : r.Left;
            Top   = Top   > Top   ? Top   : r.Top;
            Right = Right < Right ? Right : r.Right;
            Bottom= Bottom< Bottom? Bottom: r.Bottom;
 
            if(Left>Right || Top>Bottom) {
                return{0, 0, 0, 0};
            }
 
            return b;
        }
 
        basic_Bounds &operator |=(const basic_Bounds &b) const {
            Left  =Left  < b.Left  ? Left  : b.Left  ;
            Top   =Top   < b.Top   ? Top   : b.Top   ;
            Right =Right > b.Right ? Right : b.Right ;
            Bottom=Bottom> b.Bottom? Bottom: b.Bottom;
 
            return *this;
        }
 
        basic_Bounds &operator &=(const basic_Bounds &b) const {
            Left  =Left  > b.Left  ? Left  : b.Left  ;
            Top   =Top   > b.Top   ? Top   : b.Top   ;
            Right =Right < b.Right ? Right : b.Right ;
            Bottom=Bottom< b.Bottom? Bottom: b.Bottom;
 
            return *this;
        }
 
        void SetWidth(const T_ &width) {
            Right = Left + width;
        }
 
        void SetHeight(const T_ &height) {
            Bottom= Top  + height;
        }
 
        void Move(const basic_Point<T_> &p) {
            Right = (Right-Left)+p.X    ;
            Bottom= (Bottom-Top)+p.Y    ;
            Left  = p.X ;
            Top   = p.Y ;
        }
        
        void Move(const T_ &x, const T_ &y) {
            Right = (Right-Left)+x  ;
            Bottom= (Bottom-Top)+y  ;
            Left  = x;
            Top   = y;
        }
 
        basic_Bounds operator +(const basic_Point<T_> &p) const {
            return{
                Left   + p.X,
                Top    + p.Y,
                Right  + p.X,
                Bottom + p.Y
            };
        }
 
        basic_Bounds operator -(const basic_Point<T_> &p) const {
            return{
                Left   - p.X,
                Top    - p.Y,
                Right  - p.X,
                Bottom - p.Y
            };
        }
 
        basic_Bounds operator +(const basic_Size<T_> &s) const {
            return{
                Left             ,
                Top              ,
                Right  + s.Width ,
                Bottom + s.Height
            };
        }
 
        basic_Bounds operator -(const basic_Size<T_> &s) const {
            return{
                Left             ,
                Top              ,
                Right  - s.Width ,
                Bottom - s.Height
            };
        }
 
        template<class O_>
        basic_Bounds operator *(const basic_Size<O_> &s) {
            return{
                T_(Left   * s.Width),
                T_(Top    * s.Height),
                T_(Right  * s.Width),
                T_(Bottom * s.Height)
            };
        }
 
        template<class O_>
        basic_Bounds operator /(const basic_Size<O_> &s) {
            return{
                T_(Left   / s.Width),
                T_(Top    / s.Height),
                T_(Right  / s.Width),
                T_(Bottom / s.Height)
            };
        }
 
        template<class O_>
        basic_Bounds operator *(const O_ &s) {
            return{
                T_(Left   * s),
                T_(Top    * s),
                T_(Right  * s),
                T_(Bottom * s)
            };
        }
 
        template<class O_>
        basic_Bounds operator /(const O_ &s) {
            return{
                T_(Left   / s),
                T_(Top    / s),
                T_(Right  / s),
                T_(Bottom / s)
            };
        }
 
        basic_Bounds &operator +=(const basic_Point<T_> &p) {
            Left   += p.X;
            Top    += p.Y;
            Right  += p.X;
            Bottom += p.Y;
 
            return *this;
        }
 
        basic_Bounds &operator -=(const basic_Point<T_> &p) {
            Left   -= p.X;
            Top    -= p.Y;
            Right  -= p.X;
            Bottom -= p.Y;
 
            return *this;
        }
 
        basic_Bounds &operator +=(const basic_Size<T_> &s) {
            Right  += s.Width;
            Bottom += s.Height;
 
            return *this;
        }
 
        basic_Bounds &operator -=(const basic_Size<T_> &s) {
            Right  -= s.Width;
            Bottom -= s.Height;
 
            return *this;
        }
        
        template<class O_>
        basic_Bounds &operator *=(const basic_Size<O_> &s) {
            Left   = Left  *s.Width;
            Top    = Top   *s.Height;
            Right  = Right *s.Width;
            Bottom = Bottom*s.Height;
 
            return *this;
        }
 
        template<class O_>
        basic_Bounds &operator /=(const basic_Size<O_> &s) {
            Left   = Left  /s.Width;
            Top    = Top   /s.Height;
            Right  = Right /s.Width;
            Bottom = Bottom/s.Height;
 
            return *this;
        }
 
        template<class O_>
        basic_Bounds &operator *=(const O_ &s) {
            Left   = Left  *s;
            Top    = Top   *s;
            Right  = Right *s;
            Bottom = Bottom*s;
 
            return *this;
        }
 
        template<class O_>
        basic_Bounds &operator /=(const O_ &s) {
            Left   = Left  /s;
            Top    = Top   /s;
            Right  = Right /s;
            Bottom = Bottom/s;
 
            return *this;
        }
 
        T_ Left;
 
        T_ Top;
 
        T_ Right;
 
        T_ Bottom;
    };
 
 
    template <class T_>
    std::ostream &operator << (std::ostream &out, const basic_Bounds<T_> &bounds) {
        out<<"[("<<bounds.Left<<", "<<bounds.Top<<") - ("<<bounds.Right<<", "<<bounds.Bottom<<")]";
 
        return out;
    }
 
    template <class T_>
    std::istream &operator >> (std::istream &in, basic_Bounds<T_> &bounds) {
        while(in.peek()==' ')
            in.ignore(1);
        
        bool par=false;
        
        if(in.peek()=='[') {
            in.ignore(1);
            par = true;
        }
        
        decltype(bounds.TopLeft()) tl, br;
        
        in>>tl;
        
        while(in.peek()==' ')
            in.ignore(1);
        
        if(in.peek()=='-') {
            in.ignore(1);
        }
        
        in>>br;
        
        if(in.bad()) return in;
        
        bounds.Top   =tl.Y;
        bounds.Left  =tl.X;
        bounds.Bottom=br.Y;
        bounds.Right =br.X;
        
        
        if(par) {
            while(in.peek()==' ') {
                in.ignore(1);
            }
        }
 
        if(in.peek()==']')
            in.ignore(1);
 
        return in;
    }
 
    template <class T_>
    basic_Bounds<T_> Intersect(const basic_Bounds<T_> &l, const basic_Bounds<T_> &r) {
        basic_Bounds<T_> b;
        b.Left  = l.Left  > l.Left  ? l.Left  : r.Left;
        b.Top   = l.Top   > l.Top   ? l.Top   : r.Top;
        b.Right = l.Right < l.Right ? l.Right : r.Right;
        b.Bottom= l.Bottom< l.Bottom? l.Bottom: r.Bottom;
 
        if(b.Left>b.Right || b.Top>b.Bottom) {
            return basic_Bounds<T_>(0,0,0,0);
        }
 
        return b;
    }
 
    template <class T_>
    basic_Bounds<T_> Union(const basic_Bounds<T_> &l, const basic_Bounds<T_> &r) {
        return{
            l.Left  < r.Left  ? l.Left  : r.Left  , 
            l.Top   < r.Top   ? l.Top   : r.Top   , 
            l.Right > r.Right ? l.Right : r.Right , 
            l.Bottom> r.Bottom? l.Bottom: r.Bottom
        };
    }
 
    template <class T_>
    bool IsColliding(const basic_Bounds<T_> &l, const basic_Bounds<T_> &r) {
        // check disjunction x-coordinates
        if(l.Left  > r.Right) return false;
        if(l.Right < r.Left) return false;
 
        // check disjunction on y-coordinates
        if(l.Top    > r.Bottom) return false;
        if(l.Bottom < r.Top) return false;
 
        return true;
    }
 
    template<class T_>
    bool IsInside(const basic_Bounds<T_> &b, const basic_Point<T_> &p) {
        return p.X>=b.Left && p.Y>=b.Top && p.X<b.Right && p.Y<b.Bottom;
    }
 
    template<class T_>
    bool Contains(const basic_Bounds<T_> &outer, const basic_Bounds<T_> &inner) {
        return inner.Left >= outer.Left && inner.Top >= outer.Top && inner.Right <= outer.Right && inner.Bottom <= outer.Bottom;
    }
 
    template<class T_, class O_>
    void Translate(basic_Bounds<T_> &bounds, O_ x, O_ y) {
        bounds.Left  += x;
        bounds.Right += x;
        bounds.Top   += y;
        bounds.Bottom+= y;
    }
 
    template<class T_>
    void Translate(basic_Bounds<T_> &bounds, const basic_Point<T_> &other) {
        bounds.Left  += other.X;
        bounds.Right += other.X;
        bounds.Top   += other.Y;
        bounds.Bottom+= other.Y;
    }
 
    template <class T_, class O_>
    void Scale(basic_Bounds<T_> &bounds, const O_ &size) {
        Float xc = ( bounds.Left + bounds.Right ) / Float(2);
        Float yc = ( bounds.Top  + bounds.Bottom) / Float(2);
 
        bounds.Left  = T_( (bounds.Left  - xc)*size + xc );
        bounds.Right = T_( (bounds.Right - xc)*size + xc );
        bounds.Top   = T_( (bounds.Top   - yc)*size + yc );
        bounds.Left  = T_( (bounds.Left  - yc)*size + yc );
    }
 
    template <class T_, class O_>
    void Scale(basic_Bounds<T_> &bounds, const O_ &sizex, const O_ &sizey) {
        Float xc = ( bounds.Left + bounds.Right ) / Float(2);
        Float yc = ( bounds.Top  + bounds.Bottom) / Float(2);
 
        bounds.Left  = T_( (bounds.Left  - xc)*sizex + xc );
        bounds.Right = T_( (bounds.Right - xc)*sizex + xc );
        bounds.Top   = T_( (bounds.Top   - yc)*sizey + yc );
        bounds.Left  = T_( (bounds.Left  - yc)*sizey + yc );
    }
 
    template <class T_, class O_>
    void Scale(basic_Bounds<T_> &bounds, const basic_Size<O_> &size) {
        Float xc = ( bounds.Left + bounds.Right ) / Float(2);
        Float yc = ( bounds.Top  + bounds.Bottom) / Float(2);
 
        bounds.Left  = T_( (bounds.Left  - xc)*size.Width  + xc );
        bounds.Right = T_( (bounds.Right - xc)*size.Width  + xc );
        bounds.Top   = T_( (bounds.Top   - yc)*size.Height + yc );
        bounds.Left  = T_( (bounds.Left  - yc)*size.Height + yc );
    }
 
    template <class T_, class O_>
    void Scale(basic_Bounds<T_> &bounds, const O_ &size, const basic_Point<T_> &origin) {
        bounds.Left  = T_( (bounds.Left  - origin.X)*size + origin.X );
        bounds.Right = T_( (bounds.Right - origin.X)*size + origin.X );
        bounds.Top   = T_( (bounds.Top   - origin.Y)*size + origin.Y );
        bounds.Left  = T_( (bounds.Left  - origin.Y)*size + origin.Y );
    }
 
    template <class T_, class O_>
    void Scale(basic_Bounds<T_> &bounds, const O_ &sizex, const O_ &sizey, const basic_Point<T_> &origin) {
        bounds.Left  = T_( (bounds.Left  - origin.X)*sizex + origin.X );
        bounds.Right = T_( (bounds.Right - origin.X)*sizex + origin.X );
        bounds.Top   = T_( (bounds.Top   - origin.Y)*sizey + origin.Y );
        bounds.Left  = T_( (bounds.Left  - origin.Y)*sizey + origin.Y );
    }
 
    template <class T_, class O_>
    void Scale(basic_Bounds<T_> &bounds, const basic_Size<O_> &size, const basic_Point<T_> &origin) {
        bounds.Left  = T_( (bounds.Left  - origin.X)*size.Width  + origin.X );
        bounds.Right = T_( (bounds.Right - origin.X)*size.Width  + origin.X );
        bounds.Top   = T_( (bounds.Top   - origin.Y)*size.Height + origin.Y );
        bounds.Left  = T_( (bounds.Left  - origin.Y)*size.Height + origin.Y );
    }
 
 
    template<class T_>
    void Rotate(basic_Bounds<T_> &bounds, Float angle) {
        basic_Point<T_> cn = bounds.Center();
        basic_Point<T_> tl = bounds.TopLeft();
        basic_Point<T_> tr = bounds.TopRight();
        basic_Point<T_> bl = bounds.BottomLeft();
        basic_Point<T_> br = bounds.BottomRight();
 
        Rotate(tl, angle, cn);
        Rotate(tr, angle, cn);
        Rotate(bl, angle, cn);
        Rotate(br, angle, cn);
 
        bounds.Left  = std::min( std::min(tl.X, tr.X) , std::min(bl.X, br.X) );
        bounds.Right = std::max( std::max(tl.X, tr.X) , std::max(bl.X, br.X) );
        bounds.Top   = std::min( std::min(tl.Y, tr.Y) , std::min(bl.Y, br.Y) );
        bounds.Bottom= std::max( std::max(tl.Y, tr.Y) , std::max(bl.Y, br.Y) );
    }
 
    template<class T_>
    void Rotate(basic_Bounds<T_> &bounds, Float angle, const basic_Point<T_> &origin) {
        basic_Point<T_> tl = bounds.TopLeft();
        basic_Point<T_> tr = bounds.TopRight();
        basic_Point<T_> bl = bounds.BottomLeft();
        basic_Point<T_> br = bounds.BottomRight();
 
        Rotate(tl, angle, origin);
        Rotate(tr, angle, origin);
        Rotate(bl, angle, origin);
        Rotate(br, angle, origin);
 
        bounds.Left  = std::min( std::min(tl.X, tr.X) , std::min(bl.X, br.X) );
        bounds.Right = std::max( std::max(tl.X, tr.X) , std::max(bl.X, br.X) );
        bounds.Top   = std::min( std::min(tl.Y, tr.Y) , std::min(bl.Y, br.Y) );
        bounds.Bottom= std::max( std::max(tl.Y, tr.Y) , std::max(bl.Y, br.Y) );
    }
 
    template <class T_, class O_>
    void SkewX(basic_Bounds<T_> &bounds, const O_ &rate) {
        Float yc = ( bounds.Top  + bounds.Bottom) / Float(2);
 
        if(rate>0) {
            bounds.Left  = T_( bounds.Left  + (bounds.Top   -yc)*rate );
            bounds.Right = T_( bounds.Right + (bounds.Bottom-yc)*rate );
        }
        else {
            bounds.Left  = T_( bounds.Left  + (bounds.Bottom-yc)*rate );
            bounds.Right = T_( bounds.Right + (bounds.Top   -yc)*rate );
        }
    }
 
    template <class T_, class O_>
    void SkewY(basic_Bounds<T_> &bounds, const O_ &rate) {
        Float xc = ( bounds.Left + bounds.Right ) / Float(2);
 
        if(rate>0) {
            bounds.Top   = T_( bounds.Top   + (bounds.Left  -xc)*rate );
            bounds.Bottom= T_( bounds.Bottom+ (bounds.Right -xc)*rate );
        }                                                    
        else {                                               
            bounds.Top   = T_( bounds.Top   + (bounds.Right -xc)*rate );
            bounds.Bottom= T_( bounds.Bottom+ (bounds.Left  -xc)*rate );
        }
    }
 
    template <class T_, class O_>
    void SkewX(basic_Bounds<T_> &bounds, const O_ &rate, const basic_Point<T_> &origin) {
        if(rate>0) {
            bounds.Left  = T_( bounds.Left  + (bounds.Top   -origin.Y)*rate );
            bounds.Right = T_( bounds.Right + (bounds.Bottom-origin.Y)*rate );
        }
        else {
            bounds.Left  = T_( bounds.Left  + (bounds.Bottom-origin.Y)*rate );
            bounds.Right = T_( bounds.Right + (bounds.Top   -origin.Y)*rate );
        }
    }
 
    template <class T_, class O_>
    void SkewY(basic_Bounds<T_> &bounds, const O_ &rate, const basic_Point<T_> &origin) {
        if(rate>0) {
            bounds.Top   = T_( bounds.Top   + (bounds.Left  -origin.X)*rate );
            bounds.Bottom= T_( bounds.Bottom+ (bounds.Right -origin.X)*rate );
        }                                                    
        else {                                               
            bounds.Top   = T_( bounds.Top   + (bounds.Right -origin.X)*rate );
            bounds.Bottom= T_( bounds.Bottom+ (bounds.Left  -origin.X)*rate );
        }
    }
    
    typedef basic_Bounds<Float> Boundsf;
 
    typedef basic_Bounds<int>   Bounds;
 
} }