G3D::LineSegment2D Class Reference

#include <LineSegment.h>

Public Member Functions
	LineSegment2D ()
Point2	intersection (const LineSegment2D &other) const
Point2	point (int i) const
Point2	closestPoint (const Point2 &Q) const
float	distance (const Point2 &p) const
float	length () const

Static Public Member Functions
static LineSegment2D	fromTwoPoints (const Point2 &p0, const Vector2 &p1)

Private Attributes
Point2	m_origin
Vector2	m_direction
float	m_length

Constructor & Destructor Documentation

G3D::LineSegment2D::LineSegment2D ( )

inline

{}

Member Function Documentation

Vector2 G3D::LineSegment2D::closestPoint

(

const Point2 &

Q

)

const

 {
 // Two constants that appear in the result
 const Vector2 k1(m_origin - Q);
 const Vector2& k2 = m_direction;
 
 if (fuzzyEq(m_length, 0)) {
 // This line segment has no length
 return m_origin;
 }

 // Time [0, 1] at which we hit the closest point travelling from p0 to p1.
 // Derivation can be obtained by minimizing the expression
 // ||P0 + (P1 - P0)t - Q||.
 const float t = -k1.dot(k2) / (m_length * m_length);

 if (t < 0) {
 // Clipped to low end point
 return m_origin;
 } else if (t > 1) {
 // Clipped to high end point
 return m_origin + m_direction;
 } else {
 // Subsitute into the line equation to find 
 // the point on the segment.
 return m_origin + k2 * t;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::LineSegment2D::distance

(

const Point2 &

p

)

const

 {
 Vector2 closest = closestPoint(p);
 return (closest - p).length();
}

Here is the call graph for this function:

LineSegment2D G3D::LineSegment2D::fromTwoPoints ( const Point2 &  p0, const Vector2 &  p1  )

static

 {
 LineSegment2D s;
 s.m_origin = p0;
 s.m_direction = p1 - p0;
 s.m_length = s.m_direction.length();
 return s;
}

Here is the call graph for this function:

Vector2 G3D::LineSegment2D::intersection

(

const LineSegment2D &

other

)

const

Returns the intersection of these segements (including testing endpoints), or Point2::inf() if they do not intersect.

 {

 if ((m_origin == other.m_origin) ||
 (m_origin == other.m_origin + other.m_direction)) {
 return m_origin;
 }

 if (m_origin + m_direction == other.m_origin) {
 return other.m_origin;
 }

 // Note: Now that we've checked the endpoints, all other parallel lines can now be assumed
 // to not intersect (within numerical precision)

 Vector2 dir1 = m_direction;
 Vector2 dir2 = other.m_direction;
 Vector2 origin1 = m_origin;
 Vector2 origin2 = other.m_origin;

 if (dir1.x == 0) {
 // Avoid an upcoming divide by zero
 dir1 = dir1.yx();
 dir2 = dir2.yx();
 origin1 = origin1.yx();
 origin2 = origin2.yx();
 }

 // t1 = ((other.m_origin.x - m_origin.x) + other.m_direction.x * t2) / m_direction.x
 //
 // ((other.m_origin.x - m_origin.x) + other.m_direction.x * t2) * m_direction.y / m_direction.x = 
 // (other.m_origin.y - m_origin.y) + other.m_direction.y * t2
 //
 // m = m_direction.y / m_direction.x
 // d = other.m_origin - m_origin
 //
 // (d.x + other.m_direction.x * t2) * m = d.y + other.m_direction.y * t2
 //
 // d.x * m + other.m_direction.x * m * t2 = d.y + other.m_direction.y * t2
 //
 // d.x * m - d.y = (other.m_direction.y - other.m_direction.x * m) * t2
 //
 // (d.x * m - d.y) / (other.m_direction.y - other.m_direction.x * m) = t2
 //

 Vector2 d = origin2 - origin1;
 float m = dir1.y / dir1.x;

 float t2 = (d.x * m - d.y) / (dir2.y - dir2.x * m);
 if (! isFinite(t2)) {
 // Parallel lines: no intersection
 return Vector2::inf();
 }

 if ((t2 < 0.0f) || (t2 > 1.0f)) {
 // Intersection occurs past the end of the line segments
 return Vector2::inf();
 }

 float t1 = (d.x + dir2.x * t2) / dir1.x;
 if ((t1 < 0.0f) || (t1 > 1.0f)) {
 // Intersection occurs past the end of the line segments
 return Vector2::inf();
 }

 // Return the intersection point (computed from non-transposed 
 // variables even if we flipped above)
 return m_origin + m_direction * t1;
 
}

Here is the call graph for this function:

float G3D::LineSegment2D::length

(

)

const

 {
 return m_length;
}

Vector2 G3D::LineSegment2D::point

(

int

i

)

const

 {
 debugAssert(i == 0 || i == 1);
 if (i == 0) {
 return m_origin;
 } else {
 return m_direction + m_origin;
 }
}

Member Data Documentation

Vector2 G3D::LineSegment2D::m_direction

private

Not normalized

float G3D::LineSegment2D::m_length

private

Length of m_direction

Point2 G3D::LineSegment2D::m_origin

private

---

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

• dep/g3dlite/include/G3D/LineSegment.h
• dep/g3dlite/source/LineSegment.cpp