box.h

Go to the documentation of this file.

/* MIT License
 */

//== FILEDOC =========================================================================

//== BEGINNING OF CODE ===============================================================

#ifndef __SBNW_LAYOUT_BOX_H_
#define __SBNW_LAYOUT_BOX_H_

//== INCLUDES ========================================================================

#include "SagittariusCore.h"
#include "min_max.h"

//-- C++ code --
#ifdef __cplusplus

#include "point.h" // says, <graphfab/layout/point.h>, why brackets?

// #include <string>

#include <iostream>

namespace LibsbmlDraw {

    class Box {
        public:
            Box()
                {}
            
            Box(const Point& min, const Point& max)
                : _min(min), _max(max) { AT(_min.x <= _max.x && _min.y <= _max.y, "Min/max mismatch"); }
            
            Box(Real x1, Real y1, Real x2, Real y2)
                : _min(x1,y1), _max(x2,y2) {
                    if(!(_min.x <= _max.x && _min.y <= _max.y)) {
                        dump(std::cerr);
                        std::cerr << "\n";
                    }
                    AT(_min.x <= _max.x && _min.y <= _max.y, "Min/max mismatch");
                }
            
            const Point& getMin() const { return _min; }
            Real getMinX() const { return getMin().x; }
            Real getMinY() const { return getMin().y; }
            
            void setMin(const Point& p) { _min = p; }
            
            void setMinX(const Real x) { _min.x = x; }
            void setMinY(const Real y) { _min.y = y; }
            
            const Point& getMax() const { return _max; }
            Real getMaxX() const { return getMax().x; }
            Real getMaxY() const { return getMax().y; }
            
            void setMax(const Point& p) { _max = p; }
            
            void setMaxX(const Real x) { _max.x = x; }
            void setMaxY(const Real y) { _max.y = y; }
            
            Point getCenter() const { return (getMax() + getMin())/2.; }

            Point getFirstQuadCorner()  const { return getMax(); }
            Point getSecondQuadCorner() const { return Point(_min.x, _max.y); }
            Point getThirdQuadCorner()  const { return getMin(); }
            Point getFourthQuadCorner() const { return Point(_max.x, _min.y); }
            
            Point getDiag() const { return getMax() - getMin(); }
            
            Real maxDim() const {
                Real w = _max.x - _min.x;
                Real h = _max.y - _min.y;
                return max(w,h);
            }
            
            Real minDim() const {
                Real w = _max.x - _min.x;
                Real h = _max.y - _min.y;
                return min(w,h);
            }
            
            Point getTopRightCorner() const { return Point(_max.x, _min.y); }

            Point getBottomLeftCorner() const { return Point(_min.x, _max.y); }
            
            Real width() const { return _max.x - _min.x; }
            
            void setWidth(const Real w) { _max.x = _min.x+w; }
            
            Real height() const { return _max.y - _min.y; }
            
            void setHeight(const Real w) { _max.y = _min.y+w; }
            
            Real area() const {
                Real w = _max.x - _min.x;
                Real h = _max.y - _min.y;
                return w*h;
            }
            
            bool canShrink(const Real v) const {
                if(_min.x + 2*v <= _max.x && _min.y+2*v <= _max.y)
                    return true;
                else
                    return false;
            }
            
            Box shrink(const Real v) const {
                return Box(_min+Point(v,v), _max-Point(v,v));
            }
            
            void shrink_(const Real v) {
                _min.x += v;
                _min.y += v;
                _max.x -= v;
                _max.y -= v;
            }

            Box padded(const Real v) const {
                return Box(_min-Point(v,v), _max+Point(v,v));
            }
            
            // expand! to contain the other box and this box
            void expandx(const Box& other) {
                _min = Point::emin(_min, other._min);
                _max = Point::emax(_max, other._max);
            }

            void displace(const Point& d) {
                _min += d;
                _max += d;
            }
            
            void dump(std::ostream& o) const {
                o << "[" << getMin() << ", " << getMax() << "]";
            }
            
        protected:
            Point _min, _max;
    };
    
    std::ostream& operator<< (std::ostream& os, const Box& b);
    
    std::pair<bool, Point> intersectBoxLine(const Box& b, const Point& u, const Point& v);
    
}

#endif

#endif