设计高斯模糊算法的Java函数

高斯模糊是一种常用的图像处理算法，用于使图像变得模糊和平滑。下面我将为您设计一个实现高斯模糊算法的Java函数。

import java.awt.Color;
import java.awt.image.BufferedImage;

public class GaussianBlur {
    
    public static BufferedImage applyGaussianBlur(BufferedImage image, int radius, double sigma) {
        int width = image.getWidth();
        int height = image.getHeight();

        BufferedImage blurredImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        
        int size = radius * 2 + 1;
        double[][] kernel = generateGaussianKernel(size, sigma);
        
        // 遍历图像的每一个像素
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                double red = 0, green = 0, blue = 0, weightSum = 0;

                // 对于每一个像素，计算其在卷积核范围内的像素值
                for (int i = -radius; i <= radius; i++) {
                    for (int j = -radius; j <= radius; j++) {
                        if (x + i >= 0 && x + i < width && y + j >= 0 && y + j < height) {
                            Color pixelColor = new Color(image.getRGB(x + i, y + j));
                            double weight = kernel[i + radius][j + radius];
                            
                            red += pixelColor.getRed() * weight;
                            green += pixelColor.getGreen() * weight;
                            blue += pixelColor.getBlue() * weight;
                            
                            weightSum += weight;
                        }
                    }
                }

                // 根据卷积核内的像素值，计算模糊后的像素值
                int blurredRed = (int) (red / weightSum);
                int blurredGreen = (int) (green / weightSum);
                int blurredBlue = (int) (blue / weightSum);
                
                // 设置模糊后的像素值
                int blurredPixelColor = new Color(blurredRed, blurredGreen, blurredBlue).getRGB();
                blurredImage.setRGB(x, y, blurredPixelColor);
            }
        }

        return blurredImage;
    }
    
    private static double[][] generateGaussianKernel(int size, double sigma) {
        double[][] kernel = new double[size][size];

        double twoSigmaSquared = 2 * sigma * sigma;
        double sigmaRoot = Math.sqrt(twoSigmaSquared * Math.PI);
        double total = 0;

        // 生成高斯核
        for (int i = -size / 2; i <= size / 2; i++) {
            for (int j = -size / 2; j <= size / 2; j++) {
                double distance = i * i + j * j;
                double weight = Math.exp(-distance / twoSigmaSquared) / sigmaRoot;
                kernel[i + size / 2][j + size / 2] = weight;
                total += weight;
            }
        }

        // 标准化高斯核
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                kernel[i][j] /= total;
            }
        }
        
        return kernel;
    }
}

上述代码实现了高斯模糊算法的Java函数，通过调用 applyGaussianBlur 方法即可应用高斯模糊到一个给定的图像上。函数接受三个参数：image 是输入的 BufferedImage 对象，radius 是高斯卷积核的半径，决定了模糊的程度，sigma 是用于生成高斯卷积核的参数，决定了卷积核的形状。函数返回一个经过高斯模糊处理后的 BufferedImage 对象。

在函数内部，首先通过 generateGaussianKernel 方法生成高斯卷积核。然后，遍历输入图像的每一个像素，对于每一个像素，计算其在卷积核范围内的像素值，再根据卷积核内的像素值计算模糊后的像素值。最后，将计算得到的模糊后的像素值设置到一个新的 BufferedImage 对象中，并返回该对象。

通过调用该函数，可以方便地实现图像的高斯模糊效果。