OpenCV HDR 图像融合：从原理到实践的完整指南

曝光序列采集 → 图像对齐 → 曝光融合 → 色调映射 → 输出 LDR 图像
     ↓              ↓           ↓           ↓
多张不同曝光     校正偏移    合成 HDR    压缩到显示范围

import cv2

# HDR 功能位于 photo 模块
merge_mertens = cv2.createMergeMertens()  # 曝光融合（推荐）
merge_debevec = cv2.createMergeDebevec()  # CRF 方法
tonemap_drago = cv2.createTonemapDrago()  # 色调映射

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 × σ²)))

权重计算:
W_k(i,j) = C(i,j)^wc × S(i,j)^ws × E(i,j)^we

归一化:
Normalized_W_k(i,j) = W_k(i,j) / Σ(W_k(i,j))

融合结果:
Output(i,j) = Σ(Normalized_W_k(i,j) × Image_k(i,j))

1. 构建高斯金字塔    → 对每张图像进行多尺度分解
2. 计算拉普拉斯金字塔  → 提取不同频率细节
3. 分层融合         → 每一层独立按权重融合
4. 重建图像         → 从粗到细重建最终图像

merge_mertens = cv2.createMergeMertens(
    contrast_weight=1.0,      # wc: 对比度权重指数
    saturation_weight=1.0,    # ws: 饱和度权重指数
    exposure_weight=0.0       # we: 曝光适度权重指数
)

import cv2
import numpy as np
import os

def load_exposure_sequence(image_paths):
    """加载曝光序列图像"""
    images = []
    for path in image_paths:
        img = cv2.imread(path)
        if img is not None:
            images.append(img)
        else:
            print(f"警告: 无法加载图像 {path}")
    return images

def merge_hdr_mertens(images, contrast=1.0, saturation=1.0, exposure=0.0):
    """使用 Mertens 算法融合 HDR 图像"""
    if len(images) < 2:
        raise ValueError("至少需要 2 张图像进行融合")
    
    # 创建融合器
    merge_mertens = cv2.createMergeMertens(
        contrast_weight=contrast,
        saturation_weight=saturation,
        exposure_weight=exposure
    )
    
    # 执行融合
    fusion = merge_mertens.process(images)
    
    # 转换为 8-bit 图像
    # 方法1: 直接裁剪（保持亮度对比）
    fusion_8bit = np.clip(fusion * 255, 0, 255).astype(np.uint8)
    
    return fusion_8bit

# 使用示例
image_paths = [
    'exposure_1.jpg',  # 低曝光（暗）
    'exposure_2.jpg',  # 中曝光
    'exposure_3.jpg',  # 高曝光（亮）
]

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):
    """
    高级 HDR 融合，支持归一化选项
    
    Parameters:
    -----------
    images : list
        图像列表
    normalize : bool
        是否归一化输出（增强对比度，但会改变亮度范围）
    **kwargs : dict
        传递给 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:
        # 归一化到完整动态范围（增强对比度）
        result = cv2.normalize(fusion, None, 0, 255, cv2.NORM_MINMAX)
    else:
        # 保持原始亮度关系（适合批量对比）
        result = np.clip(fusion * 255, 0, 255)
    
    return result.astype(np.uint8)

import hashlib

def get_cache_path(dir_path, image_type, normalize=False):
    """生成缓存文件路径"""
    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 处理
    
    - 如果 HDR 文件已存在，直接跳过（加速 10-50 倍）
    - 如果不存在，生成并保存
    """
    cache_path = get_cache_path(dir_path, 'result', normalize)
    
    # 检查缓存
    if os.path.isfile(cache_path):
        return ('skipped', '已存在缓存，跳过处理')
    
    # 加载图像
    import glob
    image_paths = sorted(glob.glob(os.path.join(dir_path, image_pattern)))
    
    if len(image_paths) < 2:
        return ('error', f'图像不足: 仅找到 {len(image_paths)} 张')
    
    images = load_exposure_sequence(image_paths)
    
    # 融合
    result = merge_hdr_advanced(images, normalize=normalize)
    
    # 保存
    cv2.imwrite(cache_path, result)
    
    return ('success', f'已处理 {len(images)} 张图像')

传统方法（手动选择光强）:
├── 操作时间: 每批次 5-10 分钟手动选择
├── 结果质量: 依赖操作员经验
└── 一致性: 批次间差异大

HDR Fusion 方法:
├── 操作时间: ~0.15 秒/样品（自动）
├── 结果质量: 算法保证最优
└── 一致性: 100% 可重复

测试条件:
- 图像尺寸: 1920×1080 像素
- 曝光数量: 8 张
- 硬件: Intel i7 + 16GB RAM

┌────────────────┬──────────┬──────────┬────────────┐
│     方法        │  时间(s) │ 内存(MB) │ 质量得分    │
├────────────────┼──────────┼──────────┼────────────┤
│ Mertens        │   0.15   │    120   │   9.2/10   │
│ Debevec + Drago│   0.42   │    180   │   9.5/10   │
│ 手动选择最佳光强│   180*   │     50   │   7.5/10   │
└────────────────┴──────────┴──────────┴────────────┘
* 包含人工操作时间

# 如果图像有噪声，先降噪
denoised = cv2.fastNlMeansDenoisingColored(image, None, 10, 10, 7, 21)

# 如果图像有偏移（手持拍摄），先对齐
alignMTB = cv2.createAlignMTB()
aligned_images = []
alignMTB.process(images, aligned_images)

def check_quality(result):
    """检查 HDR 结果质量"""
    total_pixels = result.size
    
    # 检查过曝（饱和像素）
    saturated = np.sum(result >= 254) / total_pixels
    if saturated > 0.01:  # 超过 1%
        print("⚠️ 警告: 可能需要更多低曝光图像")
    
    # 检查欠曝（暗像素）
    dark = np.sum(result <= 1) / total_pixels
    if dark > 0.01:  # 超过 1%
        print("⚠️ 警告: 可能需要更多高曝光图像")
    
    # 检查动态范围利用
    used_range = result.max() - result.min()
    print(f"✅ 动态范围利用: {used_range}/255 ({used_range/255*100:.1f}%)")

# ❌ 错误: 输入图像数据类型不一致
images = [img1.astype(np.float32), img2]  # 混合类型

# ✅ 正确: 保持一致的 uint8 类型
images = [img1.astype(np.uint8), img2.astype(np.uint8)]

# ❌ 错误: 忘记转换融合结果
result = merge_mertens.process(images)
cv2.imwrite('output.png', result)  # 结果是 float32，保存会有问题

# ✅ 正确: 转换为 uint8
result = merge_mertens.process(images)
result_8bit = np.clip(result * 255, 0, 255).astype(np.uint8)
cv2.imwrite('output.png', result_8bit)

# 基础安装
pip install opencv-python numpy

# 完整安装（包含 contrib 模块）
pip install opencv-contrib-python numpy

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

# 检查 MergeMertens 是否可用
try:
    merge = cv2.createMergeMertens()
    print("✅ MergeMertens 可用")
except AttributeError:
    print("❌ MergeMertens 不可用，请检查 OpenCV 版本")