Full Pinhole Camera Projection

mediumFREECamera modelGeometry, Linear AlgebraComputer Vision 1

Project a 3D world point onto 2D image coordinates using the full pinhole camera model with both intrinsic and extrinsic parameters.

The full projection is:

$x = K [R | t] X_w$

Where:

$K$ is the $3 \times 3$ intrinsic matrix
$R$ is the $3 \times 3$ rotation matrix (world to camera)
$t$ is the $3 \times 1$ translation vector
$X_w$ is the 3D world point in homogeneous coordinates $[X, Y, Z, 1]^T$

Steps:

Form the $3 \times 4$ extrinsic matrix $[R | t]$
Compute the $3 \times 4$ projection matrix $P = K [R | t]$
Project: $x' = P \cdot X_w$
Normalize: $[u, v] = [x'/w', y'/w']$

Return $[u, v]$ with each coordinate rounded to 4 decimal places.

Example

Input

world_point = [10.0, 5.0, 20.0]
intrinsic_lambda = [[1000, 0, 500], [0, 1000, 400], [0, 0, 1]]
rotation_omega = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]  # Identity
translation_tau = [0, 0, 5]

Output

[900.0, 600.0]

Reasoning

Inputs: world_point is a 3D point $X_w = (10, 5, 20)$ ; intrinsic_lambda holds focal lengths $f_x = f_y = 1000$ pixels and principal point $(c_x, c_y) = (500, 400)$ ; rotation_omega is the identity (camera axes match world axes); translation_tau $= (0, 0, 5)$ shifts points 5 units along the optical axis.
World → camera: $X_c = R X_w + t = (10, 5, 20) + (0, 0, 5) = (10, 5, 25)$ . The translation pushes the point farther from the camera, from depth 20 to depth 25.
Camera → image: applying $K$ gives $x' = (1000 \cdot 10 + 500 \cdot 25,\ 1000 \cdot 5 + 400 \cdot 25,\ 25) = (22500, 15000, 25)$ , so $w' = 25$ is the depth.
Perspective divide: $u = 22500 / 25 = 900$ , $v = 15000 / 25 = 600$ , giving [900.0, 600.0].
Notice: this equals $c + f \cdot (X/Z,\ Y/Z) = (500 + 400,\ 400 + 200)$ . A larger $t_z$ would shrink the offsets from the principal point, because the point sits deeper.

Constraints

The world point w will always result in a non-zero lambda after projection
Lambda is a valid 3x3 intrinsic matrix
Omega is a 3x3 rotation matrix
Tau is a 3x1 translation vector
All inputs are floating-point numbers
Output must be rounded to 4 decimal places

Learn this in

Image FormationCV Study Plan Camera Models & Calibration3D Computer Vision

More from Computer Vision 1

Semi-Global Matching Cost Aggregationhard Compute Depth Map from Disparitymedium Stereo Rectification Checkeasy Oriented BRIEF Descriptorhard Gaussian Scale Spacemedium

Concept primer

1. Background Knowledge

The pinhole camera model is the foundational geometric model in computer vision for projecting 3D world points onto a 2D image plane, assuming light rays pass through a single point (pinhole) without distortion. It separates intrinsic parameters (internal camera properties) and extrinsic parameters (camera pose in world space).

Intrinsic matrix $K$ (3×3):

K = \begin{bmatrix} f_x & 0 & c_x \\ 0 & f_y & c_y \\ 0 & 0 & 1 \end{bmatrix}

where $f_x, f_y$ are focal lengths in pixels, and $c_x, c_y$ is the principal point.

Extrinsic parameters: $R$ (3×3 rotation matrix, world-to-camera) and $t$ (3×1 translation vector).
Homogeneous coordinates: World point $X_w = [X, Y, Z, 1]^T$ , projected to image point $x' = [x', y', w']^T$ , then normalized to $[u, v] = [x'/w', y'/w']$ .

This model assumes perspective projection where parallel lines converge, valid for standard cameras but extended in variants like fisheye.

2. Algorithm Approach

The standard algorithm computes the projection matrix $P = K [R | t]$ (3×4), then applies linear transformation followed by perspective division:

Form extrinsic matrix: $[R | t]$ by concatenating $R$ (columns 1-3) and $t$ (column 4).
$P = K \cdot [R | t]$ .
$x' = P \cdot X_w$ .
$u = x'/w'$ , $v = y'/w'$ .

Matrix multiplication is $O(1)$ for fixed 3×4×4 dimensions. Libraries like NumPy (Python) or Eigen (C++) handle this efficiently. No iterative optimization needed due to closed-form nature.

3. Step-by-Step Strategy

import numpy as np

def project_point(K, R, t, Xw):
 # Step 1: Form extrinsic matrix [R | t] (3x4)
 extrinsic = np.hstack((R, t.reshape(3, 1)))

 # Step 2: Compute projection matrix P = K @ extrinsic (3x4)
 P = K @ extrinsic

 # Step 3: Project homogeneous point (4x1)
 x_prime = P @ Xw # [x', y', w']

 # Step 4: Perspective division and round to 4 decimals
 u = x_prime / x_prime
 v = x_prime / x_prime
 return np.round([u, v], 4)

Input assumptions: $K$ ("Lambda"), $R$ ("Omega"), $t$ ("Tau"), $X_w$ as 4×1 vector. Constraints guarantee $w' \neq 0$ .

4. Common Pitfalls

Homogeneous coordinates: Forgetting to append 1 to $X_w = [X, Y, Z]$ .
Matrix dimensions: $K$ (3×3) × $[R|t]$ (3×4) → $P$ (3×4); $P$ × $X_w$ (4×1) → 3×1. Shape mismatches cause errors.
Perspective division: Dividing by zero (prevented by constraints); use $w'$ not $z$ .
Rounding: Problem specifies 4 decimal places (not 2 as initially stated); use np.round(..., 4).
Coordinate systems: $R$ transforms world-to-camera; verify convention (row-major vs column-major).
Floating-point precision: Use double precision; small numerical errors amplify in division.

5. Time & Space Complexity

Time: $O(1)$ constant time. Dominant operations: two 3×3×3 multiplications ( $K \cdot R$ ) + 3×1×4 ( $\cdot t, \cdot X_w$ ) + 2 divisions = ~100 FLOPs.
Space: $O(1)$ constant. Matrices: $K$ (9 floats), $R$ (9), $t$ (3), $X_w$ (4), $P$ (12), temporary vectors (~20 floats total).

Scalability: For $n$ points, becomes $O(n)$ via batch matrix multiplication $P @ X_w$ (3×4 × 4×n). Ideal for real-time vision pipelines.

solution.py

Python 3.13

Test results