本文目录导读：
我来提供一个完整的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);
}
}
这个实现包含：
- GUI界面：方便交互和预览效果
- 多种滤镜：灰度、反色、模糊、锐化、浮雕、马赛克
- 通用卷积：可扩展的卷积核实现
- 链式调用：支持多个滤镜组合使用
- 独立命令行：便于批量处理
你可以根据需要添加更多滤镜效果，如边缘检测、油画效果、水彩效果等。
