Radial Distortion

Normalized image coordinates $(x, y)$ come from the pinhole camera model: after dividing by depth and focal length, a 3D point projects to coordinates where the principal point is at $(0,0)$ and units are in “radii from the optical center.” In this ideal model, straight 3D lines map to straight 2D lines and all rays pass through a single pinhole. Real lenses, especially wide-angle or fisheye lenses, deviate from this ideal and bend rays, causing radial distortion: points are displaced along the line from the image center, depending only on their distance $r$ from the center.

Radial distortion is usually modeled by a polynomial in $r^2$, where $r^2 = x^2 + y^2$. The given model

$$x_d = x(1 + k_1 r^2 + k_2 r^4), \quad y_d = y(1 + k_1 r^2 + k_2 r^4)$$

multiplies both coordinates by the same radial scaling factor. Positive/negative values of $k_1, k_2$ yield barrel or pincushion effects (bulging out or in). In this problem, you already have normalized coordinates and known distortion coefficients $(k_1, k_2)$, and the task is to apply the forward distortion formula.

---

1. Background Knowledge (key points)

• Radial symmetry: Distortion depends only on radius $r = \sqrt{x^2 + y^2}$ from the center, not on the angle; hence both $x$ and $y$ share the same multiplicative factor.
• Polynomial model: Truncate the series at $r^4$:
• $r^2 = x^2 + y^2$
• Scale factor $s(r) = 1 + k_1 r^2 + k_2 r^4$
• Forward vs inverse distortion:
• Forward: given ideal $(x,y)$, compute distorted $(x_d,y_d)$ — this is what you’re doing.
• Inverse (undistortion): given $(x_d,y_d)$, recover $(x,y)$ — usually harder, often solved iteratively.

---

2. Algorithm / Approach

This is a direct formula evaluation for each point:

1. Compute $r^2 = x^2 + y^2$.
2. Compute scale $s = 1 + k_1 r^2 + k_2 r^4$.
3. Multiply:

• $x_d = x \cdot s$
• $y_d = y \cdot s$

If you’re given many points (e.g., arrays), apply the same computation element-wise (vectorization if using NumPy, etc.).

---

3. Step-by-Step Strategy

Given inputs: $x, y, k_1, k_2$.

1. Compute radius squared:

r2 = x*x + y*y

2. Compute higher power:

r4 = r2 * r2

3. Compute distortion factor:

s = 1 + k1 * r2 + k2 * r4

4. Apply to coordinates:

x_distorted = x * s
y_distorted = y * s

5. Return or store (x_\text{distorted}, y_\text{distorted}$)$.

If processing many points:

• Loop or vectorize the above steps over all coordinates.

---

4. Common Pitfalls

• Mixing squared and non-squared radius: Use $r^2 = x^2 + y^2$, then $r^4 = (r^2)^2$; do not accidentally use $r$ instead of $r^2$.
• Forgetting normalization assumption: This formula assumes coordinates are already normalized (principal point at origin and scaled by focal length). On raw pixel coordinates you’d first need to normalize, but for this problem you can skip that.
• Numeric overflow on large radii: Very large $|x|, |y|$ can make $r^4$ huge; in typical normalized coordinates $r$ is small (≈within a few units), so this is usually safe.
• Sign of coefficients: Wrong sign of $k_1$ or $k_2$ flips barrel/pincushion effect; follow the problem’s given values.

---

5. Time & Space Complexity

Assuming you process $N$ points:

• Time complexity:
• $O(N)$, since each point requires a constant number of arithmetic operations.
• Space complexity:
• $O(N)$ if you store all distorted points in a new array.
• $O(1)$ extra space if you overwrite the input coordinates in-place.