📘

Full Pinhole Camera Projection

MediumGeometry, Linear Algebra 📚 Computer 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]$ rounded to 2 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:

Form extrinsic $[R|t]$ as $3 \times 4$ matrix
Compute $P = K \cdot [R|t]$
Project: $x' = P \cdot [5, 3, 10, 1]^T$
Normalize by the third component

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

More from Computer Vision 1

Semi-Global Matching Cost AggregationHard Compute Depth Map from DisparityMedium Stereo Rectification CheckEasy Oriented BRIEF DescriptorHard Gaussian Scale SpaceMedium

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

0/0

Run code to see test results.