Box2.h

Go to the documentation of this file.

 
//
// Copyright 2020 Arvind Singh
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
//version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _TGX_BOX2_H_
#define _TGX_BOX2_H_
 
// only C++, no plain C
#ifdef __cplusplus
 
 
#include "Misc.h"
#include "Vec2.h"
 
#include <type_traits>
#include <stdint.h>
 
namespace tgx
{
 
 
    // Forward declaration 
     
    template<typename T> struct Box2;
 
 
    // Specializations
 
    typedef Box2<int> iBox2; 
 
    typedef Box2<float> fBox2; 
 
    typedef Box2<double> dBox2; 
 
 
 
    enum Anchor
        {
        CENTER = 0,                             
        LEFT = 1,                               
        RIGHT = 2,                              
        TOP = 4,                                
        BOTTOM = 8,                             
        BASELINE = 16,                          
        TOPLEFT = TOP | LEFT,                   
        TOPRIGHT = TOP | RIGHT,                 
        BOTTOMLEFT = BOTTOM | LEFT,             
        BOTTOMRIGHT = BOTTOM | RIGHT,           
        CENTERLEFT = CENTER | LEFT,             
        CENTERRIGHT = CENTER | RIGHT,           
        CENTERTOP = CENTER | TOP,               
        CENTERBOTTOM = CENTER | BOTTOM,         
        DEFAULT_TEXT_ANCHOR = BASELINE | LEFT   
        };
 
 
    inline constexpr Anchor operator|(Anchor a1, Anchor a2) { return ((Anchor)((int)a1 | (int)a2)); }
 
    inline Anchor& operator|=(Anchor& a1, Anchor a2) { a1 = a1 | a2; return a1; }
 
    inline constexpr Anchor operator&(Anchor a1, Anchor a2) { return ((Anchor)((int)a1 & (int)a2)); }
 
    inline Anchor& operator&=(Anchor& a1, Anchor a2) { a1 = a1 & a2; return a1; }
 
 
 
    enum BoxSplit
        {
        SPLIT_LEFT          = Anchor::LEFT,        
        SPLIT_RIGHT         = Anchor::RIGHT,       
        SPLIT_TOP           = Anchor::TOP,         
        SPLIT_BOTTOM        = Anchor::BOTTOM,      
        SPLIT_TOPLEFT       = Anchor::TOPLEFT,     
        SPLIT_TOPRIGHT      = Anchor::TOPRIGHT,    
        SPLIT_BOTTOMLEFT    = Anchor::BOTTOMLEFT,  
        SPLIT_BOTTOMRIGHT   = Anchor::BOTTOMRIGHT  
        };
 
 
    inline constexpr BoxSplit operator|(BoxSplit a1, BoxSplit a2) { return ((BoxSplit)((int)a1 | (int)a2)); }
 
    inline BoxSplit& operator|=(BoxSplit& a1, BoxSplit a2) { a1 = a1 | a2; return a1; }
 
    inline constexpr BoxSplit operator&(BoxSplit a1, BoxSplit a2) { return ((BoxSplit)((int)a1 & (int)a2)); }
 
    inline BoxSplit& operator&=(BoxSplit& a1, BoxSplit a2) { a1 = a1 & a2; return a1; }
 
 
 
 
    template<typename T> struct Box2
    {
 
        // mtools extension (if available).  
        #if (MTOOLS_TGX_EXTENSIONS)
        #include <mtools/extensions/tgx/tgx_ext_Box2.inl>
        #endif
 
 
        // box dimension: [minX, maxX] x [minY, maxY]
        
        T minX; 
        T maxX; 
        T minY; 
        T maxY; 
 
 
        constexpr Box2()
            {
            }
 
 
        constexpr Box2(const T minx, const T maxx, const T miny, const T maxy) : minX(minx), maxX(maxx), minY(miny), maxY(maxy)
            {
            }
 
 
        constexpr Box2(const Vec2<T>& P) : minX(P.x), maxX(P.x), minY(P.y), maxY(P.y)
            {
            }
 
 
        Box2(const Box2<T>& B) = default;
 
 
        Box2<T>& operator=(const Box2<T>& B) = default;
 
 
        template<typename U>
        explicit operator Box2<U>() { return Box2<U>((U)minX, (U)maxX, (U)minY, (U)maxY); }
 
 
        operator Box2<typename DefaultFPType<T>::fptype>() { return Box2<typename DefaultFPType<T>::fptype>((typename DefaultFPType<T>::fptype)minX, (typename DefaultFPType<T>::fptype)maxX, (typename DefaultFPType<T>::fptype)minY, (typename DefaultFPType<T>::fptype)maxY); }
 
 
        constexpr inline bool isEmpty() const { return ((maxX < minX) || (maxY < minY)); }
 
 
        void empty()
            {
            minX = (T)1; 
            maxX = (T)0;
            minY = (T)1;
            maxY = (T)0;
            }
 
 
        inline T lx() const 
            {
            if (std::is_integral<T>::value) // compiler optimize this away. 
                {
                return (maxX - minX + 1); // for integer, return the number of points
                }
            else    
                {
                return (maxX - minX); // for floating point type, return maxX - minX. 
                }                   
            }
 
 
        inline T ly() const
            {
            if (std::is_integral<T>::value) // compiler optimize this away. 
                {
                return (maxY - minY + 1); // for integer, return the number of points
                }
            else    
                {
                return (maxY - minY); // for floating point type, return maxX - minX. 
                }                   
            }
 
 
        inline bool equals(const Box2<T>& B) const
            {
            if (isEmpty()) { return B.isEmpty(); }
            return ((minX == B.minX) && (maxX == B.maxX) && (minY == B.minY) && (maxY == B.maxY));
            }
 
 
        inline bool operator==(const Box2<T>& B) const
            {
            return equals(B);
            }
 
 
        inline bool contains(const Vec2<T>& v) const
            {
            return(((minX <= v.x) && (v.x <= maxX)) && ((minY <= v.y) && (v.y <= maxY)));
            }
 
 
        inline bool contains(const Box2<T>& B) const
            {
            if (isEmpty()) return false;
            if (B.isEmpty()) return true;
            return ((minX <= B.minX) && (maxX >= B.maxX) && (minY <= B.minY) && (maxY >= B.maxY));
            }
 
 
        inline bool operator>=(const Box2<T>& B) const
            {
            return contains(B);
            }
 
 
        inline bool operator<=(const Box2<T>& B) const
            {
            return B.contains(*this);
            }
 
 
        inline bool operator>(const Box2<T>& B) const
            {
            return ((contains(B)) && (!equals(B)));
            }
 
 
        inline bool operator<(const Box2<T>& B) const
            {
            return ((B.contains(*this)) && (!B.equals(*this)));
            }
 
 
        inline Box2<T> operator&(const Box2<T>& B) const
            {
            Box2<T> R;
            if (isEmpty()) 
                {
                R = *this;
                }
            else if (B.isEmpty())
                {
                R = B;
                }
            else
                {
                R.minX = max(minX, B.minX);
                R.maxX = min(maxX, B.maxX);
                R.minY = max(minY, B.minY);
                R.maxY = min(maxY, B.maxY);
                }
            return R;
            }
 
 
        inline void operator&=(const Box2<T>& B)
            {
            (*this) = ((*this) & B);
            }
 
 
        inline Box2<T> operator|(const Box2<T>& B) const
            {
            Box2<T> R;
            if (isEmpty())
                {
                R = B;
                }
            else if (B.isEmpty())
                {
                R = (*this);
                }
            else
                {
                R.minX = min(minX, B.minX);
                R.maxX = max(maxX, B.maxX);
                R.minY = min(minY, B.minY);
                R.maxY = max(maxY, B.maxY);
                }
            return R;
            }
 
 
        inline void operator|=(const Box2<T>& B)
            {
            *this = (*this) | B;
            }
 
 
        inline Box2<T> operator|(const Vec2<T>& v) const
            {
            Box2<T> R;
            if (isEmpty())
                {
                R.minX = R.maxX = v.x;
                R.minY = R.maxY = v.y;
                }
            else
                {
                R.minX = min(minX, v.x);
                R.maxX = max(maxX, v.x);
                R.minY = min(minY, v.y);
                R.maxY = max(maxY, v.y);
                }
            return R;
            }
 
 
        inline void operator|=(const Vec2<T>& v)
            {
            (*this) = (*this) | v;
            }
 
 
        inline void operator+=(const Vec2<T> & V)
            {
            minX += V.x;
            maxX += V.x;
            minY += V.y;
            maxY += V.y;
            }
 
 
        inline Box2<T> operator+(const Vec2<T> & V) const
            {
            return Box2<T>(minX + V.x, maxX + V.x, minY + V.y, maxY + V.y);
            }
 
 
        inline void operator-=(const Vec2<T> & V)
            {
            minX -= V.x;
            maxX -= V.x;
            minY -= V.y;
            maxY -= V.y;
            }
 
 
        inline Box2<T> operator-(const Vec2<T> & V) const
            {
            return Box2<T>(minX - V.x, maxX - V.x, minY - V.y, maxY - V.y);
            }
 
 
        inline void split(BoxSplit part)
            {
            *this = getSplit(part);
            }
 
 
        Box2<T> getSplit(BoxSplit part) const
            {
            const T midX = (minX + maxX)/2;
            const T midY = (minY + maxY)/2;
            switch (part)
                {
            case SPLIT_TOP: { return Box2<T>(minX, maxX, midY, maxY); }
            case SPLIT_BOTTOM: { return Box2<T>(minX, maxX, minY, midY); }
            case SPLIT_LEFT: { return Box2<T>(minX, midX, minY, maxY); }
            case SPLIT_RIGHT: { return Box2<T>(midX, maxX, minY, maxY); }
            case SPLIT_TOPLEFT: { return Box2<T>(minX, midX, midY, maxY); }
            case SPLIT_TOPRIGHT: { return Box2<T>(midX, maxX, midY, maxY); }
            case SPLIT_BOTTOMLEFT: { return Box2<T>(minX, midX, minY, midY); }
            case SPLIT_BOTTOMRIGHT: { return Box2<T>(midX, maxX, minY, midY); }
                }
            return *this;
            }
 
 
        Vec2<T> getAnchor(Anchor anchor_pos) const
            {
            anchor_pos &= (CENTER | LEFT | RIGHT | TOP | BOTTOM); // remove baseline flag
            switch (anchor_pos)
                {
            case TOPLEFT:       return Vec2<T>(minX, minY);
            case TOPRIGHT:      return Vec2<T>(maxX, minY);
            case BOTTOMLEFT:    return Vec2<T>(minX, maxY);
            case BOTTOMRIGHT:   return Vec2<T>(maxX, maxY);
            case CENTER:        return Vec2<T>((minX + maxX) / 2, (minY + maxY) / 2);
            case CENTERLEFT:    return Vec2<T>(minX, (minY + maxY) / 2);
            case CENTERRIGHT:   return Vec2<T>(maxX, (minY + maxY) / 2);
            case CENTERTOP:     return Vec2<T>((minX + maxX) / 2, minY);
            case CENTERBOTTOM:  return Vec2<T>((minX + maxX) / 2, maxY);
            default: break;
                }
            return Vec2<T>((minX + maxX) / 2, (minY + maxY) / 2); // unknown pos returns center.
            }
 
 
        Vec2<T> center() const
            {
            return Vec2<T>((minX + maxX) / 2, (minY + maxY) / 2);
            }
            
 
        template<typename Tfloat = DefaultFPType<T> > inline  Tfloat ratio() const
            {
            if (isEmpty()) return (Tfloat)(-1);
            return ((Tfloat)(lx())) / ((Tfloat)(ly()));
            }
 
 
        void zoomOut()
            {
            const T u = lx() / 10;
            minX -= u;
            maxX += u;
            const T v = ly() / 10;
            minY -= v;
            maxY += v;
            }
 
 
        void zoomIn()
            {
            const T u = lx() / 8;
            minX += u;
            maxX -= u;
            const T v = ly() / 8;
            minY += v;
            maxY -= v;
            }
 
 
        void left()
            {
            const T u = lx() / 10;
            minX -= u;
            maxX -= u;
            }
 
 
        void right()
            {
            const T u = lx() / 10;
            minX += u;
            maxX += u;
            }
 
 
        void up()
            {
            const T v = ly() / 10;
            minY -= v;
            maxY -= v;
            }
 
 
        void down()
            {
            const T v = ly() / 10;
            minY += v;
            maxY += v;
            }
 
 
        Box2<T> getEnclosedWithSameRatioAs(const Box2<T> & B) const;
 
 
        Box2<T> getEnclosingWithSameRatioAs(const Box2<T> & B) const;
 
 
    };
 
 
 
 
 
    template<typename T> Box2<T> Box2<T>::getEnclosedWithSameRatioAs(const Box2<T> & B) const
        {
        Box2<T> C;
        if (ratio() < B.ratio())
            {
            C.minX = 0;
            C.maxX = maxX - minX;
            T ll = (T)(lx() / B.ratio());
            C.minY = (ly() - ll) / 2;
            C.maxY = C.minY + ll - (std::is_integral<T>::value ? 1 : 0);
            }
        else
            {
            C.minY = 0;
            C.maxY = maxY - minY;
            T ll = (T)(ly() * B.ratio());
            C.minX = (lx() - ll) / 2;
            C.maxX = C.minX + ll - (std::is_integral<T>::value ? 1 : 0);
            }
        return C;
        }
 
 
    template<typename T> Box2<T> Box2<T>::getEnclosingWithSameRatioAs(const Box2<T> & B) const
        {
        Box2<T> C;
        if (ratio() > B.ratio())
            {
            C.minX = 0;
            C.maxX = maxX - minX;
            T ll = (T)(lx() / B.ratio());
            C.minY = (ly() - ll) / 2;
            C.maxY = C.minY + ll - (std::is_integral<T>::value ? 1 : 0);
            }
        else
            {
            C.minY = 0;
            C.maxY = maxY - minY;
            T ll = (T)(ly() * B.ratio());
            C.minX = (lx() - ll) / 2;
            C.maxX = C.minX + ll - (std::is_integral<T>::value ? 1 : 0);
            }
        return C;
        }
 
 
}
 
 
#endif
 
#endif