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>() const { return Box2<U>((U)minX, (U)maxX, (U)minY, (U)maxY); }
 
 
        operator Box2<typename DefaultFPType<T>::fptype>() const { 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_fixed(BoxSplit part)
            {
            *this = getSplit_fixed(part);
            }
 
 
        Box2<T> getSplit_fixed(BoxSplit part) const
            {
            const T midX = minX + (maxX - minX)/2;
            const T midY = minY + (maxY - minY)/2;
            const T nextX = midX + (std::is_integral<T>::value ? (T)1 : (T)0);
            const T nextY = midY + (std::is_integral<T>::value ? (T)1 : (T)0);
            switch (part)
                {
            case SPLIT_TOP: { return Box2<T>(minX, maxX, minY, midY); }
            case SPLIT_BOTTOM: { return Box2<T>(minX, maxX, nextY, maxY); }
            case SPLIT_LEFT: { return Box2<T>(minX, midX, minY, maxY); }
            case SPLIT_RIGHT: { return Box2<T>(nextX, maxX, minY, maxY); }
            case SPLIT_TOPLEFT: { return Box2<T>(minX, midX, minY, midY); }
            case SPLIT_TOPRIGHT: { return Box2<T>(nextX, maxX, minY, midY); }
            case SPLIT_BOTTOMLEFT: { return Box2<T>(minX, midX, nextY, maxY); }
            case SPLIT_BOTTOMRIGHT: { return Box2<T>(nextX, maxX, nextY, maxY); }
                }
            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 = typename DefaultFPType<T>::fptype> 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_fixed(const Box2<T> & B) const;
 
 
        Box2<T> getEnclosingWithSameRatioAs_fixed(const Box2<T> & B) const;
 
 
    };
 
 
 
 
 
    template<typename T> Box2<T> Box2<T>::getEnclosedWithSameRatioAs_fixed(const Box2<T> & B) const
        {
        Box2<T> C;
        C.empty();
        if (isEmpty() || B.isEmpty()) return C;
 
        typedef typename DefaultFPType<T>::fptype Tfloat;
        const Tfloat target_ratio = B.template ratio<Tfloat>();
        if (target_ratio <= (Tfloat)0) return C;
 
        Tfloat llx = (Tfloat)lx();
        Tfloat lly = (Tfloat)ly();
        if (ratio<Tfloat>() < target_ratio)
            {
            lly = llx / target_ratio;
            }
        else
            {
            llx = lly * target_ratio;
            }
 
        if (std::is_integral<T>::value)
            {
            T ilx = (T)floor(llx);
            T ily = (T)floor(lly);
            if (ilx < (T)1) ilx = (T)1;
            if (ily < (T)1) ily = (T)1;
            if (ilx > lx()) ilx = lx();
            if (ily > ly()) ily = ly();
            C.minX = minX + (lx() - ilx) / 2;
            C.minY = minY + (ly() - ily) / 2;
            C.maxX = C.minX + ilx - 1;
            C.maxY = C.minY + ily - 1;
            }
        else
            {
            const Tfloat cx = ((Tfloat)minX + (Tfloat)maxX) / (Tfloat)2;
            const Tfloat cy = ((Tfloat)minY + (Tfloat)maxY) / (Tfloat)2;
            C.minX = (T)(cx - llx / (Tfloat)2);
            C.maxX = (T)(cx + llx / (Tfloat)2);
            C.minY = (T)(cy - lly / (Tfloat)2);
            C.maxY = (T)(cy + lly / (Tfloat)2);
            }
        return C;
        }
 
 
    template<typename T> Box2<T> Box2<T>::getEnclosingWithSameRatioAs_fixed(const Box2<T> & B) const
        {
        Box2<T> C;
        C.empty();
        if (isEmpty() || B.isEmpty()) return C;
 
        typedef typename DefaultFPType<T>::fptype Tfloat;
        const Tfloat target_ratio = B.template ratio<Tfloat>();
        if (target_ratio <= (Tfloat)0) return C;
 
        Tfloat llx = (Tfloat)lx();
        Tfloat lly = (Tfloat)ly();
        if (ratio<Tfloat>() > target_ratio)
            {
            lly = llx / target_ratio;
            }
        else
            {
            llx = lly * target_ratio;
            }
 
        if (std::is_integral<T>::value)
            {
            T ilx = (T)ceil(llx);
            T ily = (T)ceil(lly);
            if (ilx < lx()) ilx = lx();
            if (ily < ly()) ily = ly();
            C.minX = minX - (ilx - lx()) / 2;
            C.minY = minY - (ily - ly()) / 2;
            C.maxX = C.minX + ilx - 1;
            C.maxY = C.minY + ily - 1;
            }
        else
            {
            const Tfloat cx = ((Tfloat)minX + (Tfloat)maxX) / (Tfloat)2;
            const Tfloat cy = ((Tfloat)minY + (Tfloat)maxY) / (Tfloat)2;
            C.minX = (T)(cx - llx / (Tfloat)2);
            C.maxX = (T)(cx + llx / (Tfloat)2);
            C.minY = (T)(cy - lly / (Tfloat)2);
            C.maxY = (T)(cy + lly / (Tfloat)2);
            }
        return C;
        }
 
 
}
 
 
#endif
 
#endif