Lines and Planes in Space

Learning Objectives

By the end of this section, you will be able to:

1. Write the vector, parametric, and symmetric equations of a line in three-dimensional space
2. Derive the scalar and vector equations of a plane using normal vectors and points
3. Determine whether a line and plane are parallel, intersecting, or if the line lies within the plane
4. Calculate distances from points to lines and planes using vector projections
5. Find angles between lines, between planes, and between a line and a plane
6. Apply these concepts to real-world problems in physics, computer graphics, and machine learning

The Big Picture: Geometry Meets Algebra

"Lines and planes are the simplest geometric objects—and yet they form the foundation for understanding everything from neural network decision boundaries to airplane navigation."

In two dimensions, we described lines using equations like $y = mx + b$. But in three dimensions, this familiar form breaks down. A single equation like $y = 2x + 3$ no longer defines a line—it defines an entire plane (with no restriction on $z$).

To describe lines in 3D, we need a fundamentally different approach: we think of a line as a path traced by a moving point. This leads to parametric equations, where a single parameter $t$ generates every point on the line.

For planes, we use a different key insight: every plane can be uniquely determined by a point and a normal vector—a vector perpendicular to the plane. This connects directly to the dot product: every point on the plane satisfies $\vec{n} \cdot \vec{r} = d$.

Historical Context

The algebraic description of lines and planes evolved through centuries of mathematical development:

• René Descartes (1637) invented coordinate geometry, connecting algebra to geometry for the first time
• Leonhard Euler (1748) systematically developed equations for planes and their properties
• William Rowan Hamilton (1843) introduced quaternions, leading to modern vector notation
• Josiah Willard Gibbs (1880s) developed the modern vector algebra we use today, including dot and cross products

The parametric representation of curves was crucial for the development of calculus in multiple dimensions. Newton and Leibniz both used parametric descriptions when studying planetary orbits and other curves that couldn't be expressed as simple functions.

Lines in Three-Dimensional Space

A line in 3D space is uniquely determined by two pieces of information:

1. A point on the line (let's call it $P_0 = (x_0, y_0, z_0)$)
2. A direction vector $\vec{d} = \langle a, b, c \rangle$ indicating which way the line goes

Vector Equation of a Line

Starting from point $P_0$ and traveling in direction $\vec{d}$, we can reach any point on the line by adding a scalar multiple of $\vec{d}$:

Here, $t$ is a parameter that can take any real value:

• When $t = 0$, we're at $P_0$
• When $t > 0$, we've moved in the direction of $\vec{d}$
• When $t < 0$, we've moved opposite to $\vec{d}$

Parametric Equations

Breaking the vector equation into components, we get the parametric equations:

Example: Find parametric equations for the line through $(2, -1, 3)$ with direction $\langle 4, 2, -1 \rangle$.

Symmetric Equations

If we solve each parametric equation for $t$ and set them equal, we get the symmetric equations:

Interactive Line Explorer

Use this interactive visualization to explore lines in 3D space. Adjust the starting point and direction vector to see how the parametric equation generates points along the line:

Planes in Three-Dimensional Space

A plane in 3D is determined by a point and a normal vector. The normal vector $\vec{n} = \langle a, b, c \rangle$ is perpendicular to every vector lying in the plane.

Scalar Equation of a Plane

For any point $P = (x, y, z)$ on the plane, the vector from $P_0$ to $P$ must be perpendicular to $\vec{n}$. This gives:

Derivation: If $\vec{n} \perp \overrightarrow{P_0P}$, then:

Vector Equation of a Plane

We can also express the plane equation in compact vector form:

Example: Find the equation of the plane through $(1, 2, 3)$ with normal $\vec{n} = \langle 2, -1, 4 \rangle$.

Interactive Plane Explorer

Explore how the normal vector and constant d affect the position and orientation of a plane:

Line-Plane Relationships

A line and a plane in 3D can relate in exactly three ways:

Finding the Intersection Point

To find where a line intersects a plane:

1. Write the line in parametric form: $x = x_0 + at, \; y = y_0 + bt, \; z = z_0 + ct$
2. Substitute into the plane equation: $a \cdot x + b \cdot y + c \cdot z = d$
3. Solve for $t$
4. Plug $t$ back to get the intersection point

Formula for t: Given line $\vec{r}(t) = P_0 + t\vec{d}$ and plane $\vec{n} \cdot \vec{r} = D$:

Example: Find where the line through $(1, 0, 0)$ with direction $\langle 1, 1, 1 \rangle$ intersects the plane $x + 2y + z = 6$.

Interactive Intersection Explorer

Experiment with different line and plane configurations to see how they intersect (or don't):

Distance Formulas

Distance from a Point to a Plane

The distance from point $(x_1, y_1, z_1)$ to plane $ax + by + cz = d$ is:

Geometric interpretation: This formula computes the length of the projection of any vector from the plane to the point onto the unit normal. The numerator is the scalar projection; the denominator normalizes the normal vector.

Example: Distance from $(3, -1, 2)$ to plane $2x - 2y + z = 5$:

Distance from a Point to a Line

For point $P$ and line through $Q$ with direction $\vec{d}$:

Geometric interpretation: The cross product $\overrightarrow{QP} \times \vec{d}$ has magnitude equal to the area of the parallelogram formed by these vectors. Dividing by the base length $|\vec{d}|$ gives the height, which is the perpendicular distance.

Angles Between Lines and Planes

The relationships between angles and dot/cross products make computing angles straightforward:

Special cases:

• Perpendicular lines: $\vec{d}_1 \cdot \vec{d}_2 = 0$
• Parallel lines: $\vec{d}_1 \times \vec{d}_2 = \vec{0}$
• Perpendicular planes: $\vec{n}_1 \cdot \vec{n}_2 = 0$
• Parallel planes: $\vec{n}_1 \times \vec{n}_2 = \vec{0}$

Real-World Applications

Computer Graphics: Ray Tracing

In ray tracing, we model light as rays (lines) and compute their intersections with surfaces. For polygonal surfaces (triangles, quads), this means:

1. Find the plane containing the polygon
2. Compute the ray-plane intersection
3. Check if the intersection point lies within the polygon bounds

Robotics: Collision Detection

Robot arms move through 3D space along planned trajectories. To avoid collisions:

• Model the arm segments as cylinders or line segments
• Model obstacles as planes, boxes, or other primitives
• Compute distances between arm and obstacles
• Adjust trajectory if distance falls below safety threshold

Aviation: Flight Path Planning

Aircraft must maintain safe separations. Their flight paths are modeled as lines in 3D space (latitude, longitude, altitude). Finding the closest approach distance between two flight paths uses the line-to-line distance formula:

Machine Learning Connection

Lines and planes appear throughout machine learning, often as decision boundaries:

Linear Classifiers

In a linear classifier, we separate data points using a hyperplane (a plane in higher dimensions). The decision rule is:

This is exactly the plane equation $\vec{n} \cdot \vec{r} = d$! The weight vector $\vec{w}$ is the normal to the decision boundary, and $b$ is the offset.

Support Vector Machines (SVM)

SVMs find the hyperplane that maximizes the margin—the distance to the nearest training points. The margin is exactly the point-to-plane distance formula:

Neural Network Visualization

Each neuron in a neural network computes $\sigma(\vec{w} \cdot \vec{x} + b)$. Before the activation function $\sigma$, this is a hyperplane in input space. The activation "bends" the hyperplane into a more complex decision surface.

Python Implementation

Parametric Lines in 3D

1import numpy as np
2
3def parametric_line(P0, direction, t):
4    """
5    Compute point on line at parameter t.
6
7    Line: r(t) = P0 + t * direction
8
9    Args:
10        P0: Starting point [x0, y0, z0]
11        direction: Direction vector [a, b, c]
12        t: Parameter value (scalar or array)
13
14    Returns:
15        Point(s) on the line
16    """
17    P0 = np.array(P0)
18    direction = np.array(direction)
19    t = np.atleast_1d(t)
20
21    # Broadcast multiplication for multiple t values
22    points = P0 + np.outer(t, direction)
23    return points.squeeze()
24
25# Example: Line through (1, 2, 3) with direction <2, 1, -1>
26P0 = [1, 2, 3]
27d = [2, 1, -1]
28
29print("Points on line r(t) = (1,2,3) + t<2,1,-1>:")
30for t in [-1, 0, 1, 2]:
31    point = parametric_line(P0, d, t)
32    print(f"  t={t:2d}: {point}")
33
34# Generate many points for plotting
35t_values = np.linspace(-2, 2, 50)
36line_points = parametric_line(P0, d, t_values)
37print(f"\nGenerated {len(line_points)} points for visualization")

Planes from Points and Normals

1import numpy as np
2
3def plane_equation(normal, d, point):
4    """
5    Check if a point satisfies the plane equation.
6
7    Plane: n · r = d, or ax + by + cz = d
8
9    Args:
10        normal: Normal vector [a, b, c]
11        d: Plane constant
12        point: Point to check [x, y, z]
13
14    Returns:
15        True if point is on plane, difference otherwise
16    """
17    n = np.array(normal)
18    p = np.array(point)
19    result = np.dot(n, p)
20    return result - d  # Should be 0 if on plane
21
22def plane_from_three_points(P1, P2, P3):
23    """
24    Find plane equation from three non-collinear points.
25
26    Method: Normal = (P2-P1) × (P3-P1)
27    """
28    P1, P2, P3 = np.array(P1), np.array(P2), np.array(P3)
29
30    # Two vectors in the plane
31    v1 = P2 - P1
32    v2 = P3 - P1
33
34    # Normal via cross product
35    normal = np.cross(v1, v2)
36
37    # d = n · P1 (any of the three points works)
38    d = np.dot(normal, P1)
39
40    return normal, d
41
42# Example: Plane through (1,0,0), (0,1,0), (0,0,1)
43n, d = plane_from_three_points([1,0,0], [0,1,0], [0,0,1])
44print(f"Plane: {n[0]}x + {n[1]}y + {n[2]}z = {d}")
45print(f"This is the plane x + y + z = 1")

Line-Plane Intersection

1import numpy as np
2
3def line_plane_intersection(line_point, line_dir, plane_normal, plane_d):
4    """
5    Find intersection of line and plane.
6
7    Line: r(t) = P + t*d
8    Plane: n · r = D
9
10    Substituting: n · (P + t*d) = D
11    Solving: t = (D - n·P) / (n·d)
12
13    Returns:
14        (intersection_point, t) or None if parallel
15    """
16    P = np.array(line_point)
17    d = np.array(line_dir)
18    n = np.array(plane_normal)
19
20    n_dot_d = np.dot(n, d)
21
22    # Check if line is parallel to plane
23    if np.abs(n_dot_d) < 1e-10:
24        # Check if line lies in plane
25        if np.abs(np.dot(n, P) - plane_d) < 1e-10:
26            return "Line lies in plane", None
27        return "Parallel, no intersection", None
28
29    # Find parameter t
30    t = (plane_d - np.dot(n, P)) / n_dot_d
31
32    # Compute intersection point
33    intersection = P + t * d
34
35    return intersection, t
36
37# Example: Line through origin along <1,1,1>, plane x+y+z=3
38result, t = line_plane_intersection(
39    line_point=[0, 0, 0],
40    line_dir=[1, 1, 1],
41    plane_normal=[1, 1, 1],
42    plane_d=3
43)
44print(f"Intersection at {result} (t = {t})")
45# Point (1, 1, 1) where x+y+z = 3 ✓

Distance Calculations

1import numpy as np
2
3def point_to_plane_distance(point, plane_normal, plane_d):
4    """
5    Compute distance from point to plane.
6
7    Formula: dist = |n·P - d| / |n|
8
9    This comes from projecting the vector from any plane point
10    to P onto the unit normal.
11    """
12    P = np.array(point)
13    n = np.array(plane_normal)
14
15    numerator = np.abs(np.dot(n, P) - plane_d)
16    denominator = np.linalg.norm(n)
17
18    return numerator / denominator
19
20def point_to_line_distance(point, line_point, line_dir):
21    """
22    Compute distance from point to line.
23
24    Method: Use cross product to find perpendicular distance.
25    dist = |PQ × d| / |d|
26
27    where Q is any point on the line.
28    """
29    P = np.array(point)
30    Q = np.array(line_point)
31    d = np.array(line_dir)
32
33    # Vector from line point to our point
34    QP = P - Q
35
36    # Cross product gives parallelogram area
37    cross = np.cross(QP, d)
38
39    # Distance = area / base length
40    return np.linalg.norm(cross) / np.linalg.norm(d)
41
42# Examples
43print("Distance from (0,0,0) to plane x+y+z=3:")
44dist1 = point_to_plane_distance([0,0,0], [1,1,1], 3)
45print(f"  {dist1:.4f} = 3/√3 = √3 ≈ 1.732")
46
47print("\nDistance from (1,0,0) to line through origin along z-axis:")
48dist2 = point_to_line_distance([1,0,0], [0,0,0], [0,0,1])
49print(f"  {dist2:.4f} = 1 (perpendicular distance)")

Test Your Understanding

Summary

Lines in 3D Space

Planes in 3D Space

Key Formulas

Key Takeaways

1. Lines in 3D require two pieces of information: a point and a direction vector
2. Planes are defined by a normal vector that points perpendicular to the plane
3. The dot product determines when lines are parallel to planes ($\vec{n} \cdot \vec{d} = 0$)
4. The cross product is essential for computing distances and finding normals
5. These concepts directly apply to machine learning(decision boundaries) and computer graphics (ray tracing)

Coming Next: In the next section, we'll explore Quadric Surfaces—the 3D generalizations of conic sections like ellipses, hyperbolas, and parabolas. These surfaces include spheres, cylinders, cones, and more exotic shapes like hyperboloids.