Construct Intrinsic Matrix

The task is to compute and assemble the 3×3 intrinsic matrix $K$ from given camera parameters; conceptually this is a straightforward parameter-to-matrix mapping problem rather than an algorithmically complex one.

---

1. Background Knowledge

In pinhole camera geometry, a 3D point in camera coordinates $(X_c, Y_c, Z_c)$ is projected to image (pixel) coordinates $(u, v)$ via a projection equation of the form:

$$\lambda \begin{pmatrix} u \\ v \\ 1 \end{pmatrix} = K \begin{pmatrix} X_c \\ Y_c \\ Z_c \end{pmatrix},$$

where $K$ is the intrinsic matrix and $\lambda$ is a scale factor. $K$ encodes how real-world distances (in meters or millimeters) map to pixel units on the sensor, as well as where the principal point (optical center) lies in the image.

The intrinsic matrix is typically written as:

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

where:

• $f_x, f_y$: focal length in pixels along x and y,
• $(c_x, c_y)$: principal point coordinates in pixels,
• $s$: skew (non-orthogonality between image axes, usually 0 for modern cameras).

To get focal length in pixels from focal length in millimeters, you use the relationship between sensor size and image resolution:

$$f_{pixels} = f_{mm} \times \frac{\text{image\_width\_pixels}}{\text{sensor\_width\_mm}}$$

(and similarly for height if needed).

---

2. Algorithm / Approach

This problem is essentially:

1. Convert focal length units (mm → pixels) using sensor size and image size.
2. Assign parameters into the 3×3 matrix in the correct positions.
3. Use known simplifications for standard cameras:

• Square pixels: $f_x = f_y$,
• Zero skew: $s = 0$,
• Principal point near image center: often $(c_x, c_y) = ($\frac{W}{2}$,$\frac{H}{2}$)$ if not otherwise specified.

The implementation pattern is: compute scalar parameters → construct a fixed‑shape matrix → return it.

---

3. Step-by-Step Strategy

Assuming you are given:

• Focal length $f_{mm}$ in millimeters,
• Sensor width (and optionally height) in millimeters,
• Image width $W$ and height $H$ in pixels,
• Principal point $(c_x, c_y)$ (or you assume center),
• Skew $s$ (often 0),

you can proceed as:

1. Compute pixel focal length(s)

• If square pixels:

f_pixels = f_mm * (image_width_pixels / sensor_width_mm)
fx = fy = f_pixels

• If non-square pixels (if problem gives separate sensor height or pixel aspect ratio), compute:

fx = f_mm * (image_width_pixels / sensor_width_mm)
fy = f_mm * (image_height_pixels / sensor_height_mm)

2. Determine principal point

• If given explicitly, use those values.
• If not, use image center approximation:

cx = image_width_pixels / 2.0
cy = image_height_pixels / 2.0

3. Set skew

• For most problems: s = 0.0.

4. Assemble matrix In code-like form:

K = [[fx, s, cx],
[0, fy, cy],
[0, 0, 1]]

5. Return or print the matrix in the required format (e.g., NumPy array).

---

4. Common Pitfalls

• Mixing units: Make sure all focal lengths are converted to pixels before filling $K$. Do not directly plug $f_{mm}$ into the matrix.

• Using wrong image dimension: When computing $f_{pixels}$, match sensor width with image width, and sensor height with image height.

• Integer vs float division: In languages like Python 2 or some other languages, integer division can truncate. Ensure you use float division to get precise $f_x, f_y$.

• Principal point off by 0.5: Some conventions use $(W/2, H/2)$, others $(W/2 - 0.5, H/2 - 0.5)$. Follow the convention used by your platform or tests; in many educational problems, $W/2, H/2$ is expected.

• Matrix order: Do not swap rows or columns. The matrix must match the canonical form:

$$\begin{pmatrix} f_x & s & c_x\\ 0 & f_y & c_y\\ 0 & 0 & 1 \end{pmatrix}$$

---

5. Time & Space Complexity

• Time complexity: All operations are basic arithmetic and constant-size matrix construction, so $O(1)$.

• Space complexity: You store a fixed 3×3 matrix and a few scalars, so $O(1)$ additional space.