Linear View Blending

easyFREEView InterpolationIBRCV: Image-Based Rendering

Implement a view interpolation technique to blend two images taken from different viewpoints. This task involves creating an intermediate view using linear blending, which is a fundamental concept in image-based rendering.

The underlying concept of view interpolation is based on the idea of approximating a novel view from a set of existing views. In this case, we have two images, $I_0$ and $I_1$ , captured from two distinct viewpoints. The goal is to generate an intermediate image, $I_t$ , by combining these two images using a linear blending formula. This approach relies on the assumption that the cameras are relatively close together, resulting in minimal parallax effects.

To perform the blending, follow these steps:

Define the interpolation factor $t \in [0, 1]$ .
Apply the blending formula to each pixel in the images. The main equation for linear blending is given by:

I_t = (1 - t) \cdot I_0 + t \cdot I_1

This technique is widely used in computer vision and computer graphics applications, such as novel view synthesis and image-based rendering.

Example

Input

blend_views([[0, 0], [0, 0]], [[100, 100], [100, 100]], 0.5)

Output

[[50, 50], [50, 50]]

Reasoning

image0 and image1 are two $2 \times 2$ grayscale images of the same scene from nearby viewpoints: the first is all black (0), the second is uniformly 100. t says how far the new view sits between the two cameras.
At $t = 0.5$ the weights are $1 - t = 0.5$ on the first image and $t = 0.5$ on the second, so both views count equally. The weights always sum to 1, so every blended value lies between the two input values.
Each pixel position pairs one value from each image: $I_t = 0.5 \cdot 0 + 0.5 \cdot 100 = 0 + 50 = 50$ .
The same happens at all four positions, giving [[50, 50], [50, 50]]: the input shape, with whole-number values after rounding.
Notice the endpoints: $t = 0$ reproduces the first image exactly and $t = 1$ the second. A value such as $t = 0.25$ would give $0.75 \cdot 0 + 0.25 \cdot 100 = 25$ everywhere, a view closer to the first camera.

Constraints

image0 and image1: 2D grayscale images (same dimensions)
t: interpolation factor in [0, 1]
Return blended image with pixel values rounded to integers

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 primer

You want to create a new view by linearly blending corresponding pixels from two images using $I_t = (1 - t)\,I_0 + t\,I_1$ . This is the simplest form of image-based view interpolation: instead of rendering a 3D scene, you directly operate on pixels from captured images and interpolate their colors over time/position between views.

This works visually when:

The cameras are close and have small baseline.
Scene depth variation is small (little parallax), or objects are far away. In more challenging setups (large viewpoint change, strong parallax, occlusions), simple per-pixel blending fails (ghosting, double edges) and you need depth-based warping / 3D geometry to align content before blending.

1. Background Knowledge (Key Concepts)

Image as a function Treat an image as a function $I(x, y)$ mapping pixel coordinates to color values (e.g., RGB vectors). Linear blending forms a convex combination of two such functions:

I_t(x, y) = (1 - t)\,I_0(x, y) + t\,I_1(x, y)

for each pixel $(x, y)$ . This is done independently at every pixel.

View interpolation vs. morphing vs. rendering
View interpolation: generate intermediate viewpoints from real images with minimal geometry (your task, simplest case is direct blending).
Image morphing: often involves both geometric warping and color blending.
3D rendering: uses explicit geometry and camera models to render new views. Your problem uses no warping, just blending, which assumes corresponding structures lie at the same pixel coordinates in both images.

2. Algorithm / General Approach

The core pattern:

Input: two images $I_0$ and $I_1$ (same size, same alignment), and a scalar $t \in [0,1]$ .
For each pixel location $(x, y)$ :

Read color $c_0 = I_0(x,y)$ and $c_1 = I_1(x,y)$ .
Compute blended color:

c_t = (1 - t)\,c_0 + t\,c_1

Store $c_t$ at $(x, y)$ in output image $I_t$ .

This is a per-pixel, per-channel linear interpolation (often called “lerp”) applied uniformly over the whole image.

3. Step-by-Step Strategy

Assume both images are the same height, width, and number of channels.

Validate inputs

Check that $I_0$ and $I_1$ have identical shape: $(H, W, C)$ .
Ensure $t$ is clamped or validated in $[0,1]$ .

Choose numeric type

Internally, use a floating-point representation (e.g., float32) to avoid rounding too early.
If images are in uint8 [0, 255], convert to float first.

Compute blend

Vectorized (preferred in NumPy/PyTorch):

I_t = (1.0 - t) * I0 + t * I1

Or explicitly per pixel:

for y in range(H):
for x in range(W):
I_t[y, x, :] = (1 - t) * I0[y, x, :] + t * I1[y, x, :]

Clamp and cast back

If working with integer images:

I_t = np.clip(I_t, 0, 255)
I_t = I_t.astype(np.uint8)

For normalized floats in [0,1], clamp to [0,1] instead.

Return or display result

Optionally generate multiple views by looping over several t values (e.g., t = 0.0, 0.1,..., 1.0).

4. Common Pitfalls

Mismatched image sizes or formats
Different resolutions, aspect ratios, or channel counts will break simple per-pixel blending.
Always resize / align beforehand if necessary.
Incorrect data types
Doing (1 - t)I0 + tI1 on uint8 can cause overflow or truncation.
Convert to float before blending, then back to integer.
Not normalizing $t$
If $t$ is outside $[0,1]$ , you get extrapolation, which may be unintended:
$t < 0$ : go “before” $I_0$ .
$t > 1$ : go “beyond” $I_1$ .
For this problem, clamp to $[0,1]$ .
Expecting good results with large viewpoint changes
Without depth/warping, you will see ghosting and blur when objects move significantly between views (parallax, occlusions).
That is a limitation of this simple method, not a bug in your code.

5. Time & Space Complexity

Let $N = H \times W \times C$ be the number of pixel values.

Time complexity
You perform a constant amount of work per pixel (a few multiplications and additions).
Overall:

O(N) = O(H \cdot W \cdot C)

Space complexity
You need space for the output image $I_t$ of size $H \times W \times C$ .
Input images are given, so extra space (besides inputs) is $O(N)$ .
Total additional space:

O(N)

This linear complexity is efficient and scales proportionally with image size, which is why linear blending is often used as a baseline or starting point in view interpolation.

solution.py

Python 3.13

Test results