Line of intersection between two planes

Question

How can I find the line of intersection between two planes?

I know the mathematics idea, and I did the cross product between the the planes normal vectors

but how to get the line from the resulted vector programmatically

Answer 1

The equation of the plane is ax + by + cz + d = 0, where (a,b,c) is the plane's normal, and d is the distance to the origin. This means that every point (x,y,z) that satisfies that equation is a member of the plane.

Given two planes:

P1: a1x + b1y + c1z + d1 = 0
P2: a2x + b2y + c2z + d2 = 0

The intersection between the two is the set of points that verifies both equations. To find points along this line, you can simply pick a value for x, any value, and then solve the equations for y and z.

y = (-c1z -a1x -d1) / b1
z = ((b2/b1)*(a1x+d1) -a2x -d2)/(c2 - c1*b2/b1)

If you make x=0, this gets simpler:

y = (-c1z -d1) / b1
z = ((b2/b1)*d1 -d2)/(c2 - c1*b2/b1)

Answer 2

Finding the line between two planes can be calculated using a simplified version of the 3-plane intersection algorithm.

The 2'nd, "more robust method" from bobobobo's answer references the 3-plane intersection.

While this works well for 2 planes (where the 3rd plane can be calculated using the cross product of the first two), the problem can be further reduced for the 2-plane version.

• No need to use a 3x3 matrix determinant,
  instead we can use the squared length of the cross product between the first and second plane (which is the direction of the 3'rd plane).
• No need to include the 3rd planes distance,
  (calculating the final location).
• No need to negate the distances.
  Save some cpu-cycles by swapping the cross product order instead.

Including this code-example, since it may not be immediately obvious.

// Intersection of 2-planes: a variation based on the 3-plane version.
// see: Graphics Gems 1 pg 305
//
// Note that the 'normal' components of the planes need not be unit length
bool isect_plane_plane_to_normal_ray(
        const Plane& p1, const Plane& p2,
        // output args
        Vector3f& r_point, Vector3f& r_normal)
{
    // logically the 3rd plane, but we only use the normal component.
    const Vector3f p3_normal = p1.normal.cross(p2.normal);
    const float det = p3_normal.length_squared();
    
    // If the determinant is 0, that means parallel planes, no intersection.
    // note: you may want to check against an epsilon value here.
    if (det != 0.0) {
        // calculate the final (point, normal)
        r_point = ((p3_normal.cross(p2.normal) * p1.d) +
                   (p1.normal.cross(p3_normal) * p2.d)) / det;
        r_normal = p3_normal;
        return true;
    }
    else {
        return false;
    }
}

---

Adding this answer for completeness, since at time of writing, none of the answers here contain a working code-example which directly addresses the question.

Though other answers here already covered the principles.

Answer 3

Finding a point on the line

To get the intersection of 2 planes, you need a point on the line and the direction of that line.

Finding the direction of that line is really easy, just cross the 2 normals of the 2 planes that are intersecting.

lineDir = n1 × n2

But that line passes through the origin, and the line that runs along your plane intersections might not. So, Martinho's answer provides a great start to finding a point on the line of intersection (basically any point that is on both planes).

In case you wanted to see the derivation for how to solve this, here's the math behind it:

First let x=0. Now we have 2 unknowns in 2 equations instead of 3 unknowns in 2 equations (we arbitrarily chose one of the unknowns).

Then the plane equations are (A terms were eliminated since we chose x=0):

B₁y + C₁z + D₁ = 0

B₂y + C₂z + D₂ = 0

We want y and z such that those equations are both solved correctly (=0) for the B₁, C₁ given.

So, just multiply the top eq by (-B₂/B₁) to get

-B₂y + (-B₂/B₁)*C₁z + (-B₂/B₁)*D₁ = 0

B₂y + C₂z + D₂ = 0

Add the eqs to get

z = ( (-B₂/B₁)*D₁ - D₂ ) / (C₂ * B₂/B₁)*C₁)

Throw the z you find into the 1st equation now to find y as

y = (-D₁ - C₁z) / B₁

Note the best variable to make 0 is the one with the lowest coefficients, because it carries no information anyway. So if C₁ and C₂ were both 0, choosing z=0 (instead of x=0) would be a better choice.

The above solution can still screw up if B₁=0 (which isn't that unlikely). You could add in some if statements that check if B₁=0, and if it is, be sure to solve for one of the other variables instead.

Solution using intersection of 3 planes

From user's answer, a closed form solution for the intersection of 3 planes was actually in Graphics Gems 1. The formula is:

P_intersection = (( point_on1 • n1 )( n2 × n3 ) + ( point_on2 • n2 )( n3 × n1 ) + ( point_on3 • n3 )( n1 × n2 )) / det(n1,n2,n3)

Actually point_on1 • n1 = -d1 (assuming you write your planes Ax + By + Cz + D=0, and not =-D). So, you could rewrite it as:

P_intersection = (( -d1 )( n2 × n3 ) + ( -d2 )( n3 × n1 ) + ( -d3 )( n1 × n2 )) / det(n1,n2,n3)

A function that intersects 3 planes:

// Intersection of 3 planes, Graphics Gems 1 pg 305
static Vector3f getIntersection( const Plane& plane1, const Plane& plane2, const Plane& plane3 )
{
  float det = Matrix3f::det( plane1.normal, plane2.normal, plane3.normal ) ;
    
  // If the determinant is 0, that means parallel planes, no intn.
  if( det == 0.f ) return 0 ; //could return inf or whatever
  
  return ( plane2.normal.cross( plane3.normal )*-plane1.d +
           plane3.normal.cross( plane1.normal )*-plane2.d + 
           plane1.normal.cross( plane2.normal )*-plane3.d ) / det ;            
}

Proof it works (yellow dot is intersection of rgb planes here)

Getting the line

Once you have a point of intersection common to the 2 planes, the line just goes

P + t*d

Where P is the point of intersection, t can go from (-inf, inf), and d is the direction vector that is the cross product of the normals of the two original planes.

The line of intersection between the red and blue planes looks like this

Efficiency and stability

The "robust" (2nd way) takes 48 elementary ops by my count, vs the 36 elementary ops that the 1st way (isolation of x,y) uses. There is a trade off between stability and # computations between these 2 ways.

It'd be pretty catastrophic to get (0,inf,inf) back from a call to the 1st way in the case that B₁ was 0 and you didn't check. So adding in if statements and making sure not to divide by 0 to the 1st way may give you the stability at the cost of code bloat, and the added branching (which might be quite expensive). The 3 plane intersection method is almost branchless and won't give you infinities.

Answer 4

This method avoids division by zero as long as the two planes are not parallel.

If these are the planes:

A1*x + B1*y + C1*z + D1 = 0
A2*x + B2*y + C2*z + D2 = 0

1) Find a vector parallel to the line of intersection. This is also the normal of a 3rd plane which is perpendicular to the other two planes:

(A3,B3,C3) = (A1,B1,C1) cross (A2,B2,C2)

2) Form a system of 3 equations. These describe 3 planes which intersect at a point:

A1*x1 + B1*y1 + C1*z1 + D1 = 0
A2*x1 + B2*y1 + C2*z1 + D2 = 0
A3*x1 + B3*y1 + C3*z1 = 0

3) Solve them to find x1,y1,z1. This is a point on the line of intersection.

4) The parametric equations of the line of intersection are:

x = x1 + A3 * t
y = y1 + B3 * t
z = z1 + C3 * t

Answer 5

The determinant-based approach is neat, but it's hard to follow why it works.

Here's another way that's more intuitive.

The idea is to first go from the origin to the closest point on the first plane (p1), and then from there go to the closest point on the line of intersection of the two planes. (Along a vector that I'm calling v below.)

Given
=====
 First plane: n1 • r = k1
Second plane: n2 • r = k2

Working
=======
dir = n1 × n2
p1 = (k1 / (n1 • n1)) * n1
v = n1 × dir
pt = LineIntersectPlane(line = (p1, v), plane = (n2, k2))

LineIntersectPlane
==================
#We have n2 • (p1 + lambda * v) = k2
lambda = (k2 - n2 • p1) / (n2 • v)
Return p1 + lambda * v

Output
======
Line where two planes intersect: (pt, dir)

This should give the same point as the determinant-based approach. There's almost certainly a link between the two. At least the denominator, n2 • v, is the same, if we apply the "scalar triple product" rule. So these methods are probably similar as far as condition numbers go.

Don't forget to check for (almost) parallel planes. For example: if (dir • dir < 1e-8) should work well if unit normals are used.

Answer 6

You can find the formula for the intersection line of two planes in this link.

P1: a1x + b1y + c1z  = d1
P2: a2x + b2y + c2z  = d2
n1=(a1,b1,c1); n2=(a2,b2,c2); n12=Norm[Cross[n1,n2]]^2
If n12 != 0
 a1 = (d1*Norm[n2]^2 - d2*n1.n2)/n12;  
 a2 = (d2*Norm[n1]^2 - d1*n1.n2)/n12;
 P = a1 n1 + a2 n2;
 (*formula for the intersection line*)
 Li[t_] := P + t*Cross[n1, n2]; 

Answer 7

The cross product of the line is the direction of the intersection line. Now you need a point in the intersection.

You can do this by taking a point on the cross product, then subtracting Normal of plane A * distance to plane A and Normal of plane B * distance to plane b. Cleaner:

p = Point on cross product

intersection point = ([p] - ([Normal of plane A] * [distance from p to plane A]) - ([Normal of plane B] * [distance from p to plane B]))

Edit:

You have two planes with two normals:

N1 and N2

The cross product is the direction of the Intersection Line:

C = N1 x N2

The class above has a function to calculate the distance between a point and a plane. Use it to get the distance of some point p on C to both planes:

p = C //p = 1 times C to get a point on C
d1 = plane1.getDistance(p)
d2 = plane2.getDistance(p)

Intersection line:

resultPoint1 = (p - (d1 * N1) - (d2 * N2))
resultPoint2 = resultPoint1 + C