Distortion Center Offset

mediumFREELens DistortionsCamera ModelCV: Image Formation

Implement a function to apply radial distortion with a distortion center offset. This task involves understanding how lens distortions affect image formation, particularly when the distortion center is not at the origin. The concept of radial distortion is crucial in computer vision as it helps correct for the nonlinear effects of camera lenses on image points, which can be described using the distortion center $(c_x, c_y)$ and distortion coefficients $k_1$ and $k_2$ .

Translate a point to the distortion center
Apply radial distortion using the distortion coefficients
Translate the distorted point back to its original position

r^2 = (x - c_x)^2 + (y - c_y)^2

The offset from the center is scaled by the radial factor $1 + k_1 r^2 + k_2 r^4$ :

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

This technique is widely used in image correction applications.

Example

Input

distort_with_center([1, 1], [0.5, 0.5], -0.1, 0)

Output

[0.975, 0.975]

Reasoning

Inputs: the point $(x, y) = (1, 1)$ , the distortion center $(c_x, c_y) = (0.5, 0.5)$ , and coefficients $k_1 = -0.1$ , $k_2 = 0$ . Distortion is measured relative to the center, not the origin.
Relative to the center, the point sits at offset $(0.5, 0.5)$ , so its squared radius is $r^2 = 0.5^2 + 0.5^2 = 0.5$ (and $r^4 = 0.25$ ).
The radial factor is $1 + k_1 r^2 + k_2 r^4 = 1 + (-0.1)(0.5) + 0 \cdot 0.25 = 0.95$ , so the offset shrinks to $0.95 \times 0.5 = 0.475$ in each coordinate.
Measured back from the center, the distorted point is $0.5 + 0.475 = 0.975$ in both $x$ and $y$ , giving [0.975, 0.975], rounded to 4 decimal places.
Notice that a negative $k_1$ pulls points toward the center (barrel distortion), and the pull grows with $r^2$ . A point exactly at the center has $r = 0$ and does not move: [0.5, 0.5] maps to [0.5, 0.5].

Constraints

center is [cx, cy]
Return distorted point rounded to 4 decimal places

Learn this in

Image FormationCV Study Plan Camera Models & Calibration3D Computer Vision

More from CV: Image Formation

Perspective Projection with Intrinsicsmedium Rodrigues Rotation Formulahard Compose 3D Transformationsmedium Undistort Pointhard Radial Distortionmedium

Concept primer

You are applying a radial distortion model but with a shifted distortion center $(c_x, c_y)$ instead of the origin. Conceptually, you treat the distortion center as a new local origin: move the point so the center is at $(0,0)$ , apply the usual radial distortion there, then move back.

1. Background Knowledge

In simple pinhole camera models, image points are assumed to lie on an ideal projection plane with no distortions. Real lenses, however, introduce radial distortion, where points farther from the center are displaced either outward (barrel distortion) or inward (pincushion distortion). This radial displacement is typically modeled as a function of the radius $r$ from a distortion center:

r = \sqrt{x^2 + y^2}, \quad (x', y') = (x, y) \cdot f(r)

where $f(r)$ is usually a polynomial in $r^2$ , e.g. $f(r) = 1 + k_1 r^2 + k_2 r^4 + \dots$ .

The distortion center is not always at the coordinate origin or even exactly at the image center. In many camera models, the optical center (or principal point) $(c_x, c_y)$ is somewhere in the image, and radial distortion is defined with respect to that point. To use the same radial formula, you work in a coordinate system centered at $(c_x, c_y)$ , apply the distortion there, then translate back to the original coordinate system.

2. Algorithm / General Approach

The general pattern for “radial distortion with offset center” is:

Translate the point from the original coordinates to a coordinate system whose origin is the distortion center $(c_x, c_y)$ .
Compute radius $r$ in this local system and apply the radial distortion function $f(r)$ to get a scaling factor.
Scale the translated coordinates by this factor.
Translate back to the original coordinate system.

This is simply composing:

a translation,
a radial scaling about the origin,
the inverse translation.

3. Step-by-Step Strategy

Assume you are given:

Original point $(u, v)$ (e.g., pixel coordinates or normalized image coordinates),
Distortion center $(c_x, c_y)$ ,
Radial distortion function parameters (for example a simple one-parameter model).

A typical step-by-step procedure:

Translate to center coordinates

x = u - c_x
y = v - c_y

Compute radius

r2 = x*x + y*y # r^2
r = math.sqrt(r2) # optional, if your model needs r, otherwise r2 is enough

Compute distortion factor

For a common polynomial model in terms of $r^2$ :

s = 1 + k_1 r^2 + k_2 r^4 + k_3 r^6 + \dots

s = 1 + k1 * r2 + k2 * (r2*r2) # etc., depending on model

Apply radial distortion in centered coordinates

x_dist = x * s
y_dist = y * s

Translate back to original coordinate system

u_dist = x_dist + c_x
v_dist = y_dist + c_y

Return / store the distorted point

return u_dist, v_dist

This pattern generalizes to any radial function $f(r)$ ; only step 3 changes.

4. Common Pitfalls

Forgetting the translations: Applying the radial function directly to $(u, v)$ without shifting by $(c_x, c_y)$ distorts around the origin, not around the true distortion center.
Using wrong units / coordinate system:
Make sure $(u, v)$ and $(c_x, c_y)$ are in the same space (both in pixels, or both normalized).
If the problem expects normalized camera coordinates, convert consistently before distorting.
Mixing up $r$ and $r^2$ : Many models are in terms of $r^2$ . If the formula says $1 + k_1 r^2 + k_2 r^4$ , you do not re-square $r^4$ incorrectly.
Overflow / numerical issues for large radii: If points can be far from the center, high-order polynomials might grow too large; in a coding exercise, usually radii are moderate, but be aware of potential float overflow or NaNs if parameters are extreme.
Order of operations: The translation-back step must happen after scaling, not before.

5. Time & Space Complexity

If you apply this distortion to a single point:

Time complexity: $O(1)$ — a constant number of arithmetic operations.
Space complexity: $O(1)$ — using a fixed number of scalar variables.

If you apply it independently to each pixel in an $H \times W$ image:

Time complexity: $O(HW)$ — each pixel is processed once with constant work.
Space complexity:
$O(HW)$ if you store a separate distorted image.
$O(1)$ extra if you write results in-place with care (though in practice in-place mapping is tricky because mapping is not one-to-one).

solution.py

Python 3.13

Test results