AxisBox.hpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */
 
#ifndef MB_AXIS_BOX_HPP
#define MB_AXIS_BOX_HPP
 
#include <limits>
#include "moab/Interface.hpp"
 
namespace moab
{
 
/**
 * \brief Class representing axis-aligned bounding box
 * \author Jason Kraftcheck ([email protected])
 * \date August, 2006
 */
class AxisBox
{
 public:
 inline AxisBox();
 
 inline AxisBox( const double* min, const double* max );
 
 inline AxisBox( const double* point );
 
 static ErrorCode get_tag( Tag& tag_handle_out, Interface* interface, const char* tag_name = 0 );
 
 /** Calculate a box bounding the entities contained in the passed set */
 static ErrorCode calculate( AxisBox& box_out, EntityHandle set, Interface* interface );
 
 /** Calculate a box bounding the vertices/elements in the passed Range */
 static ErrorCode calculate( AxisBox& box_out, const Range& elements, Interface* interface );
 
 /** intersect */
 inline AxisBox& operator&=( const AxisBox& other );
 
 /** unite */
 inline AxisBox& operator|=( const AxisBox& other );
 
 /** unite */
 inline AxisBox& operator|=( const double* point );
 
 inline const double* minimum() const
 {
 return minVect;
 }
 
 inline const double* maximum() const
 {
 return maxVect;
 }
 
 inline double* minimum()
 {
 return minVect;
 }
 
 inline double* maximum()
 {
 return maxVect;
 }
 
 inline void center( double* center_out ) const;
 
 inline void diagonal( double* diagonal_out ) const;
 
 /**\brief Check if two boxes intersect.
 *
 * Check if two boxes are within the specified tolerance of
 * each other. If tolerance is less than zero, then boxes must
 * overlap by at least the magnitude of the tolerance to be
 * considered intersecting.
 */
 inline bool intersects( const AxisBox& other, double tolerance ) const;
 
 /**\brief Check if box contains point
 *
 * Check if a position is in or on the box, within the specified tolerance
 */
 inline bool intersects( const double* point, double tolerance ) const;
 
 /**\brief Check that box is valid
 *
 * Check that box is defined (contains at least a single point.)
 */
 inline bool valid() const;
 
 /**\brief Find closest position on/within box to input position.
 *
 * Find the closest position in the solid box to the input position.
 * If the input position is on or within the box, then the output
 * position will be the same as the input position. If the input
 * position is outside the box, the outside position will be the
 * closest point on the box boundary to the input position.
 */
 inline void closest_position_within_box( const double* input_position, double* output_position ) const;
 
 private:
 double minVect[3], maxVect[3];
};
 
/** intersect */
inline AxisBox operator&( const AxisBox& a, const AxisBox& b )
{
 return AxisBox( a ) &= b;
}
 
/** unite */
inline AxisBox operator|( const AxisBox& a, const AxisBox& b )
{
 return AxisBox( a ) |= b;
}
 
/** intersects */
inline bool operator||( const AxisBox& a, const AxisBox& b )
{
 return a.minimum()[0] <= b.maximum()[0] && a.minimum()[1] <= b.maximum()[1] && a.minimum()[2] <= b.maximum()[2] &&
 a.maximum()[0] >= b.minimum()[0] && a.maximum()[1] >= b.minimum()[1] && a.maximum()[2] >= b.minimum()[2];
}
 
inline AxisBox::AxisBox()
{
 minVect[0] = minVect[1] = minVect[2] = std::numeric_limits< double >::max();
 maxVect[0] = maxVect[1] = maxVect[2] = -std::numeric_limits< double >::max();
}
 
inline AxisBox::AxisBox( const double* min, const double* max )
{
 minVect[0] = min[0];
 minVect[1] = min[1];
 minVect[2] = min[2];
 maxVect[0] = max[0];
 maxVect[1] = max[1];
 maxVect[2] = max[2];
}
 
inline AxisBox::AxisBox( const double* point )
{
 minVect[0] = maxVect[0] = point[0];
 minVect[1] = maxVect[1] = point[1];
 minVect[2] = maxVect[2] = point[2];
}
 
inline AxisBox& AxisBox::operator&=( const AxisBox& other )
{
 for( int i = 0; i < 3; ++i )
 {
 if( minVect[i] < other.minVect[i] ) minVect[i] = other.minVect[i];
 if( maxVect[i] > other.maxVect[i] ) maxVect[i] = other.maxVect[i];
 }
 return *this;
}
 
inline AxisBox& AxisBox::operator|=( const AxisBox& other )
{
 for( int i = 0; i < 3; ++i )
 {
 if( minVect[i] > other.minVect[i] ) minVect[i] = other.minVect[i];
 if( maxVect[i] < other.maxVect[i] ) maxVect[i] = other.maxVect[i];
 }
 return *this;
}
 
inline AxisBox& AxisBox::operator|=( const double* point )
{
 for( int i = 0; i < 3; ++i )
 {
 if( minVect[i] > point[i] ) minVect[i] = point[i];
 if( maxVect[i] < point[i] ) maxVect[i] = point[i];
 }
 return *this;
}
 
inline void AxisBox::center( double* center_out ) const
{
 center_out[0] = 0.5 * ( minVect[0] + maxVect[0] );
 center_out[1] = 0.5 * ( minVect[1] + maxVect[1] );
 center_out[2] = 0.5 * ( minVect[2] + maxVect[2] );
}
 
inline void AxisBox::diagonal( double* diagonal_out ) const
{
 diagonal_out[0] = maxVect[0] - minVect[0];
 diagonal_out[1] = maxVect[1] - minVect[1];
 diagonal_out[2] = maxVect[2] - minVect[2];
}
 
inline bool AxisBox::intersects( const AxisBox& other, double tolerance ) const
{
 return minVect[0] - other.maxVect[0] <= tolerance && minVect[1] - other.maxVect[1] <= tolerance &&
 minVect[2] - other.maxVect[2] <= tolerance && other.minVect[0] - maxVect[0] <= tolerance &&
 other.minVect[1] - maxVect[1] <= tolerance && other.minVect[2] - maxVect[2] <= tolerance;
}
 
inline bool AxisBox::intersects( const double* point, double tolerance ) const
{
 return minVect[0] - point[0] <= tolerance && minVect[1] - point[1] <= tolerance &&
 minVect[2] - point[2] <= tolerance && maxVect[0] - point[0] <= tolerance &&
 maxVect[1] - point[1] <= tolerance && maxVect[2] - point[2] <= tolerance;
}
 
inline bool AxisBox::valid() const
{
 return minVect[0] <= maxVect[0] && minVect[1] <= maxVect[1] && minVect[2] <= maxVect[2];
}
 
inline void AxisBox::closest_position_within_box( const double* input_position, double* output_position ) const
{
 for( int i = 0; i < 3; ++i )
 {
 if( input_position[i] < minVect[i] )
 output_position[i] = minVect[i];
 else if( input_position[i] > maxVect[i] )
 output_position[i] = maxVect[i];
 else
 output_position[i] = input_position[i];
 }
}
 
} // namespace moab
 
#endif