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

// ============================================================================
// Copyright © 2026 Hexagon Technology Center GmbH. All Rights Reserved.
// 文件� HistogramEqualizationProcessor.cs
// �述: 直方图�衡化算�，用于增强图�对比度
// 功能:
//   - 全局直方图�衡化
//   - 自适应直方图�衡化（CLAHE�
//   - �制对比度增�
//   - 改善图�的整体对比度
// 算法: 直方图�衡化�CLAHE
// 作� �伟 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 HistogramEqualizationProcessor : ImageProcessorBase
{
    private static readonly ILogger _logger = Log.ForContext<HistogramEqualizationProcessor>();

    public HistogramEqualizationProcessor()
    {
        Name = LocalizationHelper.GetString("HistogramEqualizationProcessor_Name");
        Description = LocalizationHelper.GetString("HistogramEqualizationProcessor_Description");
    }

    protected override void InitializeParameters()
    {
        Parameters.Add("Method", new ProcessorParameter(
            "Method",
            LocalizationHelper.GetString("HistogramEqualizationProcessor_Method"),
            typeof(string),
            "Global",
            null,
            null,
            LocalizationHelper.GetString("HistogramEqualizationProcessor_Method_Desc"),
            new string[] { "Global", "CLAHE" }));

        Parameters.Add("ClipLimit", new ProcessorParameter(
            "ClipLimit",
            LocalizationHelper.GetString("HistogramEqualizationProcessor_ClipLimit"),
            typeof(double),
            2.0,
            1.0,
            10.0,
            LocalizationHelper.GetString("HistogramEqualizationProcessor_ClipLimit_Desc")));

        Parameters.Add("TileSize", new ProcessorParameter(
            "TileSize",
            LocalizationHelper.GetString("HistogramEqualizationProcessor_TileSize"),
            typeof(int),
            8,
            4,
            32,
            LocalizationHelper.GetString("HistogramEqualizationProcessor_TileSize_Desc")));
        _logger.Debug("InitializeParameters");
    }

    public override Image<Gray, byte> Process(Image<Gray, byte> inputImage)
    {
        string method = GetParameter<string>("Method");
        double clipLimit = GetParameter<double>("ClipLimit");
        int tileSize = GetParameter<int>("TileSize");

        Image<Gray, byte> result;

        if (method == "CLAHE")
        {
            result = ApplyCLAHE(inputImage, clipLimit, tileSize);
        }
        else // Global
        {
            result = new Image<Gray, byte>(inputImage.Size);
            CvInvoke.EqualizeHist(inputImage, result);
        }

        _logger.Debug("Process: Method = {Method}, ClipLimit = {ClipLimit}, TileSize = {TileSize}",
            method, clipLimit, tileSize);
        return result;
    }

    private Image<Gray, byte> ApplyCLAHE(Image<Gray, byte> inputImage, double clipLimit, int tileSize)
    {
        int width = inputImage.Width;
        int height = inputImage.Height;

        int tilesX = (width + tileSize - 1) / tileSize;
        int tilesY = (height + tileSize - 1) / tileSize;

        var result = new Image<Gray, byte>(width, height);

        // 对�个tile进行直方图�衡化
        for (int ty = 0; ty < tilesY; ty++)
        {
            for (int tx = 0; tx < tilesX; tx++)
            {
                int x = tx * tileSize;
                int y = ty * tileSize;
                int w = Math.Min(tileSize, width - x);
                int h = Math.Min(tileSize, height - y);

                var roi = new System.Drawing.Rectangle(x, y, w, h);
                inputImage.ROI = roi;
                var tile = inputImage.Copy();
                inputImage.ROI = System.Drawing.Rectangle.Empty;

                // 应用直方图�衡化
                var equalizedTile = new Image<Gray, byte>(tile.Size);
                CvInvoke.EqualizeHist(tile, equalizedTile);

                // 应用�制（简化版本）
                var floatTile = tile.Convert<Gray, float>();
                var floatEqualized = equalizedTile.Convert<Gray, float>();
                var diff = floatEqualized - floatTile;
                var limited = floatTile + diff * Math.Min(clipLimit / 10.0, 1.0);
                var limitedByte = limited.Convert<Gray, byte>();

                // �制到结果图�
                result.ROI = roi;
                limitedByte.CopyTo(result);
                result.ROI = System.Drawing.Rectangle.Empty;

                tile.Dispose();
                equalizedTile.Dispose();
                floatTile.Dispose();
                floatEqualized.Dispose();
                diff.Dispose();
                limited.Dispose();
                limitedByte.Dispose();
            }
        }

        return result;
    }
}