OpenCV HDR Image Fusion: A Complete Guide from Theory to Practice

Exposure Sequence → Image Alignment → Exposure Fusion → Tone Mapping → LDR Output
       ↓                  ↓                ↓               ↓
Multiple exposures    Correct shifts    Compose HDR    Compress to display range

import cv2

# HDR features are in the photo module
merge_mertens = cv2.createMergeMertens()  # Exposure fusion (recommended)
merge_debevec = cv2.createMergeDebevec()  # CRF method
tonemap_drago = cv2.createTonemapDrago()  # Tone mapping

C(i,j) = |I(i,j) - mean(I_neighbors)|

S(i,j) = std(R, G, B) at pixel (i,j)

E(i,j) = exp(-((I(i,j) - 0.5)² / (2 × σ²)))

Weight calculation:
W_k(i,j) = C(i,j)^wc × S(i,j)^ws × E(i,j)^we

Normalization:
Normalized_W_k(i,j) = W_k(i,j) / Σ(W_k(i,j))

Fusion result:
Output(i,j) = Σ(Normalized_W_k(i,j) × Image_k(i,j))

1. Build Gaussian pyramid    → Multi-scale decomposition for each image
2. Compute Laplacian pyramid → Extract details at different frequencies
3. Layer-wise fusion         → Each layer fused independently by weights
4. Reconstruct image         → Rebuild final image from coarse to fine

merge_mertens = cv2.createMergeMertens(
    contrast_weight=1.0,      # wc: Contrast weight exponent
    saturation_weight=1.0,    # ws: Saturation weight exponent
    exposure_weight=0.0       # we: Well-exposedness weight exponent
)

import cv2
import numpy as np
import os

def load_exposure_sequence(image_paths):
    """Load exposure sequence images"""
    images = []
    for path in image_paths:
        img = cv2.imread(path)
        if img is not None:
            images.append(img)
        else:
            print(f"Warning: Cannot load image {path}")
    return images

def merge_hdr_mertens(images, contrast=1.0, saturation=1.0, exposure=0.0):
    """Merge HDR images using Mertens algorithm"""
    if len(images) < 2:
        raise ValueError("At least 2 images required for fusion")
    
    # Create merger
    merge_mertens = cv2.createMergeMertens(
        contrast_weight=contrast,
        saturation_weight=saturation,
        exposure_weight=exposure
    )
    
    # Perform fusion
    fusion = merge_mertens.process(images)
    
    # Convert to 8-bit image
    # Method 1: Direct clipping (maintains brightness contrast)
    fusion_8bit = np.clip(fusion * 255, 0, 255).astype(np.uint8)
    
    return fusion_8bit

# Usage example
image_paths = [
    'exposure_1.jpg',  # Low exposure (dark)
    'exposure_2.jpg',  # Medium exposure
    'exposure_3.jpg',  # High exposure (bright)
]

images = load_exposure_sequence(image_paths)
result = merge_hdr_mertens(images)
cv2.imwrite('hdr_result.png', result)

def merge_hdr_advanced(images, normalize=False, **kwargs):
    """
    Advanced HDR fusion with normalization option
    
    Parameters:
    -----------
    images : list
        List of images
    normalize : bool
        Whether to normalize output (enhances contrast but changes brightness range)
    **kwargs : dict
        Parameters passed to createMergeMertens
    """
    merge_mertens = cv2.createMergeMertens(
        contrast_weight=kwargs.get('contrast', 1.0),
        saturation_weight=kwargs.get('saturation', 1.0),
        exposure_weight=kwargs.get('exposure', 0.0)
    )
    
    fusion = merge_mertens.process(images)
    
    if normalize:
        # Normalize to full dynamic range (enhances contrast)
        result = cv2.normalize(fusion, None, 0, 255, cv2.NORM_MINMAX)
    else:
        # Maintain original brightness relationships (good for batch comparison)
        result = np.clip(fusion * 255, 0, 255)
    
    return result.astype(np.uint8)

import hashlib

def get_cache_path(dir_path, image_type, normalize=False):
    """Generate cache file path"""
    suffix = '_NORMALIZED' if normalize else ''
    return os.path.join(dir_path, f'HDR_FUSED_{image_type}{suffix}.png')

def process_hdr_with_cache(dir_path, image_pattern, normalize=False):
    """
    HDR processing with smart caching
    
    - If HDR file exists, skip (10-50x speedup)
    - If not, generate and save
    """
    cache_path = get_cache_path(dir_path, 'result', normalize)
    
    # Check cache
    if os.path.isfile(cache_path):
        return ('skipped', 'Cache exists, skipping processing')
    
    # Load images
    import glob
    image_paths = sorted(glob.glob(os.path.join(dir_path, image_pattern)))
    
    if len(image_paths) < 2:
        return ('error', f'Insufficient images: only found {len(image_paths)}')
    
    images = load_exposure_sequence(image_paths)
    
    # Fuse
    result = merge_hdr_advanced(images, normalize=normalize)
    
    # Save
    cv2.imwrite(cache_path, result)
    
    return ('success', f'Processed {len(images)} images')

Traditional method (manual intensity selection):
├── Operation time: 5-10 minutes per batch for manual selection
├── Result quality: Depends on operator experience
└── Consistency: Large variations between batches

HDR Fusion method:
├── Operation time: ~0.15 sec/sample (automatic)
├── Result quality: Algorithm ensures optimal
└── Consistency: 100% reproducible

Test conditions:
- Image size: 1920×1080 pixels
- Number of exposures: 8
- Hardware: Intel i7 + 16GB RAM

┌─────────────────┬──────────┬──────────┬────────────┐
│     Method      │ Time (s) │ RAM (MB) │ Quality    │
├─────────────────┼──────────┼──────────┼────────────┤
│ Mertens         │   0.15   │    120   │   9.2/10   │
│ Debevec + Drago │   0.42   │    180   │   9.5/10   │
│ Manual selection│   180*   │     50   │   7.5/10   │
└─────────────────┴──────────┴──────────┴────────────┘
* Includes manual operation time

# If images are noisy, denoise first
denoised = cv2.fastNlMeansDenoisingColored(image, None, 10, 10, 7, 21)

# If images have shifts (handheld shooting), align first
alignMTB = cv2.createAlignMTB()
aligned_images = []
alignMTB.process(images, aligned_images)

def check_quality(result):
    """Check HDR result quality"""
    total_pixels = result.size
    
    # Check overexposure (saturated pixels)
    saturated = np.sum(result >= 254) / total_pixels
    if saturated > 0.01:  # Over 1%
        print("⚠️ Warning: May need more low-exposure images")
    
    # Check underexposure (dark pixels)
    dark = np.sum(result <= 1) / total_pixels
    if dark > 0.01:  # Over 1%
        print("⚠️ Warning: May need more high-exposure images")
    
    # Check dynamic range utilization
    used_range = result.max() - result.min()
    print(f"✅ Dynamic range utilization: {used_range}/255 ({used_range/255*100:.1f}%)")

# ❌ Wrong: Input image data types inconsistent
images = [img1.astype(np.float32), img2]  # Mixed types

# ✅ Correct: Keep consistent uint8 type
images = [img1.astype(np.uint8), img2.astype(np.uint8)]

# ❌ Wrong: Forgot to convert fusion result
result = merge_mertens.process(images)
cv2.imwrite('output.png', result)  # Result is float32, saving will have issues

# ✅ Correct: Convert to uint8
result = merge_mertens.process(images)
result_8bit = np.clip(result * 255, 0, 255).astype(np.uint8)
cv2.imwrite('output.png', result_8bit)

# Basic installation
pip install opencv-python numpy

# Full installation (includes contrib modules)
pip install opencv-contrib-python numpy

import cv2
print(f"OpenCV version: {cv2.__version__}")

# Check if MergeMertens is available
try:
    merge = cv2.createMergeMertens()
    print("✅ MergeMertens available")
except AttributeError:
    print("❌ MergeMertens unavailable, please check OpenCV version")