Alpha Compositing

easyFREEImage MattingMattingCV: Computational Photography

Composite a foreground image over a background using an alpha matte.

Alpha compositing is the fundamental operation for combining images with transparency. The compositing equation blends foreground and background based on the alpha (opacity) value:

$C = \alpha \cdot F + (1 - \alpha) \cdot B$

where:

$C$ is the composited output color
$F$ is the foreground color
$B$ is the background color
$\alpha$ is the alpha/opacity value in [0, 1]

For each RGB channel:

$\alpha = 1$ : fully foreground (opaque)
$\alpha = 0$ : fully background (transparent)
$\alpha = 0.5$ : 50% blend of both

This operation is applied independently to each color channel.

Example

Input

composite((255, 0, 0), (0, 0, 255), 0.5)

Output

(128, 0, 128)

Reasoning

Inputs: foreground is pure red $(255, 0, 0)$ , background is pure blue $(0, 0, 255)$ , and alpha $= 0.5$ means the foreground is half opaque, so each colour gets equal weight: $\alpha = 0.5$ and $1 - \alpha = 0.5$ .
Red: $C_R = 0.5 \cdot 255 + 0.5 \cdot 0 = 127.5$ , which rounds to the nearest integer $128$ .
Green: neither colour has any green, so $C_G = 0.5 \cdot 0 + 0.5 \cdot 0 = 0$ .
Blue: $C_B = 0.5 \cdot 0 + 0.5 \cdot 255 = 127.5$ , which rounds to $128$ .
Output: the three channels together give (128, 0, 128), a medium purple: half red, half blue, as integers in $[0, 255]$ .
Notice that each channel is blended on its own, and the two weights always sum to $1$ , so the result stays inside the range of the inputs. With alpha $= 1$ you get the foreground back unchanged; with alpha $= 0$ you get the background.

Constraints

foreground: RGB tuple of integers [0, 255]
background: RGB tuple of integers [0, 255]
alpha: float in range [0, 1]
Return composited RGB as tuple of integers (rounded)

Learn this in

Computational PhotographyCV Study Plan

More from CV: Computational Photography

Trimap-Based Alpha Estimationhard Drago Adaptive Log Mappinghard Gram Matrix for Stylehard Alpha Matte Compositingmedium Reinhard Global Tone Mappingmedium

Concept primer

Alpha Compositing: Background Knowledge & Implementation Guide

Background Knowledge

Alpha Compositing Fundamentals

Alpha compositing is a core operation in digital image processing that combines two images by blending them based on transparency values. The alpha channel represents the opacity of each pixel, where values range from 0 (completely transparent) to 1 (completely opaque). This allows smooth transitions between foreground and background, creating realistic layering effects widely used in film production, digital media, and image editing. The compositing equation you've been given is the over operation, the standard method for blending images in computer graphics.

The Alpha Channel and Compositing Equation

The alpha value acts as a weighting factor that determines how much of the foreground contributes to the final pixel color versus the background. When $\alpha = 1$ , the foreground completely dominates (the background is invisible). When $\alpha = 0$ , only the background shows through. Intermediate values create semi-transparent blending, which is essential for realistic effects like soft edges, anti-aliasing, and depth-of-field effects. The equation is applied independently to each RGB channel, meaning you compute the composited red, green, and blue values separately using the same alpha value.

Practical Context in Image Matting

Image matting is the process of extracting foreground objects from images with precise alpha values, and alpha compositing is the inverse operation—using those alpha values to place the foreground onto new backgrounds. Understanding compositing helps you appreciate why accurate alpha estimation matters: poor alpha values lead to visible artifacts, color fringing, or unrealistic blending when compositing onto new backgrounds.

Algorithm/Approach

The solution follows a straightforward per-pixel, per-channel approach:

Load or receive the foreground image, background image, and alpha matte
Iterate through each pixel in the images
For each pixel and each color channel, apply the compositing equation: $C =$ \alpha $\cdot F + (1 -$ \alpha $) \cdot B$
Store the result in the output image
Return or save the composited image

This is a direct mathematical operation with no complex algorithms needed—the challenge is in correct implementation and handling data types properly.

Step-by-Step Strategy

Step 1: Understand Input Constraints

Verify that foreground, background, and alpha matte have compatible dimensions
Confirm that pixel values are in the correct range (typically 0-255 for 8-bit images or 0.0-1.0 for floating-point)
Check whether alpha is a single-channel grayscale image or if it's embedded in the foreground's alpha channel

Step 2: Normalize Data if Necessary

If working with 8-bit images (0-255), consider converting to floating-point (0.0-1.0) for the computation to avoid integer overflow and precision loss
Ensure alpha values are in [0, 1] range; if they're in [0, 255], divide by 255

Step 3: Apply the Compositing Equation

For each pixel position $(i, j)$ and each color channel (R, G, B):
Retrieve $F_{i,j}$ , $B_{i,j}$ , and $\alpha_{i,j}$
Compute $C_{i,j} =$ \alpha $_{i,j} \cdot F_{i,j} + (1 -$ \alpha $_{i,j}) \cdot B_{i,j}$
Store the result

Step 4: Handle Output Format

If you converted to floating-point, convert back to 8-bit (multiply by 255 and round)
Ensure output values are clipped to valid ranges (0-255 for 8-bit or 0.0-1.0 for float)
Maintain the same image format as the input

Step 5: Vectorize if Possible

Use NumPy broadcasting or similar vectorized operations to process all pixels at once rather than nested loops
This dramatically improves performance for large images

Common Pitfalls

Pitfall	Issue	Solution
Integer overflow	Computing with 8-bit values can overflow before normalization	Convert to float before computation, then convert back
Alpha range mismatch	Alpha in [0, 255] instead of [0, 1]	Always verify and normalize alpha to [0, 1]
Dimension mismatch	Foreground, background, and alpha have different sizes	Ensure all inputs are resized to the same dimensions before compositing
Forgetting per-channel application	Treating alpha as a single value for all channels	Apply the equation separately to R, G, and B channels
Output clipping	Results exceed valid ranges (e.g., > 255 for 8-bit)	Clip output to valid range: np.clip(result, 0, 255)
Premultiplied alpha confusion	Mixing straight alpha with premultiplied alpha	Use the standard "over" equation provided; don't premultiply unless specified

Time & Space Complexity

Time Complexity: $\mathcal{O}(w \times h \times c)$

$w$ = image width, $h$ = image height, $c$ = number of color channels (typically 3 for RGB)
You must visit every pixel and process every channel once
Each operation (multiplication, addition) is constant time
With vectorized operations (NumPy), this reduces to a single pass through the data

Space Complexity: $\mathcal{O}(w \times h \times c)$

You need to store the output image, which is the same size as the input images
If you're not reusing input arrays, you need space for: foreground + background + alpha + output = $\mathcal{O}(w \times h \times c)$
In-place operations can reduce this, but typically you'll allocate a new output array

solution.py

Python 3.13

Test results