Radial Distortion

mediumFREELens DistortionsCamera ModelCV: Image Formation

Implement a function to apply radial distortion to normalized image coordinates, a crucial step in correcting lens distortions in computer vision. This process involves modeling the distortion that occurs when light passes through a camera lens, causing images to appear warped.

Radial distortion is a type of distortion that occurs when light rays bend differently as they pass through a lens, resulting in a distorted image. The distortion can be modeled using the distortion coefficients $k_1$ and $k_2$ , which describe the amount of distortion present in the lens. The relationship between the original and distorted coordinates can be described using the equations $r^2 = x^2 + y^2$ , $x_{distorted} = x(1 + k_1 r^2 + k_2 r^4)$ , and $y_{distorted} = y(1 + k_1 r^2 + k_2 r^4)$ .

To apply radial distortion, follow these steps:

Calculate the squared distance $r^2$ from the optical center.
Compute the distortion factor using the coefficients $k_1$ and $k_2$ .
Apply the distortion factor to the original coordinates.

r^2 = x^2 + y^2

x_{distorted} = x(1 + k_1 r^2 + k_2 r^4)

y_{distorted} = y(1 + k_1 r^2 + k_2 r^4)

This technique is widely used in camera calibration to correct for lens distortions and produce more accurate images.

Example

Input

radial_distort([0.5, 0.5], -0.1, 0.01)

Output

[0.4762, 0.4762]

Reasoning

Inputs: point is a location $(x, y)$ in normalized image coordinates, measured from the optical center. k1 $= -0.1$ and k2 $= 0.01$ set how much, and in which direction, points move radially: negative pulls inward (barrel), positive pushes outward (pincushion).
Radius: the squared distance from the center is $r^2 = 0.5^2 + 0.5^2 = 0.5$ , which gives $r^4 = 0.25$ .
Scale factor: $1 + k_1 r^2 + k_2 r^4 = 1 - 0.05 + 0.0025 = 0.9525$ . The negative $k_1$ term dominates, so the factor is below 1 and the point is pulled inward.
Output: both coordinates are multiplied by the same factor: $0.5 \times 0.9525 = 0.47625$ . Rounded to 4 decimal places that gives [0.4762, 0.4762]. $0.47625$ is a tie, but in floating point the product lands just below it, so it rounds to $0.4762$ .
Notice: the direction from the center never changes, only the distance does. A point at the center ( $r = 0$ ) stays where it is, and with $k_1 = k_2 = 0$ every point stays put.

Constraints

Input point is [x, y] (normalized coordinates)
k1, k2 are distortion coefficients
Return distorted [x', y'] rounded to 4 decimal places

Learn this in

Structure from Motion and SLAMCV Study Plan Image FormationCV Study Plan Camera Models & Calibration3D Computer Vision

More from CV: Image Formation

Perspective Projection with Intrinsicsmedium Rodrigues Rotation Formulahard Compose 3D Transformationsmedium Distortion Center Offsetmedium Undistort Pointhard

Concept primer

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:

Compute $r^2 = x^2 + y^2$ .
Compute scale $s = 1 + k_1 r^2 + k_2 r^4$ .
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$ .

Compute radius squared:

r2 = x*x + y*y

Compute higher power:

r4 = r2 * r2

Compute distortion factor:

s = 1 + k1 * r2 + k2 * r4

Apply to coordinates:

x_distorted = x * s
y_distorted = y * s

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.

solution.py

Python 3.13

Test results