Pinhole Camera Intrinsic Projection

mediumFREECamera modelGeometry, Linear AlgebraComputer Vision 1

Given a 3D point in camera coordinates and a camera intrinsic matrix $K$ , compute the projected 2D pixel coordinates using the pinhole camera model.

The intrinsic matrix $K$ has the form:

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

Where $f_x, f_y$ are focal lengths, $(c_x, c_y)$ is the principal point, and $s$ is the skew (often $0$ , but it may be nonzero, so apply the full matrix).

The projection formula is:

$\begin{bmatrix} u \\ v \\ 1 \end{bmatrix} = \frac{1}{Z_c} K \begin{bmatrix} X_c \\ Y_c \\ Z_c \end{bmatrix}$

Return the 2D pixel coordinates $[u, v]$ rounded to 4 decimal places.

Example

Input

print(pinhole_projection([[800.0, 0.0, 320.0], [0.0, 800.0, 240.0], [0.0, 0.0, 1.0]], [10.0, 20.0, 5.0]))

Output

[1920.0, 3440.0]

Reasoning

Inputs: intrinsic_lambda is the $3 \times 3$ matrix $K$ with $f_x = f_y = 800$ , principal point $(c_x, c_y) = (320, 240)$ and zero skew. point_w_prime is the camera-frame point $(X_c, Y_c, Z_c) = (10, 20, 5)$ , so it sits 5 units in front of the camera.
Perspective: dividing by depth puts the point on the plane $Z = 1$ : $\left(\tfrac{10}{5}, \tfrac{20}{5}, 1\right) = (2, 4, 1)$ . Points twice as far away would land half as far from the optical axis.
Intrinsics: $K$ scales those normalized coordinates into pixels and shifts them to the principal point: $u = 800 \cdot 2 + 0 \cdot 4 + 320 = 1920$ , $v = 800 \cdot 4 + 240 = 3440$ . The third row gives $1$ , confirming the homogeneous form.
Output: the pixel pair [1920.0, 3440.0], floats rounded to 4 decimal places.
Notice the result lies far outside a $640 \times 480$ image: the projection never clips, it just maps the ray. With a nonzero skew $s$ , $u$ would also pick up $s$ times the normalized $y$ .

Constraints

The 3D point [X_c, Y_c, Z_c] is in camera coordinates with depth Z_c > 0
K (passed as intrinsic_lambda) is a valid 3x3 intrinsic matrix
All inputs are floating-point numbers
Output must be rounded to 4 decimal places

Learn this in

Structure from Motion and SLAMCV 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 idealization in computer vision for perspective projection, assuming light rays pass through a single point (pinhole) to form an image on the sensor plane. Key concepts include:

Camera coordinates: 3D point $\mathbf{P_c} = [X_c, Y_c, Z_c]^T$ in the camera frame, where $Z_c > 0$ is depth (behind the pinhole).
Intrinsic matrix $K$ : Encodes internal parameters—focal lengths $f_x, f_y$ (pixels per radian in x/y), principal point $(c_x, c_y)$ (image center offset).
Homogeneous coordinates: Enable perspective division; projection yields $[u, v, 1]^T =$ \frac{1}{Z_c} $K \mathbf{P_c}$ , where pixel $[u, v]$ is the normalized image point.
Prerequisites: Matrix multiplication, perspective division, NumPy-like array operations. No distortion assumed here (ideal pinhole).

This model underpins tasks like 3D reconstruction and augmented reality.

2. Algorithm Approach

Direct matrix-vector multiplication followed by normalization:

Compute intermediate homogeneous point: $\mathbf{p'} = K \mathbf{P_c}$ .
Apply perspective division: $u = p'_x / p'_z$ , $v = p'_y / p'_z$ .

Pseudocode:

import numpy as np

def project_point(Pc, K):
 p_hom = K @ Pc # 3x3 @ 3x1 -> 3x1
 u = p_hom / p_hom
 v = p_hom / p_hom
 return np.round([u, v], 4) # As per constraints

This is $O(1)$ per point—pure linear algebra, no iteration or search.

3. Step-by-Step Strategy

Parse inputs: Extract $\mathbf{P_c} = [X_c, Y_c, Z_c]^T$ (3x1 vector), $K$ (3x3 matrix). Verify $Z_c > 0$ .
Matrix multiply: $\mathbf{p'} = K$ \mathbf{P_c} $= \begin{bmatrix} f_x X_c + c_x Z_c \\ f_y Y_c + c_y Z_c \\ Z_c \end{bmatrix}$ .
Divide: $u = p'_0 / p'_2$ , $v = p'_1 / p'_2$ (0-indexed).
Round: To 4 decimal places (overrides description's 2).
Return: $[u, v]$ .

Example (assume $K = \begin{bmatrix} 800 & 0 & 320 \\ 0 & 800 & 240 \\ 0 & 0 & 1 \end{bmatrix}$ , $\mathbf{P_c} = [1, 0.5, 2]^T$ ):

$\mathbf{p'} = [800\cdot1 + 320\cdot2, 800\cdot0.5 + 240\cdot2, 2] = [1920, 1360, 2]$
$[u, v] = [960.00, 680.00]$

4. Common Pitfalls

No division by zero: $Z_c > 0$ guaranteed, but floating-point underflow near zero causes NaN—add epsilon check ( $10^{-6}$ ).
Matrix orientation: Ensure $K$ row-major, $\mathbf{P_c}$ column vector (not row).
Rounding mismatch: Use 4 decimals per constraints, not 2.
Homogeneous scaling: Ignore overall scale; only divide x/y by z.
Units: Inputs in pixels/meters consistently; no world-to-camera transform needed.
Distortion ignored: Problem assumes ideal pinhole—real cameras need correction.

5. Time & Space Complexity

Time: $O(1)$ constant—9 multiplications + 4 additions + 2 divisions for matrix-vector product.
Space: $O(1)$ constant—stores one 3x1 vector and reuses $K$ (3x3).

Full implementation (Python):

def pinhole_projection(Xc, Yc, Zc, fx, fy, cx, cy):
 # Or parse full K matrix
 u = (fx * Xc + cx * Zc) / Zc
 v = (fy * Yc + cy * Zc) / Zc
 return [round(u, 4), round(v, 4)]

This solves the problem directly while building intuition for camera geometry.

solution.py

Python 3.13

Test results