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