高斯滤波自适应去噪代码java

### 回答1：
高斯滤波是一种常用的图像去噪方法，它通过对图像进行平滑处理来减少噪声。自适应高斯滤波是一种改进的高斯滤波方法，它通过动态调整滤波器的标准差来适应不同区域的噪声强度。下面是一个用Java实现的自适应高斯滤波的简单代码示例：

import java.awt.image.BufferedImage;

public class AdaptiveGaussianFilter {

    public static BufferedImage apply(BufferedImage image, int radius) {
        BufferedImage filteredImage = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());

        int imageSize = image.getWidth() * image.getHeight();
        int[] pixels = new int[imageSize];
        image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth());

        for (int y = 0; y < image.getHeight(); y++) {
            for (int x = 0; x < image.getWidth(); x++) {
                double sum = 0;
                double totalWeight = 0;

                for (int i = -radius; i <= radius; i++) {
                    for (int j = -radius; j <= radius; j++) {
                        int nx = x + i;
                        int ny = y + j;

                        if (nx >= 0 && nx < image.getWidth() && ny >= 0 && ny < image.getHeight()) {
                            int pixel = pixels[ny * image.getWidth() + nx];
                            double weight = gaussian(i, j, radius);
                            sum += weight * pixel;
                            totalWeight += weight;
                        }
                    }
                }

                int filteredPixel = (int) (sum / totalWeight);
                filteredImage.setRGB(x, y, filteredPixel);
            }
        }

        return filteredImage;
    }

    private static double gaussian(int x, int y, int radius) {
        double variance = radius / 2.0;
        double distanceSquared = x * x + y * y;
        return Math.exp(-distanceSquared / (2 * variance * variance)) / (2 * Math.PI * variance * variance);
    }
}

在该代码中，我们使用了一个双层循环来遍历图像的每个像素点。对于每个像素点，我们计算了以它为中心的一个正方形区域内所有像素的加权平均值作为该像素点的新值。

计算加权平均值时，我们使用了高斯函数来计算每个像素的权重。权重与距离成反比，距离越近的像素具有更高的权重。通过调整高斯函数的标准差，我们可以控制权重的分布情况，以适应不同区域的噪声强度。

最后，我们将计算得到的新像素值设置到滤波后的图像中，并返回滤波后的图像对象。

### 回答2：
高斯滤波是一种经典的图像处理方法，用于降低图像中的噪声。下面是一个使用Java语言实现的自适应高斯滤波的代码示例：

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

public class GaussianFilter {
    private static final int KERNEL_SIZE = 3;
    private static final double SIGMA = 1.4;

    public static BufferedImage apply(BufferedImage inputImage) {
        int width = inputImage.getWidth();
        int height = inputImage.getHeight();

        BufferedImage outputImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        // 定义高斯核
        double[][] kernel = createGaussianKernel(KERNEL_SIZE, SIGMA);

        // 遍历图像的每个像素
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                // 对每个像素应用高斯滤波
                outputImage.setRGB(x, y, applyGaussianFilter(inputImage, x, y, kernel).getRGB());
            }
        }

        return outputImage;
    }

    private static BufferedImage applyGaussianFilter(BufferedImage inputImage, int x, int y, double[][] kernel) {
        int kCenter = KERNEL_SIZE / 2;
        int width = inputImage.getWidth();
        int height = inputImage.getHeight();

        double r = 0, g = 0, b = 0;

        // 遍历高斯核
        for (int i = 0; i < KERNEL_SIZE; i++) {
            for (int j = 0; j < KERNEL_SIZE; j++) {
                int xOffset = x + i - kCenter;
                int yOffset = y + j - kCenter;

                // 边缘像素处理，超出图像范围用原像素值填充
                if (xOffset < 0 || xOffset >= width || yOffset < 0 || yOffset >= height) {
                    xOffset = x;
                    yOffset = y;
                }

                Color color = new Color(inputImage.getRGB(xOffset, yOffset));

                // 计算新的颜色值
                r += kernel[i][j] * color.getRed();
                g += kernel[i][j] * color.getGreen();
                b += kernel[i][j] * color.getBlue();
            }
        }

        // 确保颜色值在0-255之间
        r = Math.max(0, Math.min(255, r));
        g = Math.max(0, Math.min(255, g));
        b = Math.max(0, Math.min(255, b));

        return new Color((int) r, (int) g, (int) b).getRGB();
    }

    private static double[][] createGaussianKernel(int size, double sigma) {
        int kCenter = size / 2;
        double sum = 0.0;

        // 创建高斯核
        double[][] kernel = new double[size][size];
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                kernel[i][j] = Math.exp(-0.5 * (Math.pow((i - kCenter) / sigma, 2.0) + Math.pow((j - kCenter) / sigma, 2.0)))
                        / (2 * Math.PI * sigma * sigma);

                sum += kernel[i][j];
            }
        }

        // 归一化处理
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                kernel[i][j] /= sum;
            }
        }

        return kernel;
    }
}

以上代码实现了自适应高斯滤波的算法，在应用高斯滤波之前，首先创建了一个高斯核，然后对图像的每个像素应用高斯滤波。通过调整`KERNEL_SIZE`和`SIGMA`参数，可以控制滤波的大小和强度。最终返回处理后的图像。

### 回答3：
高斯滤波是一种常用的图像去噪方法，通过对图像的每个像素点及其邻域进行加权平均，可以减少图像中的噪声。自适应高斯滤波则是在进行加权平均时，根据每个像素点邻域的灰度值差异来动态调整权重，以更好地平衡保留图像细节和去除噪声的效果。

下面是一个使用Java编写的自适应高斯滤波的示例代码：

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

public class AdaptiveGaussianFilter {

    private static final int WINDOW_SIZE = 3; // 邻域窗口大小

    public static BufferedImage adaptiveGaussianFilter(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();

        BufferedImage filteredImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                Color pixelColor = new Color(image.getRGB(x, y));
                int red = pixelColor.getRed();
                int green = pixelColor.getGreen();
                int blue = pixelColor.getBlue();

                int[] neighbors = getNeighbors(image, x, y);
                int[] filteredValues = applyAdaptiveGaussian(neighbors, red, green, blue);

                int filteredRed = filteredValues[0];
                int filteredGreen = filteredValues[1];
                int filteredBlue = filteredValues[2];

                Color filteredColor = new Color(filteredRed, filteredGreen, filteredBlue);
                filteredImage.setRGB(x, y, filteredColor.getRGB());
            }
        }

        return filteredImage;
    }

    private static int[] getNeighbors(BufferedImage image, int x, int y) {
        int[] neighbors = new int[WINDOW_SIZE * WINDOW_SIZE];
        int index = 0;

        for (int i = -1; i <= 1; i++) {
            for (int j = -1; j <= 1; j++) {
                int neighborX = x + i;
                int neighborY = y + j;

                if (neighborX >= 0 && neighborX < image.getWidth()
                        && neighborY >= 0 && neighborY < image.getHeight()) {
                    Color neighborColor = new Color(image.getRGB(neighborX, neighborY));
                    int neighborGray = (neighborColor.getRed() + neighborColor.getGreen() + neighborColor.getBlue()) / 3;

                    neighbors[index] = neighborGray;
                } else {
                    neighbors[index] = 0; // 超出边界的像素置为0
                }

                index++;
            }
        }

        return neighbors;
    }

    private static int[] applyAdaptiveGaussian(int[] neighbors, int red, int green, int blue) {
        int[] filteredValues = new int[3];
        int centerGray = (red + green + blue) / 3;
        double totalWeight = 0;
        double filteredRed = 0;
        double filteredGreen = 0;
        double filteredBlue = 0;

        for (int neighborGray : neighbors) {
            double weight = Math.exp(-Math.pow((neighborGray - centerGray), 2) / (2 * Math.pow(20, 2))); // 根据差异计算权重
            totalWeight += weight;
            filteredRed += weight * red;
            filteredGreen += weight * green;
            filteredBlue += weight * blue;
        }

        filteredRed /= totalWeight;
        filteredGreen /= totalWeight;
        filteredBlue /= totalWeight;

        filteredValues[0] = (int) filteredRed;
        filteredValues[1] = (int) filteredGreen;
        filteredValues[2] = (int) filteredBlue;

        return filteredValues;
    }
}

上述代码实现了自适应高斯滤波的功能。代码中使用了Java的`BufferedImage`类来处理图像，通过遍历图像的每个像素点及其邻域，计算每个像素点的颜色值，并获取邻域像素点的灰度值。然后，利用灰度值的差异来计算每个像素点的权重，并对邻域像素点的颜色值进行加权平均，得到去噪后的像素点颜色值。

最后，返回经过自适应高斯滤波处理后的图像。