libMesh::BoundingBox Class Reference

Defines a Cartesian bounding box by the two corner extremum. More...

#include <bounding_box.h>

Inheritance diagram for libMesh::BoundingBox:

Public Member Functions
	BoundingBox (const Point &new_min, const Point &new_max)
	BoundingBox (const std::pair< Point, Point > &bbox)
	BoundingBox ()
	Default constructor sets invalid bounds. More...
void	invalidate ()
	Sets the bounding box to be "inverted". More...
const Point &	min () const
Point &	min ()
const Point &	max () const
Point &	max ()
bool	contains (const BoundingBox &) const
bool	intersects (const BoundingBox &) const
bool	intersects (const BoundingBox &, Real abstol) const
bool	contains_point (const Point &) const
bool	contains_point (const Point &p, Real abs_tol, Real rel_tol) 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...
void	scale (const Real factor)
	Scales each dimension of the bounding box by factor. More...
Real	max_size () const
	Returns the maximum size of a finite box extent. More...
void	print (std::ostream &os=libMesh::out) const
	Formatted print, by default to libMesh::out. More...

Friends
std::ostream &	operator<< (std::ostream &os, const BoundingBox &b)
	Formatted print as above but supports the syntax: More...

Detailed Description

Defines a Cartesian bounding box by the two corner extremum.

Definition at line 40 of file bounding_box.h.

Constructor & Destructor Documentation

BoundingBox() [1/3]

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

inline

Definition at line 44 of file bounding_box.h.

                                      :
    std::pair<Point, Point>(new_min, new_max)
  {}

BoundingBox() [2/3]

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

inline

Definition at line 49 of file bounding_box.h.

                                                   :
    std::pair<Point, Point> (bbox)
  {}

BoundingBox() [3/3]

libMesh::BoundingBox::BoundingBox ( )

inline

Default constructor sets invalid bounds.

Definition at line 56 of file bounding_box.h.

References invalidate().

  {
    this->invalidate();
  }

Member Function Documentation

contains()

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

inline

Returns

true if the other bounding box is contained in this bounding box. Exact floating point <= comparisons are performed.

Definition at line 209 of file bounding_box.h.

Referenced by libMesh::NetGenMeshInterface::triangulate().

{
  const libMesh::Point & my_lower = this->first;
  const libMesh::Point & my_upper = this->second;

  const libMesh::Point & other_lower = other_box.first;
  const libMesh::Point & other_upper = other_box.second;

  for (unsigned int dir=0; dir<LIBMESH_DIM; ++dir)
    if (my_lower(dir) > other_lower(dir) ||
        other_upper(dir) > my_upper(dir))
      return false;

  return true;
}

contains_point() [1/2]

bool libMesh::BoundingBox::contains_point

(

const Point &

p

)

const

Returns

true if the bounding box contains the given point.

Definition at line 35 of file bounding_box.C.

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

Referenced by OutputAssembly::interior_assembly(), main(), libMesh::GmshIO::read_mesh(), signed_distance(), and ElemTest< elem_type >::test_bounding_box().

{
  // 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;
}

contains_point() [2/2]

bool libMesh::BoundingBox::contains_point	(	const Point &	p,
		Real	abs_tol,
		Real	rel_tol
	)		const

Returns

true if the bounding box contains the given point, to within at least one of the given tolerance(s). At least one tolerance should be set to greater than zero; otherwise use the other contains_point overload for efficiency.

Relative tolerances are computed relative to the maximum finite extent of the bounding box, max_size()

Definition at line 83 of file bounding_box.C.

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

{
  libmesh_assert_greater_equal(abs_tol, Real(0));
  libmesh_assert_greater_equal(rel_tol, Real(0));

  // Just use the other contains_point overload
  libmesh_assert_greater(rel_tol+abs_tol, Real(0));

  // Find absolute tolerance from relative tolerance
  const Real tol = std::max(abs_tol, this->max_size()*rel_tol);

  // Make local variables first to make things more clear in a moment
  const Real my_min_x = this->first(0) - tol;
  const Real my_max_x = this->second(0) + tol;
  const bool x_int = is_between(my_min_x, p(0), my_max_x);

  bool intersection_true = x_int;

#if LIBMESH_DIM > 1
  const Real my_min_y = this->first(1) - tol;
  const Real my_max_y = this->second(1) + tol;
  const bool y_int = is_between(my_min_y, p(1), my_max_y);

  intersection_true = intersection_true && y_int;
#endif


#if LIBMESH_DIM > 2
  const Real my_min_z = this->first(2) - tol;
  const Real my_max_z = this->second(2) + tol;
  const bool z_int = is_between(my_min_z, p(2), my_max_z);

  intersection_true = intersection_true && z_int;
#endif

  return intersection_true;
}

intersect_with()

void libMesh::BoundingBox::intersect_with

(

const BoundingBox &

other_box

)

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

Definition at line 123 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

inline

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 231 of file bounding_box.h.

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

{
  const libMesh::Point & my_lower = this->first;
  const libMesh::Point & my_upper = this->second;

  const libMesh::Point & other_lower = other_box.first;
  const libMesh::Point & other_upper = other_box.second;

  // Since boxes are tensor products of line intervals it suffices to check
  // that the line segments for each coordinate axis overlap.
  for (unsigned int dir=0; dir<LIBMESH_DIM; ++dir)
    {
      // Line segments can intersect in two ways:
      // 1. They can overlap.
      // 2. One can be inside the other.
      //
      // In the first case we want to see if either end point of the second
      // line segment lies within the first. In the second case we can simply
      // check that one end point of the first line segment lies in the second
      // line segment. Note that we don't need, in the second case, to do two
      // checks since that case is already covered by the first.
      if (!((my_lower(dir) <= other_lower(dir) &&
             other_lower(dir) <= my_upper(dir)) ||
            (my_lower(dir) <= other_upper(dir) &&
             other_upper(dir) <= my_upper(dir))) &&
          !((other_lower(dir) <= my_lower(dir) &&
             my_lower(dir) <= other_upper(dir))))
        {
          return false;
        }
    }

  return true;
}

intersects() [2/2]

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

inline

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 268 of file bounding_box.h.

References intersects(), and libMesh::libmesh_assert().

{
  // If you want to use abstol==0, you need to call the "exact"
  // comparison version of the intersects() function.
  libmesh_assert(abstol > 0.);

  BoundingBox expanded_my_box = *this;
  for (unsigned int dir=0; dir<LIBMESH_DIM; ++dir)
    {
      expanded_my_box.first(dir) -= abstol;
      expanded_my_box.second(dir) += abstol;
    }
  return expanded_my_box.intersects(other_box);
}

invalidate()

void libMesh::BoundingBox::invalidate ( )

inline

Sets the bounding box to be "inverted".

This is a useful starting point for future union_with operations.

Definition at line 65 of file bounding_box.h.

Referenced by BoundingBox().

  {
    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();
      }
  }

max() [1/2]

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

inline

Returns

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

Definition at line 86 of file bounding_box.h.

Referenced by OutputAssembly::interior_assembly(), main(), print(), libMesh::GmshIO::read_mesh(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildSquare(), and union_with().

  { return this->second; }

max() [2/2]

Point& libMesh::BoundingBox::max ( )

inline

Definition at line 89 of file bounding_box.h.

  { return this->second; }

max_size()

Real libMesh::BoundingBox::max_size

(

)

const

Returns the maximum size of a finite box extent.

If the bounding box is infinite (or effectively so, e.g. using numeric_limits<Real>::max()) in some dimension, then that dimension is ignored.

Definition at line 66 of file bounding_box.C.

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

{
  Real size = 0;
  for (unsigned int d = 0; d != LIBMESH_DIM; ++d)
    {
      Real sized = this->second(d) - this->first(d);
      if (!libmesh_isinf(sized) &&
          this->second(d) != std::numeric_limits<Real>::max() &&
          this->first(d) != -std::numeric_limits<Real>::max())
        size = std::max(size, sized);
    }
  return size;
}

min() [1/2]

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

inline

Returns

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

Definition at line 77 of file bounding_box.h.

Referenced by OutputAssembly::interior_assembly(), main(), print(), libMesh::GmshIO::read_mesh(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildSquare(), and union_with().

  { return this->first; }

min() [2/2]

Point& libMesh::BoundingBox::min ( )

inline

Definition at line 80 of file bounding_box.h.

  { return this->first; }

print()

void libMesh::BoundingBox::print

(

std::ostream &

os = libMesh::out

)

const

Formatted print, by default to libMesh::out.

Definition at line 212 of file bounding_box.C.

References max(), and min().

{
  os << "(min=" << this->min() << ", max=" << this->max() << ")";
}

scale()

void libMesh::BoundingBox::scale

(

const Real

factor

)

Scales each dimension of the bounding box by factor.

Has no effect for dimensions in which either min(dim) == std::numeric_limits<Real>::max() or max(dim) == -std::numeric_limits<Real>::max(), which is the "invalid" state set by the default constructor and by invalidate().

Definition at line 195 of file bounding_box.C.

References dim, and libMesh::Real.

{
  Real append;
  for (unsigned int dim = 0; dim != LIBMESH_DIM; ++dim)
  {
    if (this->first(dim) != std::numeric_limits<Real>::max() &&
        this->second(dim) != -std::numeric_limits<Real>::max())
    {
      libmesh_assert_greater_equal(this->second(dim), this->first(dim));
      append = (this->second(dim) - this->first(dim)) * factor;
      this->first(dim) -= append;
      this->second(dim) += append;
    }
  }
}

signed_distance()

Real libMesh::BoundingBox::signed_distance

(

const Point &

p

)

const

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 158 of file bounding_box.C.

References contains_point(), and libMesh::Real.

Referenced by BBoxTest::test_signed_distance().

{
  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]);
    }
}

union_with() [1/2]

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

inline

Enlarges this bounding box to include the given point.

Definition at line 286 of file bounding_box.h.

References max(), and min().

Referenced by libMesh::MeshBase::get_info(), libMesh::Cell::loose_bounding_box(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

{
  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));
    }
}

union_with() [2/2]

void libMesh::BoundingBox::union_with

(

const BoundingBox &

other_box

)

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

Definition at line 140 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
}

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  os, const BoundingBox &  b  )

friend

Formatted print as above but supports the syntax:

BoundingBox b;
std::cout << b << std::endl;

Definition at line 195 of file bounding_box.h.

  {
    b.print(os);
    return os;
  }

---

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

• include/geom/bounding_box.h
• src/geom/bounding_box.C