李伟
549 lines
19 KiB
C#
549 lines
19 KiB
C#
// ============================================================================
|
||
// Copyright © 2026 Hexagon Technology Center GmbH. All Rights Reserved.
|
||
// 文件名: HDREnhancementProcessor.cs
|
||
// 描述: 高动态范围（HDR）图像增强算子
|
||
// 功能:
|
||
// - 局部色调映射（Local Tone Mapping）
|
||
// - 自适应对数映射（Adaptive Logarithmic Mapping）
|
||
// - Drago色调映射
|
||
// - 双边滤波色调映射
|
||
// - 增强图像暗部和亮部细节
|
||
// 算法: 基于色调映射的HDR增强
|
||
// 作者: 李伟 wei.lw.li@hexagon.com
|
||
// ============================================================================
|
||
|
||
using Emgu.CV;
|
||
using Emgu.CV.Structure;
|
||
using XP.ImageProcessing.Core;
|
||
using Serilog;
|
||
|
||
namespace XP.ImageProcessing.Processors;
|
||
|
||
/// <summary>
|
||
/// 高动态范围图像增强算子
|
||
/// </summary>
|
||
public class HDREnhancementProcessor : ImageProcessorBase
|
||
{
|
||
private static readonly ILogger _logger = Log.ForContext<HDREnhancementProcessor>();
|
||
|
||
public HDREnhancementProcessor()
|
||
{
|
||
Name = LocalizationHelper.GetString("HDREnhancementProcessor_Name");
|
||
Description = LocalizationHelper.GetString("HDREnhancementProcessor_Description");
|
||
}
|
||
|
||
protected override void InitializeParameters()
|
||
{
|
||
Parameters.Add("Method", new ProcessorParameter(
|
||
"Method",
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_Method"),
|
||
typeof(string),
|
||
"LocalToneMap",
|
||
null,
|
||
null,
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_Method_Desc"),
|
||
new string[] { "LocalToneMap", "AdaptiveLog", "Drago", "BilateralToneMap" }));
|
||
|
||
Parameters.Add("Gamma", new ProcessorParameter(
|
||
"Gamma",
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_Gamma"),
|
||
typeof(double),
|
||
1.0,
|
||
0.1,
|
||
5.0,
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_Gamma_Desc")));
|
||
|
||
Parameters.Add("Saturation", new ProcessorParameter(
|
||
"Saturation",
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_Saturation"),
|
||
typeof(double),
|
||
1.0,
|
||
0.0,
|
||
3.0,
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_Saturation_Desc")));
|
||
|
||
Parameters.Add("DetailBoost", new ProcessorParameter(
|
||
"DetailBoost",
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_DetailBoost"),
|
||
typeof(double),
|
||
1.5,
|
||
0.0,
|
||
5.0,
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_DetailBoost_Desc")));
|
||
|
||
Parameters.Add("SigmaSpace", new ProcessorParameter(
|
||
"SigmaSpace",
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_SigmaSpace"),
|
||
typeof(double),
|
||
20.0,
|
||
1.0,
|
||
100.0,
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_SigmaSpace_Desc")));
|
||
|
||
Parameters.Add("SigmaColor", new ProcessorParameter(
|
||
"SigmaColor",
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_SigmaColor"),
|
||
typeof(double),
|
||
30.0,
|
||
1.0,
|
||
100.0,
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_SigmaColor_Desc")));
|
||
|
||
Parameters.Add("Bias", new ProcessorParameter(
|
||
"Bias",
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_Bias"),
|
||
typeof(double),
|
||
0.85,
|
||
0.0,
|
||
1.0,
|
||
LocalizationHelper.GetString("HDREnhancementProcessor_Bias_Desc")));
|
||
|
||
_logger.Debug("InitializeParameters");
|
||
}
|
||
|
||
public override Image<Gray, byte> Process(Image<Gray, byte> inputImage)
|
||
{
|
||
string method = GetParameter<string>("Method");
|
||
double gamma = GetParameter<double>("Gamma");
|
||
double saturation = GetParameter<double>("Saturation");
|
||
double detailBoost = GetParameter<double>("DetailBoost");
|
||
double sigmaSpace = GetParameter<double>("SigmaSpace");
|
||
double sigmaColor = GetParameter<double>("SigmaColor");
|
||
double bias = GetParameter<double>("Bias");
|
||
|
||
Image<Gray, byte> result;
|
||
|
||
switch (method)
|
||
{
|
||
case "AdaptiveLog":
|
||
result = AdaptiveLogarithmicMapping(inputImage, gamma, bias);
|
||
break;
|
||
|
||
case "Drago":
|
||
result = DragoToneMapping(inputImage, gamma, bias);
|
||
break;
|
||
|
||
case "BilateralToneMap":
|
||
result = BilateralToneMapping(inputImage, gamma, sigmaSpace, sigmaColor, detailBoost);
|
||
break;
|
||
|
||
default: // LocalToneMap
|
||
result = LocalToneMapping(inputImage, gamma, sigmaSpace, detailBoost, saturation);
|
||
break;
|
||
}
|
||
|
||
_logger.Debug("Process: Method={Method}, Gamma={Gamma}, Saturation={Saturation}, DetailBoost={DetailBoost}, SigmaSpace={SigmaSpace}, SigmaColor={SigmaColor}, Bias={Bias}",
|
||
method, gamma, saturation, detailBoost, sigmaSpace, sigmaColor, bias);
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 局部色调映射
|
||
/// 将图像分解为基础层（光照）和细节层，分别处理后合成
|
||
/// Base = GaussianBlur(log(I))
|
||
/// Detail = log(I) - Base
|
||
/// Output = exp(Base_compressed + Detail * boost)
|
||
/// </summary>
|
||
private Image<Gray, byte> LocalToneMapping(Image<Gray, byte> inputImage,
|
||
double gamma, double sigmaSpace, double detailBoost, double saturation)
|
||
{
|
||
int width = inputImage.Width;
|
||
int height = inputImage.Height;
|
||
|
||
// 转换为浮点并归一化到 (0, 1]
|
||
var floatImage = inputImage.Convert<Gray, float>();
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
floatImage.Data[y, x, 0] = floatImage.Data[y, x, 0] / 255.0f + 0.001f;
|
||
|
||
// 对数域
|
||
var logImage = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
logImage.Data[y, x, 0] = (float)Math.Log(floatImage.Data[y, x, 0]);
|
||
|
||
// 基础层：大尺度高斯模糊提取光照分量
|
||
int kernelSize = (int)(sigmaSpace * 6) | 1;
|
||
if (kernelSize < 3) kernelSize = 3;
|
||
var baseLayer = new Image<Gray, float>(width, height);
|
||
CvInvoke.GaussianBlur(logImage, baseLayer, new System.Drawing.Size(kernelSize, kernelSize), sigmaSpace);
|
||
|
||
// 细节层
|
||
var detailLayer = logImage - baseLayer;
|
||
|
||
// 压缩基础层的动态范围
|
||
double baseMin = double.MaxValue, baseMax = double.MinValue;
|
||
for (int y = 0; y < height; y++)
|
||
{
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float v = baseLayer.Data[y, x, 0];
|
||
if (v < baseMin) baseMin = v;
|
||
if (v > baseMax) baseMax = v;
|
||
}
|
||
}
|
||
|
||
double baseRange = baseMax - baseMin;
|
||
if (baseRange < 0.001) baseRange = 0.001;
|
||
|
||
// 目标动态范围（对数域）
|
||
double targetRange = Math.Log(256.0);
|
||
double compressionFactor = targetRange / baseRange;
|
||
|
||
var compressedBase = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
{
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float normalized = (float)((baseLayer.Data[y, x, 0] - baseMin) / baseRange);
|
||
compressedBase.Data[y, x, 0] = (float)(normalized * targetRange + Math.Log(0.01));
|
||
}
|
||
}
|
||
|
||
// 合成：压缩后的基础层 + 增强的细节层
|
||
var combined = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
{
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float val = compressedBase.Data[y, x, 0] + detailLayer.Data[y, x, 0] * (float)detailBoost;
|
||
combined.Data[y, x, 0] = val;
|
||
}
|
||
}
|
||
|
||
// 指数变换回线性域
|
||
var linearResult = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
linearResult.Data[y, x, 0] = (float)Math.Exp(combined.Data[y, x, 0]);
|
||
|
||
// Gamma校正
|
||
if (Math.Abs(gamma - 1.0) > 0.01)
|
||
{
|
||
double invGamma = 1.0 / gamma;
|
||
double maxVal = 0;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
if (linearResult.Data[y, x, 0] > maxVal) maxVal = linearResult.Data[y, x, 0];
|
||
|
||
if (maxVal > 0)
|
||
{
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
double normalized = linearResult.Data[y, x, 0] / maxVal;
|
||
linearResult.Data[y, x, 0] = (float)(Math.Pow(normalized, invGamma) * maxVal);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 饱和度增强（对比度微调）
|
||
if (Math.Abs(saturation - 1.0) > 0.01)
|
||
{
|
||
double mean = 0;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
mean += linearResult.Data[y, x, 0];
|
||
mean /= (width * height);
|
||
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
double diff = linearResult.Data[y, x, 0] - mean;
|
||
linearResult.Data[y, x, 0] = (float)(mean + diff * saturation);
|
||
}
|
||
}
|
||
|
||
// 归一化到 [0, 255]
|
||
var result = NormalizeToByteImage(linearResult);
|
||
|
||
floatImage.Dispose();
|
||
logImage.Dispose();
|
||
baseLayer.Dispose();
|
||
detailLayer.Dispose();
|
||
compressedBase.Dispose();
|
||
combined.Dispose();
|
||
linearResult.Dispose();
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 自适应对数映射
|
||
/// 根据场景的整体亮度自适应调整对数映射曲线
|
||
/// L_out = (log(1 + L_in) / log(1 + L_max)) ^ (1/gamma)
|
||
/// 使用局部自适应：L_max 根据邻域计算
|
||
/// </summary>
|
||
private Image<Gray, byte> AdaptiveLogarithmicMapping(Image<Gray, byte> inputImage,
|
||
double gamma, double bias)
|
||
{
|
||
int width = inputImage.Width;
|
||
int height = inputImage.Height;
|
||
|
||
var floatImage = inputImage.Convert<Gray, float>();
|
||
|
||
// 归一化到 [0, 1]
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
floatImage.Data[y, x, 0] /= 255.0f;
|
||
|
||
// 计算全局最大亮度
|
||
float globalMax = 0;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
if (floatImage.Data[y, x, 0] > globalMax)
|
||
globalMax = floatImage.Data[y, x, 0];
|
||
|
||
if (globalMax < 0.001f) globalMax = 0.001f;
|
||
|
||
// 计算对数平均亮度
|
||
double logAvg = 0;
|
||
int count = 0;
|
||
for (int y = 0; y < height; y++)
|
||
{
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float v = floatImage.Data[y, x, 0];
|
||
if (v > 0.001f)
|
||
{
|
||
logAvg += Math.Log(v);
|
||
count++;
|
||
}
|
||
}
|
||
}
|
||
logAvg = Math.Exp(logAvg / Math.Max(count, 1));
|
||
|
||
// 自适应对数映射
|
||
// bias 控制暗部和亮部的平衡
|
||
double logBase = Math.Log(2.0 + 8.0 * Math.Pow(logAvg / globalMax, Math.Log(bias) / Math.Log(0.5)));
|
||
|
||
var result = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
{
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float lum = floatImage.Data[y, x, 0];
|
||
double mapped = Math.Log(1.0 + lum) / logBase;
|
||
result.Data[y, x, 0] = (float)mapped;
|
||
}
|
||
}
|
||
|
||
// Gamma校正
|
||
if (Math.Abs(gamma - 1.0) > 0.01)
|
||
{
|
||
double invGamma = 1.0 / gamma;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
result.Data[y, x, 0] = (float)Math.Pow(Math.Max(0, result.Data[y, x, 0]), invGamma);
|
||
}
|
||
|
||
var byteResult = NormalizeToByteImage(result);
|
||
|
||
floatImage.Dispose();
|
||
result.Dispose();
|
||
|
||
return byteResult;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Drago色调映射
|
||
/// 使用自适应对数基底进行色调映射
|
||
/// L_out = log_base(1 + L_in) / log_base(1 + L_max)
|
||
/// base = 2 + 8 * (L_in / L_max) ^ (ln(bias) / ln(0.5))
|
||
/// </summary>
|
||
private Image<Gray, byte> DragoToneMapping(Image<Gray, byte> inputImage,
|
||
double gamma, double bias)
|
||
{
|
||
int width = inputImage.Width;
|
||
int height = inputImage.Height;
|
||
|
||
var floatImage = inputImage.Convert<Gray, float>();
|
||
|
||
// 归一化到 [0, 1]
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
floatImage.Data[y, x, 0] /= 255.0f;
|
||
|
||
// 全局最大亮度
|
||
float maxLum = 0;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
if (floatImage.Data[y, x, 0] > maxLum)
|
||
maxLum = floatImage.Data[y, x, 0];
|
||
|
||
if (maxLum < 0.001f) maxLum = 0.001f;
|
||
|
||
double biasP = Math.Log(bias) / Math.Log(0.5);
|
||
double divider = Math.Log10(1.0 + maxLum);
|
||
if (divider < 0.001) divider = 0.001;
|
||
|
||
var result = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
{
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float lum = floatImage.Data[y, x, 0];
|
||
// 自适应对数基底
|
||
double adaptBase = 2.0 + 8.0 * Math.Pow(lum / maxLum, biasP);
|
||
double logAdapt = Math.Log(1.0 + lum) / Math.Log(adaptBase);
|
||
double mapped = logAdapt / divider;
|
||
result.Data[y, x, 0] = (float)Math.Max(0, Math.Min(1.0, mapped));
|
||
}
|
||
}
|
||
|
||
// Gamma校正
|
||
if (Math.Abs(gamma - 1.0) > 0.01)
|
||
{
|
||
double invGamma = 1.0 / gamma;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
result.Data[y, x, 0] = (float)Math.Pow(result.Data[y, x, 0], invGamma);
|
||
}
|
||
|
||
var byteResult = NormalizeToByteImage(result);
|
||
|
||
floatImage.Dispose();
|
||
result.Dispose();
|
||
|
||
return byteResult;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 双边滤波色调映射
|
||
/// 使用双边滤波分离基础层和细节层
|
||
/// 双边滤波保边特性使得细节层更加精确
|
||
/// </summary>
|
||
private Image<Gray, byte> BilateralToneMapping(Image<Gray, byte> inputImage,
|
||
double gamma, double sigmaSpace, double sigmaColor, double detailBoost)
|
||
{
|
||
int width = inputImage.Width;
|
||
int height = inputImage.Height;
|
||
|
||
// 转换为浮点并取对数
|
||
var floatImage = inputImage.Convert<Gray, float>();
|
||
var logImage = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
logImage.Data[y, x, 0] = (float)Math.Log(floatImage.Data[y, x, 0] / 255.0f + 0.001);
|
||
|
||
// 双边滤波提取基础层（保边平滑）
|
||
int diameter = (int)(sigmaSpace * 2) | 1;
|
||
if (diameter < 3) diameter = 3;
|
||
if (diameter > 31) diameter = 31;
|
||
|
||
var baseLayer = new Image<Gray, float>(width, height);
|
||
// 转换为 byte 进行双边滤波，再转回 float
|
||
var logNorm = NormalizeToByteImage(logImage);
|
||
var baseNorm = new Image<Gray, byte>(width, height);
|
||
CvInvoke.BilateralFilter(logNorm, baseNorm, diameter, sigmaColor, sigmaSpace);
|
||
|
||
// 将基础层转回浮点对数域
|
||
double logMin = double.MaxValue, logMax = double.MinValue;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float v = logImage.Data[y, x, 0];
|
||
if (v < logMin) logMin = v;
|
||
if (v > logMax) logMax = v;
|
||
}
|
||
|
||
double logRange = logMax - logMin;
|
||
if (logRange < 0.001) logRange = 0.001;
|
||
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
baseLayer.Data[y, x, 0] = (float)(baseNorm.Data[y, x, 0] / 255.0 * logRange + logMin);
|
||
|
||
// 细节层 = 对数图像 - 基础层
|
||
var detailLayer = logImage - baseLayer;
|
||
|
||
// 压缩基础层
|
||
double baseMin = double.MaxValue, baseMax = double.MinValue;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float v = baseLayer.Data[y, x, 0];
|
||
if (v < baseMin) baseMin = v;
|
||
if (v > baseMax) baseMax = v;
|
||
}
|
||
|
||
double bRange = baseMax - baseMin;
|
||
if (bRange < 0.001) bRange = 0.001;
|
||
double targetRange = Math.Log(256.0);
|
||
double compression = targetRange / bRange;
|
||
|
||
// 合成
|
||
var combined = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
{
|
||
float compBase = (float)((baseLayer.Data[y, x, 0] - baseMin) * compression + Math.Log(0.01));
|
||
combined.Data[y, x, 0] = compBase + detailLayer.Data[y, x, 0] * (float)detailBoost;
|
||
}
|
||
|
||
// 指数变换回线性域
|
||
var linearResult = new Image<Gray, float>(width, height);
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
linearResult.Data[y, x, 0] = (float)Math.Exp(combined.Data[y, x, 0]);
|
||
|
||
// Gamma校正
|
||
if (Math.Abs(gamma - 1.0) > 0.01)
|
||
{
|
||
double invGamma = 1.0 / gamma;
|
||
double maxVal = 0;
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
if (linearResult.Data[y, x, 0] > maxVal) maxVal = linearResult.Data[y, x, 0];
|
||
|
||
if (maxVal > 0)
|
||
for (int y = 0; y < height; y++)
|
||
for (int x = 0; x < width; x++)
|
||
linearResult.Data[y, x, 0] = (float)(Math.Pow(linearResult.Data[y, x, 0] / maxVal, invGamma) * maxVal);
|
||
}
|
||
|
||
var result = NormalizeToByteImage(linearResult);
|
||
|
||
floatImage.Dispose();
|
||
logImage.Dispose();
|
||
logNorm.Dispose();
|
||
baseNorm.Dispose();
|
||
baseLayer.Dispose();
|
||
detailLayer.Dispose();
|
||
combined.Dispose();
|
||
linearResult.Dispose();
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 归一化浮点图像到字节图像
|
||
/// </summary>
|
||
private Image<Gray, byte> NormalizeToByteImage(Image<Gray, float> floatImage)
|
||
{
|
||
double minVal = double.MaxValue;
|
||
double maxVal = double.MinValue;
|
||
|
||
for (int y = 0; y < floatImage.Height; y++)
|
||
for (int x = 0; x < floatImage.Width; x++)
|
||
{
|
||
float val = floatImage.Data[y, x, 0];
|
||
if (val < minVal) minVal = val;
|
||
if (val > maxVal) maxVal = val;
|
||
}
|
||
|
||
var result = new Image<Gray, byte>(floatImage.Size);
|
||
double range = maxVal - minVal;
|
||
if (range > 0)
|
||
{
|
||
for (int y = 0; y < floatImage.Height; y++)
|
||
for (int x = 0; x < floatImage.Width; x++)
|
||
{
|
||
int normalized = (int)((floatImage.Data[y, x, 0] - minVal) / range * 255.0);
|
||
result.Data[y, x, 0] = (byte)Math.Max(0, Math.Min(255, normalized));
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
} |