Bilinear Light Field Interpolation

mediumPROLight FieldsLight FieldCV: Image-Based Rendering

Interpolate color from a light field using bilinear interpolation.

Given a query position $(s, t)$ between captured camera positions, we interpolate from the four nearest cameras using bilinear weights:

$C = (1-f_s)(1-f_t) C_{00} + f_s(1-f_t) C_{10} + (1-f_s)f_t C_{01} + f_s f_t C_{11}$

where:

$f_s = s - \lfloor s \rfloor$ is the fractional part in s
$f_t = t - \lfloor t \rfloor$ is the fractional part in t
$C_{ij}$ are the colors at the four corner cameras, with corners $(\lfloor s \rfloor, \lfloor t \rfloor)$ through $(\lfloor s \rfloor + 1, \lfloor t \rfloor + 1)$
A corner missing from samples counts as color $0$ (this happens when the query lies on the last grid line, where that corner's weight is zero anyway)

This enables smooth transitions between camera positions.

Example

Input

interpolate_lightfield({(0,0): 100, (1,0): 200, (0,1): 150, (1,1): 250}, 0.5, 0.5)

Output

175.0

Reasoning

samples stores the colour captured by each camera on the integer grid: $(0,0) \to 100$ , $(1,0) \to 200$ , $(0,1) \to 150$ , $(1,1) \to 250$ .
The enclosing cell's lower corner is $(\lfloor 0.5 \rfloor, \lfloor 0.5 \rfloor) = (0, 0)$ , so $f_s = 0.5$ and $f_t = 0.5$ .
Each corner's weight is the area of the rectangle opposite it: $(1-f_s)(1-f_t)$ , $f_s(1-f_t)$ , $(1-f_s)f_t$ and $f_s f_t$ all equal $0.25$ here. The four weights always sum to $1$ .
Blending in $s$ first gives the same answer: bottom edge $0.5 \cdot 100 + 0.5 \cdot 200 = 150$ , top edge $0.5 \cdot 150 + 0.5 \cdot 250 = 200$ , then in $t$ : $0.5 \cdot 150 + 0.5 \cdot 200 = 175$ .
The output 175.0 is the plain average of the four cameras, since the query is equidistant from all of them.
Notice that at an integer query such as $(1, 1)$ , $f_s = f_t = 0$ , so one camera takes all the weight and you get 250; the absent far corners like $(2, 1)$ count as $0$ with zero weight.

Constraints

samples: dict mapping (s, t) integer coordinates to color values
query_s, query_t: floating-point query position
Return interpolated color, rounded to 4 decimal places

Learn this in

Image-Based RenderingCV Study Plan

More from CV: Image-Based Rendering

Differentiable Renderer Forwardhard Video Loop Findinghard Light Field Refocusinghard Depth-Based View Synthesishard Front-to-Back Splat Accumulationmedium

Concept primerPREVIEW

To solve this problem, you just need to understand light fields as 2D grids of cameras and apply standard bilinear interpolation over that grid.

1. Background Knowledge

A light field (in this context) can be thought of as a 4D array of rays, often parameterized by camera position $(s, t)$ and pixel position $(x, y)$ . For a fixed pixel $(x, y)$ , varying $(s, t)$ moves across different cameras that see that pixel from different viewpoints. Rendering a novel view at a non-integer $(s, t)$ between cameras is essentially interpolating between the colors from nearby cameras.

Bilinear interpolation is just performing linear interpolation twice in 2D: first along one axis, then along the other. Given a continuous coordinate $(s, t)$ , we find the four neighboring integer grid points and combine their values with weights based on the fractional parts $f_s$ and $f_t$ . This gives smooth transitions between grid points and avoids popping artifacts when moving the virtual camera.

Here, each $C_{ij}$ is the color from a specific camera (at integer $(s, t)$ ), and the formula you’re given is the standard bilinear interpolation formula.

2. Algorithm / General Approach

Pattern:

Locate the cell in the camera grid that contains the query $(s, t)$ : find the lower-left integer indices and their neighbors.
Compute fractional offsets within that cell: $f_s$ and $f_t$ .
Fetch corner values $C_{00}, C_{10}, C_{01}, C_{11}$ for the chosen pixel from those four cameras.
Apply bilinear interpolation formula to get the interpolated color.

This is a per-pixel, per-query-view operation.

3. Step-by-Step Strategy

Assume:

Cameras are indexed on a 2D integer grid $(S, T)$ .
You’re given a query $(s, t)$ and you’re interpolating a specific pixel $(x, y)$ .

Compute integer indices and fractions

s0 = floor(s)
t0 = floor(t)
s1 = s0 + 1
t1 = t0 + 1

f_s = s - s0 # in [0, 1)
f_t = t - t0 # in [0, 1)

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results