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