OrientedBoundingBox Class Reference

Oriented bounding box in 2 D or 3 D. More...

#include <OrientedBoundingBox.h>

Public Member Functions
	OrientedBoundingBox ()
	Default-constructs an empty box (zero dimension, no axes).
	OrientedBoundingBox (const std::vector< std::pair< Point, Point > > &axis_pairs)
	Build the box from a set of axis end-points.
bool	contains (const Point &pt, const Real tolerance=libMesh::TOLERANCE) const
	Test whether a point lies inside or on the box.
Point	centroid () const
Point	getAxisDirection (unsigned int i) const
Real	getAxisLength (unsigned int i) const
Point	getMinimalCorner () const
Point	getMaximalCorner () const
void	print (std::ostream &os) const
	Print a summary (dimension, origin, axes).
void	writeMesh (const std::filesystem::path &path, const libMesh::Parallel::Communicator &comm) const
	Write the oriented box as a single libMesh element to a mesh file.
void	writeRayAlongShortestAxis (const std::filesystem::path &ray_path, const libMesh::Parallel::Communicator &comm) const
	Write a single-EDGE2 mesh representing a "ray" emanating from the box.
Real	getProjectedLength (const Point &pt, unsigned int i) const
	Get the length of the projection of a point onto axis i.

Private Attributes
Point	_minimal_corner
	shared minimal corner
Point	_maximal_corner
	shared maximal corner
std::vector< Point >	_dirs
	orthonormal basis vectors (size = _dim)
std::vector< Real >	_len
	length along each basis (size = _dim)
unsigned int	_dim = 0u
	spatial dimension (2 or 3)

Detailed Description

Oriented bounding box in 2 D or 3 D.

An N-D (N = 2 or 3) oriented bounding box defined by one common origin, N orthonormal directions, and a length along each direction.

Construction is based on N "(min,max)" pairs that share a common min point:

• axis_pairs[i].first = shared origin
• axis_pairs[i].second = far-end point on axis i

Example (3-D): {{o, o+dx}, {o, o+dy}, {o, o+dz}}

The sequence of pairs is usually supplied in the order main axis, secondary axis, then minor axis (in other class).

Definition at line 44 of file OrientedBoundingBox.h.

Constructor & Destructor Documentation

OrientedBoundingBox() [1/2]

OrientedBoundingBox::OrientedBoundingBox ( )

default

Default-constructs an empty box (zero dimension, no axes).

OrientedBoundingBox() [2/2]

OrientedBoundingBox::OrientedBoundingBox ( const std::vector< std::pair< Point, Point > > &  axis_pairs )

explicit

Build the box from a set of axis end-points.

Each element in axis_pairs is a (origin, far-end) pair defining one axis. The first element's first point is taken as the shared origin. The vectors v_i = (axis_pairs[i].second - origin) are normalised to obtain an orthonormal basis; their norms become the edge lengths. If the supplied axes are not mutually orthogonal, construction fails with a run-time assertion.

Definition at line 26 of file OrientedBoundingBox.C.

{
  _dim = static_cast<unsigned int>(axis_pairs.size());
  mooseAssert(_dim == 2 || _dim == 3, "OrientedBoundingBox requires 2 or 3 axis pairs");
  _dirs.resize(_dim);
  _len.resize(_dim);
 
  _minimal_corner = axis_pairs[0].first;
 
  _maximal_corner = _minimal_corner;
  // (a) Build orthonormal basis & lengths
  for (const auto i : make_range(_dim))
  {
    const Point vec = axis_pairs[i].second - _minimal_corner;
    _dirs[i] = vec.unit();
    _len[i] = vec.norm();
    _maximal_corner += _len[i] * _dirs[i];
  }
 
  // (b) Ensure orthogonality
  for (const auto i : make_range(_dim))
    for ([[maybe_unused]] const auto j : make_range(i + 1, _dim))
      mooseAssert(MooseUtils::absoluteFuzzyEqual(_dirs[i] * _dirs[j], 0.0),
                  "Basis directions are not orthogonal");
}

Member Function Documentation

centroid()

Point OrientedBoundingBox::centroid

(

)

const

Returns

Geometric centroid of the box.

Definition at line 75 of file OrientedBoundingBox.C.

{
  return 0.5 * (_minimal_corner + _maximal_corner);
}

contains()

bool OrientedBoundingBox::contains	(	const Point &	pt,
		const Real	tolerance = libMesh::TOLERANCE
	)		const

Test whether a point lies inside or on the box.

Parameters

pt	Query point.
tolerance	Fuzzy tolerance applied along each axis (default: libMesh::TOLERANCE).

Returns

true if the point projection along every axis falls in the range [0, len_i] within the specified tolerance.

Definition at line 61 of file OrientedBoundingBox.C.

{
  const Point rel = pt - _minimal_corner;
  for (const auto i : make_range(_dim))
  {
    const Real proj = rel * _dirs[i];
    if (!MooseUtils::absoluteFuzzyGreaterEqual(proj, 0.0, tolerance) ||
        !MooseUtils::absoluteFuzzyLessEqual(proj, _len[i], tolerance))
      return false;
  }
  return true;
}

Referenced by AdaptiveRayContainmentCheck::isOutsideBoundingBox().

getAxisDirection()

Point OrientedBoundingBox::getAxisDirection

(

unsigned int

i

)

const

Returns

Unit direction vector of axis i.

Definition at line 81 of file OrientedBoundingBox.C.

{
  mooseAssert(i < _dim, "Invalid axis index");
  return _dirs[i];
}

Referenced by AdaptiveRayContainmentCheck::sideness().

getAxisLength()

Real OrientedBoundingBox::getAxisLength

(

unsigned int

i

)

const

Returns

Length of axis i.

Definition at line 88 of file OrientedBoundingBox.C.

{
  mooseAssert(i < _dim, "Invalid axis index");
  return _len[i];
}

Referenced by AdaptiveRayContainmentCheck::rayStartOutsideOBB().

getMaximalCorner()

Point OrientedBoundingBox::getMaximalCorner

(

)

const

Returns

The shared maximal corner of the box.

Definition at line 109 of file OrientedBoundingBox.C.

{
  return _maximal_corner;
}

Referenced by AdaptiveRayContainmentCheck::rayStartOutsideOBB().

getMinimalCorner()

Point OrientedBoundingBox::getMinimalCorner

(

)

const

Returns

The shared minimal corner of the box.

Definition at line 103 of file OrientedBoundingBox.C.

{
  return _minimal_corner;
}

Referenced by AdaptiveRayContainmentCheck::rayStartOutsideOBB().

getProjectedLength()

Real OrientedBoundingBox::getProjectedLength	(	const Point &	pt,
		unsigned int	i
	)		const

Get the length of the projection of a point onto axis i.

This computes the length of the projection of the point pt onto the orthonormal basis vector dirs[i], relative to the minimal corner.

Parameters

pt	Query point.
i	Axis index (0 for first, 1 for second, etc.).

Returns

Length of the projection along axis i.

Definition at line 95 of file OrientedBoundingBox.C.

{
  mooseAssert(i < _dim, "Invalid axis index");
  const Point rel = pt - _minimal_corner;
  return rel * _dirs[i];
}

Referenced by AdaptiveRayContainmentCheck::rayStartOutsideOBB().

print()

void OrientedBoundingBox::print

(

std::ostream &

os

)

const

Print a summary (dimension, origin, axes).

Definition at line 53 of file OrientedBoundingBox.C.

{
  os << "OrientedBoundingBox: dim=" << _dim << ", origin=" << _minimal_corner << '\n';
  for (const auto i : make_range(_dim))
    os << "  axis[" << i << "] dir=" << _dirs[i] << ", len=" << _len[i] << '\n';
}

writeMesh()

void OrientedBoundingBox::writeMesh	(	const std::filesystem::path &	path,
		const libMesh::Parallel::Communicator &	comm
	)		const

Write the oriented box as a single libMesh element to a mesh file.

Builds one reference element (QUAD4 in 2-D, HEX8 in 3-D), maps its corners onto the oriented box, and delegates file output to libMesh's mesh writer. The output format is chosen from the file extension (use .e for ExodusII, which is always available). Writing is collective, so all ranks on comm must call it.

Parameters

path	Output path; extension selects the libMesh writer.
comm	Communicator the temporary mesh is built and written on.

Definition at line 115 of file OrientedBoundingBox.C.

{
  mooseAssert(_dim == 2 || _dim == 3, "writeMesh supports only 2D or 3D boxes.");
 
  // Build a single reference element (unit square in 2D, unit cube in 3D) and let
  // libMesh own the node ordering, connectivity, and output format.
  libMesh::ReplicatedMesh mesh(comm, _dim);
  if (_dim == 2)
    libMesh::MeshTools::Generation::build_square(mesh, 1, 1, 0., 1., 0., 1., libMesh::QUAD4);
  else
    libMesh::MeshTools::Generation::build_cube(
        mesh, 1, 1, 1, 0., 1., 0., 1., 0., 1., libMesh::HEX8);
 
  // Map each reference corner onto the oriented box:
  //   x = origin + sum_axis r_axis * len_axis * dir_axis
  for (auto * node : mesh.node_ptr_range())
  {
    const Point reference = *node;
    Point mapped = _minimal_corner;
    for (const auto axis : make_range(_dim))
      mapped += reference(axis) * _len[axis] * _dirs[axis];
    *node = mapped;
  }
 
  if (!path.parent_path().empty())
  {
    std::error_code ec;
    fs::create_directories(path.parent_path(), ec);
  }
  mesh.write(path.string());
}

Referenced by AdaptiveRayContainmentCheck::buildObbKdtreeAndMaxProjectedDiagonal().

writeRayAlongShortestAxis()

void OrientedBoundingBox::writeRayAlongShortestAxis	(	const std::filesystem::path &	ray_path,
		const libMesh::Parallel::Communicator &	comm
	)		const

Write a single-EDGE2 mesh representing a "ray" emanating from the box.

(a) The ray originates at the centre of the face (2-D) or face-centre (3-D) orthogonal to the shortest axis. (b) It is aligned with that shortest axis and its length equals the corresponding edge length.

The output format is chosen from the file extension (use .e for ExodusII). Writing is collective, so all ranks on comm must call it.

Parameters

ray_path	Output path; extension selects the libMesh writer.
comm	Communicator the temporary mesh is built and written on.

Definition at line 149 of file OrientedBoundingBox.C.

{
  mooseAssert(_dim == 2 || _dim == 3, "Ray writing only supports 2D or 3D");
 
  unsigned int i_min = 0;
  for (const auto i : make_range(1u, _dim))
    if (_len[i] < _len[i_min])
      i_min = i;
 
  Point start = _minimal_corner;
  for (const auto i : make_range(_dim))
    if (i != i_min)
      start += 0.5 * _len[i] * _dirs[i];
 
  const Point end = start + _len[i_min] * _dirs[i_min];
 
  // A single EDGE2 spanning the ray; libMesh owns the output format.
  libMesh::ReplicatedMesh mesh(comm, 1);
  libMesh::Node * n0 = mesh.add_point(start, 0);
  libMesh::Node * n1 = mesh.add_point(end, 1);
  auto edge = libMesh::Elem::build(libMesh::EDGE2);
  edge->set_node(0, n0);
  edge->set_node(1, n1);
  mesh.add_elem(std::move(edge));
  mesh.prepare_for_use();
 
  if (!ray_path.parent_path().empty())
  {
    std::error_code ec;
    fs::create_directories(ray_path.parent_path(), ec);
  }
  mesh.write(ray_path.string());
}

Referenced by AdaptiveRayContainmentCheck::buildObbKdtreeAndMaxProjectedDiagonal().

Member Data Documentation

_dim

unsigned int OrientedBoundingBox::_dim = 0u

private

spatial dimension (2 or 3)

Definition at line 145 of file OrientedBoundingBox.h.

Referenced by contains(), getAxisDirection(), getAxisLength(), getProjectedLength(), OrientedBoundingBox(), print(), writeMesh(), and writeRayAlongShortestAxis().

_dirs

std::vector<Point> OrientedBoundingBox::_dirs

private

orthonormal basis vectors (size = _dim)

Definition at line 143 of file OrientedBoundingBox.h.

Referenced by contains(), getAxisDirection(), getProjectedLength(), OrientedBoundingBox(), print(), writeMesh(), and writeRayAlongShortestAxis().

_len

std::vector<Real> OrientedBoundingBox::_len

private

length along each basis (size = _dim)

Definition at line 144 of file OrientedBoundingBox.h.

Referenced by contains(), getAxisLength(), OrientedBoundingBox(), print(), writeMesh(), and writeRayAlongShortestAxis().

_maximal_corner

Point OrientedBoundingBox::_maximal_corner

private

shared maximal corner

Definition at line 142 of file OrientedBoundingBox.h.

Referenced by centroid(), getMaximalCorner(), and OrientedBoundingBox().

_minimal_corner

Point OrientedBoundingBox::_minimal_corner

private

shared minimal corner

Definition at line 141 of file OrientedBoundingBox.h.

Referenced by centroid(), contains(), getMinimalCorner(), getProjectedLength(), OrientedBoundingBox(), print(), writeMesh(), and writeRayAlongShortestAxis().

---

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

• include/geometries/OrientedBoundingBox.h
• src/geometries/OrientedBoundingBox.C