Hi guys, quick question on the plane equation and finding if a point is on a plane or not.

Given a plane defined by a normal (ABC) and a distance from origin (D). I've read articles describing that a point is on the plane if it satisfies the plane equation:

Ax + By + Cz + D = 0

Which seems to me like it is the equivalent of:

DOT(ABC, xyz) + D = 0

These are the articles in question, tough many google results show the same thing:

http://gamedeveloperjourney.blogspot.com/2009/04/point-plane-collision-detection.html

http://www.xbdev.net/maths_of_3d/collision_detection/point_to_plane/index.php

So far so good, however after writing a few test programs, this does not seem accurate. I read "Real Time Collision Detection" by Christer Ericson, he gives this definition of a plane:

struct Plane {
	Vector n; // Plane normal. Points x on the plane satisfy Dot(n,x) = d 
	float d; // d = dot(n,p) for a given point p on the plane
};

By this definition, the equation of a plane should be

Ax + By + Cz = D

Meaning a point is on the plane if it satisfies:

Ax + By + Cz - D = 0

A quick google turned up this page, which seems to confirm the above assertion:

-d is the more "correct" version. Since it's a constant we can name it whatever we like, and even define d as -d. Point being, if you compute ax + by + cz you get a scalar, and this scalar is d. We end up with:

ax + by + cz = d

We can then move everything to one side:

ax + by + cz - d = 0

And, if we are so inclined we can re-name d to be positive:

ax + by + cz + d = 0

Why would anyone do this? Who knows. Personally I think it's annoying and should be negative.

   0 = Ax + By + Cz + D
?  0 = Px*Nx + Py*Ny + Pz*Nz + D
?  0 = (Px,Py,Pz,1) dot (Nx,Ny,Nz,D)
?  0 = (float4(pt.xyz,1)) dot (float4(normal,distance))

I mean, that's exactly what i'm confused about!

Let's assume D is a scalar

Ax + By + Cz = D

Now, if we do:

Ax + By + Cz - D = 0

The expands to

Ax + By + Cz - (Ax + By + Cz) = 0

If i just change the sign of D to positive for shits and giggles it becomes:

Ax + By + Cz + (Ax + By + Cz) = 0

I mean, it's not just me right, that's a VERY different equation! Like you can't just make a number positive for shits and giggles!

These two pieces of code return very different results!

bool PointOnPlane(Point point, Plane plane) {
	float result = plane.n.X * point.X + plane.n.Y * point.Y + plane.n.Z * point.Z + plane.d;
	return Math.Abs(0f - result) < 0.00001f;
}

bool PointOnPlane(Point point, Plane plane) {
	float result = plane.n.X * point.X + plane.n.Y * point.Y + plane.n.Z * point.Z - plane.d;
	return Math.Abs(0f - result) < 0.00001f;
}

OR are you saying that d in the definition of a plane:

struct Plane {
    Vector n; // Plane normal. Points x on the plane satisfy Dot(n,x) = d 
    float d; // d = dot(n,p) for a given point p on the plane
};

doesn't actually stand for distance from origin, rather a scalar?

OR are we saying that D in the plane equation and D in

d = dot(n,p) for a given point p on the plane

are two different distances, both just happen to be refered to as d. But one stands for the distance of the plane from origin, where the other is the distance of the point from the plane?

Ax + By + Cz + D = 0 

I think that this form is more used because it is in sync with the rest of the math. Additionally it is much easier to memorize formulas if there aren't many different version of the sign.

And of course depending on your logic behind it it is a bit more intuitive (or vice versa)

I think about planes as being defined by a normal n and a point on the plane p. Then we can define the plane as (read * as dot-product):

P: n * x - n * p = n * ( x - p ) = 0

We can now define d = n * p and get:

P: n * x - d = 0

I thinks this is the more formal definition that you would find it in a textbook. If you use 4D vectors for planes and want to define the distance of a point to a plane using the dot product you would define d = -n * p which yields:

P : n * x + d = 0

I think the 4D vector definition also works well with transformations where you simply multiply the 4D 'plane' vector with a 4x4 transformation matrix (not sure though). Personally I prefer the more formal definition and use explicit plane functions to evaluate the distance to planes or transform them. If you want to wrap everything into a generic 4D vector the later might be the better choice.

HTH,

-Dirk