AxisBox.hpp

Go to the documentation of this file.

#ifndef MB_AXIS_BOX_HPP
#define MB_AXIS_BOX_HPP

#include <limits>
#include "moab/Interface.hpp"

namespace moab {

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 );
    
    static ErrorCode calculate( AxisBox& box_out,
                                  EntityHandle set,
                                  Interface* interface );
                                      
    static ErrorCode calculate( AxisBox& box_out,
                                  const Range& elements,
                                  Interface* interface );
                                  
    inline AxisBox& operator &=( const AxisBox& other );

    inline AxisBox& operator |=( const AxisBox& other );
    
    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;
    
    inline bool intersects( const AxisBox& other, 
                            double tolerance ) const;
  
    inline bool intersects( const double* point,
                            double tolerance ) const;
    
    inline bool valid() const;
                      
     inline void closest_position_within_box( const double* input_position,
                                    double* output_position ) const;
                            
  private:
  
    double minVect[3], maxVect[3];
};

inline AxisBox operator&( const AxisBox& a, const AxisBox& b )
  { return AxisBox(a) &= b; }

inline AxisBox operator|( const AxisBox& a, const AxisBox& b )
  { return AxisBox(a) |= b; }

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