Helper class that computes the intersection of a line segment defined by a point and a direction and a bounding box. More...

#include <BoundingBoxIntersectionHelper.h>

Public Member Functions
	BoundingBoxIntersectionHelper (const libMesh::BoundingBox &bbox, const unsigned int dim)
	Constructor. More...

libMesh::Point	intersection (const libMesh::Point &point, const libMesh::Point &direction) const

Private Attributes
libMesh::Parallel::Communicator	_comm
	Dummy communicator for the dummy mesh. More...

const std::unique_ptr< libMesh::Mesh >	_mesh
	Dummy mesh that contains a single element used for TraceRayTools intersection methods. More...

libMesh::Real	_hmax
	hmax for the dummy element More...

Detailed Description

Helper class that computes the intersection of a line segment defined by a point and a direction and a bounding box.

Definition at line 23 of file BoundingBoxIntersectionHelper.h.

Constructor & Destructor Documentation

◆ BoundingBoxIntersectionHelper()

BoundingBoxIntersectionHelper::BoundingBoxIntersectionHelper	(	const libMesh::BoundingBox &	bbox,
		const unsigned int	dim
	)

Constructor.

Parameters

bbox	The bounding box
dim	The dimension of the bounding box

Definition at line 22 of file BoundingBoxIntersectionHelper.C.

   : _comm(), _mesh(std::make_unique<Mesh>(_comm, dim))
 {
   // Add the nodes that represent our bounding box
   _mesh->add_point(Point(bbox.min()(0), bbox.min()(1), bbox.min()(2)), 0, 0);
   _mesh->add_point(Point(bbox.max()(0), bbox.min()(1), bbox.min()(2)), 1, 0);
   if (dim > 1)
   {
     _mesh->add_point(Point(bbox.max()(0), bbox.max()(1), bbox.min()(2)), 2, 0);
     _mesh->add_point(Point(bbox.min()(0), bbox.max()(1), bbox.min()(2)), 3, 0);
 
     if (dim == 3)
     {
       _mesh->add_point(Point(bbox.min()(0), bbox.min()(1), bbox.max()(2)), 4, 0);
       _mesh->add_point(Point(bbox.max()(0), bbox.min()(1), bbox.max()(2)), 5, 0);
       _mesh->add_point(Point(bbox.max()(0), bbox.max()(1), bbox.max()(2)), 6, 0);
       _mesh->add_point(Point(bbox.min()(0), bbox.max()(1), bbox.max()(2)), 7, 0);
     }
   }
 
   // Build the element and set the nodes accordingly
   Elem * elem;
   if (dim == 1)
     elem = Elem::build(EDGE2).release();
   else if (dim == 2)
     elem = Elem::build(QUAD4).release();
   else
     elem = Elem::build(HEX8).release();
   elem = _mesh->add_elem(elem);
   elem->subdomain_id() = 0;
   elem->processor_id(0);
   elem->set_id() = 0;
   for (unsigned int n = 0; n < _mesh->n_nodes(); ++n)
     elem->set_node(n, _mesh->node_ptr(n));
 
   // All done with the mesh
   _mesh->skip_partitioning(true);
   _mesh->prepare_for_use();
 
   // This costs a little bit so why not cache it now
   _hmax = elem->hmax();
 }

Member Function Documentation

◆ intersection()

Point BoundingBoxIntersectionHelper::intersection	(	const libMesh::Point &	point,
		const libMesh::Point &	direction
	)		const

Returns: The intersection of the segment defined by the point point and the direction direction. Will return RayTracingCommon::invalid_point if no intersection is found.

Definition at line 67 of file BoundingBoxIntersectionHelper.C.

 {
   mooseAssert(std::abs(1.0 - direction.norm()) < TOLERANCE, "Unnormalized direction");
 
   const Elem * elem = _mesh->elem_ptr(0);
 
   // We're going to check all possible intersections and keep the one that's furthest away
   Point best_intersection_point = RayTracingCommon::invalid_point;
   Real best_intersection_distance = -std::numeric_limits<Real>::max();
 
   // For use in the intersection routines
   Point intersection_point;
   ElemExtrema intersected_extrema;
   Real intersection_distance;
   bool intersected;
 
   // Check intersection with sides
   for (const auto s : elem->side_index_range())
   {
     intersection_point = RayTracingCommon::invalid_point;
     intersected_extrema.invalidate();
 
     if (elem->dim() == 3) // 3D: Intersect HEX8
       intersected = TraceRayTools::sideIntersectedByLine<Hex8>(elem,
                                                                point,
                                                                direction,
                                                                s,
                                                                _hmax,
                                                                intersection_point,
                                                                intersection_distance,
                                                                intersected_extrema,
                                                                _hmax
 #ifdef DEBUG_RAY_INTERSECTIONS
                                                                ,
                                                                false
 #endif
       );
     else if (elem->dim() == 2) // 2D: Intersect QUAD4
     {
       intersected = TraceRayTools::sideIntersectedByLine<Quad4>(elem,
                                                                 point,
                                                                 direction,
                                                                 s,
                                                                 _hmax,
                                                                 intersection_point,
                                                                 intersection_distance,
                                                                 intersected_extrema,
                                                                 _hmax
 #ifdef DEBUG_RAY_INTERSECTIONS
                                                                 ,
                                                                 false
 #endif
       );
     }
     else // 1D: see if side point is between point and end far away
     {
       // Dummy end point outside of the element
       const Point dummy_end = point + 1.01 * direction * _hmax;
 
       intersected = TraceRayTools::isWithinSegment(point, dummy_end, elem->point(s));
       if (intersected)
       {
         intersection_distance = (elem->point(s) - point).norm();
         intersection_point = elem->point(s);
       }
     }
 
     if (intersected && intersection_distance > best_intersection_distance)
     {
       best_intersection_distance = intersection_distance;
       best_intersection_point = intersection_point;
     }
   }
 
   return best_intersection_point;
 }