Pinhole Camera Intrinsic Projection

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:

1. Compute intermediate homogeneous point: $\mathbf{p'} = K \mathbf{P_c}$.
2. 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

1. Parse inputs: Extract $\mathbf{P_c} = [X_c, Y_c, Z_c]^T$ (3x1 vector), $K$ (3x3 matrix). Verify $Z_c > 0$.
2. 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}$.
3. Divide: $u = p'_0 / p'_2$, $v = p'_1 / p'_2$ (0-indexed).
4. Round: To 4 decimal places (overrides description's 2).
5. 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.