如何用Java案例实现图片滤镜？

wen java案例 2026-06-17 247

本文目录导读：

如何用Java案例实现图片滤镜？

基础框架实现
滤镜算法实现
独立命令行版本
滤镜链式调用实现

我来提供一个完整的Java图片滤镜实现案例,包含多种滤镜效果。

基础框架实现

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class ImageFilterDemo extends JFrame {
    private BufferedImage originalImage;
    private BufferedImage processedImage;
    private JLabel imageLabel;
    public ImageFilterDemo() {
        setTitle("图片滤镜演示");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());
        // 创建按钮面板
        JPanel buttonPanel = new JPanel();
        addFilterButtons(buttonPanel);
        // 图片显示区域
        imageLabel = new JLabel();
        imageLabel.setHorizontalAlignment(JLabel.CENTER);
        add(buttonPanel, BorderLayout.NORTH);
        add(new JScrollPane(imageLabel), BorderLayout.CENTER);
        setSize(800, 600);
        setLocationRelativeTo(null);
    }
    private void addFilterButtons(JPanel panel) {
        String[] filterNames = {"原图", "灰度", "反色", "模糊", "锐化", "浮雕", "马赛克"};
        for (String name : filterNames) {
            JButton button = new JButton(name);
            button.addActionListener(e -> applyFilter(name));
            panel.add(button);
        }
    }
    private void applyFilter(String filterName) {
        if (originalImage == null) return;
        processedImage = new BufferedImage(
            originalImage.getWidth(),
            originalImage.getHeight(),
            BufferedImage.TYPE_INT_RGB
        );
        switch (filterName) {
            case "灰度":
                applyGrayscale();
                break;
            case "反色":
                applyInvert();
                break;
            case "模糊":
                applyBlur();
                break;
            case "锐化":
                applySharpen();
                break;
            case "浮雕":
                applyEmboss();
                break;
            case "马赛克":
                applyMosaic();
                break;
            default:
                processedImage = originalImage;
        }
        displayImage(processedImage);
    }
    // 显示图片
    private void displayImage(BufferedImage image) {
        ImageIcon icon = new ImageIcon(image);
        imageLabel.setIcon(icon);
        revalidate();
        repaint();
    }
    // 加载图片
    public void loadImage(String path) {
        try {
            originalImage = ImageIO.read(new File(path));
            processedImage = originalImage;
            displayImage(originalImage);
        } catch (IOException e) {
            JOptionPane.showMessageDialog(this, "加载图片失败: " + e.getMessage());
        }
    }
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            ImageFilterDemo demo = new ImageFilterDemo();
            demo.setVisible(true);
            // 使用默认图片或从参数读取
            demo.loadImage(args.length > 0 ? args[0] : "test.jpg");
        });
    }
}

滤镜算法实现

// 灰度滤镜
private void applyGrayscale() {
    for (int y = 0; y < originalImage.getHeight(); y++) {
        for (int x = 0; x < originalImage.getWidth(); x++) {
            int rgb = originalImage.getRGB(x, y);
            Color color = new Color(rgb);
            // 加权平均法计算灰度值
            int gray = (int)(0.299 * color.getRed() + 
                            0.587 * color.getGreen() + 
                            0.114 * color.getBlue());
            Color grayColor = new Color(gray, gray, gray);
            processedImage.setRGB(x, y, grayColor.getRGB());
        }
    }
}
// 反色滤镜
private void applyInvert() {
    for (int y = 0; y < originalImage.getHeight(); y++) {
        for (int x = 0; x < originalImage.getWidth(); x++) {
            int rgb = originalImage.getRGB(x, y);
            Color color = new Color(rgb);
            Color inverted = new Color(
                255 - color.getRed(),
                255 - color.getGreen(),
                255 - color.getBlue()
            );
            processedImage.setRGB(x, y, inverted.getRGB());
        }
    }
}
// 模糊滤镜（均值模糊）
private void applyBlur() {
    int blurRadius = 3;
    int size = blurRadius * 2 + 1;
    float[] kernel = new float[size * size];
    float weight = 1.0f / (size * size);
    // 初始化卷积核
    for (int i = 0; i < kernel.length; i++) {
        kernel[i] = weight;
    }
    applyConvolution(kernel, blurRadius);
}
// 锐化滤镜
private void applySharpen() {
    float[] kernel = {
        0, -1, 0,
        -1, 5, -1,
        0, -1, 0
    };
    applyConvolution(kernel, 1);
}
// 浮雕滤镜
private void applyEmboss() {
    float[] kernel = {
        -2, -1, 0,
        -1, 1, 1,
        0, 1, 2
    };
    applyConvolution(kernel, 1);
}
// 通用的卷积操作
private void applyConvolution(float[] kernel, int radius) {
    int width = originalImage.getWidth();
    int height = originalImage.getHeight();
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            float rSum = 0, gSum = 0, bSum = 0;
            // 卷积计算
            for (int ky = -radius; ky <= radius; ky++) {
                for (int kx = -radius; kx <= radius; kx++) {
                    int px = Math.min(Math.max(x + kx, 0), width - 1);
                    int py = Math.min(Math.max(y + ky, 0), height - 1);
                    Color pixel = new Color(originalImage.getRGB(px, py));
                    float weight = kernel[(ky + radius) * (2 * radius + 1) + (kx + radius)];
                    rSum += pixel.getRed() * weight;
                    gSum += pixel.getGreen() * weight;
                    bSum += pixel.getBlue() * weight;
                }
            }
            // 限制颜色值范围
            int r = clamp((int)rSum, 0, 255);
            int g = clamp((int)gSum, 0, 255);
            int b = clamp((int)bSum, 0, 255);
            processedImage.setRGB(x, y, new Color(r, g, b).getRGB());
        }
    }
}
// 马赛克滤镜
private void applyMosaic() {
    int mosaicSize = 10;
    int width = originalImage.getWidth();
    int height = originalImage.getHeight();
    for (int y = 0; y < height; y += mosaicSize) {
        for (int x = 0; x < width; x += mosaicSize) {
            // 获取马赛克块的采样颜色
            int sampleX = Math.min(x + mosaicSize / 2, width - 1);
            int sampleY = Math.min(y + mosaicSize / 2, height - 1);
            Color sampleColor = new Color(originalImage.getRGB(sampleX, sampleY));
            // 填充马赛克块
            for (int my = y; my < y + mosaicSize && my < height; my++) {
                for (int mx = x; mx < x + mosaicSize && mx < width; mx++) {
                    processedImage.setRGB(mx, my, sampleColor.getRGB());
                }
            }
        }
    }
}
// 辅助方法：限制值在范围内
private int clamp(int value, int min, int max) {
    return Math.max(min, Math.min(max, value));
}

独立命令行版本

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class ImageFilterCommandLine {
    public static void main(String[] args) {
        if (args.length < 3) {
            System.out.println("用法: java ImageFilterCommandLine <输入图片> <输出图片> <滤镜类型>");
            System.out.println("滤镜类型: grayscale, invert, blur, sharpen, emboss, mosaic");
            return;
        }
        try {
            BufferedImage image = ImageIO.read(new File(args[0]));
            BufferedImage result = applyFilter(image, args[2]);
            ImageIO.write(result, "jpg", new File(args[1]));
            System.out.println("处理完成！");
        } catch (IOException e) {
            System.err.println("错误: " + e.getMessage());
        }
    }
    public static BufferedImage applyFilter(BufferedImage source, String filterType) {
        BufferedImage result = new BufferedImage(
            source.getWidth(), 
            source.getHeight(), 
            BufferedImage.TYPE_INT_RGB
        );
        ImageFilterDemo filter = new ImageFilterDemo();
        switch (filterType.toLowerCase()) {
            case "grayscale":
                // 实现灰度滤镜逻辑
                for (int y = 0; y < source.getHeight(); y++) {
                    for (int x = 0; x < source.getWidth(); x++) {
                        Color c = new Color(source.getRGB(x, y));
                        int gray = (int)(0.299 * c.getRed() + 0.587 * c.getGreen() + 0.114 * c.getBlue());
                        result.setRGB(x, y, new Color(gray, gray, gray).getRGB());
                    }
                }
                break;
            case "invert":
                // 实现反色滤镜逻辑
                for (int y = 0; y < source.getHeight(); y++) {
                    for (int x = 0; x < source.getWidth(); x++) {
                        Color c = new Color(source.getRGB(x, y));
                        result.setRGB(x, y, new Color(
                            255 - c.getRed(),
                            255 - c.getGreen(),
                            255 - c.getBlue()
                        ).getRGB());
                    }
                }
                break;
            // 其他滤镜实现...
            default:
                return source;
        }
        return result;
    }
}

滤镜链式调用实现

import java.awt.image.BufferedImage;
import java.awt.Color;
public class ImageFilterChain {
    @FunctionalInterface
    interface Filter {
        BufferedImage apply(BufferedImage image);
    }
    public static BufferedImage applyFilters(BufferedImage image, Filter... filters) {
        BufferedImage result = image;
        for (Filter filter : filters) {
            result = filter.apply(result);
        }
        return result;
    }
    // 使用示例
    public static void main(String[] args) {
        BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB);
        Filter grayscale = img -> {
            BufferedImage out = new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_INT_RGB);
            for (int y = 0; y < img.getHeight(); y++) {
                for (int x = 0; x < img.getWidth(); x++) {
                    Color c = new Color(img.getRGB(x, y));
                    int gray = (int)(0.299 * c.getRed() + 0.587 * c.getGreen() + 0.114 * c.getBlue());
                    out.setRGB(x, y, new Color(gray, gray, gray).getRGB());
                }
            }
            return out;
        };
        Filter sharpen = img -> {
            // 锐化实现...
            return img;
        };
        // 链式调用多个滤镜
        BufferedImage result = applyFilters(image, grayscale, sharpen);
    }
}

这个实现包含：