BoundBox.hpp

Go to the documentation of this file.

#ifndef BOUND_BOX_HPP
#define BOUND_BOX_HPP

#include "moab/Interface.hpp"
#include "moab/CartVect.hpp"

#include <cfloat>

namespace moab
{

class BoundBox
{
  public:
    BoundBox() : bMin( DBL_MAX ), bMax( -DBL_MAX ) {}
    BoundBox( const CartVect& min, const CartVect& max ) : bMin( min ), bMax( max ) {}
    BoundBox( const double* corners );
    // constructor used in element maps
    BoundBox( std::vector< CartVect > points ) : bMin( DBL_MAX ), bMax( -DBL_MAX )
    {
        for( size_t i = 0; i < points.size(); i++ )
        {
            update_min( points[i].array() );
            update_max( points[i].array() );
        }
    }
    BoundBox( const BoundBox& from ) : bMin( from.bMin ), bMax( from.bMax ) {}

    ~BoundBox() {}

    bool contains_point( const double* point, const double tol = 0.0 ) const;
    bool intersects_box( const BoundBox& b, const double tol = 0.0 ) const;
    void compute_center( CartVect& center );
    void update( const BoundBox& other_box );
    void update( const double* coords );
    ErrorCode update( Interface& iface, const Range& elems, bool spherical = false, double radius = 1. );
    ErrorCode update( Interface& iface, const EntityHandle ent, bool spherical = false, double radius = 1. );
    void update_min( const BoundBox& other_box );
    void update_min( const double* coords );
    void update_max( const BoundBox& other_box );
    void update_max( const double* coords );
    ErrorCode get( double* coords );
    /** in case of spherical elements, account for curvature if needed
     */
    void update_box_spherical_elem( const CartVect* coordverts, int len, double radius );

    /** \brief Return the diagonal length of this box
     */
    double diagonal_length() const;

    /** \brief Return the square of the diagonal length of this box
     */
    double diagonal_squared() const;

    /** \brief Return square of distance from box, or zero if inside
     * \param from_point Point from which you want distance_sq
     */
    double distance_squared( const double* from_point ) const;

    /** \brief Return distance from box, or zero if inside
     * \param from_point Point from which you want distance
     */
    double distance( const double* from_point ) const;

    BoundBox& operator=( const BoundBox& from )
    {
        bMin = from.bMin;
        bMax = from.bMax;
        return *this;
    }
    inline bool operator==( const BoundBox& box ) const
    {
        return ( bMin == box.bMin && bMax == box.bMax );
    }

    CartVect bMin, bMax;
};

inline BoundBox::BoundBox( const double* corners )
{
    // relies on CartVect being Plain Old Data, no virtual table
    double* arr = bMin.array();
    for( int i = 0; i < 6; i++ )
        arr[i] = corners[i];
}

inline bool BoundBox::contains_point( const double* point, const double tol ) const
{
    if( point[0] < bMin[0] - tol || point[0] > bMax[0] + tol || point[1] < bMin[1] - tol || point[1] > bMax[1] + tol ||
        point[2] < bMin[2] - tol || point[2] > bMax[2] + tol )
        return false;
    else
        return true;
}

inline bool BoundBox::intersects_box( const BoundBox& b, const double tol ) const
{
    if( b.bMax[0] < bMin[0] - tol || b.bMin[0] > bMax[0] + tol || b.bMax[1] < bMin[1] - tol ||
        b.bMin[1] > bMax[1] + tol || b.bMax[2] < bMin[2] - tol || b.bMin[2] > bMax[2] + tol )
        return false;

    else
        return true;
}

inline void BoundBox::update( const BoundBox& other_box )
{
    update_min( other_box );
    update_max( other_box );
}

inline void BoundBox::update( const double* coords )
{
    update_min( coords );
    update_max( coords + 3 );
}

inline void BoundBox::update_min( const BoundBox& other_box )
{
    bMin[0] = std::min( bMin[0], other_box.bMin[0] );
    bMin[1] = std::min( bMin[1], other_box.bMin[1] );
    bMin[2] = std::min( bMin[2], other_box.bMin[2] );
}

inline void BoundBox::update_min( const double* coords )
{
    bMin[0] = std::min( bMin[0], coords[0] );
    bMin[1] = std::min( bMin[1], coords[1] );
    bMin[2] = std::min( bMin[2], coords[2] );
}

inline void BoundBox::update_max( const BoundBox& other_box )
{
    bMax[0] = std::max( bMax[0], other_box.bMax[0] );
    bMax[1] = std::max( bMax[1], other_box.bMax[1] );
    bMax[2] = std::max( bMax[2], other_box.bMax[2] );
}

inline void BoundBox::update_max( const double* coords )
{
    bMax[0] = std::max( bMax[0], coords[0] );
    bMax[1] = std::max( bMax[1], coords[1] );
    bMax[2] = std::max( bMax[2], coords[2] );
}

inline ErrorCode BoundBox::get( double* coords )
{
    bMin.get( coords );
    bMax.get( coords + 3 );
    return MB_SUCCESS;
}

inline void BoundBox::compute_center( CartVect& center )
{
    center = 0.5 * ( bMin + bMax );
}

inline std::ostream& operator<<( std::ostream& out, const BoundBox& box )
{
    out << ( std::string ) "Min: ";
    out << box.bMin;
    out << ( std::string ) ", Max: ";
    out << box.bMax;
    return out;
}

inline ErrorCode BoundBox::update( Interface& iface, const EntityHandle ent, bool spherical, double radius )
{
    Range tmp_range( ent, ent );
    return update( iface, tmp_range, spherical, radius );
}

inline double BoundBox::distance_squared( const double* from_point ) const
{
    double dist_sq = 0.0;
    for( int i = 0; i < 3; ++i )
    {
        if( from_point[i] < bMin[i] )
            dist_sq += ( bMin[i] - from_point[i] ) * ( bMin[i] - from_point[i] );
        else if( from_point[i] > bMax[i] )
            dist_sq += ( bMax[i] - from_point[i] ) * ( bMax[i] - from_point[i] );
    }
    return dist_sq;
}

inline double BoundBox::distance( const double* from_point ) const
{
    double dist_sq = distance_squared( from_point );
    return sqrt( dist_sq );
}

inline double BoundBox::diagonal_length() const
{
    if( DBL_MAX == bMax[0] || DBL_MAX == bMax[1] || DBL_MAX == bMax[2] || DBL_MAX == bMin[0] || DBL_MAX == bMin[1] ||
        DBL_MAX == bMin[2] )
        return DBL_MAX;
    return ( bMax - bMin ).length();
}

inline double BoundBox::diagonal_squared() const
{
    if( DBL_MAX == bMax[0] || DBL_MAX == bMax[1] || DBL_MAX == bMax[2] || DBL_MAX == bMin[0] || DBL_MAX == bMin[1] ||
        DBL_MAX == bMin[2] )
        return DBL_MAX;
    return ( bMax - bMin ).length_squared();
}

}  // namespace moab

#endif