Exposure Merge Weights

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:

1. Loop over all pixels in one image (or over all images if needed).
2. For each pixel value $z$, compute its weight using the given formula.
3. 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:

1. Prepare constants:

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

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

3. Store the weight:

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

4. (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.