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

// ============================================================================
// Copyright © 2026 Hexagon Technology Center GmbH. All Rights Reserved.
// 文件� SharpenProcessor.cs
// �述: �化算�，用于增强图�边缘和细节
// 功能:
//   - 拉普拉斯�化
//   - ��化掩蔽（Unsharp Masking�
//   - �调节�化强�
//   - 支�多��化�
// 算法: 拉普拉斯算����化掩蔽
// 作� �伟 wei.lw.li@hexagon.com
// ============================================================================

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

namespace XP.ImageProcessing.Processors;

/// <summary>
/// �化算�
/// </summary>
public class SharpenProcessor : ImageProcessorBase
{
    private static readonly ILogger _logger = Log.ForContext<SharpenProcessor>();

    public SharpenProcessor()
    {
        Name = LocalizationHelper.GetString("SharpenProcessor_Name");
        Description = LocalizationHelper.GetString("SharpenProcessor_Description");
    }

    protected override void InitializeParameters()
    {
        Parameters.Add("Method", new ProcessorParameter(
            "Method",
            LocalizationHelper.GetString("SharpenProcessor_Method"),
            typeof(string),
            "Laplacian",
            null,
            null,
            LocalizationHelper.GetString("SharpenProcessor_Method_Desc"),
            new string[] { "Laplacian", "UnsharpMask" }));

        Parameters.Add("Strength", new ProcessorParameter(
            "Strength",
            LocalizationHelper.GetString("SharpenProcessor_Strength"),
            typeof(double),
            1.0,
            0.1,
            5.0,
            LocalizationHelper.GetString("SharpenProcessor_Strength_Desc")));

        Parameters.Add("KernelSize", new ProcessorParameter(
            "KernelSize",
            LocalizationHelper.GetString("SharpenProcessor_KernelSize"),
            typeof(int),
            3,
            1,
            15,
            LocalizationHelper.GetString("SharpenProcessor_KernelSize_Desc")));
        _logger.Debug("InitializeParameters");
    }

    public override Image<Gray, byte> Process(Image<Gray, byte> inputImage)
    {
        string method = GetParameter<string>("Method");
        double strength = GetParameter<double>("Strength");
        int kernelSize = GetParameter<int>("KernelSize");

        if (kernelSize % 2 == 0) kernelSize++;

        Image<Gray, byte> result;

        if (method == "UnsharpMask")
        {
            result = ApplyUnsharpMask(inputImage, kernelSize, strength);
        }
        else // Laplacian
        {
            result = ApplyLaplacianSharpening(inputImage, strength);
        }

        _logger.Debug("Process: Method = {Method}, Strength = {Strength}, KernelSize = {KernelSize}",
            method, strength, kernelSize);
        return result;
    }

    private Image<Gray, byte> ApplyLaplacianSharpening(Image<Gray, byte> inputImage, double strength)
    {
        // 计算拉普拉斯算�
        var laplacian = new Image<Gray, float>(inputImage.Size);
        CvInvoke.Laplacian(inputImage, laplacian, DepthType.Cv32F, 1);

        // 转�为字节类�
        var laplacianByte = laplacian.Convert<Gray, byte>();

        // 将拉普拉斯结果加到原图上进行�化
        var floatImage = inputImage.Convert<Gray, float>();
        var sharpened = floatImage + laplacian * strength;

        // �制范围并转�回字节类型
        var result = sharpened.Convert<Gray, byte>();

        laplacian.Dispose();
        laplacianByte.Dispose();
        floatImage.Dispose();
        sharpened.Dispose();

        return result;
    }

    private Image<Gray, byte> ApplyUnsharpMask(Image<Gray, byte> inputImage, int kernelSize, double strength)
    {
        // 创建模糊图�
        var blurred = new Image<Gray, byte>(inputImage.Size);
        CvInvoke.GaussianBlur(inputImage, blurred,
            new System.Drawing.Size(kernelSize, kernelSize), 0);

        // 计算差异（细节）
        var floatInput = inputImage.Convert<Gray, float>();
        var floatBlurred = blurred.Convert<Gray, float>();
        var detail = floatInput - floatBlurred;

        // 将细节加回原�
        var sharpened = floatInput + detail * strength;

        // 转�回字节类�
        var result = sharpened.Convert<Gray, byte>();

        blurred.Dispose();
        floatInput.Dispose();
        floatBlurred.Dispose();
        detail.Dispose();
        sharpened.Dispose();

        return result;
    }
}