Java实现图像美颜效果

最新推荐文章于 2024-04-22 11:14:16 发布

Benjamin.

最新推荐文章于 2024-04-22 11:14:16 发布

阅读量1.8k

点赞数 6

分类专栏：代码集文章标签： java

本文链接：https://blog.csdn.net/qq_44836027/article/details/108125014

版权

代码集专栏收录该内容

3 篇文章 0 订阅

订阅专栏

图像原理

对计算机中的一张图片，我们可以将其看成一个宽w*高h的二维数组，即一张图片=int [w][h]，在这个二维数组中每个位置对应着一个int值，它们就是这张图片中每个点的像素值，那么我们要对这张图像做处理，实际上就是对这张图片的二维数组进行操作。下面我们首先来实现将原图显示在界面上吧。

实现原图显示

在这里插入图片描述

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

public class Image {

	public static void main(String[] args) {
		Image image=new Image();
		image.UI();

	}
	
	public void UI() {
		JFrame frame=new JFrame("图像处理");
		frame.setSize(1000,1000);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		frame.setVisible(true);
		//获取界面的画笔，要放在界面可视之后
		Graphics g=frame.getGraphics();
		showImage(g);
	}
	
	public void showImage(Graphics g) {
		//这里我写的是我放在同包下的一张图片的路径
		//小伙伴们可以根据实际修改
		File file=new File("src/img/1.jpg");
		BufferedImage bi=null;
		try {
			bi=ImageIO.read(file);
		} catch (Exception e) {
			e.printStackTrace();
		}
		int w=bi.getWidth();
		int h=bi.getHeight();
		int [][]data=new int[w][h];
		for(int i=0;i<data.length;i++) {
			for(int j=0;j<data[i].length;j++) {
				int v=bi.getRGB(i, j);
				data[i][j]=v;
				Color color=new Color(v);
				g.setColor(color);
				g.drawLine(i, j, i, j);
			}
		}
	}

}

图像基本效果

下面的图像效果介绍，我们尝试去修改上面showImage方法中的循环就可以实现不同的效果啦。

灰度1

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				int change = (r + gr + b) / 3;
				c = new Color(change, change, change);
				g.setColor(c);
				g.drawLine(i, j, i, j);
			}
		}

灰度2

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				int change = (Math.max(r, Math.max(gr, b)) + Math.min(r, Math.min(gr, b))) / 2;
				c = new Color(change, change, change);
				bg.setColor(c);
				bg.drawLine(i, j, i, j);
			}
		}

珠纹化

在这里插入图片描述

for (int i = 0; i < data.length; i += 5) {
			for (int j = 0; j < data[i].length; j += 5) {
				Color c = new Color(data[i][j]);
				g.setColor(c);
				g.fillOval(i, j, 4, 4);
			}
		}

油画

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				g.setColor(c);
				Random rand = new Random();
				int k = rand.nextInt(10) + 1;
				g.fillOval(i, j, k, k);
			}
		}

熔铸滤镜

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				r = r * 128 / (gr + b + 1);
				gr = gr * 128 / (r + b + 1);
				b = b * 128 / (r + gr + 1);
				if (r > 255)
					r = c.getRed();
				if (gr > 255)
					gr = c.getGreen();
				if (b > 255)
					b = c.getBlue();
				c = new Color(r, gr, b);
				g.setColor(c);
				g.drawLine(i, j, i, j);
			}
		}

去色滤镜

这个效果还不是很理想，如果要做得强大的话，还是要花费时间去做的。
在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int gr = c.getGreen();
				if (gr < 52) {
					g.setColor(c);
					g.drawLine(i, j, i, j);
				}
			}
		}

马赛克滤镜

在这里插入图片描述

for (int i = 0; i < data.length; i += 5) {
			for (int j = 0; j < data[i].length; j += 5) {
				Color c = new Color(data[i][j]);
				g.setColor(c);
				g.fillRect(i, j, 8, 8);
			}
		}

连环画滤镜

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				r = Math.abs(gr - b + gr + r) * r / 256;
				gr = Math.abs(b - gr + b + r) * r / 256;
				b = Math.abs(b - gr + b + r) * gr / 256;
				if (r < 0 || r > 255)
					r = c.getRed();
				if (gr < 0 || gr > 255)
					gr = c.getGreen();
				if (b < 0 || b > 255)
					b = c.getBlue();
				c = new Color(r, gr, b);
				g.setColor(c);
				g.drawLine(i, j, i, j);
			}
		}

怀旧滤镜

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				// 处理溢出
				r = (int) (0.393 * r + 0.769 * gr + 0.189 * b);
				gr = (int) (0.349 * r + 0.686 * gr + 0.168 * b);
				b = (int) (0.272 * r + 0.534 * gr + 0.131 * b);
				if (r > 255)
					r = c.getRed();
				if (gr > 255)
					gr = c.getGreen();
				if (b > 255)
					b = c.getBlue();
				c = new Color(r, gr, b);
				g.setColor(c);
				g.drawLine(i, j, i, j);
			}
		}

黑白滤镜

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				int val = (r + gr + b) / 3;
				if (val > 80) {
					g.setColor(Color.white);
				} else {
					g.setColor(Color.black);
				}
				g.drawLine(i, j, i, j);
			}
		}

褐色滤镜

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				r = (int) (r * 0.393 + gr * 0.769 + b * 0.189);
				gr = (int) (r * 0.349 + gr * 0.686 + b * 0.168);
				b = (int) (r * 0.272 + gr * 0.534 + b * 0.131);
				if (r < 0 || r > 255)
					r = c.getRed();
				if (gr < 0 || gr > 255)
					gr = c.getGreen();
				if (b < 0 || b > 255)
					b = c.getBlue();
				c = new Color(r, gr, b);
				g.setColor(c);
				g.drawLine(i, j, i, j);
			}
		}

图片合并

在这里插入图片描述

	public void showImage(Graphics g) {
		// 选取两张照片
		File file1 = new File("src/img/1.jpg");
		File file2 = new File("src/img/2.jpg");
		BufferedImage bi = null;
		BufferedImage bii = null;
		try {
			bi = ImageIO.read(file1);
			bii = ImageIO.read(file2);
		} catch (Exception e) {
			e.printStackTrace();
		}
		// 取其宽高的最小值，防止数组越界
		int w = Math.min(bi.getWidth(), bii.getWidth());
		int h = Math.min(bi.getHeight(), bii.getHeight());
		// 创建一块与打开的图片一样大小的缓冲区
		bi_img = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
		// 获取缓冲区的画笔
		bg = bi_img.getGraphics();

		for (int i = 0; i < w; i++) {
			for (int j = 0; j < h; j++) {
				int v1 = bi.getRGB(i, j);
				int v2 = bii.getRGB(i, j);
	
				Color color1 = new Color(v1);
				Color color2=new Color(v2);
				// 在缓冲区中绘制图像的每个像素点
				int r=(int)(color1.getRed()*0.7+color2.getRed()*0.3);
				int gr=(int)(color1.getGreen()*0.3+color2.getGreen()*0.7);
				int b=(int)(color1.getBlue()*0.3+color2.getBlue()*0.7);
				Color color=new Color(r,gr,b);
				bg.setColor(color);
				bg.drawLine(i, j, i, j);
			}
		}
		// 缓冲区绘制完成后，用界面的画笔一次性将图像画出来
		g.drawImage(bi_img, 0, 0, bi_img.getWidth(), bi_img.getHeight(), null);
	}

负片

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(-data[i][j]);
				g.setColor(c);
				g.drawLine(i, j, i, j);
			}
		}

反向滤镜

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				r = 255 - r;
				gr = 255 - gr;
				b = 255 - b;
				c = new Color(r, gr, b);
				g.setColor(c);
				g.drawLine(i, j, i, j);
			}
		}

冰冻滤镜

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color c = new Color(data[i][j]);
				int r = c.getRed();
				int gr = c.getGreen();
				int b = c.getBlue();
				r = (r - gr - b) * 3 / 2;
				gr = (gr - r - b) * 3 / 2;
				b = (b - r - gr) * 3 / 2;
				if (r < 0 || r > 255)
					r = c.getRed();
				if (gr < 0 || gr > 255)
					gr = c.getGreen();
				if (b < 0 || b > 255)
					b = c.getBlue();
				c = new Color(r, gr, b);
				g.setColor(c);
				g.drawLine(i, j, i, j);
			}
		}

单色滤镜

在这里插入图片描述

红色

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color color = new Color(data[i][j]);
				int r = color.getRed();
				color = new Color(r, 0, 0);
				g.setColor(color);
				g.drawLine(i, j, i, j);
			}
		}

绿色

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color color = new Color(data[i][j]);
				int gr = color.getGreen();
				color = new Color(0, gr, 0);
				g.setColor(color);
				g.drawLine(i, j, i, j);
			}
		}

蓝色

在这里插入图片描述

for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[i].length; j++) {
				Color color = new Color(data[i][j]);
				int b = color.getBlue();
				color = new Color(0, 0, b);
				g.setColor(color);
				g.drawLine(i, j, i, j);
			}
		}

优化图像显示

图像缓冲区

计算机当中设备的速度大体上可以分为CPU、内存、IO设备三类（其实CPU与内存之间还有cache，但在这里并不影响解释这个问题），它们的速度由快到慢，也就是说IO设备在计算机中属于低速设备，与IO设备进行交互的话将会花费大量时间。而我们上面的写法都是将图像中的每个像素点依次去画在界面上，当图像过大的时候，显示在界面上就会需要等待一定的响应时间。但是现在我们首先在缓冲区中将图像绘制下来，在缓冲区中图像绘制完成以后，再一次性将图像在界面上画出来就好了，那么原来需要与IO设备交互w*h次，现在就只需要交互一次就够了，性能上就会有显著提升。我们还是以显示原图为例来演示缓冲区的使用。

使用缓冲区显示原图

	public void showImage(Graphics g) {
		//这里我写的是我放在同包下的一张图片的路径
		//小伙伴们可以根据实际修改
		File file=new File("src/img/1.jpg");
		BufferedImage bi=null;	
		try {
			bi=ImageIO.read(file);
		} catch (Exception e) {
			e.printStackTrace();
		}
		int w=bi.getWidth();
		int h=bi.getHeight();
		//创建一块与打开的图片一样大小的缓冲区
		BufferedImage bi_img=new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
		//获取缓冲区的画笔
		Graphics bg=bi_img.getGraphics();
		int [][]data=new int[w][h];
		for(int i=0;i<data.length;i++) {
			for(int j=0;j<data[i].length;j++) {
				int v=bi.getRGB(i, j);
				data[i][j]=v;
				Color color=new Color(v);
				//在缓冲区中绘制图像的每个像素点
				bg.setColor(color);
				bg.drawLine(i, j, i, j);
			}
		}
		//缓冲区绘制完成后，用界面的画笔一次性将图像画出来
		g.drawImage(bi_img, 0, 0, bi_img.getWidth(), bi_img.getHeight(), null);
	}

文件选择器

我们的代码写的图片路径都是直接固定的，那在不同的电脑上可能不会存在这样的路径或者图片，那么我们这时候可以提供一个对话框来供用户选择图片，然后对选择的图片做处理这样子。

文件选择器代码示例

我们通过下面的测试openFile方法已经可以成功返回我们在电脑上选择图片的绝对路径，那么我们只需要对上面的showImage方法的参数添加一个String类的参数，然后将new File的路径改成这个String类的参数就可以了。

public class Image {

	public static void main(String[] args) {
		Image image=new Image();
        System.out.println(image.openFile());
	}
	
	public String openFile() {
		JFileChooser chooser=new JFileChooser();
		// 文件选择器添加过滤
		FileNameExtensionFilter filter=new FileNameExtensionFilter("Image files", "jpg");
		chooser.setFileFilter(filter);
		// 显示（打开文件）的选择器
		int returnVal=chooser.showOpenDialog(null);
		// 判断返回值
		if(returnVal==JFileChooser.APPROVE_OPTION) {
			// 获取选择的文件
			File file=chooser.getSelectedFile();
			// 返回文件的绝对路径
			return file.getAbsolutePath();
		}
		// 没有选择文件的情况
		return "";
	}

图像重绘

最后的一个小优化就是，当我们拖动界面或者将窗体改变大小时，界面上的图像就会消失，那么这时候我们就要继承JFrame并且重写paint方法，让窗体发生改变时，我们的界面重新绘制图像。paint方法并不需要我们定义何时调用，我们只需要在里面写代码规定窗体改变时（会自动调用paint方法）需要重绘的内容即可。所以我们的UI方法也有些许改变，而且为了方便我的重绘操作，我将缓冲区与缓冲区的画笔设置成了全局的变量。所以，我这里就再贴了一次有点相似的代码。

图像重绘代码示例

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

public class Image extends JFrame{

	BufferedImage bi_img=null;
	Graphics bg=null;
	
	public static void main(String[] args) {
		Image image=new Image();
		image.UI();

	}
	
	public void UI() {
		this.setTitle("图像处理");
		this.setSize(1000,1000);
		this.setLocationRelativeTo(null);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		this.setVisible(true);
		//获取界面的画笔，要放在界面可视之后
		Graphics g=this.getGraphics();
		showImage(g);
	}
	
	public void showImage(Graphics g) {
		//这里我写的是我放在同包下的一张图片的路径
		//小伙伴们可以根据实际修改
		File file=new File("src/img/1.jpg");
		BufferedImage bi=null;	
		try {
			bi=ImageIO.read(file);
		} catch (Exception e) {
			e.printStackTrace();
		}
		int w=bi.getWidth();
		int h=bi.getHeight();
		//创建一块与打开的图片一样大小的缓冲区
		bi_img=new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
		//获取缓冲区的画笔
		bg=bi_img.getGraphics();
		int [][]data=new int[w][h];
		for(int i=0;i<data.length;i++) {
			for(int j=0;j<data[i].length;j++) {
				int v=bi.getRGB(i, j);
				data[i][j]=v;
				Color color=new Color(v);
				//在缓冲区中绘制图像的每个像素点
				bg.setColor(color);
				bg.drawLine(i, j, i, j);
			}
		}
		//缓冲区绘制完成后，用界面的画笔一次性将图像画出来
		g.drawImage(bi_img, 0, 0, bi_img.getWidth(), bi_img.getHeight(), null);
	}
	
	public void paint(Graphics g) {
		super.paint(g);
		if(bi_img!=null)g.drawImage(bi_img, 0, 0, bi_img.getWidth(), bi_img.getHeight(), null);
	}

}

Benjamin.

关注

6
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
Java实现图像美颜效果

图像原理对计算机中的一张图片，我们可以将其看成一个宽w*高h的二维数组，即一张图片=int [w][h]，在这个二维数组中每个位置对应着一个int值，它们就是这张图片中每个点的像素值，那么我们要对这张图像做处理，实际上就是对这张图片的二维数组进行操作。下面我们首先来实现将原图显示在界面上吧。实现原图显示import java.awt.Color;import java.awt.Graphics;import java.awt.image.BufferedImage;import java.io
复制链接

扫一扫