libMesh::MeshTools::BoundingBox Class Reference

Backwards compatibility with forward declarations. More...

#include <mesh_tools.h>

Inheritance diagram for libMesh::MeshTools::BoundingBox:

Public Member Functions
	BoundingBox (const Point &new_min, const Point &new_max)
	BoundingBox (const std::pair< Point, Point > &bbox)
	BoundingBox ()
void	invalidate ()
	Sets the bounding box to encompass the universe. More...
const Point &	min () const
Point &	min ()
const Point &	max () const
Point &	max ()
bool	intersects (const BoundingBox &) const
bool	intersects (const BoundingBox &, Real abstol) const
bool	intersect (const BoundingBox &b) const
bool	contains_point (const Point &) const
void	intersect_with (const BoundingBox &)
	Sets this bounding box to be the intersection with the other bounding box. More...
void	union_with (const Point &p)
	Enlarges this bounding box to include the given point. More...
void	union_with (const BoundingBox &)
	Sets this bounding box to be the union with the other bounding box. More...
Real	signed_distance (const Point &p) const
	Computes the signed distance, d, from a given Point p to this BoundingBox. More...

Detailed Description

Backwards compatibility with forward declarations.

Definition at line 70 of file mesh_tools.h.

Constructor & Destructor Documentation

BoundingBox() [1/3]

libMesh::MeshTools::BoundingBox::BoundingBox ( const Point &  new_min, const Point &  new_max  )

inline

Definition at line 73 of file mesh_tools.h.

                                      :
    libMesh::BoundingBox(new_min, new_max) {
    libmesh_deprecated(); // Switch to libMesh::BoundingBox
  }

BoundingBox() [2/3]

libMesh::MeshTools::BoundingBox::BoundingBox ( const std::pair< Point, Point > &  bbox )

inline

Definition at line 79 of file mesh_tools.h.

                                                   :
    libMesh::BoundingBox(bbox) {
    libmesh_deprecated(); // Switch to libMesh::BoundingBox
  }

BoundingBox() [3/3]

libMesh::MeshTools::BoundingBox::BoundingBox ( )

inline

Definition at line 84 of file mesh_tools.h.

                 {
    libmesh_deprecated(); // Switch to libMesh::BoundingBox
  }

Member Function Documentation

contains_point()

bool libMesh::BoundingBox::contains_point ( const Point &  p ) const

inherited

Returns

true if the bounding box contains the given point.

Definition at line 135 of file bounding_box.C.

{
  // Make local variables first to make things more clear in a moment
  Real my_min_x = this->first(0);
  Real my_max_x = this->second(0);
  bool x_int = is_between(my_min_x, p(0), my_max_x);
 
  bool intersection_true = x_int;
 
#if LIBMESH_DIM > 1
  Real my_min_y = this->first(1);
  Real my_max_y = this->second(1);
  bool y_int = is_between(my_min_y, p(1), my_max_y);
 
  intersection_true = intersection_true && y_int;
#endif
 
 
#if LIBMESH_DIM > 2
  Real my_min_z = this->first(2);
  Real my_max_z = this->second(2);
  bool z_int = is_between(my_min_z, p(2), my_max_z);
 
  intersection_true = intersection_true && z_int;
#endif
 
  return intersection_true;
}

References libMesh::is_between(), and libMesh::Real.

Referenced by main(), libMesh::BoundingBox::signed_distance(), and ElemTest< elem_type >::test_bounding_box().

intersect()

bool libMesh::BoundingBox::intersect ( const BoundingBox &  b ) const

inlineinherited

Returns

true if the other bounding box has a non-empty intersection with this bounding box.

Definition at line 121 of file bounding_box.h.

  { libmesh_deprecated(); return this->intersects(b); }

References libMesh::BoundingBox::intersects().

intersect_with()

void libMesh::BoundingBox::intersect_with ( const BoundingBox &  other_box )

inherited

Sets this bounding box to be the intersection with the other bounding box.

Definition at line 165 of file bounding_box.C.

{
  this->first(0)  = std::max(this->first(0),  other_box.first(0));
  this->second(0) = std::min(this->second(0), other_box.second(0));
 
#if LIBMESH_DIM > 1
  this->first(1)  = std::max(this->first(1),  other_box.first(1));
  this->second(1) = std::min(this->second(1), other_box.second(1));
#endif
 
#if LIBMESH_DIM > 2
  this->first(2)  = std::max(this->first(2),  other_box.first(2));
  this->second(2) = std::min(this->second(2), other_box.second(2));
#endif
}

intersects() [1/2]

bool libMesh::BoundingBox::intersects ( const BoundingBox &  other_box ) const

inherited

Returns

true if the other bounding box has a non-empty intersection with this bounding box. Exact floating point <= comparisons are performed.

Definition at line 35 of file bounding_box.C.

{
  // Make local variables first to make things more clear in a moment
  const Real & my_min_x = this->first(0);
  const Real & my_max_x = this->second(0);
  const Real & other_min_x = other_box.first(0);
  const Real & other_max_x = other_box.second(0);
 
  const bool x_int = is_between(my_min_x, other_min_x, my_max_x) || is_between(my_min_x, other_max_x, my_max_x) ||
    is_between(other_min_x, my_min_x, other_max_x) || is_between(other_min_x, my_max_x, other_max_x);
 
  bool intersection_true = x_int;
 
#if LIBMESH_DIM > 1
  const Real & my_min_y = this->first(1);
  const Real & my_max_y = this->second(1);
  const Real & other_min_y = other_box.first(1);
  const Real & other_max_y = other_box.second(1);
 
  const bool y_int = is_between(my_min_y, other_min_y, my_max_y) || is_between(my_min_y, other_max_y, my_max_y) ||
    is_between(other_min_y, my_min_y, other_max_y) || is_between(other_min_y, my_max_y, other_max_y);
 
  intersection_true = intersection_true && y_int;
#endif
 
#if LIBMESH_DIM > 2
  const Real & my_min_z = this->first(2);
  const Real & my_max_z = this->second(2);
  const Real & other_min_z = other_box.first(2);
  const Real & other_max_z = other_box.second(2);
 
  const bool z_int = is_between(my_min_z, other_min_z, my_max_z) || is_between(my_min_z, other_max_z, my_max_z) ||
    is_between(other_min_z, my_min_z, other_max_z) || is_between(other_min_z, my_max_z, other_max_z);
 
  intersection_true = intersection_true && z_int;
#endif
 
  return intersection_true;
}

References libMesh::is_between(), and libMesh::Real.

Referenced by libMesh::TreeNode< N >::insert(), libMesh::BoundingBox::intersect(), BBoxTest::test_no_degenerate(), BBoxTest::test_one_degenerate(), and BBoxTest::test_two_degenerate().

intersects() [2/2]

bool libMesh::BoundingBox::intersects ( const BoundingBox &  other_box, Real  abstol  ) const

inherited

Returns

true if the other bounding box has a non-empty intersection with this bounding box. abstol is an absolute tolerance used to make "fuzzy" comparisons. abstol must be strictly > 0.0, and both BBoxes being compared are "inflated" by abstol in each direction, i.e. (xmin, ymin, zmin) -> (xmin - abstol, ymin - abstol, zmin - abstol) (xmax, ymax, zmax) -> (xmax + abstol, ymax + abstol, zmax + abstol) before the intersection comparisons are made. This approach can be helpful for detecting intersections between two degenerate (planar) bounding boxes that lie in nearly (to within abstol) the same plane and in certain situations should be considered intersecting.

Definition at line 75 of file bounding_box.C.

{
  // If you want to use abstol==0, you need to call the "exact"
  // comparison version of the intersects() function.
  libmesh_assert(abstol > 0.);
 
  // Make local variables first to make things more clear in a moment
  const Real & my_min_x = this->first(0);
  const Real & my_max_x = this->second(0);
  const Real & ot_min_x = other_box.first(0);
  const Real & ot_max_x = other_box.second(0);
 
  const bool x_int =
    is_between(my_min_x - abstol, ot_min_x, my_max_x + abstol) ||
    is_between(my_min_x - abstol, ot_max_x, my_max_x + abstol) ||
    is_between(ot_min_x - abstol, my_min_x, ot_max_x + abstol) ||
    is_between(ot_min_x - abstol, my_max_x, ot_max_x + abstol);
 
  bool intersection_true = x_int;
 
  if (!intersection_true)
    return false;
 
#if LIBMESH_DIM > 1
  const Real & my_min_y = this->first(1);
  const Real & my_max_y = this->second(1);
  const Real & ot_min_y = other_box.first(1);
  const Real & ot_max_y = other_box.second(1);
 
  const bool y_int =
    is_between(my_min_y - abstol, ot_min_y, my_max_y + abstol) ||
    is_between(my_min_y - abstol, ot_max_y, my_max_y + abstol) ||
    is_between(ot_min_y - abstol, my_min_y, ot_max_y + abstol) ||
    is_between(ot_min_y - abstol, my_max_y, ot_max_y + abstol);
 
  intersection_true = intersection_true && y_int;
 
  if (!intersection_true)
    return false;
#endif
 
#if LIBMESH_DIM > 2
  const Real & my_min_z = this->first(2);
  const Real & my_max_z = this->second(2);
  const Real & ot_min_z = other_box.first(2);
  const Real & ot_max_z = other_box.second(2);
 
  const bool z_int =
    is_between(my_min_z - abstol, ot_min_z, my_max_z + abstol) ||
    is_between(my_min_z - abstol, ot_max_z, my_max_z + abstol) ||
    is_between(ot_min_z - abstol, my_min_z, ot_max_z + abstol) ||
    is_between(ot_min_z - abstol, my_max_z, ot_max_z + abstol);
 
  intersection_true = intersection_true && z_int;
#endif
 
  return intersection_true;
}

References libMesh::is_between(), libMesh::libmesh_assert(), and libMesh::Real.

invalidate()

void libMesh::BoundingBox::invalidate ( )

inlineinherited

Sets the bounding box to encompass the universe.

Definition at line 64 of file bounding_box.h.

  {
    for (unsigned int i=0; i<LIBMESH_DIM; i++)
      {
        this->first(i)  =  std::numeric_limits<Real>::max();
        this->second(i) = -std::numeric_limits<Real>::max();
      }
  }

Referenced by libMesh::BoundingBox::BoundingBox().

max() [1/2]

Point& libMesh::BoundingBox::max ( )

inlineinherited

Definition at line 88 of file bounding_box.h.

  { return this->second; }

max() [2/2]

const Point& libMesh::BoundingBox::max ( ) const

inlineinherited

Returns

A point at the maximum x,y,z coordinates of the box.

Definition at line 85 of file bounding_box.h.

  { return this->second; }

Referenced by main(), and libMesh::BoundingBox::union_with().

min() [1/2]

Point& libMesh::BoundingBox::min ( )

inlineinherited

Definition at line 79 of file bounding_box.h.

  { return this->first; }

min() [2/2]

const Point& libMesh::BoundingBox::min ( ) const

inlineinherited

Returns

A point at the minimum x,y,z coordinates of the box.

Definition at line 76 of file bounding_box.h.

  { return this->first; }

Referenced by main(), and libMesh::BoundingBox::union_with().

signed_distance()

Real libMesh::BoundingBox::signed_distance ( const Point &  p ) const

inherited

Computes the signed distance, d, from a given Point p to this BoundingBox.

The sign convention is: d > 0 if the point is outside the BoundingBox d <= 0 if the point is inside the Bounding Box

Definition at line 200 of file bounding_box.C.

{
  if (contains_point(p))
    {
      // Sign convention: if Point is inside the bbox, the distance is
      // negative. We then find the smallest distance to the different
      // sides of the box and return that.
      Real min_dist = std::numeric_limits<Real>::max();
 
      for (unsigned int dir=0; dir<LIBMESH_DIM; ++dir)
        {
          min_dist = std::min(min_dist, std::abs(p(dir) - second(dir)));
          min_dist = std::min(min_dist, std::abs(p(dir) - first(dir)));
        }
 
      return -min_dist;
    }
  else // p is outside the box
    {
      Real dx[3] = {0., 0., 0.};
 
      // Compute distance "above"/"below" the box in each
      // direction. If the point is somewhere in between the (min,
      // max) values of the box, dx is 0.
      for (unsigned int dir=0; dir<LIBMESH_DIM; ++dir)
        {
          if (p(dir) > second(dir))
            dx[dir] = p(dir) - second(dir);
          else if (p(dir) < first(dir))
            dx[dir] = p(dir) - first(dir);
        }
 
      return std::sqrt(dx[0]*dx[0] + dx[1]*dx[1] + dx[2]*dx[2]);
    }
}

References std::abs(), libMesh::BoundingBox::contains_point(), libMesh::Real, and std::sqrt().

Referenced by BBoxTest::test_signed_distance().

union_with() [1/2]

void libMesh::BoundingBox::union_with ( const BoundingBox &  other_box )

inherited

Sets this bounding box to be the union with the other bounding box.

Definition at line 182 of file bounding_box.C.

{
  this->first(0)  = std::min(this->first(0),  other_box.first(0));
  this->second(0) = std::max(this->second(0), other_box.second(0));
 
#if LIBMESH_DIM > 1
  this->first(1)  = std::min(this->first(1),  other_box.first(1));
  this->second(1) = std::max(this->second(1), other_box.second(1));
#endif
 
#if LIBMESH_DIM > 2
  this->first(2)  = std::min(this->first(2),  other_box.first(2));
  this->second(2) = std::max(this->second(2), other_box.second(2));
#endif
}

union_with() [2/2]

void libMesh::BoundingBox::union_with ( const Point &  p )

inlineinherited

Enlarges this bounding box to include the given point.

Definition at line 163 of file bounding_box.h.

{
  for (unsigned int i=0; i<LIBMESH_DIM; i++)
    {
      min()(i) = std::min(min()(i), p(i));
      max()(i) = std::max(max()(i), p(i));
    }
}

References libMesh::BoundingBox::max(), and libMesh::BoundingBox::min().

Referenced by libMesh::Cell::loose_bounding_box().

---

The documentation for this class was generated from the following file:

• include/mesh/mesh_tools.h