G3D::Plane Class Reference

#include <Plane.h>

Public Member Functions
	Plane ()
	Plane (const class Any &a)
Any	toAny () const
	Plane (const Point3 &point0, const Point3 &point1, const Point3 &point2)
	Plane (Vector4 point0, Vector4 point1, Vector4 point2)
	Plane (const Vector3 &normal, const Point3 &point)
	Plane (class BinaryInput &b)
void	serialize (class BinaryOutput &b) const
void	deserialize (class BinaryInput &b)
virtual	~Plane ()
bool	halfSpaceContains (Point3 point) const
bool	halfSpaceContains (const Vector4 &point) const
bool	halfSpaceContainsFinite (const Point3 &point) const
bool	fuzzyContains (const Point3 &point) const
const Vector3 &	normal () const
float	distance (const Vector3 &x) const
Point3	closestPoint (const Point3 &x) const
Vector3	center () const
void	flip ()
void	getEquation (Vector3 &normal, double &d) const
void	getEquation (Vector3 &normal, float &d) const
void	getEquation (double &a, double &b, double &c, double &d) const
void	getEquation (float &a, float &b, float &c, float &d) const
std::string	toString () const

Static Public Member Functions
static Plane	fromEquation (float a, float b, float c, float d)

Private Member Functions
	Plane (const Vector3 &n, float d)

Private Attributes
Vector3	_normal
float	_distance

Detailed Description

An infinite 2D plane in 3D space.

Constructor & Destructor Documentation

G3D::Plane::Plane ( const Vector3 &  n, float  d  )

inlineprivate

Assumes the normal has unit length.

 : _normal(n), _distance(d) {
 }

G3D::Plane::Plane ( )

inline

 : _normal(Vector3::unitY()), _distance(0) {
 }

Here is the caller graph for this function:

G3D::Plane::Plane ( const class Any &  a )

explicit

Format is:

• Plane(normal, point)

G3D::Plane::Plane	(	const Point3 &	point0,
		const Point3 &	point1,
		const Point3 &	point2
	)

Constructs a plane from three points.

 {

 _normal = (point1 - point0).cross(point2 - point0).direction();
 _distance = _normal.dot(point0);
}

Here is the call graph for this function:

G3D::Plane::Plane	(	Vector4	point0,
		Vector4	point1,
		Vector4	point2
	)

Constructs a plane from three points, where at most two are at infinity (w = 0, not xyz = inf).

 {
 
 debugAssertM(
 point0.w != 0 || 
 point1.w != 0 || 
 point2.w != 0,
 "At least one point must be finite.");

 // Rotate the points around so that the finite points come first.

 while ((point0.w == 0) && 
 ((point1.w == 0) || (point2.w != 0))) {
 Vector4 temp = point0;
 point0 = point1;
 point1 = point2;
 point2 = temp;
 }

 Vector3 dir1;
 Vector3 dir2;

 if (point1.w == 0) {
 // 1 finite, 2 infinite points; the plane must contain
 // the direction of the two direcitons
 dir1 = point1.xyz();
 dir2 = point2.xyz();
 } else if (point2.w != 0) {
 // 3 finite points, the plane must contain the directions
 // betwseen the points.
 dir1 = point1.xyz() - point0.xyz();
 dir2 = point2.xyz() - point0.xyz();
 } else {
 // 2 finite, 1 infinite point; the plane must contain
 // the direction between the first two points and the
 // direction of the third point.
 dir1 = point1.xyz() - point0.xyz();
 dir2 = point2.xyz();
 }

 _normal = dir1.cross(dir2).direction();
 _distance = _normal.dot(point0.xyz());
}

Here is the call graph for this function:

G3D::Plane::Plane	(	const Vector3 &	normal,
		const Point3 &	point
	)

The normal will be unitized.

 {

 _normal = __normal.direction();
 _distance = _normal.dot(point);
}

Here is the call graph for this function:

G3D::Plane::Plane

(

class BinaryInput &

b

)

 {
 deserialize(b);
}

Here is the call graph for this function:

virtual G3D::Plane::~Plane ( )

inlinevirtual

{}

Member Function Documentation

Vector3 G3D::Plane::center ( ) const

inline

Returns normal * distance from origin

 {
 return _normal * _distance;
 }

Point3 G3D::Plane::closestPoint ( const Point3 &  x ) const

inline

 {
 return x + (_normal * (-distance(x)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Plane::deserialize

(

class BinaryInput &

b

)

 {
 _normal.deserialize(b);
 _distance = (float)b.readFloat64();
}

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Plane::distance ( const Vector3 &  x ) const

inline

Returns distance from point to plane. Distance is negative if point is behind (not in plane in direction opposite normal) the plane.

 {
 return (_normal.dot(x) - _distance);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Plane::flip

(

)

Inverts the facing direction of the plane so the new normal is the inverse of the old normal.

 {
 _normal = -_normal;
 _distance = -_distance;
}

Plane G3D::Plane::fromEquation ( float  a, float  b, float  c, float  d  )

static

 {
 Vector3 n(a, b, c);
 float magnitude = n.magnitude();
 d /= magnitude;
 n /= magnitude;
 return Plane(n, -d);
}

Here is the call graph for this function:

bool G3D::Plane::fuzzyContains ( const Point3 &  point ) const

inline

Returns true if the point is nearly in the plane.

 {
 return fuzzyEq(point.dot(_normal), _distance);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Plane::getEquation	(	Vector3 &	normal,
		double &	d
	)		const

Returns the equation in the form:

normal.Dot(Vector3(x, y, z)) + d = 0

 {
 n = _normal;
 d = -_distance;
}

Here is the caller graph for this function:

void G3D::Plane::getEquation	(	Vector3 &	normal,
		float &	d
	)		const

 {
 double _d;
 getEquation(n, _d);
 d = (float)_d;
}

Here is the call graph for this function:

void G3D::Plane::getEquation	(	double &	a,
		double &	b,
		double &	c,
		double &	d
	)		const

ax + by + cz + d = 0

 {
 a = _normal.x;
 b = _normal.y;
 c = _normal.z;
 d = -_distance;
}

void G3D::Plane::getEquation	(	float &	a,
		float &	b,
		float &	c,
		float &	d
	)		const

 {
 double _a, _b, _c, _d;
 getEquation(_a, _b, _c, _d);
 a = (float)_a;
 b = (float)_b;
 c = (float)_c;
 d = (float)_d;
}

Here is the call graph for this function:

bool G3D::Plane::halfSpaceContains ( Point3  point ) const

inline

Returns true if point is on the side the normal points to or is in the plane.

 {
 // Clamp to a finite range for testing
 point = point.clamp(Vector3::minFinite(), Vector3::maxFinite());

 // We can get away with putting values *at* the limits of the float32 range into
 // a dot product, since the dot product is carried out on float64.
 return _normal.dot(point) >= _distance;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Plane::halfSpaceContains ( const Vector4 &  point ) const

inline

Returns true if point is on the side the normal points to or is in the plane.

 {
 if (point.w == 0) {
 return _normal.dot(point.xyz()) > 0;
 } else {
 return halfSpaceContains(point.xyz() / point.w);
 }
 }

Here is the call graph for this function:

bool G3D::Plane::halfSpaceContainsFinite ( const Point3 &  point ) const

inline

Returns true if point is on the side the normal points to or is in the plane. Only call on finite points. Faster than halfSpaceContains.

 {
 debugAssert(point.isFinite());
 return _normal.dot(point) >= _distance;
 }

Here is the call graph for this function:

const Vector3& G3D::Plane::normal ( ) const

inline

 {
 return _normal;
 }

Here is the caller graph for this function:

void G3D::Plane::serialize

(

class BinaryOutput &

b

)

const

 {
 _normal.serialize(b);
 b.writeFloat64(_distance);
}

Here is the call graph for this function:

Any G3D::Plane::toAny

(

)

const

 {
 Any a(Any::ARRAY, "Plane");
 a.append(normal(), normal() * _distance);
 return a;
}

Here is the call graph for this function:

std::string G3D::Plane::toString

(

)

const

 {
 return format("Plane(%g, %g, %g, %g)", _normal.x, _normal.y, _normal.z, _distance);
}

Here is the call graph for this function:

Member Data Documentation

float G3D::Plane::_distance

private

Vector3 G3D::Plane::_normal

private

normal.Dot(x,y,z) = distance

---

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

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