ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Math: converted Geometry::Distance and Intersection to namespaces. 

No need for them to be classes, less indentation, less keywords and
boilerplate, more space for documentation, better `using` usage. Also
revised and fixed various issues in the documentation.
pull/190/head
Vladimír Vondruš 10 years ago
parent
e722286200
commit
7f89105a51
3 changed files with 319 additions and 314 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      doc/namespaces.dox
  2. 376
      src/Magnum/Math/Geometry/Distance.h
  3. 241
      src/Magnum/Math/Geometry/Intersection.h

16
doc/namespaces.dox
Unescape View File

@ -94,7 +94,21 @@ and @ref cmake for more information.
/** @namespace Magnum::Math::Geometry /** @namespace Magnum::Math::Geometry
@brief Geometry library @brief Geometry library
Functions for computing intersections, distances, areas and volumes. This library is built as part of Magnum by default. To use it, you need to
find `Magnum` package and link to `Magnum::Magnum` target. See @ref building
and @ref cmake for more information.
*/
/** @namespace Magnum::Math::Geometry::Distance
@brief Functions for calculating distances
This library is built as part of Magnum by default. To use it, you need to
find `Magnum` package and link to `Magnum::Magnum` target. See @ref building
and @ref cmake for more information.
*/
/** @namespace Magnum::Math::Geometry::Intersection
@brief Function for calculating intersections
This library is built as part of Magnum by default. To use it, you need to This library is built as part of Magnum by default. To use it, you need to
find `Magnum` package and link to `Magnum::Magnum` target. See @ref building find `Magnum` package and link to `Magnum::Magnum` target. See @ref building

376
src/Magnum/Math/Geometry/Distance.h
Unescape View File

@ -27,202 +27,192 @@
*/ */
/** @file /** @file
* @brief Class @ref Magnum::Math::Geometry::Distance * @brief Namespace @ref Magnum::Math::Geometry::Distance
*/ */
#include "Magnum/Math/Functions.h" #include "Magnum/Math/Functions.h"
#include "Magnum/Math/Vector3.h" #include "Magnum/Math/Vector3.h"
#include "Magnum/Math/Vector4.h" #include "Magnum/Math/Vector4.h"
namespace Magnum { namespace Math { namespace Geometry { namespace Magnum { namespace Math { namespace Geometry { namespace Distance {
/** @brief Functions for computing distances */ /**
class Distance { @brief Distance of line and point in 2D, squared
public: @param a First point of the line
Distance() = delete; @param b Second point of the line
@param point Point
/**
* @brief Distance of line and point in 2D More efficient than @ref linePoint(const Vector2<T>&, const Vector2<T>&, const Vector2<T>&)
* @param a First point of the line for comparing distance with other values, because it doesn't calculate the
* @param b Second point of the line square root.
* @param point Point */
* template<class T> inline T linePointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
* The distance *d* is computed from point **p** and line defined by **a** const Vector2<T> bMinusA = b - a;
* and **b** using @ref cross(const Vector2<T>&, const Vector2<T>&) "perp-dot product": @f[ return Math::pow<2>(cross(bMinusA, a - point))/bMinusA.dot();
* d = \frac{|(\boldsymbol b - \boldsymbol a)_\bot \cdot (\boldsymbol a - \boldsymbol p)|} {|\boldsymbol b - \boldsymbol a|} }
* @f]
* Source: http://mathworld.wolfram.com/Point-LineDistance2-Dimensional.html /**
* @see @ref linePointSquared(const Vector2<T>&, const Vector2<T>&, const Vector2<T>&) @brief Distance of line and point in 2D
*/ @param a First point of the line
template<class T> static T linePoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) { @param b Second point of the line
const Vector2<T> bMinusA = b - a; @param point Point
return std::abs(cross(bMinusA, a - point))/bMinusA.length();
} The distance @f$ d @f$ is calculated from point @f$ \boldsymbol{p} @f$ and line
defined by @f$ \boldsymbol{a} @f$ and @f$ \boldsymbol{b} @f$ using
/** @ref cross(const Vector2<T>&, const Vector2<T>&) "perp-dot product": @f[
* @brief Distance of line and point in 2D, squared d = \frac{|(\boldsymbol b - \boldsymbol a)_\bot \cdot (\boldsymbol a - \boldsymbol p)|}{|\boldsymbol b - \boldsymbol a|}
* @param a First point of the line @f]
* @param b Second point of the line Source: http://mathworld.wolfram.com/Point-LineDistance2-Dimensional.html
* @param point Point @see @ref linePointSquared(const Vector2<T>&, const Vector2<T>&, const Vector2<T>&)
* */
* More efficient than template<class T> inline T linePoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
* @ref linePoint(const Vector2<T>&, const Vector2<T>&, const Vector2<T>&) const Vector2<T> bMinusA = b - a;
* for comparing distance with other values, because it doesn't return std::abs(cross(bMinusA, a - point))/bMinusA.length();
* compute the square root. }
*/
template<class T> static T linePointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) { /**
const Vector2<T> bMinusA = b - a; @brief Distance of line and point in 3D, squared
return Math::pow<2>(cross(bMinusA, a - point))/bMinusA.dot();
} More efficient than @ref linePoint(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&)
for comparing distance with other values, because it doesn't calculate the
/** square root.
* @brief Distance of line and point in 3D */
* @param a First point of the line template<class T> inline T linePointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) {
* @param b Second point of the line return cross(point - a, point - b).dot()/(b - a).dot();
* @param point Point }
*
* The distance *d* is computed from point **p** and line defined by **a** /**
* and **b** using @ref cross(const Vector3<T>&, const Vector3<T>&) "cross product": @f[ @brief Distance of line and point in 3D
* d = \frac{|(\boldsymbol p - \boldsymbol a) \times (\boldsymbol p - \boldsymbol b)|} @param a First point of the line
* {|\boldsymbol b - \boldsymbol a|} @param b Second point of the line
* @f] @param point Point
* Source: http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
* @see @ref linePointSquared(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&) The distance @f$ d @f$ is calculated from point @f$ \boldsymbol{p} @f$ and line
*/ defined by @f$ \boldsymbol{a} @f$ and @f$ \boldsymbol{b} @f$ using
template<class T> static T linePoint(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) { @ref cross(const Vector3<T>&, const Vector3<T>&) "cross product": @f[
return std::sqrt(linePointSquared(a, b, point)); d = \frac{|(\boldsymbol p - \boldsymbol a) \times (\boldsymbol p - \boldsymbol b)|}{|\boldsymbol b - \boldsymbol a|}
} @f]
Source: http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
/** @see @ref linePointSquared(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&)
* @brief Distance of line and point in 3D, squared */
* template<class T> inline T linePoint(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) {
* More efficient than @ref linePoint(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&) return std::sqrt(linePointSquared(a, b, point));
* for comparing distance with other values, because it doesn't }
* compute the square root.
*/ /**
template<class T> static T linePointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) { @brief Distance of point from line segment in 2D, squared
return cross(point - a, point - b).dot()/(b - a).dot();
} More efficient than @ref lineSegmentPoint() for comparing distance with other
values, because it doesn't calculate the square root.
/** */
* @brief Dístance of point from line segment in 2D template<class T> T lineSegmentPointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point);
* @param a Starting point of the line
* @param b Ending point of the line /**
* @param point Point @brief Dístance of point from line segment in 2D
* @param a Starting point of the line
* Returns distance of point from line segment or from its @param b Ending point of the line
* starting/ending point, depending on where the point lies. @param point Point
*
* Determining whether the point lies next to line segment or outside Returns distance of point from line segment or from its starting/ending point,
* is done using Pythagorean theorem. If the following equation depending on where the point lies.
* applies, the point **p** lies outside line segment closer to **a**: @f[
* |\boldsymbol p - \boldsymbol b|^2 > |\boldsymbol b - \boldsymbol a|^2 + |\boldsymbol p - \boldsymbol a|^2 Determining whether the point lies next to line segment or outside is done
* @f] using Pythagorean theorem. If the following equation applies, the point
* On the other hand, if the following equation applies, the point @f$ \boldsymbol{p} @f$ lies outside line segment closer to @f$ \boldsymbol{a} @f$: @f[
* lies outside line segment closer to **b**: @f[ |\boldsymbol p - \boldsymbol b|^2 > |\boldsymbol b - \boldsymbol a|^2 + |\boldsymbol p - \boldsymbol a|^2
* |\boldsymbol p - \boldsymbol a|^2 > |\boldsymbol b - \boldsymbol a|^2 + |\boldsymbol p - \boldsymbol b|^2 @f]
* @f] On the other hand, if the following equation applies, the point lies outside
* The last alternative is when the following equation applies. The line segment closer to @f$ \boldsymbol{b} @f$: @f[
* point then lies between **a** and **b** and the distance is |\boldsymbol p - \boldsymbol a|^2 > |\boldsymbol b - \boldsymbol a|^2 + |\boldsymbol p - \boldsymbol b|^2
* computed the same way as in @ref linePoint(). @f[ @f]
* |\boldsymbol b - \boldsymbol a|^2 > |\boldsymbol p - \boldsymbol a|^2 + |\boldsymbol p - \boldsymbol b|^2 The last alternative is when the following equation applies. The point then
* @f] lies between @f$ \boldsymbol{a} @f$ and @f$ \boldsymbol{b} @f$ and the distance
* is calculated the same way as in @ref linePoint(). @f[
* @see @ref lineSegmentPointSquared() |\boldsymbol b - \boldsymbol a|^2 > |\boldsymbol p - \boldsymbol a|^2 + |\boldsymbol p - \boldsymbol b|^2
*/ @f]
template<class T> static T lineSegmentPoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point);
@see @ref lineSegmentPointSquared()
/** */
* @brief Distance of point from line segment in 2D, squared template<class T> T lineSegmentPoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point);
*
* More efficient than @ref lineSegmentPoint() for comparing distance /**
* with other values, because it doesn't compute the square root. @brief Distance of point from line segment in 3D, squared
*/
template<class T> static T lineSegmentPointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point); More efficient than @ref lineSegmentPoint(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&)
for comparing distance with other values, because it doesn't calculate the
/** square root.
* @brief Dístance of point from line segment in 3D */
* @param a Starting point of the line template<class T> T lineSegmentPointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point);
* @param b Ending point of the line
* @param point Point /**
* @brief Dístance of point from line segment in 3D
* Similar to 2D implementation @param a Starting point of the line
* @ref lineSegmentPoint(const Vector2<T>&, const Vector2<T>&, const Vector2<T>&). @param b Ending point of the line
* @param point Point
* @see @ref lineSegmentPointSquared(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&)
*/ Similar to 2D implementation @ref lineSegmentPoint(const Vector2<T>&, const Vector2<T>&, const Vector2<T>&).
template<class T> static T lineSegmentPoint(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) { @see @ref lineSegmentPointSquared(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&)
return std::sqrt(lineSegmentPointSquared(a, b, point)); */
} template<class T> inline T lineSegmentPoint(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) {
return std::sqrt(lineSegmentPointSquared(a, b, point));
/** }
* @brief Distance of point from line segment in 3D, squared
* /**
* More efficient than @brief Distance of point from plane, scaled by the length of the planes normal
* @ref lineSegmentPoint(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&)
* for comparing distance with other values, because it doesn't compute The distance @f$ d @f$ is calculated from point @f$ \boldsymbol{p} @f$ and
* the square root. plane with normal @f$ \boldsymbol{n} @f$ and @f$ w @f$ using: @f[
*/ d = \boldsymbol{p} \cdot \boldsymbol{n} + w
template<class T> static T lineSegmentPointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point); @f]
The distance is negative if the point lies behind the plane.
/**
* @brief Distance of point from plane More efficient than @ref pointPlane() when merely the sign of the distance is
* of interest, for example when testing on which half space of the plane the
* The distance **d** is computed from point **p** and plane with point lies.
* normal **n** and **w** using: @f[ @see @ref pointPlaneNormalized()
* d = \frac{p \cdot n + w}{\left| n \right|} */
* @f] template<class T> inline T pointPlaneScaled(const Vector3<T>& point, const Vector4<T>& plane) {
* The distance is negative if the point lies behind the plane. return dot(plane.xyz(), point) + plane.w();
* }
* In cases where the planes normal is a unit vector,
* @ref pointPlaneUnnormalized() is more efficient. If merely the sign /**
* of the distance is of interest, @ref pointPlaneScaled() is more @brief Distance of point from plane
* efficient.
*/ The distance @f$ d @f$ is calculated from point @f$ \boldsymbol{p} @f$ and
template<class T> static T pointPlane(const Vector3<T>& point, const Vector4<T>& plane) { plane with normal @f$ \boldsymbol{n} @f$ and @f$ w @f$ using: @f[
return pointPlaneScaled<T>(point, plane)/plane.xyz().length(); d = \frac{\boldsymbol{p} \cdot \boldsymbol{n} + w}{\left| \boldsymbol{n} \right|}
} @f]
The distance is negative if the point lies behind the plane.
/**
* @brief Distance of point from plane, scaled by the length of the planes normal In cases where the planes normal is a unit vector, @ref pointPlaneNormalized()
* is more efficient. If merely the sign of the distance is of interest,
* The distance **d** is computed from point **p** and plane with @ref pointPlaneScaled() is more efficient.
* normal **n** and **w** using: @f[ */
* d = p \cdot n + w template<class T> inline T pointPlane(const Vector3<T>& point, const Vector4<T>& plane) {
* @f] return pointPlaneScaled<T>(point, plane)/plane.xyz().length();
* The distance is negative if the point lies behind the plane. }
*
* More efficient than @ref pointPlane() when merely the sign of the /**
* distance is of interest, for example when testing on which half @brief Distance of point from plane with normalized normal
* space of the plane the point lies.
* @see @ref pointPlaneNormalized() The distance @f$ d @f$ is calculated from point @f$ \boldsymbol{p} @f$ and plane
*/ with normal @f$ \boldsymbol{n} @f$ and @f$ w @f$ using: @f[
template<class T> static T pointPlaneScaled(const Vector3<T>& point, const Vector4<T>& plane) { d = \boldsymbol{p} \cdot \boldsymbol{n} + w
return Math::dot(plane.xyz(), point) + plane.w(); @f]
} The distance is negative if the point lies behind the plane. Expects that
@p plane normal is normalized.
/**
* @brief Distance of point from plane with normalized normal More efficient than @ref pointPlane() in cases where the plane's normal is
* normalized. Equivalent to @ref pointPlaneScaled() but with assertion added on
* The distance **d** is computed from point **p** and plane with top.
* normal **n** and **w** using: @f[ */
* d = p \cdot n + w template<class T> inline T pointPlaneNormalized(const Vector3<T>& point, const Vector4<T>& plane) {
* @f] CORRADE_ASSERT(plane.xyz().isNormalized(),
* The distance is negative if the point lies behind the plane. Expects "Math::Geometry::Distance::pointPlaneNormalized(): plane normal is not an unit vector", {});
* that @p plane normal is normalized. return pointPlaneScaled<T>(point, plane);
* }
* More efficient than @ref pointPlane() in cases where the planes
* normal is normalized. Equivalent to @ref pointPlaneScaled() but with template<class T> T lineSegmentPoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
* assertion added on top.
*/
template<class T> static T pointPlaneNormalized(const Vector3<T>& point, const Vector4<T>& plane) {
CORRADE_ASSERT(plane.xyz().isNormalized(),
"Math::Geometry::Distance::pointPlaneNormalized(): plane normal is not an unit vector", {});
return pointPlaneScaled<T>(point, plane);
}
};
template<class T> T Distance::lineSegmentPoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
const Vector2<T> pointMinusA = point - a; const Vector2<T> pointMinusA = point - a;
const Vector2<T> pointMinusB = point - b; const Vector2<T> pointMinusB = point - b;
const Vector2<T> bMinusA = b - a; const Vector2<T> bMinusA = b - a;
@ -242,7 +232,7 @@ template<class T> T Distance::lineSegmentPoint(const Vector2<T>& a, const Vector
return std::abs(cross(bMinusA, -pointMinusA))/std::sqrt(bDistanceA); return std::abs(cross(bMinusA, -pointMinusA))/std::sqrt(bDistanceA);
} }
template<class T> T Distance::lineSegmentPointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) { template<class T> T lineSegmentPointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
const Vector2<T> pointMinusA = point - a; const Vector2<T> pointMinusA = point - a;
const Vector2<T> pointMinusB = point - b; const Vector2<T> pointMinusB = point - b;
const Vector2<T> bMinusA = b - a; const Vector2<T> bMinusA = b - a;
@ -262,7 +252,7 @@ template<class T> T Distance::lineSegmentPointSquared(const Vector2<T>& a, const
return Math::pow<2>(cross(bMinusA, -pointMinusA))/bDistanceA; return Math::pow<2>(cross(bMinusA, -pointMinusA))/bDistanceA;
} }
template<class T> T Distance::lineSegmentPointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) { template<class T> T lineSegmentPointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) {
const Vector3<T> pointMinusA = point - a; const Vector3<T> pointMinusA = point - a;
const Vector3<T> pointMinusB = point - b; const Vector3<T> pointMinusB = point - b;
const T pointDistanceA = pointMinusA.dot(); const T pointDistanceA = pointMinusA.dot();
@ -281,6 +271,6 @@ template<class T> T Distance::lineSegmentPointSquared(const Vector3<T>& a, const
return cross(pointMinusA, pointMinusB).dot()/bDistanceA; return cross(pointMinusA, pointMinusB).dot()/bDistanceA;
} }
}}} }}}}
#endif #endif

241
src/Magnum/Math/Geometry/Intersection.h
Unescape View File

@ -27,7 +27,7 @@
*/ */
/** @file /** @file
* @brief Class @ref Magnum::Math::Geometry::Intersection * @brief Namespace @ref Magnum::Math::Geometry::Intersection
*/ */
#include "Magnum/Math/Frustum.h" #include "Magnum/Math/Frustum.h"
@ -35,126 +35,127 @@
#include "Magnum/Math/Range.h" #include "Magnum/Math/Range.h"
#include "Magnum/Math/Vector3.h" #include "Magnum/Math/Vector3.h"
namespace Magnum { namespace Math { namespace Geometry { namespace Magnum { namespace Math { namespace Geometry { namespace Intersection {
/** @brief Functions for computing intersections */ /**
class Intersection { @brief Intersection of two line segments in 2D
public: @param p Starting point of first line segment
Intersection() = delete; @param r Direction of first line segment
@param q Starting point of second line segment
/** @param s Direction of second line segment
* @brief Intersection of two line segments in 2D
* @param p Starting point of first line segment Returns intersection point positions @f$ t @f$, @f$ u @f$ on both lines, NaN if
* @param r Direction of first line segment the lines are collinear or infinity if they are parallel. Intersection point
* @param q Starting point of second line segment can be then calculated with @f$ \boldsymbol{p} + t \boldsymbol{r} @f$ or
* @param s Direction of second line segment @f$ \boldsymbol{q} + u \boldsymbol{s} @f$. If @f$ t @f$ is in range
* @return Intersection point positions `t`, `u` on both lines, NaN if @f$ [ 0 ; 1 ] @f$, the intersection is inside the line segment defined by
* the lines are collinear or infinity if they are parallel. @f$ \boldsymbol{p} @f$ and @f$ \boldsymbol{p} + \boldsymbol{r} @f$, if @f$ u @f$
* Intersection point can be then computed with `p + t*r` or is in range @f$ [ 0 ; 1 ] @f$, the intersection is inside the line segment
* `q + u*s`. If `t` is in range @f$ [ 0 ; 1 ] @f$, the defined by @f$ \boldsymbol{q} @f$ and @f$ \boldsymbol{q} + \boldsymbol{s} @f$.
* intersection is inside the line segment defined by `p` and
* `p + r`, if `u` is in range @f$ [ 0 ; 1 ] @f$, the intersection The two lines intersect if @f$ t @f$ and @f$ u @f$ exist such that: @f[
* is inside the line segment defined by `q` and `q + s`. \boldsymbol p + t \boldsymbol r = \boldsymbol q + u \boldsymbol s
* @f]
* The two lines intersect if **t** and **u** exist such that: @f[ Crossing both sides with @f$ \boldsymbol{s} @f$, distributing the cross product
* \boldsymbol p + t \boldsymbol r = \boldsymbol q + u \boldsymbol s and eliminating @f$ \boldsymbol s \times \boldsymbol s = 0 @f$, then solving
* @f] for @f$ t @f$ and similarly for @f$ u @f$: @f[
* Crossing both sides with **s**, distributing the cross product and \begin{array}{rcl}
* eliminating @f$ \boldsymbol s \times \boldsymbol s = 0 @f$, then (\boldsymbol p + t \boldsymbol r) \times s & = & (\boldsymbol q + u \boldsymbol s) \times s \\
* solving for **t** and similarly for **u**: @f[ t (\boldsymbol r \times s) & = & (\boldsymbol q - \boldsymbol p) \times s \\
* \begin{array}{rcl} t & = & \cfrac{(\boldsymbol q - \boldsymbol p) \times s}{\boldsymbol r \times \boldsymbol s} \\
* (\boldsymbol p + t \boldsymbol r) \times s & = & (\boldsymbol q + u \boldsymbol s) \times s \\ u & = & \cfrac{(\boldsymbol q - \boldsymbol p) \times r}{\boldsymbol r \times \boldsymbol s}
* t (\boldsymbol r \times s) & = & (\boldsymbol q - \boldsymbol p) \times s \\ \end{array}
* t & = & \cfrac{(\boldsymbol q - \boldsymbol p) \times s}{\boldsymbol r \times \boldsymbol s} \\ @f]
* u & = & \cfrac{(\boldsymbol q - \boldsymbol p) \times r}{\boldsymbol r \times \boldsymbol s}
* \end{array} See also @ref lineSegmentLine() which calculates only @f$ t @f$, useful if you
* @f] don't need to test that the intersection lies inside line segment defined by
* @f$ \boldsymbol{q} @f$ and @f$ \boldsymbol{q} + \boldsymbol{s} @f$.
* See also @ref lineSegmentLine() which computes only **t**, which is */
* useful if you don't need to test that the intersection lies inside template<class T> inline std::pair<T, T> lineSegmentLineSegment(const Vector2<T>& p, const Vector2<T>& r, const Vector2<T>& q, const Vector2<T>& s) {
* line segment defined by `q` and `q + s`. const Vector2<T> qp = q - p;
*/ const T rs = cross(r, s);
template<class T> static std::pair<T, T> lineSegmentLineSegment(const Vector2<T>& p, const Vector2<T>& r, const Vector2<T>& q, const Vector2<T>& s) { return {cross(qp, s)/rs, cross(qp, r)/rs};
const Vector2<T> qp = q - p; }
const T rs = cross(r, s);
return {cross(qp, s)/rs, cross(qp, r)/rs};
}
/** /**
* @brief Intersection of line segment and line in 2D @brief Intersection of line segment and line in 2D
* @param p Starting point of first line segment @param p Starting point of first line segment
* @param r Direction of first line segment @param r Direction of first line segment
* @param q Starting point of second line @param q Starting point of second line
* @param s Direction of second line @param s Direction of second line
* @return Intersection point position `t` on first line, NaN if the
* lines are collinear or infinity if they are parallel.
* Intersection point can be then with `p + t*r`. If returned
* value is in range @f$ [ 0 ; 1 ] @f$, the intersection is inside
* the line segment defined by `p` and `p + r`.
*
* Unlike @ref lineSegmentLineSegment() computes only **t**.
*/
template<class T> static T lineSegmentLine(const Vector2<T>& p, const Vector2<T>& r, const Vector2<T>& q, const Vector2<T>& s) {
return cross(q - p, s)/cross(r, s);
}
/** Returns intersection point position @f$ t @f$ on first line, NaN if the lines
* @brief Intersection of a plane and line are collinear or infinity if they are parallel. Intersection point can be then
* @param planePosition Plane position calculated with @f$ \boldsymbol{p} + t \boldsymbol{r} @f$. If returned value is
* @param planeNormal Plane normal in range @f$ [ 0 ; 1 ] @f$, the intersection is inside the line segment defined
* @param p Starting point of the line by @f$ \boldsymbol{p} @f$ and @f$ \boldsymbol{p} + \boldsymbol{r} @f$.
* @param r Direction of the line
* @return Intersection point position `t` on the line, NaN if the Unlike @ref lineSegmentLineSegment() calculates only @f$ t @f$.
* line lies on the plane or infinity if the intersection doesn't */
* exist. Intersection point can be then computed from with template<class T> inline T lineSegmentLine(const Vector2<T>& p, const Vector2<T>& r, const Vector2<T>& q, const Vector2<T>& s) {
* `p + t*r`. If returned value is in range @f$ [ 0 ; 1 ] @f$, the return cross(q - p, s)/cross(r, s);
* intersection is inside the line segment defined by `p` and `r`. }
*
* First the parameter *f* of parametric equation of the plane /**
* is computed from plane normal **n** and plane position: @f[ @brief Intersection of a plane and line
* \begin{pmatrix} n_0 \\ n_1 \\ n_2 \end{pmatrix} \cdot @param planePosition Plane position
* \begin{pmatrix} x \\ y \\ z \end{pmatrix} - f = 0 @param planeNormal Plane normal
* @f] @param p Starting point of the line
* Using plane normal **n**, parameter *f* and line defined by **p** @param r Direction of the line
* and **r**, value of *t* is computed and returned. @f[
* \begin{array}{rcl} Returns intersection point position @f$ t @f$ on the line, NaN if the line lies
* f & = & \boldsymbol n \cdot (\boldsymbol p + t \boldsymbol r) \\ on the plane or infinity if the intersection doesn't exist. Intersection point
* \Rightarrow t & = & \cfrac{f - \boldsymbol n \cdot \boldsymbol p}{\boldsymbol n \cdot \boldsymbol r} can be then calculated from with @f$ \boldsymbol{p} + t \boldsymbol{r} @f$. If
* \end{array} returned value is in range @f$ [ 0 ; 1 ] @f$, the intersection is inside the
* @f] line segment defined by @f$ \boldsymbol{p} @f$ and @f$ \boldsymbol{r} @f$.
*/
template<class T> static T planeLine(const Vector3<T>& planePosition, const Vector3<T>& planeNormal, const Vector3<T>& p, const Vector3<T>& r) { First the parameter @f$ f @f$ of parametric equation of the plane is calculated
const T f = dot(planePosition, planeNormal); from plane normal @f$ \boldsymbol{n} @f$ and plane position: @f[
return (f-dot(planeNormal, p))/dot(planeNormal, r); \begin{pmatrix} n_0 \\ n_1 \\ n_2 \end{pmatrix} \cdot
} \begin{pmatrix} x \\ y \\ z \end{pmatrix} - f = 0
@f]
Using plane normal @f$ \boldsymbol{n} @f$, parameter @f$ f @f$ and line defined
by @f$ \boldsymbol{p} @f$ and @f$ \boldsymbol{r} @f$, value of @f$ t @f$ is
calculated and returned. @f[
\begin{array}{rcl}
f & = & \boldsymbol n \cdot (\boldsymbol p + t \boldsymbol r) \\
\Rightarrow t & = & \cfrac{f - \boldsymbol n \cdot \boldsymbol p}{\boldsymbol n \cdot \boldsymbol r}
\end{array}
@f]
*/
template<class T> inline T planeLine(const Vector3<T>& planePosition, const Vector3<T>& planeNormal, const Vector3<T>& p, const Vector3<T>& r) {
const T f = dot(planePosition, planeNormal);
return (f - dot(planeNormal, p))/dot(planeNormal, r);
}
/**
@brief Intersection of a point and a camera frustum
@param point Point
@param frustum Frustum planes with normals pointing outwards
Returns `true` if the point is on or inside the frustum.
Checks for each plane of the frustum whether the point is behind the plane (the
points distance from the plane is negative) using @ref Distance::pointPlaneScaled().
*/
template<class T> bool pointFrustum(const Vector3<T>& point, const Frustum<T>& frustum);
/**
@brief Intersection of an axis-aligned box and a camera frustum
@param box Axis-aligned box
@param frustum Frustum planes with normals pointing outwards
Returns `true` if the box intersects with the camera frustum.
Counts for each plane of the frustum how many points of the box lie in front of
the plane (outside of the frustum). If none, the box must lie entirely outside
of the frustum and there is no intersection. Else, the box is considered as
intersecting, even if it is merely corners of the box overlapping with corners
of the frustum, since checking the corners is less efficient.
*/
template<class T> bool boxFrustum(const Range3D<T>& box, const Frustum<T>& frustum);
/** template<class T> bool pointFrustum(const Vector3<T>& point, const Frustum<T>& frustum) {
* @brief Intersection of a point and a camera frustum
* @param point Point
* @param frustum Frustum planes with normals pointing outwards
* @return `true` if the point is on or inside the frustum.
*
* Checks for each plane of the frustum whether the point is behind the
* plane (the points distance from the plane is negative) using
* @ref Distance::pointPlaneScaled().
*/
template<class T> static bool pointFrustum(const Vector3<T>& point, const Frustum<T>& frustum);
/**
* @brief Intersection of a range and a camera frustum
* @return `true` if the box intersects with the camera frustum
*
* Counts for each plane of the frustum how many points of the box lie
* in front of the plane (outside of the frustum). If none, the box
* must lie entirely outside of the frustum and there is no
* intersection. Else, the box is considered as intersecting, even if
* it is merely corners of the box overlapping with corners of the
* frustum, since checking the corners is less efficient.
*/
template<class T> static bool boxFrustum(const Range3D<T>& box, const Frustum<T>& frustum);
};
template<class T> bool Intersection::pointFrustum(const Vector3<T>& point, const Frustum<T>& frustum) {
for(const Vector4<T>& plane: frustum.planes()) { for(const Vector4<T>& plane: frustum.planes()) {
/* The point is in front of one of the frustum planes (normals point /* The point is in front of one of the frustum planes (normals point
outwards) */ outwards) */
@ -165,7 +166,7 @@ template<class T> bool Intersection::pointFrustum(const Vector3<T>& point, const
return true; return true;
} }
template<class T> bool Intersection::boxFrustum(const Range3D<T>& box, const Frustum<T>& frustum) { template<class T> bool boxFrustum(const Range3D<T>& box, const Frustum<T>& frustum) {
for(const Vector4<T>& plane: frustum.planes()) { for(const Vector4<T>& plane: frustum.planes()) {
bool cornerHit = 0; bool cornerHit = 0;
@ -187,6 +188,6 @@ template<class T> bool Intersection::boxFrustum(const Range3D<T>& box, const Fru
return true; return true;
} }
}}} }}}}
#endif #endif

Write Preview
Loading…
Cancel
Save