extent3.h

Go to the documentation of this file.

#pragma once
#include "extent2.h"
 
template <class T> class Extent3 {
public:
    // Creators
    constexpr Extent3()=default;
    constexpr Extent3(const Extent3<T> &)=default;
    constexpr Extent3<T> &operator=(const Extent3 &e)=default;
 
    Extent3(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) { }
    Extent3(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()) { }
    explicit Extent3(const Extent2<T> &r) : tx1_(r.x1()), tx2_(r.x2()), ty1_(r.y1()), ty2_(r.y2()), tz1_(0), tz2_(1) { }
    static constexpr Extent3<T> nothing() { Extent3<T> c(limits<T>::max(),-limits<T>::max(),
                                                         limits<T>::max(),-limits<T>::max(),
                                                         limits<T>::max(),-limits<T>::max());  return c; }
    // 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 u) const {
        assert(u<3);
        switch (u) {
        case 1:  return ty1_;
        case 2:  return tz1_;
        }
        return tx1_;
    }
    const T &dof2(uint32 u) const {
        assert(u<3);
        switch (u) {
        case 1:  return ty2_;
        case 2:  return tz2_;
        }
        return tx2_;
    }
    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_ + tol >= tx2_) || (ty1_ + tol >= ty2_) || (tz1_ + tol >= tz2_) ); }
    bool operator==(const Extent3<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 Extent3<T> &r) const { return !operator==(r); }
    bool operator<(const Extent3<T> &c) const { return (volume() < c.volume()); }
    bool operator>(const Extent3<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 Extent3<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 Extent3<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 Extent3<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 Extent3<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 u) {
        assert(u<3);
        switch (u) {
        case 1:  return ty1_;
        case 2:  return tz1_;
        }
        return tx1_;
    }
    T &rdof2(uint32 u) {
        assert(u<3);
        switch (u) {
        case 1:  return ty2_;
        case 2:  return tz2_;
        }
        return tx2_;
    }
    // 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 Extent3<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 Extent3<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
    Extent3<T> operator+(const Vector3<T> &v) const { Extent3<T> out(tx1_+v.x(),tx2_+v.x(),ty1_+v.y(),ty2_+v.y(),tz1_+v.z(),tz2_+v.z());  return out; }
    Extent3<T> operator-(const Vector3<T> &v) const { Extent3<T> out(tx1_-v.x(),tx2_-v.x(),ty1_-v.y(),ty2_-v.y(),tz1_-v.z(),tz2_-v.z());  return out; }
    Extent3<T> intersectedWith(const Extent3<T> &r) const {
        Extent3<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 Extent3<T> &expandToInclude(const Extent3<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 Extent3<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 Extent3<T> &expandToInclude(const T &x,const T &y,const T &z) {
        return expandToInclude(Vector3<T>(x,y,z));
    }
    Extent3<T> expandedToInclude(const Extent3<T> &r) const {
        Extent3<T> out(*this);
        out.expandToInclude(r);
        return out;
    }
    Extent3<T> expandedToInclude(const Vector3<T> &v) const {
        Extent3<T> out(*this);
        out.expandToInclude(v);
        return out;
    }
    Extent3<T> expandedToInclude(const T &x,const T &y,const T &z) const {
        return expandedToInclude(Vector3<T>(x,y,z));
    }
    const Extent3<T> &expand(const T &tol) { tx1_ -= tol;  tx2_ += tol;  ty1_ -= tol;  ty2_ += tol;  tz1_ -= tol;  tz2_ += tol;  return *this; }
    Extent3<T> expanded(const T &tol) const { Extent3<T> out(*this);  return out.expand(tol); }
    Extent3<T> biggerBy(const T &fact) const {
        auto s = size()*0.5;
        s += s*fact;
        auto c = centroid();
        Extent3<T> out(c-s,c+s);
        return out;
    }
    const Extent3<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;
    }
    Extent3<T> center(const Vector3<T> &v) const {
        Extent3<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{};
    T tx2_=T{};
    T ty1_=T{};
    T ty2_=T{};
    T tz1_=T{};
    T tz2_=T{};
};
 
 
// Predefined types for standard template arguments.
using DExtent3   = Extent3<double>;  
using FExtent3   = Extent3<float>;   
using IExtent3   = Extent3<int32>;   
using UExtent3   = Extent3<uint32>;  
using I64Extent3 = Extent3<int64>;   
using U64Extent3 = Extent3<uint64>;  
 
template <class T> inline const Extent3<T> &toExtent3(const Extent3<T> &t) { return t; }
template <class T> inline Extent3<T> toExtent3(const Extent2<T> &t) { return Extent3<T>(t.x1(),t.x2(),t.y1(),t.y2(),0.0,0.0); }
 
// EoF