XplorePlane/XP.ImageProcessing.Processors/图像增强/HierarchicalEnhancementProcessor.cs

// ============================================================================
// Copyright ﾂｩ 2026 Hexagon Technology Center GmbH. All Rights Reserved.
// 譁�ｻｶ蜷? HierarchicalEnhancementProcessor.cs
// 謠剰ｿｰ: 螻よｬ｡蠅槫ｼｺ邂怜ｭ撰ｼ悟渕莠主､壼ｰｺ蠎ｦ鬮俶民蛻�ｧ｣蟇ｹ荳榊酔蟆ｺ蠎ｦ扈�鰍迢ｬ遶句｢槫ｼ?
// 蜉溯�:
//   - 蟆�崟蜒丞�隗｣荳ｺ螟壼ｱらｻ�鰍螻?+ 蝓ｺ遑€螻?
//   - 蟇ｹ豈丞ｱらｻ�鰍迢ｬ遶区而蛻ｶ蠅樒�?
//   - 謾ｯ謖∝渕遑€螻ゆｺｮ蠎ｦ隹�紛蜥悟ｯｹ豈泌ｺｦ髯仙�?
// 邂玲ｳ�: 螟壼ｰｺ蠎ｦ鬮俶民蟾ｮ蛻��隗｣荳朱㍾蟒ｺ
// 菴懆€? 譚惹ｼ� wei.lw.li@hexagon.com
// ============================================================================

using Emgu.CV;
using Emgu.CV.Structure;
using Serilog;
using XP.ImageProcessing.Core;

namespace XP.ImageProcessing.Processors;

/// <summary>
/// 螻よｬ｡蠅槫ｼｺ邂怜ｭ撰ｼ悟渕莠主､壼ｰｺ蠎ｦ鬮俶民蟾ｮ蛻�ｯｹ荳榊酔蟆ｺ蠎ｦ逧�崟蜒冗ｻ�鰍霑幄｡檎峡遶句｢槫ｼｺ
/// </summary>
public class HierarchicalEnhancementProcessor : ImageProcessorBase
{
    private static readonly ILogger _logger = Log.ForContext<HierarchicalEnhancementProcessor>();

    public HierarchicalEnhancementProcessor()
    {
        Name = LocalizationHelper.GetString("HierarchicalEnhancementProcessor_Name");
        Description = LocalizationHelper.GetString("HierarchicalEnhancementProcessor_Description");
    }

    protected override void InitializeParameters()
    {
        Parameters.Add("Levels", new ProcessorParameter(
            "Levels",
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_Levels"),
            typeof(int),
            4,
            2,
            8,
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_Levels_Desc")));

        Parameters.Add("FineGain", new ProcessorParameter(
            "FineGain",
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_FineGain"),
            typeof(double),
            2.0,
            0.0,
            10.0,
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_FineGain_Desc")));

        Parameters.Add("MediumGain", new ProcessorParameter(
            "MediumGain",
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_MediumGain"),
            typeof(double),
            1.5,
            0.0,
            10.0,
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_MediumGain_Desc")));

        Parameters.Add("CoarseGain", new ProcessorParameter(
            "CoarseGain",
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_CoarseGain"),
            typeof(double),
            1.0,
            0.0,
            10.0,
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_CoarseGain_Desc")));

        Parameters.Add("BaseGain", new ProcessorParameter(
            "BaseGain",
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_BaseGain"),
            typeof(double),
            1.0,
            0.0,
            3.0,
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_BaseGain_Desc")));

        Parameters.Add("ClipLimit", new ProcessorParameter(
            "ClipLimit",
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_ClipLimit"),
            typeof(double),
            0.0,
            0.0,
            50.0,
            LocalizationHelper.GetString("HierarchicalEnhancementProcessor_ClipLimit_Desc")));

        _logger.Debug("InitializeParameters");
    }

    public override Image<Gray, byte> Process(Image<Gray, byte> inputImage)
    {
        int levels = GetParameter<int>("Levels");
        double fineGain = GetParameter<double>("FineGain");
        double mediumGain = GetParameter<double>("MediumGain");
        double coarseGain = GetParameter<double>("CoarseGain");
        double baseGain = GetParameter<double>("BaseGain");
        double clipLimit = GetParameter<double>("ClipLimit");

        _logger.Debug("Process: Levels={Levels}, Fine={Fine}, Medium={Medium}, Coarse={Coarse}, Base={Base}, Clip={Clip}",
            levels, fineGain, mediumGain, coarseGain, baseGain, clipLimit);

        int h = inputImage.Height;
        int w = inputImage.Width;

        // === 螟壼ｰｺ蠎ｦ鬮俶民蟾ｮ蛻��隗｣�亥�驛ｨ蝨ｨ蜴溷ｧ句�霎ｨ邇�ｸ頑桃菴懶ｼ梧裏髴€驥大ｭ怜｡比ｸ贋ｸ矩㊦譬ｷ�� ===
        // 逕ｨ騾貞｢� sigma 逧�ｫ俶民讓｡邉顔函謌仙ｹｳ貊大ｱょｺ丞��哦0(蜴溷崟), G1, G2, ..., G_n(蝓ｺ遑€螻?
        // 扈�鰍螻?D_i = G_i - G_{i+1}
        // 驥榊ｻｺ�嗤utput = sum(D_i * gain_i) + G_n * baseGain

        // 隶｡邂玲ｯ丞ｱら噪鬮俶�?sigma�域欠謨ｰ騾貞｢橸ｼ?
        var sigmas = new double[levels];
        for (int i = 0; i < levels; i++)
            sigmas[i] = Math.Pow(2, i + 1); // 2, 4, 8, 16, ...

        // 逕滓�蟷ｳ貊大ｱょｺ丞���loat 謨ｰ扈�ｼ碁∩蜈?Emgu float Image 逧�琉鬚假ｼ�
        var smoothLayers = new float[levels + 1][]; // [0]=蜴溷崟, [1..n]=鬮俶民讓｡邉�
        smoothLayers[0] = new float[h * w];
        var srcData = inputImage.Data;
        Parallel.For(0, h, y =>
        {
            int row = y * w;
            for (int x = 0; x < w; x++)
                smoothLayers[0][row + x] = srcData[y, x, 0];
        });

        for (int i = 0; i < levels; i++)
        {
            int ksize = ((int)(sigmas[i] * 3)) | 1; // 遑ｮ菫晏･�焚
            if (ksize < 3) ksize = 3;

            using var src = new Image<Gray, byte>(w, h);
            // 莉惹ｸ贋ｸ€螻?float 霓?byte 蛛夐ｫ俶民讓｡邉?
            var prevLayer = smoothLayers[i];
            var sd = src.Data;
            Parallel.For(0, h, y =>
            {
                int row = y * w;
                for (int x = 0; x < w; x++)
                    sd[y, x, 0] = (byte)Math.Clamp((int)Math.Round(prevLayer[row + x]), 0, 255);
            });

            using var dst = new Image<Gray, byte>(w, h);
            CvInvoke.GaussianBlur(src, dst, new System.Drawing.Size(ksize, ksize), sigmas[i]);

            smoothLayers[i + 1] = new float[h * w];
            var dd = dst.Data;
            var nextLayer = smoothLayers[i + 1];
            Parallel.For(0, h, y =>
            {
                int row = y * w;
                for (int x = 0; x < w; x++)
                    nextLayer[row + x] = dd[y, x, 0];
            });
        }

        // === 隶｡邂怜｢樒寢謠貞€ｼ蟷ｶ逶ｴ謗･驥榊ｻｺ ===
        var gains = new double[levels];
        for (int i = 0; i < levels; i++)
        {
            double t = levels <= 1 ? 0.0 : (double)i / (levels - 1);
            if (t <= 0.5)
            {
                double t2 = t * 2.0;
                gains[i] = fineGain * (1.0 - t2) + mediumGain * t2;
            }
            else
            {
                double t2 = (t - 0.5) * 2.0;
                gains[i] = mediumGain * (1.0 - t2) + coarseGain * t2;
            }
        }

        // 驥榊ｻｺ�嗤utput = baseGain * G_n + sum(gain_i * (G_i - G_{i+1}))
        float fBaseGain = (float)baseGain;
        float fClip = (float)clipLimit;
        var baseLayerData = smoothLayers[levels];

        var result = new Image<Gray, byte>(w, h);
        var resultData = result.Data;

        // 鬚�ｽｬ謐?gains 荳?float
        var fGains = new float[levels];
        for (int i = 0; i < levels; i++)
            fGains[i] = (float)gains[i];

        Parallel.For(0, h, y =>
        {
            int row = y * w;
            for (int x = 0; x < w; x++)
            {
                int idx = row + x;
                float val = baseLayerData[idx] * fBaseGain;

                for (int i = 0; i < levels; i++)
                {
                    float detail = smoothLayers[i][idx] - smoothLayers[i + 1][idx];
                    detail *= fGains[i];
                    if (fClip > 0)
                        detail = Math.Clamp(detail, -fClip, fClip);
                    val += detail;
                }

                resultData[y, x, 0] = (byte)Math.Clamp((int)Math.Round(val), 0, 255);
            }
        });

        _logger.Debug("Process completed: {Levels} levels, output={W}x{H}", levels, w, h);
        return result;
    }
}