Weighted Depth Fusion

mediumPROMulti-view StereoMVSCV: Depth Estimation

Fuse multiple depth estimates using weighted averaging.

When we have depth estimates from multiple stereo pairs or viewpoints, we can combine them to get a more robust estimate. Weighted averaging gives more influence to confident estimates:

$Z_{fused} = \frac{\sum_i w_i \cdot Z_i}{\sum_i w_i}$

where:

$Z_i$ is the depth estimate from source $i$
$w_i$ is the confidence/weight for that estimate
$Z_{fused}$ is the final fused depth

Weights typically come from matching confidence, geometric consistency, or photo consistency scores.

Example

Input

fuse_depths([5.0, 5.2, 4.8], [1.0, 0.5, 0.5])

Output

5.0

Reasoning

Inputs: depths holds three estimates of the same point's distance, $Z = (5.0, 5.2, 4.8)$ , and weights holds how much each source is trusted, $w = (1.0, 0.5, 0.5)$ . Source 1 counts twice as much as each of the others.
Numerator: multiply each depth by its weight and add: $5.0 \cdot 1.0 + 5.2 \cdot 0.5 + 4.8 \cdot 0.5 = 5.0 + 2.6 + 2.4 = 10.0$ .
Denominator: the total weight, $1.0 + 0.5 + 0.5 = 2.0$ . Dividing by it rescales the weights so they act like fractions summing to 1 ( $0.5, 0.25, 0.25$ ).
Output: $Z_{fused} = 10.0 / 2.0 = 5.0$ , a single float rounded to 4 decimal places.
Notice: the two low-confidence estimates sit symmetrically around 5.0 ( $+0.2$ and $-0.2$ ) with equal weight, so they cancel. If the weights were $(0.5, 1.0, 0.5)$ instead, the result would shift toward 5.2: $10.1 / 2.0 = 5.05$ .

Constraints

depths: list of depth values from different sources
weights: list of confidence weights (positive values)
Return fused depth rounded to 4 decimal places

Learn this in

Depth EstimationCV Study Plan Multi-View Geometry3D Computer Vision Depth Estimation3D Computer Vision 3D Scene Understanding3D Computer Vision

More from CV: Depth Estimation

Plane Sweep Stereohard Block Matching Disparityhard Epipolar Line Visualizationhard Ordinal Depth Ranking Lossmedium Depth Map Normalizationeasy

Concept primerPREVIEW

In multi-view stereo, each stereo pair or viewpoint often produces its own depth map with its own confidence or reliability score per pixel (e.g., from matching cost, variance, or probability distribution). These per-view estimates are noisy and may contain outliers due to occlusions, low texture, or specularities. The goal of depth fusion is to combine multiple such estimates into a single, more robust depth value per pixel or 3D point. A simple and widely used way to do this is weighted averaging, where more reliable estimates contribute more to the final depth.
Mathematically, if you have depth estimates $Z_i$ with corresponding weights $w_i$ , the fused depth is

Z_{\text{fused}} = \frac{\sum_i w_i Z_i}{\sum_i w_i}.

This is the weighted mean, which is optimal (in the least-squares sense) if each estimate has Gaussian noise with variance proportional to $1 / w_i$ . In practice, $w_i$ can come from:

a confidence score from the stereo matcher,
inverse of an estimated depth variance,
photo-consistency measures,
geometric consistency checks (e.g., reproject to other views and measure agreement).

2. Algorithm / Approach

The general pattern for this problem:

For each pixel (or 3D point), collect all available depth estimates $Z_i$ and their weights $w_i$ .
Optionally filter or clamp estimates with very low confidence or invalid values.
Compute the weighted sum of depths and the sum of weights.
Return the normalized weighted average $Z_{$ \text{fused} $}$ ; handle cases where the sum of weights is zero.

This is essentially a per-pixel (or per-point) reduction operation over views.

3. Step-by-Step Strategy

Assume you’re given, for each pixel index p:

A list/array of depth estimates Z[i] (for views i),
A corresponding list/array of weights w[i].

Steps:

Initialize accumulators:

num = 0.0 (for $\sum_i w_i Z_i$ )
den = 0.0 (for $\sum_i w_i$ )

Loop over all sources $i$ :

If w[i] <= 0 or Z[i] is invalid (NaN, inf, or sentinel value), skip it.
Optionally cap or normalize weights if they are on very different scales.
Accumulate:

num += w[i] * Z[i]
den += w[i]

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