Distortion Center Offset

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:

1. Translate the point from the original coordinates to a coordinate system whose origin is the distortion center $(c_x, c_y)$.
2. Compute radius $r$ in this local system and apply the radial distortion function $f(r)$ to get a scaling factor.
3. Scale the translated coordinates by this factor.
4. 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:

1. Translate to center coordinates

x = u - c_x
y = v - c_y

2. Compute radius

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

3. 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

4. Apply radial distortion in centered coordinates

x_dist = x * s
y_dist = y * s

5. Translate back to original coordinate system

u_dist = x_dist + c_x
v_dist = y_dist + c_y

6. 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).