AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

boundingBox.h

Go to the documentation of this file.

#ifndef ANIMAL__BOUNDINGBOX___________
#define ANIMAL__BOUNDINGBOX___________

#include <iostream>
//#include <animal/numerics.h>
#include <animal/vec3.h>
#include <animal/container_traits.h>

namespace animal {

//===================================================================
// BoundingBox3D
//===================================================================

template < 
    class Point = Vec3, 
    class Real = typename container_traits<Point>::value_type
    >
class BoundingBox3D
{
public:
    
    
    BoundingBox3D( 
        Real xm =  INFINITY,  // minimum along x
        Real ym =  INFINITY,  // minimum along y
        Real zm =  INFINITY,  // minimum along z 
        Real xM = -INFINITY,  // maximum along x 
        Real yM = -INFINITY,  // maximum along y 
        Real zM = -INFINITY   // maximum along z  
    )
    {
        _min[0] = xm; _min[1] = ym; _min[2] = zm;
        _max[0] = xM; _max[1] = yM; _max[2] = zM;
    }
    
    BoundingBox3D( const Point& v )
    {
        for( int i=0; i<3; ++i ){
            _min[i] = _max[i] = v[i];
        }
    }
    
    BoundingBox3D( const Point& v_min, const Point& v_max )
    {
        for( int i=0; i<3; ++i ){
            _min[i] = v_min[i];
            _max[i] = v_max[i];
        }
    }
    
    
    
    Point min() const { return Point(_min[0],_min[1],_min[2]); }
    
    Point max() const { return Point(_max[0], _max[1], _max[2]); }
    
    
    
    
    void insert( const Point& v )
    {
        for( int i=0; i<3; ++i ){
            if( v[i]<_min[i] ) _min[i]=v[i];
            else if( v[i]>_max[i] ) _max[i] = v[i];
        }
    }
    
    void insert( const BoundingBox3D& b )
    {
        for( int i=0; i<3; ++i ){
            if( b._min[i]<_min[i] ) _min[i] = b._min[i];
            if( b._max[i]>_max[i] ) _max[i] = b._max[i];
        }
    }
    
    void shift( const Point& v )
    {
        for( int i=0; i<3; ++i ){
            _min[i] += v[i];
            _max[i] += v[i];
        }
    }
    
    
    template< class RotationMatrix >
    BoundingBox3D move ( const Point& p, const RotationMatrix& r )
    {
        // center on origin
        Real center[3], half[3];
        for( int i=0; i<3; ++i ){
            center[i] = (_max[i] + _min[i]) /2;
            half[i]   = (_max[i] - _min[i]) /2;
        }

        // rotate: compute new half
        Real newhalf[3] = {0,0,0};
        {for( int i=0; i<3; ++i ){
            for( int j=0; j<3; ++j ){
                newhalf[i] += fabs( r[i][j] * half[j] );
            }
        }}

        // move center  
        Real newcenter[3];
        {for( int i=0; i<3; ++i ){
            newcenter[i] = p[i];
            for( int j=0; j<3; ++j ){
                newcenter[i] += r[i][j] * center[j] ;
            }
        }}

//      cerr<<"center: "<<center[0]<<" "<<center[1]<<" "<<center[2]<<endl;
//      cerr<<"half: "<<half[0]<<" "<<half[1]<<" "<<half[2]<<endl;
//      cerr<<"rotation matrix: "<<endl;
//      {for( int i=0; i<3; ++i ){
//          for( int j=0; j<3; ++j )
//              cerr<<r[i][j]<<" ";
//          cerr << endl;
//      }}
//      cerr<<"newcenter: "<<newcenter[0]<<" "<<newcenter[1]<<" "<<newcenter[2]<<endl;
//      cerr<<"newhalf: "<<newhalf[0]<<" "<<newhalf[1]<<" "<<newhalf[2]<<endl;

        return BoundingBox3D(
            newcenter[0] - newhalf[0],
            newcenter[1] - newhalf[1],
            newcenter[2] - newhalf[2],
            newcenter[0] + newhalf[0],
            newcenter[1] + newhalf[1],
            newcenter[2] + newhalf[2]
        );

    }


    
    template < class P, class R >
    friend bool intersect( const BoundingBox3D<P,R>& b1, const BoundingBox3D<P,R>& b2 );


    
    template < class P, class R >
    friend std::ostream& operator << ( std::ostream&, const BoundingBox3D<P,R>& );
    

private:

    Real _max[3];           
    Real _min[3];           

};

// -----------------------------------------------------
//  
//  
// -----------------------------------------------------

template < class P, class R >
inline std::ostream& operator<< ( std::ostream& os, const BoundingBox3D<P,R>& b )
{
    os<<b._min[0]<<" "<<b._min[1]<<" "<<b._min[2]<<" "
        <<b._max[0]<<" "<<b._max[1]<<" "<<b._max[2];
    return os;
}

template < class P, class R >
inline bool intersect( const BoundingBox3D<P,R>& b1, const BoundingBox3D<P,R>& b2 )
{
    return !( 
           b1._max[0]<b2._min[0] || b2._max[0]<b1._min[0]
        || b1._max[1]<b2._min[1] || b2._max[1]<b1._min[1]
        || b1._max[2]<b2._min[2] || b2._max[2]<b1._min[2]
        );
}

} // close namespace animal
#endif

---