cube.h

Go to the documentation of this file.

#pragma once
#include "extent2.h"
 
template <class T> class Cube 
{
public:
 // Creators
 Cube() { }
 Cube(const T &x1,const T &x2,const T &y1,const T &y2,const T &z1,const T &z2) 
 :tx1_(x1), tx2_(x2), ty1_(y1), ty2_(y2), tz1_(z1), tz2_(z2) { }
 Cube(const Vector3<T> &v111,const Vector3<T> &v222) 
 :tx1_(v111.x()), tx2_(v222.x()), ty1_(v111.y()), ty2_(v222.y()), tz1_(v111.z()), tz2_(v222.z()) { }
PUSHWARNING
#pragma clang diagnostic ignored "-Wdeprecated-copy"
 Cube(const Cube<T> &r) : tx1_(r.tx1_), tx2_(r.tx2_), ty1_(r.ty1_), ty2_(r.ty2_), tz1_(r.tz1_), tz2_(r.tz2_) { }
 explicit Cube(const Extent2<T> &r) : tx1_(r.x1()), tx2_(r.x2()), ty1_(r.y1()), ty2_(r.y2()), tz1_(0), tz2_(1) { }
 static Cube<T> nothing() { Cube<T> c(limits<T>::max(),-limits<T>::max(),
 limits<T>::max(),-limits<T>::max(),
 limits<T>::max(),-limits<T>::max()); return c; }
POPWARNING
 // 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 &z1() const { return tz1_; }
 const T &z2() const { return tz2_; }
 const T &dof1(uint32 dof) const { assert(dof<3); return *(&tx1_+(2*dof)); }
 const T &dof2(uint32 dof) const { assert(dof<3); return *(&tx2_+(2*dof)); }
 T width() const { return (tx2_-tx1_); }
 T height() const { return (ty2_-ty1_); }
 T depth() const { return (tz2_-tz1_); }
 Vector3<T> centroid() const { Vector3<T> v((tx1_+tx2_)/2,(ty1_+ty2_)/2,(tz1_+tz2_)/2); return v; }
 T volume() const { return (width()*height()*depth()); }
 T diagonal() const { return (size().mag()); }
 Vector3<T> corner(uint32 x,uint32 y,uint32 z) const
 { if (x) {
 if (y) { if (z) return c222(); else return c221(); }
 else { if (z) return c212(); else return c211(); }
 } else {
 if (y) { if (z) return c122(); else return c121(); }
 else { if (z) return c112(); else return c111(); }
 }
 }
 
 // Corner functions - returns the 8 corners of the region.
 Vector3<T> c111() const { Vector3<T> out(tx1_,ty1_,tz1_); return out; }
 Vector3<T> c121() const { Vector3<T> out(tx1_,ty2_,tz1_); return out; }
 Vector3<T> c211() const { Vector3<T> out(tx2_,ty1_,tz1_); return out; }
 Vector3<T> c221() const { Vector3<T> out(tx2_,ty2_,tz1_); return out; }
 Vector3<T> c112() const { Vector3<T> out(tx1_,ty1_,tz2_); return out; }
 Vector3<T> c122() const { Vector3<T> out(tx1_,ty2_,tz2_); return out; }
 Vector3<T> c212() const { Vector3<T> out(tx2_,ty1_,tz2_); return out; }
 Vector3<T> c222() const { Vector3<T> out(tx2_,ty2_,tz2_); return out; }
 Vector3<T> lowerBound() const { return c111(); }
 Vector3<T> upperBound() const { return c222(); }
 Vector3<T> size() const { Vector3<T> out(width(),height(),depth()); return out; }
 
 // Comparison Operators
 bool isEmpty() const { return ( (tx1_>=tx2_) || (ty1_>=ty2_) || (tz1_>=tz2_) ); }
 bool tolIsEmpty(const double &tol = limits<double>::epsilon() * 100) const { return ( (tx1_ >= tx2_ + tol) || (ty1_ >= ty2_ + tol) || (tz1_ >= tz2_ + tol) ); }
 bool operator==(const Cube<T> &c) const 
 { 
 return( (tx1_==c.tx1_)&&(tx2_==c.tx2_)&&(ty1_==c.ty1_)&&(ty2_==c.ty2_)&&(tz1_==c.tz1_)&&(tz2_==c.tz2_) ); 
 }
 bool operator!=(const Cube<T> &r) const { return !operator==(r); }
 bool operator<(const Cube<T> &c) const { return (volume() < c.volume()); }
 bool operator>(const Cube<T> &c) const { return (volume() > c.volume()); }
 bool isIn(const Vector3<T> &v) const 
 { 
 if ( (v.x()>=tx1_) && (v.x()<=tx2_) && (v.y()>=ty1_) && (v.y()<=ty2_) && (v.z()>=tz1_) && (v.z()<=tz2_) ) return true; 
 return false; 
 }
 bool isIn(const Cube<T> &c) const 
 { 
 if ( (c.x1()>=tx1_) && (c.x2()<=tx2_) && (c.y1()>=ty1_) && (c.y2()<=ty2_) && (c.z1()>=tz1_) && (c.z2()<=tz2_) ) return true; 
 return false; 
 }
 bool tolIsIn(const Vector3<T> &v,const T &tol) const 
 { 
 if ( (v.x()>=tx1_-tol) && (v.x()<=tx2_+tol) && (v.y()>=ty1_-tol) && (v.y()<=ty2_+tol) && (v.z()>=tz1_-tol) && (v.z()<=tz2_+tol) ) return true; 
 return false; 
 }
 bool tolIsIn(const Cube<T> &c,const T &tol) const 
 { 
 if ( (c.x1()>=tx1_-tol) && (c.x2()<=tx2_+tol) && (c.y1()>=ty1_-tol) && (c.y2()<=ty2_+tol) && (c.z1()>=tz1_-tol) && (c.z2()<=tz2_+tol) ) return true; 
 return false; 
 }
 bool intersects(const Cube<T> &c) const
 {
 if ((c.tx2_<tx1_) || (c.tx1_>tx2_) || 
 (c.ty2_<ty1_) || (c.ty1_>ty2_) ||
 (c.tz2_<tz1_) || (c.tz1_>tz2_)) return false;
 return true;
 }
 bool tolIntersects(const Cube<T> &c,const T &tol) const
 {
 if ((c.tx2_<tx1_-tol) || (c.tx1_>tx2_+tol) || 
 (c.ty2_<ty1_-tol) || (c.ty1_>ty2_+tol) ||
 (c.tz2_<tz1_-tol) || (c.tz1_>tz2_+tol)) return false;
 return true;
 }
 
 // Setters
 T &rx1() { return tx1_; } 
 T &rx2() { return tx2_; } 
 T &ry1() { return ty1_; } 
 T &ry2() { return ty2_; } 
 T &rz1() { return tz1_; } 
 T &rz2() { return tz2_; } 
 T &rdof1(uint32 dof) { assert(dof<3); return *(&tx1_+(2*dof)); }
 T &rdof2(uint32 dof) { assert(dof<3); return *(&tx2_+(2*dof)); }
 // Setting width, height, depth assumes LL corner (c111) stays constant.
 void width(const T &t) { tx2_ = tx1_ + t; }
 void height(const T &t) { ty2_ = ty1_ + t; }
 void depth(const T &t) { tz2_ = tz1_ + t; }
 void c111(const Vector3<T> &v) { tx1_ = v.x(); ty1_ = v.y(); tz1_ = v.z(); }
 void c121(const Vector3<T> &v) { tx1_ = v.x(); ty2_ = v.y(); tz1_ = v.z(); }
 void c211(const Vector3<T> &v) { tx2_ = v.x(); ty1_ = v.y(); tz1_ = v.z(); }
 void c221(const Vector3<T> &v) { tx2_ = v.x(); ty2_ = v.y(); tz1_ = v.z(); }
 void c112(const Vector3<T> &v) { tx1_ = v.x(); ty1_ = v.y(); tz2_ = v.z(); }
 void c122(const Vector3<T> &v) { tx1_ = v.x(); ty2_ = v.y(); tz2_ = v.z(); }
 void c212(const Vector3<T> &v) { tx2_ = v.x(); ty1_ = v.y(); tz2_ = v.z(); }
 void c222(const Vector3<T> &v) { tx2_ = v.x(); ty2_ = v.y(); tz2_ = v.z(); }
 void lowerBound(const Vector3<T> &v) { c111(v); }
 void upperBound(const Vector3<T> &v) { c222(v); }
 void size(const Vector3<T> &v) { width(v.x()); height(v.y()); depth(v.z()); }
 Vector3<T> bound(const Vector3<T> &v) const { return Vector3<T>(pBound(tx1_,v.x(),tx2_),pBound(ty1_,v.y(),ty2_),pBound(tz1_,v.z(),tz2_)); }
 
 // Manipulators - unary in place
 const Cube<T> &operator+=(const Vector3<T> &v) { tx1_+=v.x(); tx2_+=v.x(); ty1_+=v.y(); ty2_+=v.y(); tz1_+=v.z(); tz2_+=v.z(); return *this;}
 const Cube<T> &operator-=(const Vector3<T> &v) { tx1_-=v.x(); tx2_-=v.x(); ty1_-=v.y(); ty2_-=v.y(); tz1_-=v.z(); tz2_-=v.z(); return *this;}
 
 // binary operators 
 Cube<T> operator+(const Vector3<T> &v) const { Cube<T> out(tx1_+v.x(),tx2_+v.x(),ty1_+v.y(),ty2_+v.y(),tz1_+v.z(),tz2_+v.z()); return out; }
 Cube<T> operator-(const Vector3<T> &v) const { Cube<T> out(tx1_-v.x(),tx2_-v.x(),ty1_-v.y(),ty2_-v.y(),tz1_-v.z(),tz2_-v.z()); return out; }
 Cube<T> intersectedWith(const Cube<T> &r) const 
 {
 Cube<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_),
 std::max<T>(tz1_,r.tz1_),std::min<T>(tz2_,r.tz2_)); 
 return out; 
 }
 const Cube<T> &expandToInclude(const Cube<T> &r)
 {
 tx1_ = std::min<T>(tx1_,r.tx1_);
 ty1_ = std::min<T>(ty1_,r.ty1_);
 tz1_ = std::min<T>(tz1_,r.tz1_);
 tx2_ = std::max<T>(tx2_,r.tx2_);
 ty2_ = std::max<T>(ty2_,r.ty2_);
 tz2_ = std::max<T>(tz2_,r.tz2_);
 return *this;
 }
 const Cube<T> &expandToInclude(const Vector3<T> &v)
 {
 tx1_ = std::min<T>(tx1_,v.x());
 ty1_ = std::min<T>(ty1_,v.y());
 tz1_ = std::min<T>(tz1_,v.z());
 tx2_ = std::max<T>(tx2_,v.x());
 ty2_ = std::max<T>(ty2_,v.y());
 tz2_ = std::max<T>(tz2_,v.z());
 return *this;
 }
 const Cube<T> &expandToInclude(const T &x,const T &y,const T &z) 
 {
 return expandToInclude(Vector3<T>(x,y,z));
 }
 Cube<T> expandedToInclude(const Cube<T> &r) const 
 { 
 Cube<T> out(*this);
 out.expandToInclude(r);
 return out; 
 }
 Cube<T> expandedToInclude(const Vector3<T> &v) const 
 { 
 Cube<T> out(*this);
 out.expandToInclude(v);
 return out; 
 }
 Cube<T> expandedToInclude(const T &x,const T &y,const T &z) const 
 { 
 return expandedToInclude(Vector3<T>(x,y,z));
 }
 const Cube<T> &expand(const T &tol) { tx1_ -= tol; tx2_ += tol; ty1_ -= tol; ty2_ += tol; tz1_ -= tol; tz2_ += tol; return *this; }
 Cube<T> expanded(const T &tol) const { Cube<T> out(*this); return out.expand(tol); }
 Cube<T> biggerBy(const T &fact) const 
 { 
 Vector3<T> s(size()*fact*0.5); 
 Cube<T> out(tx1_-s.x(),tx2_+s.x(),ty1_-s.y(),ty2_+s.y(),tz1_-s.z(),tz2_+s.z()); 
 return out; 
 }
 const Cube<T> &center(const Vector3<T> &v)
 {
 Vector3<T> trans = v - this->centroid();
 tx1_ += trans.x();
 tx2_ += trans.x();
 ty1_ += trans.y();
 ty2_ += trans.y();
 tz1_ += trans.z();
 tz2_ += trans.z();
 return *this;
 }
 Cube<T> center(const Vector3<T> &v) const 
 {
 Cube<T> out(*this);
 out.center(v); 
 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_;
 T tz1_;
 T tz2_;
};
 
 
// Predefined types for standard template arguments.
typedef Cube<double> DCube; 
typedef Cube<float> FCube; 
typedef Cube<int32> ICube; 
typedef Cube<uint32> UCube; 
 
template <class T> inline const Cube<T> &toCube(const Cube<T> &t) { return t; }
template <class T> inline Cube<T> toCube(const Extent2<T> &t) { return Cube<T>(t.x1(),t.x2(),t.y1(),t.y2(),0.0,0.0); }
 
// EoF