extent2.h

#pragma once
#include "vect.h"
 
template <class T> class Extent2 {
public:
    // Creators
#ifdef _DEBUG
    Extent2() { tx1_ = tx2_ = ty1_ = ty2_ = initVal<T>(); }
#else
    Extent2() {}
#endif
    Extent2(const T &x1,const T &x2,const T &y1,const T &y2) : tx1_(x1), tx2_(x2), ty1_(y1), ty2_(y2) { }
    Extent2(const Vector2<T> &v11,const Vector2<T> &v22) : tx1_(v11.x()), tx2_(v22.x()), ty1_(v11.y()), ty2_(v22.y()) { }
    Extent2(const Extent2<T> &r) : tx1_(r.tx1_), tx2_(r.tx2_), ty1_(r.ty1_), ty2_(r.ty2_) { }
    constexpr const Extent2 &operator=(const Extent2 &e) { tx1_=e.tx1_; tx2_=e.tx2_; ty1_=e.ty1_; ty2_=e.ty2_; return *this; }
    static constexpr Extent2<T> nothing() { Extent2<T> r(limits<T>::max(),-limits<T>::max(),
                                                         limits<T>::max(),-limits<T>::max());  return r; }
    // Accessors
    const T &x1() const { return tx1_; }
    const T &x2() const { return tx2_; }
    const T &y1() const { return ty1_; }
    const T &y2() const { return ty2_; }
    const T &dof1(uint32 u) const {
        assert(u<2);
        if (u)
            return ty1_;
        return tx1_;
    }
    const T &dof2(uint32 u) const {
        assert(u<2);
        if (u)
            return ty2_;
        return tx2_;
    }
    T width() const { return (tx2_-tx1_); }
    T height() const { return (ty2_-ty1_); }
    Vector2<T> centroid() const { Vector2<T> out((tx1_+tx2_)/2,(ty1_+ty2_)/2);  return out; }
    Vector2<T> c11() const { Vector2<T> out(tx1_,ty1_); return out; }
    Vector2<T> c12() const { Vector2<T> out(tx1_,ty2_); return out; }
    Vector2<T> c21() const { Vector2<T> out(tx2_,ty1_); return out; }
    Vector2<T> c22() const { Vector2<T> out(tx2_,ty2_); return out; }
    Vector2<T> lowerBound() const { return c11(); }
    Vector2<T> upperBound() const { return c22(); }
    Vector2<T> size() const { Vector2<T> out(width(),height());  return out; }
    T area() const { return (width()*height()); }
    T volume() const { return area(); }
    T diagonal() const { return size().mag(); }
    bool isEmpty() const { return( (tx1_>=tx2_) || (ty1_>=ty2_) ); }
    bool tolIsEmpty(const double &tol = limits<double>::epsilon() * 100) const { return ( (tx1_ + tol >= tx2_) || (ty1_ + tol >= ty2_) ); }
 
    // Comparison operators
    bool operator==(const Extent2<T> &r) const { return ( (tx1_==r.tx1_)&&(tx2_==r.tx2_)&&(ty1_==r.ty1_)&&(ty2_==r.ty2_) ); }
    bool operator!=(const Extent2<T> &r) const { return !operator==(r); }
    bool operator<(const Extent2<T> &r) const { return (area() < r.area()); }
    bool operator>(const Extent2<T> &r) const { return (area() > r.area()); }
    bool isIn(const Vector2<T> &v) const { return ((v.x()>=tx1_)&&(v.x()<=tx2_)&&(v.y()>=ty1_)&&(v.y()<=ty2_)); }
    bool isIn(const Extent2<T> &r) const {
        if ( (r.tx1_>=tx1_) && (r.tx2_<=tx2_) && (r.ty1_>=ty1_) && (r.ty2_<=ty2_) ) return true;
        return false;
    }
    bool tolIsIn(const Vector2<T> &v,const T &tol) const {
        return ((v.x()>=tx1_-tol)&&(v.x()<=tx2_+tol)&&(v.y()>=ty1_-tol)&&(v.y()<=ty2_+tol));
    }
    bool tolIsIn(const Extent2<T> &r,const T &tol) const {
        if ( (r.tx1_>=tx1_-tol) && (r.tx2_<=tx2_+tol) && (r.ty1_>=ty1_-tol) && (r.ty2_<=ty2_+tol) ) return true;
        return false;
    }
    bool intersects(const Extent2<T> &r) const {
        if ((r.tx2_<tx1_) || (r.tx1_>tx2_) ||
            (r.ty2_<ty1_) || (r.ty1_>ty2_)) return false;
        return true;
    }
    bool tolIntersects(const Extent2<T> &r,const T &tol) const {
        if ((r.tx2_<tx1_-tol) || (r.tx1_>tx2_+tol) ||
            (r.ty2_<ty1_-tol) || (r.ty1_>ty2_+tol)) return false;
        return true;
    }
 
    // Setters
    T &rx1() { return tx1_; }
    T &rx2() { return tx2_; }
    T &ry1() { return ty1_; }
    T &ry2() { return ty2_; }
    T &rdof1(uint32 u) {
        assert(u<2);
        if (u)
            return ty1_;
        return tx1_;
    }
    T &rdof2(uint32 u) {
        assert(u<2);
        if (u)
            return ty2_;
        return tx2_;
    }
    //   Changing width or height assumes LL corner (c11) stays constant.
    void width(const T &t) { tx2_ = tx1_ + t; }
    void height(const T &t) { ty2_ = ty1_ + t; }
    void c11(const Vector2<T> &v) { rx1() = v.x();  ry1() = v.y();  }
    void c12(const Vector2<T> &v) { rx1() = v.x();  ry2() = v.y();  }
    void c21(const Vector2<T> &v) { rx2() = v.x();  ry1() = v.y();  }
    void c22(const Vector2<T> &v) { rx2() = v.x();  ry2() = v.y();  }
    void lowerBound(const Vector2<T> &v) { c11(v); }
    void upperBound(const Vector2<T> &v) { c22(v); }
    void size(const Vector2<T> &v) { width(v.x());  height(v.y()); }
    Vector2<T> bound(const Vector2<T> &v) const { return Vector2<T>(pbound(tx1_,v.x(),tx2_),pbound(ty1_,v.y(),ty2_)); }
 
    // Manipulators - unary in place
    const Extent2<T> &operator+=(const Vector2<T> &v) { tx1_+=v.x(); tx2_+=v.x(); ty1_+=v.y(); ty2_+=v.y(); return *this; }
    const Extent2<T> &operator-=(const Vector2<T> &v) { tx1_-=v.x(); tx2_-=v.x(); ty1_-=v.y(); ty2_-=v.y(); return *this; }
 
    // Binary operators
    Extent2<T> operator+(const Vector2<T> &v) const { Extent2<T> out(tx1_+v.x(),tx2_+v.x(),ty1_+v.y(),ty2_+v.y());  return out; }
    Extent2<T> operator-(const Vector2<T> &v) const { Extent2<T> out(tx1_-v.x(),tx2_-v.x(),ty1_-v.y(),ty2_-v.y());  return out; }
    Extent2<T> intersectedWith(const Extent2<T> &r) const {
        Extent2<T> out(std::max<T>(tx1_,r.tx1_),std::min<T>(tx2_,r.tx2_),std::max<T>(ty1_,r.ty1_),std::min<T>(ty2_,r.ty2_));
        return out;
    }
    const Extent2<T> &expandToInclude(const Extent2<T> &r) {
        tx1_ = std::min<T>(tx1_,r.tx1_);
        tx2_ = std::max<T>(tx2_,r.tx2_);
        ty1_ = std::min<T>(ty1_,r.ty1_);
        ty2_ = std::max<T>(ty2_,r.ty2_);
        return *this;
    }
    const Extent2<T> &expandToInclude(const Vector2<T> &v) {
        tx1_ = std::min<T>(tx1_,v.x());
        tx2_ = std::max<T>(tx2_,v.x());
        ty1_ = std::min<T>(ty1_,v.y());
        ty2_ = std::max<T>(ty2_,v.y());
        return *this;
    }
    Extent2<T> expandedToInclude(const Extent2<T> &r) const {
        Extent2<T> out(*this);
        out.expandToInclude(r);
        return out;
    }
    Extent2<T> expandedToInclude(const Vector2<T> &v) const {
        Extent2<T> out(*this);
        out.expandToInclude(v);
        return out;
    }
    const Extent2<T> &expand(const T &tol) { tx1_ -= tol;  tx2_ += tol;  ty1_ -= tol;  ty2_ += tol;  return *this; }
    Extent2<T> expanded(const T &tol) const { Extent2<T> out(*this);  return out.expand(tol); }
    const Extent2<T> &center(const Vector2<T> &v) {
        Vector2<T> trans = v - this->centroid();
        tx1_ += trans.x();
        tx2_ += trans.x();
        ty1_ += trans.y();
        ty2_ += trans.y();
        return *this;
    }
    Extent2<T> center(const Vector2<T> &v) const {
        Extent2<T> out(*this);
        out.center(v);
        return out;
    }
    Extent2<T> biggerBy(const T &fact) const {
        auto s = size()*0.5;
        s += s*fact;
        auto c = centroid();
        Extent2<T> out(c-s,c+s);
        return out;
    }
 
private:
    T pbound(const T &min,const T &v,const T &max) const { return std::min(std::max(v,min),max); }
    T tx1_;
    T tx2_;
    T ty1_;
    T ty2_;
};
 
typedef Extent2<double> DExtent2; 
typedef Extent2<float>  FExtent2; 
typedef Extent2<int32>  IExtent2; 
typedef Extent2<uint32> UExtent2; 
typedef Extent2<int64>  I64Extent2; 
typedef Extent2<uint64> U64Extent2; 
 
// EoF