Exposure Merge Weights

mediumFREEHDR ImagingHDRCV: Computational Photography

Compute pixel weights for HDR merging based on exposure quality.

In HDR imaging, we combine multiple exposures to capture scenes with high dynamic range. However, not all pixels from each exposure are equally reliable:

Under-exposed pixels (dark, near 0) contain noise
Over-exposed pixels (bright, near 255) are saturated/clipped
Well-exposed pixels (mid-gray, near 128) are most reliable

We use a Gaussian weighting function centered at mid-gray:

$w(z) = \exp\left(-\frac{(z - 128)^2}{2\sigma^2}\right)$

where:

$z$ is the pixel value in range [0, 255]
$\sigma$ controls the width of the acceptable exposure range
The weight peaks at 1.0 for z = 128 and falls off for extreme values

This ensures that HDR merging prioritizes well-exposed samples while downweighting unreliable saturated or noisy regions.

Example

Input

exposure_weight(128, 50)

Output

1.0

Reasoning

Inputs: pixel_value $= 128$ is an 8-bit intensity (0 is black, 255 is white), and sigma $= 50$ sets how quickly trust drops as a pixel moves away from mid-gray.
Deviation: the distance from the ideal exposure is $z - 128 = 128 - 128 = 0$ .
Exponent: the Gaussian exponent is $-\frac{0^2}{2 \cdot 50^2} = -\frac{0}{5000} = 0$ .
Weight: $e^{0} = 1$ , so after rounding to 4 decimal places the output is 1.0, the largest weight any pixel can receive.
Notice: the weight depends only on the squared distance, so it is symmetric. A pixel one $\sigma$ away on either side ( $z = 178$ or $z = 78$ ) gets $e^{-1/2} \approx 0.6065$ , while pure black ( $z = 0$ , deviation $128$ ) gives $e^{-16384/5000} = e^{-3.2768} \approx 0.0377$ .
A larger $\sigma$ widens the bell, so extreme pixels keep more weight; a smaller $\sigma$ trusts only values close to 128.

Constraints

pixel_value is an integer in range [0, 255]
sigma is the Gaussian width parameter (positive float, default 50)
Return weight rounded to 4 decimal places
Weight should be in range [0, 1]

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

In HDR merging, we assign higher weights to mid-tone pixels (around 128) and lower weights to extreme dark/bright pixels using a Gaussian function of the pixel intensity. The problem mainly asks you to evaluate that formula for given pixel values and a chosen $\sigma$ .

1. Background Knowledge

HDR imaging via exposure bracketing: Instead of one photo that either blows out highlights or crushes shadows, we capture several low dynamic range (LDR) images at different exposure times. Each pixel position across images will have:
Good detail in some exposures (well-exposed)
Noise in very dark exposures
Saturation/clipping in very bright exposures
Why weighting is needed: When merging, we want to trust well-exposed pixels more. A pixel close to 0 is under-exposed (noisy), close to 255 is over-exposed (clipped), and values near mid-gray (128) typically have better signal-to-noise and unsaturated detail. So each pixel gets a weight reflecting its reliability.
Gaussian weighting function: A Gaussian centered at mid-gray:

w(z) = \exp\left(-\frac{(z - 128)^2}{2\sigma^2}\right)

gives:

Max weight 1 at $z = 128$
Smoothly decreasing weights as $z$ moves away from 128
$\sigma$ controls how quickly weights drop (small $\sigma$ = narrow “good” exposure band)

2. Algorithm / Approach

For this kind of problem, the general pattern is:

Loop over all pixels in one image (or over all images if needed).
For each pixel value $z$ , compute its weight using the given formula.
Optionally:

Clamp the result to a valid range (e.g., [0, 1]) if using floating point.
Store the weight in a separate weight map with the same size as the image.

In many HDR algorithms, you then use these weights to compute a weighted sum of pixel values across exposures and normalize by the total weight.

3. Step-by-Step Strategy

Assuming:

Input: an 8-bit image (or array) with pixel values $z \in [0, 255]$
Given: $\sigma$ (e.g., 20 or 30)

Steps:

Prepare constants:

Let mid = 128.0
Let two_sigma2 = 2 * sigma * sigma

Iterate over pixels:

For each pixel intensity z (convert to float):
Compute the difference: diff = z - mid
Compute the exponent argument: arg = -(diff * diff) / two_sigma2
Compute the weight: w = exp(arg)

Store the weight:

Place w into a weight array weights at the same pixel index.

(If part of a full HDR pipeline):

For each pixel location across N exposures:

I_{\text{HDR}}(x,y) = \frac{\sum_{i=1}^N w_i(x,y)\, E_i(x,y)}{\sum_{i=1}^N w_i(x,y)}

where $E_i$ is some radiance / exposure-compensated value, and $w_i$ is the computed weight.

Simple implementation sketch (per pixel):

import math

def compute_weight(z, sigma):
 mid = 128.0
 diff = z - mid
 return math.exp(-(diff * diff) / (2.0 * sigma * sigma))

Then apply this to each pixel in the image.

4. Common Pitfalls

Integer vs float math: Ensure you use floating-point for the exponent calculation. Integer division will break the formula.
Wrong center or range:
The formula assumes 8-bit pixels with range [0, 255] and center at 128.
If the input is normalized [0, 1], you must adjust the formula (e.g., center at 0.5, and scale $\sigma$ accordingly).
Confusing $\sigma$ ’s effect:
Too small $\sigma$ → only very narrow range around 128 gets significant weight.
Too large $\sigma$ → almost all pixels get similar weight, defeating the purpose.
Not handling all channels:
For color images, you often compute weights from luminance or one channel, not per RGB channel independently (unless specified).

5. Time & Space Complexity

Time complexity:
You compute one exponential per pixel.
For an image with $M \times N$ pixels:
Time: $O(MN)$
If there are $K$ exposures, and you compute weights for each, then $O(KMN)$ .
Space complexity:
You need a weight value per pixel per image.
For one image: $O(MN)$
For $K$ images: $O(KMN)$ if storing all weight maps.

solution.py

Python 3.13

Test results