devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Apply clang-format

Browse Source
This commit is contained in:
Tobias Wood
2023-11-29 11:12:48 +00:00
parent 9ea520fc45
commit f38e16c193
534 changed files with 103368 additions and 116934 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
unsupported/Eigen/BVH
View File

@@ -28,47 +28,57 @@ namespace Eigen {
* #include <unsupported/Eigen/BVH>
* \endcode
*
* A bounding volume hierarchy (BVH) can accelerate many geometric queries. This module provides a generic implementation
* of the two basic algorithms over a BVH: intersection of a query object against all objects in the hierarchy and minimization
* of a function over the objects in the hierarchy. It also provides intersection and minimization over a cartesian product of
* two BVH's. A BVH accelerates intersection by using the fact that if a query object does not intersect a volume, then it cannot
* intersect any object contained in that volume. Similarly, a BVH accelerates minimization because the minimum of a function
* A bounding volume hierarchy (BVH) can accelerate many geometric queries. This module provides a generic
implementation
* of the two basic algorithms over a BVH: intersection of a query object against all objects in the hierarchy and
minimization
* of a function over the objects in the hierarchy. It also provides intersection and minimization over a cartesian
product of
* two BVH's. A BVH accelerates intersection by using the fact that if a query object does not intersect a volume,
then it cannot
* intersect any object contained in that volume. Similarly, a BVH accelerates minimization because the minimum of a
function
* over a volume is no greater than the minimum of a function over any object contained in it.
*
* Some sample queries that can be written in terms of intersection are:
* - Determine all points where a ray intersects a triangle mesh
* - Given a set of points, determine which are contained in a query sphere
* - Given a set of spheres, determine which contain the query point
* - Given a set of disks, determine if any is completely contained in a query rectangle (represent each 2D disk as a point \f$(x,y,r)\f$
* in 3D and represent the rectangle as a pyramid based on the original rectangle and shrinking in the \f$r\f$ direction)
* - Given a set of points, count how many pairs are \f$d\pm\epsilon\f$ apart (done by looking at the cartesian product of the set
* - Given a set of disks, determine if any is completely contained in a query rectangle (represent each 2D disk as a
point \f$(x,y,r)\f$
* in 3D and represent the rectangle as a pyramid based on the original rectangle and shrinking in the \f$r\f$
direction)
* - Given a set of points, count how many pairs are \f$d\pm\epsilon\f$ apart (done by looking at the cartesian
product of the set
* of points with itself)
*
* Some sample queries that can be written in terms of function minimization over a set of objects are:
* - Find the intersection between a ray and a triangle mesh closest to the ray origin (function is infinite off the ray)
* - Find the intersection between a ray and a triangle mesh closest to the ray origin (function is infinite off the
ray)
* - Given a polyline and a query point, determine the closest point on the polyline to the query
* - Find the diameter of a point cloud (done by looking at the cartesian product and using negative distance as the function)
* - Find the diameter of a point cloud (done by looking at the cartesian product and using negative distance as the
function)
* - Determine how far two meshes are from colliding (this is also a cartesian product query)
*
* This implementation decouples the basic algorithms both from the type of hierarchy (and the types of the bounding volumes) and
* from the particulars of the query. To enable abstraction from the BVH, the BVH is required to implement a generic mechanism
* This implementation decouples the basic algorithms both from the type of hierarchy (and the types of the bounding
volumes) and
* from the particulars of the query. To enable abstraction from the BVH, the BVH is required to implement a generic
mechanism
* for traversal. To abstract from the query, the query is responsible for keeping track of results.
*
* To be used in the algorithms, a hierarchy must implement the following traversal mechanism (see KdBVH for a sample implementation): \code
typedef Volume //the type of bounding volume
typedef Object //the type of object in the hierarchy
typedef Index //a reference to a node in the hierarchy--typically an int or a pointer
typedef VolumeIterator //an iterator type over node children--returns Index
typedef ObjectIterator //an iterator over object (leaf) children--returns const Object &
Index getRootIndex() const //returns the index of the hierarchy root
const Volume &getVolume(Index index) const //returns the bounding volume of the node at given index
void getChildren(Index index, VolumeIterator &outVBegin, VolumeIterator &outVEnd,
ObjectIterator &outOBegin, ObjectIterator &outOEnd) const
* To be used in the algorithms, a hierarchy must implement the following traversal mechanism (see KdBVH for a sample
implementation): \code typedef Volume //the type of bounding volume typedef Object //the type of object in the
hierarchy typedef Index //a reference to a node in the hierarchy--typically an int or a pointer typedef
VolumeIterator //an iterator type over node children--returns Index typedef ObjectIterator //an iterator over object
(leaf) children--returns const Object & Index getRootIndex() const //returns the index of the hierarchy root const
Volume &getVolume(Index index) const //returns the bounding volume of the node at given index void getChildren(Index
index, VolumeIterator &outVBegin, VolumeIterator &outVEnd, ObjectIterator &outOBegin, ObjectIterator &outOEnd) const
//getChildren takes a node index and makes [outVBegin, outVEnd) range over its node children
//and [outOBegin, outOEnd) range over its object children
\endcode
*
* To use the hierarchy, call BVIntersect or BVMinimize, passing it a BVH (or two, for cartesian product) and a minimizer or intersector.
* To use the hierarchy, call BVIntersect or BVMinimize, passing it a BVH (or two, for cartesian product) and a
minimizer or intersector.
* For an intersection query on a single BVH, the intersector encapsulates the query and must provide two functions:
* \code
bool intersectVolume(const Volume &volume) //returns true if the query intersects the volume
@@ -79,7 +89,8 @@ namespace Eigen {
* responsibility of the intersectObject function to keep track of the results in whatever manner is appropriate.
* The cartesian product intersection and the BVMinimize queries are similar--see their individual documentation.
*
* The following is a simple but complete example for how to use the BVH to accelerate the search for a closest red-blue point pair:
* The following is a simple but complete example for how to use the BVH to accelerate the search for a closest
red-blue point pair:
* \include BVH_Example.cpp
* Output: \verbinclude BVH_Example.out
*/
@@ -94,4 +105,4 @@ namespace Eigen {
//@}
#endif // EIGEN_BVH_MODULE_H
#endif // EIGEN_BVH_MODULE_H