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. 354
      src/Magnum/Math/Geometry/Distance.h
  3. 225
      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

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

225
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
* line segment defined by `q` and `q + 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) { 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) {
const Vector2<T> qp = q - p; const Vector2<T> qp = q - p;
const T rs = cross(r, s); const T rs = cross(r, s);
return {cross(qp, s)/rs, cross(qp, r)/rs}; 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. Returns intersection point position @f$ t @f$ on first line, NaN if the lines
* Intersection point can be then with `p + t*r`. If returned are collinear or infinity if they are parallel. Intersection point can be then
* value is in range @f$ [ 0 ; 1 ] @f$, the intersection is inside calculated with @f$ \boldsymbol{p} + t \boldsymbol{r} @f$. If returned value is
* the line segment defined by `p` and `p + r`. in range @f$ [ 0 ; 1 ] @f$, the intersection is inside the line segment defined
* by @f$ \boldsymbol{p} @f$ and @f$ \boldsymbol{p} + \boldsymbol{r} @f$.
* Unlike @ref lineSegmentLineSegment() computes only **t**.
*/ Unlike @ref lineSegmentLineSegment() calculates only @f$ t @f$.
template<class T> static T lineSegmentLine(const Vector2<T>& p, const Vector2<T>& r, const Vector2<T>& q, const Vector2<T>& s) { */
template<class T> inline 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); return cross(q - p, s)/cross(r, s);
} }
/** /**
* @brief Intersection of a plane and line @brief Intersection of a plane and line
* @param planePosition Plane position @param planePosition Plane position
* @param planeNormal Plane normal @param planeNormal Plane normal
* @param p Starting point of the line @param p Starting point of the line
* @param r Direction of the line @param r Direction of the line
* @return Intersection point position `t` on the line, NaN if the
* line lies on the plane or infinity if the intersection doesn't Returns intersection point position @f$ t @f$ on the line, NaN if the line lies
* exist. Intersection point can be then computed from with on the plane or infinity if the intersection doesn't exist. Intersection point
* `p + t*r`. If returned value is in range @f$ [ 0 ; 1 ] @f$, the can be then calculated from with @f$ \boldsymbol{p} + t \boldsymbol{r} @f$. If
* intersection is inside the line segment defined by `p` and `r`. returned value is in range @f$ [ 0 ; 1 ] @f$, the intersection is inside the
* line segment defined by @f$ \boldsymbol{p} @f$ and @f$ \boldsymbol{r} @f$.
* First the parameter *f* of parametric equation of the plane
* is computed from plane normal **n** and plane position: @f[ First the parameter @f$ f @f$ of parametric equation of the plane is calculated
* \begin{pmatrix} n_0 \\ n_1 \\ n_2 \end{pmatrix} \cdot from plane normal @f$ \boldsymbol{n} @f$ and plane position: @f[
* \begin{pmatrix} x \\ y \\ z \end{pmatrix} - f = 0 \begin{pmatrix} n_0 \\ n_1 \\ n_2 \end{pmatrix} \cdot
* @f] \begin{pmatrix} x \\ y \\ z \end{pmatrix} - f = 0
* Using plane normal **n**, parameter *f* and line defined by **p** @f]
* and **r**, value of *t* is computed and returned. @f[ Using plane normal @f$ \boldsymbol{n} @f$, parameter @f$ f @f$ and line defined
* \begin{array}{rcl} by @f$ \boldsymbol{p} @f$ and @f$ \boldsymbol{r} @f$, value of @f$ t @f$ is
* f & = & \boldsymbol n \cdot (\boldsymbol p + t \boldsymbol r) \\ calculated and returned. @f[
* \Rightarrow t & = & \cfrac{f - \boldsymbol n \cdot \boldsymbol p}{\boldsymbol n \cdot \boldsymbol r} \begin{array}{rcl}
* \end{array} f & = & \boldsymbol n \cdot (\boldsymbol p + t \boldsymbol r) \\
* @f] \Rightarrow t & = & \cfrac{f - \boldsymbol n \cdot \boldsymbol p}{\boldsymbol n \cdot \boldsymbol r}
\end{array}
@f]
*/ */
template<class T> static T planeLine(const Vector3<T>& planePosition, const Vector3<T>& planeNormal, const Vector3<T>& p, const Vector3<T>& r) { 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); const T f = dot(planePosition, planeNormal);
return (f-dot(planeNormal, p))/dot(planeNormal, r); return (f - dot(planeNormal, p))/dot(planeNormal, r);
} }
/** /**
* @brief Intersection of a point and a camera frustum @brief Intersection of a point and a camera frustum
* @param point Point @param point Point
* @param frustum Frustum planes with normals pointing outwards @param frustum Frustum planes with normals pointing outwards
* @return `true` if the point is on or inside the frustum.
* 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 Checks for each plane of the frustum whether the point is behind the plane (the
* @ref Distance::pointPlaneScaled(). 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); template<class T> bool pointFrustum(const Vector3<T>& point, const Frustum<T>& frustum);
/** /**
* @brief Intersection of a range and a camera frustum @brief Intersection of an axis-aligned box and a camera frustum
* @return `true` if the box intersects with the camera frustum @param box Axis-aligned box
* @param frustum Frustum planes with normals pointing outwards
* 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 Returns `true` if the box intersects with the camera frustum.
* must lie entirely outside of the frustum and there is no
* intersection. Else, the box is considered as intersecting, even if Counts for each plane of the frustum how many points of the box lie in front of
* it is merely corners of the box overlapping with corners of the the plane (outside of the frustum). If none, the box must lie entirely outside
* frustum, since checking the corners is less efficient. 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
template<class T> static bool boxFrustum(const Range3D<T>& box, const Frustum<T>& frustum); 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 Intersection::pointFrustum(const Vector3<T>& point, const Frustum<T>& frustum) { template<class T> bool 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