Bitmap在C#中的图像去模糊技术

在C#中，可以使用Bitmap类来处理图像并实现去模糊技术。一种常见的去模糊技术是高斯模糊，可以通过应用高斯卷积核来实现。

以下是使用Bitmap类和高斯模糊技术来模糊图像的示例代码：

using System;
using System.Drawing;
using System.Drawing.Imaging;

public static class ImageBlur
{
    public static Bitmap ApplyGaussianBlur(Bitmap image, int radius)
    {
        Bitmap blurredImage = new Bitmap(image.Width, image.Height);

        // Create Gaussian kernel
        double[,] kernel = CreateGaussianKernel(radius);

        // Apply convolution to blur image
        BitmapData imageData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
        BitmapData blurredData = blurredImage.LockBits(new Rectangle(0, 0, blurredImage.Width, blurredImage.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

        unsafe
        {
            byte* imagePtr = (byte*)imageData.Scan0.ToPointer();
            byte* blurredPtr = (byte*)blurredData.Scan0.ToPointer();

            int imageStride = imageData.Stride;
            int blurredStride = blurredData.Stride;

            for (int y = 0; y < image.Height; y++)
            {
                for (int x = 0; x < image.Width; x++)
                {
                    double[] pixel = { 0, 0, 0, 0 };

                    for (int ky = -radius; ky <= radius; ky++)
                    {
                        for (int kx = -radius; kx <= radius; kx++)
                        {
                            int pixelX = Math.Max(0, Math.Min(image.Width - 1, x + kx));
                            int pixelY = Math.Max(0, Math.Min(image.Height - 1, y + ky));

                            byte* currentPtr = imagePtr + pixelY * imageStride + pixelX * 4;

                            for (int i = 0; i < 4; i++)
                            {
                                pixel[i] += currentPtr[i] * kernel[ky + radius, kx + radius];
                            }
                        }
                    }

                    byte* blurredCurrentPtr = blurredPtr + y * blurredStride + x * 4;

                    for (int i = 0; i < 4; i++)
                    {
                        blurredCurrentPtr[i] = (byte)pixel[i];
                    }
                }
            }
        }

        image.UnlockBits(imageData);
        blurredImage.UnlockBits(blurredData);

        return blurredImage;
    }

    private static double[,] CreateGaussianKernel(int radius)
    {
        double[,] kernel = new double[radius * 2 + 1, radius * 2 + 1];
        double sigma = radius / 3.0;
        double twoSigmaSquare = 2 * sigma * sigma;
        double constant = 1 / (Math.PI * twoSigmaSquare);

        for (int y = -radius; y <= radius; y++)
        {
            for (int x = -radius; x <= radius; x++)
            {
                double distance = x * x + y * y;
                kernel[y + radius, x + radius] = constant * Math.Exp(-distance / twoSigmaSquare);
            }
        }

        return kernel;
    }
}

在这段代码中，首先定义了一个ApplyGaussianBlur方法，该方法接受一个Bitmap对象和模糊半径作为输入，并返回一个模糊后的Bitmap对象。然后，创建了一个高斯卷积核的方法CreateGaussianKernel，用于生成高斯核矩阵。最后，在ApplyGaussianBlur方法中，对图像进行高斯模糊处理。

通过调用上述方法，可以对图像进行高斯模糊处理，从而实现图像去模糊的效果。