Three-Dimensional Coordinate Systems

Learning Objectives

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

1. Describe the three-dimensional rectangular coordinate system and understand its relationship to the 2D Cartesian plane
2. Plot points in 3D space and interpret ordered triples $(x, y, z)$
3. Calculate distances between points in 3D using the distance formula
4. Find midpoints of line segments in three-dimensional space
5. Write equations of spheres and identify their centers and radii
6. Identify coordinate planes, axes, and octants in 3D space
7. Connect 3D coordinates to applications in physics, computer graphics, and machine learning

The Big Picture: Why Three Dimensions?

"Space is three-dimensional. We live in three dimensions, and to describe the world accurately, mathematics must embrace all three." — Adapted from various mathematical traditions

We live in a three-dimensional world. When you describe the location of a coffee cup on your desk, you might say it's 30 cm from the left edge, 20 cm from the front edge, and sitting on the surface (0 cm above the desk). You've just used three coordinates.

Two-dimensional calculus — with its $(x, y)$ coordinates — works beautifully for flat problems: curves in a plane, areas, and functions of one variable. But the physical world demands more:

Historical Origins: From Descartes to Modern 3D

The rectangular coordinate system bears the name of René Descartes (1596–1650), the French philosopher and mathematician who revolutionized mathematics by connecting algebra and geometry. His insight was profound: geometric shapes can be described by equations, and equations can be visualized as shapes.

Descartes' Revolutionary Idea

In his 1637 work La Géométrie, Descartes showed that a point in a plane could be uniquely identified by two numbers — its horizontal and vertical distances from a reference point. This "Cartesian" coordinate system unified algebra and geometry, transforming how we understand mathematics.

The extension to three dimensions was natural but took time to develop fully. Mathematicians including Pierre de Fermat, Leonhard Euler, and Joseph-Louis Lagrange contributed to establishing 3D analytic geometry in the 17th and 18th centuries.

The Three-Dimensional Rectangular Coordinate System

To locate points in 3D space, we extend the familiar 2D Cartesian plane by adding a third axis perpendicular to both the $x$-axis and the $y$-axis.

The Three Axes

Ordered Triples

Every point $P$ in 3D space is represented by an ordered triple:

where $x$ is the horizontal distance from the $yz$-plane, $y$ is the distance from the $xz$-plane, and $z$ is the distance from the $xy$-plane.

Interactive: Explore the 3D Coordinate System

Use the interactive visualization below to explore how 3D coordinates work. Drag the point to see how its $(x, y, z)$ coordinates change, and observe how the perpendicular projections to each plane help locate the point.

Plotting Points in 3D Space

To plot a point $P = (a, b, c)$ in 3D:

1. Start at the origin $O = (0, 0, 0)$
2. Move $a$ units along the $x$-axis
3. Move $b$ units parallel to the $y$-axis
4. Move $c$ units parallel to the $z$-axis

Examples of Plotting Points

Distance Formula in 3D

The distance between two points in 3D is a natural extension of the 2D Pythagorean theorem. Just as the 2D distance comes from a right triangle, the 3D distance comes from a rectangular box.

Derivation from the Pythagorean Theorem

Consider two points $P_1 = (x_1, y_1, z_1)$ and $P_2 = (x_2, y_2, z_2)$:

1. First, find the distance in the $xy$-plane: $d_{xy} = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$
2. Then, use this as one leg of a right triangle with the $z$-difference as the other leg
3. Apply Pythagorean theorem again: $d = \sqrt{d_{xy}^2 + (z_2 - z_1)^2}$

Example: Computing Distance

Find the distance between $A = (1, 2, 3)$ and $B = (4, 6, 3)$.

Notice that since the $z$-coordinates are equal, the points lie in a plane parallel to the $xy$-plane, and the distance reduces to the 2D formula.

Interactive: Explore Distance in 3D

Midpoint Formula in 3D

The midpoint of a line segment is the point exactly halfway between the endpoints. In 3D, we simply average each coordinate.

Example: Finding a Midpoint

Find the midpoint of the segment from $A = (2, 4, 6)$ to $B = (8, 2, 4)$.

Equations of Spheres

A sphere is the set of all points in 3D space that are a fixed distance (the radius) from a fixed point (the center). This is the 3D analog of a circle in 2D.

Standard Equation of a Sphere

This equation directly comes from the distance formula: a point $(x, y, z)$ is on the sphere if and only if its distance from the center equals the radius.

Example: Writing Sphere Equations

Write the equation of a sphere with center $(2, -3, 1)$ and radius $5$.

General Form of a Sphere

Expanding the standard form gives the general form:

To convert from general to standard form, we complete the square for each variable.

Example: Converting General to Standard Form

Find the center and radius of the sphere: $x^2 + y^2 + z^2 - 4x + 6y - 2z - 11 = 0$

Interactive: Explore Spheres in 3D

Coordinate Planes and Octants

The Three Coordinate Planes

The three axes define three coordinate planes that divide 3D space into regions:

The Eight Octants

Just as the 2D coordinate system has four quadrants, the 3D coordinate system has eight octants. The first octant is where all three coordinates are positive.

Surfaces in 3D

In 2D, an equation like $x^2 + y^2 = 4$ describes a curve (a circle). In 3D, similar equations describe surfaces.

Planes Parallel to Coordinate Planes

Cylinders

A cylinder in 3D is a surface generated by moving a curve along a line parallel to one of the axes. When an equation is missing one variable, it represents a cylinder.

Real-World Applications

1. GPS and Navigation

GPS uses a 3D coordinate system (actually, a spherical one wrapped around Earth) to pinpoint your location. Your phone receives signals from satellites and uses the 3D distance formula to triangulate your position.

2. Computer Graphics and Gaming

Every 3D video game and animated movie uses 3D coordinates. Objects are defined by vertices (points in 3D space), and transformations like rotation, scaling, and translation are applied using coordinate geometry.

3. Physics and Engineering

• Mechanics: Position, velocity, and acceleration are 3D vectors
• Electromagnetism: Electric and magnetic fields are defined at every point in 3D space
• Structural engineering: Forces and stresses are analyzed in 3D

4. Medical Imaging

CT scans and MRI create 3D images of the body. Each pixel (or "voxel" in 3D) has coordinates $(x, y, z)$ and an intensity value representing tissue density.

Machine Learning Applications

Three-dimensional coordinates and the distance formula are fundamental to many machine learning algorithms, even when working in higher dimensions.

Feature Spaces

In ML, data is often represented in a feature space where each feature is a dimension. A 3-feature dataset places each sample at a point $(x_1, x_2, x_3)$ in 3D space.

K-Nearest Neighbors (KNN)

KNN classification uses the Euclidean distance formula to find the closest training points to a new sample. It literally asks: "What are the k nearest neighbors in feature space?"

Clustering Algorithms

Algorithms like K-Means use distance calculations to group similar data points. The "cluster center" is the centroid (average position) of all points in the cluster.

Neural Network Embeddings

Modern NLP models (like word2vec, BERT) map words to vectors in high-dimensional space. Similar words are close together in this space — measured by Euclidean or cosine distance.

Python Implementation

Basic 3D Distance and Midpoint

For A=(1,2,3) and B=(4,6,3): d = √[(4-1)² + (6-2)² + (3-3)²] = √[9 + 16 + 0] = 5

Midpoint of (1,2,3) and (4,6,3) = ((1+4)/2, (2+6)/2, (3+3)/2) = (2.5, 4, 3)

1import numpy as np
2import matplotlib.pyplot as plt
3from mpl_toolkits.mplot3d import Axes3D
4
5def distance_3d(p1, p2):
6    """
7    Calculate the Euclidean distance between two points in 3D.
8
9    This is the direct extension of the Pythagorean theorem
10    to three dimensions: d = sqrt((x2-x1)² + (y2-y1)² + (z2-z1)²)
11    """
12    return np.sqrt(
13        (p2[0] - p1[0])**2 +
14        (p2[1] - p1[1])**2 +
15        (p2[2] - p1[2])**2
16    )
17
18def midpoint_3d(p1, p2):
19    """
20    Find the midpoint between two points in 3D.
21
22    The midpoint is simply the average of each coordinate:
23    M = ((x1+x2)/2, (y1+y2)/2, (z1+z2)/2)
24    """
25    return (
26        (p1[0] + p2[0]) / 2,
27        (p1[1] + p2[1]) / 2,
28        (p1[2] + p2[2]) / 2
29    )
30
31# Example: Calculate distance and midpoint
32A = (1, 2, 3)
33B = (4, 6, 3)
34
35print(f"Point A: {A}")
36print(f"Point B: {B}")
37print(f"\nDistance from A to B: {distance_3d(A, B):.4f}")
38print(f"Midpoint: {midpoint_3d(A, B)}")
39
40# Visualize points and their connection in 3D
41fig = plt.figure(figsize=(10, 8))
42ax = fig.add_subplot(111, projection='3d')
43
44# Plot points
45ax.scatter(*A, color='red', s=100, label=f'A{A}')
46ax.scatter(*B, color='blue', s=100, label=f'B{B}')
47
48# Plot midpoint
49M = midpoint_3d(A, B)
50ax.scatter(*M, color='green', s=100, label=f'M{tuple(round(x, 1) for x in M)}')
51
52# Draw line connecting A and B
53ax.plot([A[0], B[0]], [A[1], B[1]], [A[2], B[2]],
54        'k--', linewidth=2, label='Distance line')
55
56# Set labels and title
57ax.set_xlabel('X')
58ax.set_ylabel('Y')
59ax.set_zlabel('Z')
60ax.set_title('3D Distance and Midpoint Visualization')
61ax.legend()
62
63plt.tight_layout()
64plt.show()

Spheres in 3D

1import numpy as np
2import matplotlib.pyplot as plt
3from mpl_toolkits.mplot3d import Axes3D
4
5def sphere_equation(center, radius, num_points=50):
6    """
7    Generate points on a sphere surface.
8
9    Sphere equation: (x - h)² + (y - k)² + (z - l)² = r²
10    where (h, k, l) is the center and r is the radius.
11
12    We use spherical coordinates to generate surface points:
13    - x = h + r*sin(φ)*cos(θ)
14    - y = k + r*sin(φ)*sin(θ)
15    - z = l + r*cos(φ)
16
17    where φ ∈ [0, π] and θ ∈ [0, 2π]
18    """
19    h, k, l = center
20    r = radius
21
22    # Create meshgrid for spherical coordinates
23    phi = np.linspace(0, np.pi, num_points)     # Polar angle
24    theta = np.linspace(0, 2*np.pi, num_points) # Azimuthal angle
25    phi, theta = np.meshgrid(phi, theta)
26
27    # Convert to Cartesian coordinates
28    x = h + r * np.sin(phi) * np.cos(theta)
29    y = k + r * np.sin(phi) * np.sin(theta)
30    z = l + r * np.cos(phi)
31
32    return x, y, z
33
34def check_point_on_sphere(point, center, radius, tolerance=1e-6):
35    """
36    Check if a point lies on the sphere.
37
38    A point P=(x,y,z) lies on the sphere if:
39    (x - h)² + (y - k)² + (z - l)² = r²
40    """
41    h, k, l = center
42    distance_squared = (
43        (point[0] - h)**2 +
44        (point[1] - k)**2 +
45        (point[2] - l)**2
46    )
47    return abs(distance_squared - radius**2) < tolerance
48
49# Example: Sphere centered at (2, 1, 3) with radius 4
50center = (2, 1, 3)
51radius = 4
52
53print(f"Sphere center: {center}")
54print(f"Sphere radius: {radius}")
55print(f"\nSphere equation:")
56print(f"(x - {center[0]})² + (y - {center[1]})² + (z - {center[2]})² = {radius}²")
57print(f"\nExpanded form:")
58print(f"x² + y² + z² - {2*center[0]}x - {2*center[1]}y - {2*center[2]}z + {sum(c**2 for c in center) - radius**2} = 0")
59
60# Test some points
61test_points = [
62    (2, 1, 7),    # Top of sphere (z = l + r)
63    (6, 1, 3),    # Right side (x = h + r)
64    (0, 0, 0),    # Origin (probably not on sphere)
65]
66
67print(f"\nTesting points:")
68for p in test_points:
69    on_sphere = check_point_on_sphere(p, center, radius)
70    print(f"  {p}: {'ON' if on_sphere else 'NOT on'} the sphere")
71
72# Visualize the sphere
73fig = plt.figure(figsize=(10, 8))
74ax = fig.add_subplot(111, projection='3d')
75
76X, Y, Z = sphere_equation(center, radius)
77ax.plot_surface(X, Y, Z, alpha=0.6, cmap='viridis')
78
79# Mark center
80ax.scatter(*center, color='red', s=100, label='Center')
81
82ax.set_xlabel('X')
83ax.set_ylabel('Y')
84ax.set_zlabel('Z')
85ax.set_title(f'Sphere: Center {center}, Radius {radius}')
86ax.legend()
87
88plt.tight_layout()
89plt.show()

Machine Learning: Distance in Feature Space

1import numpy as np
2from sklearn.neighbors import KNeighborsClassifier
3from sklearn.datasets import make_classification
4
5# Generate 3D classification dataset
6# In ML, we often work with high-dimensional "feature spaces"
7# where each dimension represents a feature
8
9np.random.seed(42)
10X, y = make_classification(
11    n_samples=200,
12    n_features=3,      # 3D feature space
13    n_informative=3,
14    n_redundant=0,
15    n_clusters_per_class=1,
16    random_state=42
17)
18
19print("3D Feature Space in Machine Learning")
20print("=" * 50)
21print(f"Dataset shape: {X.shape}")
22print(f"First 5 samples (3D points):")
23for i in range(5):
24    print(f"  Point {i+1}: ({X[i,0]:.2f}, {X[i,1]:.2f}, {X[i,2]:.2f}) -> Class {y[i]}")
25
26# K-Nearest Neighbors uses DISTANCE in feature space
27knn = KNeighborsClassifier(n_neighbors=5)
28knn.fit(X, y)
29
30# Classify a new point based on its 3D distance to neighbors
31new_point = np.array([[0.5, 0.5, 0.5]])
32prediction = knn.predict(new_point)
33distances, indices = knn.kneighbors(new_point)
34
35print(f"\nClassifying new point: {new_point[0]}")
36print(f"5 nearest neighbors (by 3D Euclidean distance):")
37for i, (dist, idx) in enumerate(zip(distances[0], indices[0])):
38    print(f"  Neighbor {i+1}: Point {idx} at distance {dist:.3f}, Class {y[idx]}")
39print(f"\nPredicted class: {prediction[0]}")
40
41# The sphere of influence: all points within radius r
42radius = 1.5
43points_in_sphere = []
44for i, point in enumerate(X):
45    dist = np.sqrt(np.sum((point - new_point[0])**2))
46    if dist <= radius:
47        points_in_sphere.append((i, dist, y[i]))
48
49print(f"\nPoints within sphere of radius {radius} from {new_point[0]}:")
50for idx, dist, label in sorted(points_in_sphere, key=lambda x: x[1]):
51    print(f"  Point {idx}: distance {dist:.3f}, class {label}")

Test Your Understanding

Summary

The three-dimensional coordinate system extends our familiar 2D geometry into the space we actually live in. Understanding 3D coordinates is essential for multivariable calculus and has countless applications in physics, engineering, computer graphics, and machine learning.

Key Concepts

Key Takeaways

1. The 3D coordinate system uses three perpendicular axes that meet at the origin, following the right-hand rule convention
2. Every point is uniquely identified by an ordered triple $(x, y, z)$
3. The distance formula extends the Pythagorean theorem to three dimensions
4. A sphere is the set of all points at a fixed distance from a center
5. The three coordinate planes divide space into eight octants
6. These 3D concepts extend naturally to higher dimensions used in machine learning

Coming Next: In the next section, we'll introduce vectors — mathematical objects that have both magnitude and direction. Vectors are the language of physics and the foundation of linear algebra, essential for understanding forces, velocities, and gradients in machine learning.