Camera Projection Matrix

mediumFREE3D to 2D ProjectionsProjectionCV: Image Formation

Implement a camera projection matrix to transform 3D world coordinates into 2D image coordinates. This process is crucial in computer vision for understanding how 3D scenes are mapped onto 2D images.

The concept of 3D to 2D projection involves representing a 3D point in a 2D space, which is essential for image formation. The projection matrix $P$ plays a key role in this transformation, mapping 3D world coordinates $(X, Y, Z)$ to 2D image coordinates $(u, v)$ .

Here are the steps to apply the projection matrix:

Represent the 3D point as a homogeneous coordinate vector.
Multiply the projection matrix $P$ by the 3D point.
Obtain the projected 2D coordinates.

\begin{pmatrix} u \\ v \\ w \end{pmatrix} = P \cdot \begin{pmatrix} X \\ Y \\ Z \\ 1 \end{pmatrix}

The final 2D coordinates are given by $(u/w, v/w)$ . This technique is widely used in image processing and computer vision applications.

Example

Input

project([[1,0,0,0],[0,1,0,0],[0,0,1,0]], [10, 20, 5])

Output

[2.0, 4.0]

Reasoning

Inputs: $P$ is a $3 \times 4$ camera matrix and point is a 3D world point $(X, Y, Z) = (10, 20, 5)$ . Here $P = [\,I \mid 0\,]$ : the identity block with a zero last column, i.e. focal length 1, no offset, camera at the origin.
Append a 1 to get the homogeneous point $(10, 20, 5, 1)$ ; that 1 is what lets the fourth column of $P$ act as a translation.
Each row of $P$ dotted with it gives one component: $u = 1\cdot10 + 0\cdot20 + 0\cdot5 + 0\cdot1 = 10$ , $v = 20$ , $w = 5$ .
Perspective divide: $(u/w,\ v/w) = (10/5,\ 20/5) = (2.0,\ 4.0)$ , which is the output [2.0, 4.0], rounded to 4 decimal places.
Notice that $w$ ended up being the depth $Z$ : points farther away get divided by more and land closer to the image centre. Doubling the point to $(20, 40, 10)$ projects to the same $(2.0, 4.0)$ , since every point on one ray from the camera hits the same pixel.

Constraints

P is a 3×4 matrix
point is [X, Y, Z]
Return [x, y] rounded to 4 decimal places

Learn this in

Introduction to 3D Computer Vision3D Computer Vision 3D Object Detection3D Computer Vision

More from CV: Image Formation

Perspective Projection with Intrinsicsmedium Rodrigues Rotation Formulahard Compose 3D Transformationsmedium Distortion Center Offsetmedium Undistort Pointhard

Concept primer

Background Knowledge

In the standard pinhole camera model, a 3D point in homogeneous world coordinates is written as $(X, Y, Z, 1)^T$ . The camera is modeled by a projection matrix $P$ of size $3 \times 4$ , which encapsulates both intrinsic parameters (focal length, principal point, skew) and extrinsic parameters (rotation and translation from world to camera coordinates). Applying $P$ to a 3D homogeneous point gives a 2D homogeneous image point $(u, v, w)^T$ .

Homogeneous coordinates let us express perspective projection as a linear transform followed by a divide. The key idea: linear algebra handles the projective mapping $P \cdot (X, Y, Z, 1)^T = (u, v, w)^T$ , and then we convert back to standard 2D coordinates by normalizing: $(u', v') = (u/w, v/w)$ . The division by $w$ produces the non-linear perspective effect: points further in depth map closer together in image space.

Algorithm / Approach

General pattern for this type of problem:

Represent the 3D point in 4D homogeneous form: $(X, Y, Z, 1)$ .
Perform a matrix-vector multiplication with the $3 \times 4$ projection matrix $P$ .
Obtain a 3D homogeneous image point $(u, v, w)$ .
Convert to 2D inhomogeneous coordinates by dividing by $w$ : $(u/w, v/w)$ .

This is a straightforward application of linear algebra and homogeneous coordinate normalization.

Step-by-Step Strategy

Assume:

P is a 3×4 matrix
X, Y, Z are the world coordinates (scalars or elements of a vector)

Steps:

Form the input vector Create a 4D column vector for the 3D point in homogeneous form:

X_world = [X, Y, Z, 1] # or as a column vector

Multiply by the projection matrix Compute:

u = P*X + P*Y + P*Z + P*1
v = P*X + P*Y + P*Z + P*1
w = P*X + P*Y + P*Z + P*1

or using a library (e.g., NumPy):

import numpy as np
Xh = np.array([X, Y, Z, 1.0])
uh, vh, wh = P @ Xh # 3x4 @ 4 -> 3

Normalize homogeneous coordinates

u_img = u / w
v_img = v / w

Return the 2D point The final 2D image coordinates are:

return (u_img, v_img)

Common Pitfalls

Forgetting the homogeneous 1: Using $(X, Y, Z)$ instead of $(X, Y, Z, 1)$ will make the multiplication invalid or incorrect.
Not dividing by w: Returning $(u, v)$ directly from the matrix multiplication without normalizing by $w$ gives homogeneous, not pixel, coordinates.
Division by zero or near-zero w: If $w = 0$ (or extremely small), the point is at or beyond the camera’s projection plane, and the projection is undefined or numerically unstable. You typically need to check abs(w) < eps.
Type / precision issues: Using integer arithmetic can cause truncation during division; make sure to use floating-point types.
Matrix shape mismatch: Ensure P is 3×4 and the point vector is length 4; otherwise, you’ll get runtime errors.

Time & Space Complexity

Time complexity: For a single point, multiplying a $3 \times 4$ matrix by a 4D vector is $O(1)$ (a fixed number of multiplications and additions). For $N$ points, doing this independently is $O(N)$ .
Space complexity:
Storing the projection matrix: $O(1)$ (12 numbers).
Storing each point and its projection: $O(1)$ per point; $O(N)$ if you keep all $N$ results.

solution.py

Python 3.13

Test results