SWT 遍历图片像素点并处理像素点

悠悠 2023-10-12 23:11 117阅读 0赞

1.图像原理

通常图像都是2D，对一副图像，可以看做其宽ｗ＊高ｈ的一个二维数组， 即 图像＝int[w][h]，在ｗ和ｈ位置的每一个 int 值，就是这个点的像素值。

图像处理的本质是：对代表图像二维数组中的值进行重新计算。

2.思路：

将一张图片转化成一个int型癿二维数组

对于每一个像素点大小和颜色进行计算达到图像处理的效果。

在画笔中设置好颜色，填充形状然后将新的图片画出。

3.实现效果

获取像素点方法，首先利用文件imageIO读取图片，然后根据图片长宽进行遍历得到每个像素点的颜色，最后return一个二维数组为处理做准备。

  1. /**
  2.  * 根据图片路径，获取该该图片的每个像素点并保存到对应的二维数组中
  3.  * @param path 图片路径
  4.  * @return 保存像素点的二维数组
  5.  */
  6.  public int[][] getImgPixel(String path){
  7.  File file = new File(path);
  8.  BufferedImage buffImg = null; //缓冲图片
  9.  try {
  10.   buffImg = ImageIO.read(file);
  11.  } catch (IOException e) {
  12.   e.printStackTrace();
  13.  }
  14.  int w = buffImg.getWidth();
  15.  int h = buffImg.getHeight();
  16.  //定义二维数组，保存像素点
  17.  int[][] pixelArray = new int[w][h];
  18.  //读取每个位置的像素点
  19.  for(int i=0;i<w;i++){
  20.   for(int j=0;j<h;j++){
  21.   int pixel = buffImg.getRGB(i, j); //获取每个位置像素值
  22.   pixelArray[i][j] = pixel;
  23.   }
  24.  }
  25.  return pixelArray;
  26.  }

原图

根据之前得到的二维数组进行遍历，然后使用Color对象的get方法得到图片颜色，最后再使用画笔画出图像。

  1. //原图
  2.  public void drawImg(String path, Graphics gr){
  3.    //得到图片路径
  4.  int[][] img = getImgPixel(path);
  5.  for(int i=0;i<img.length;i++){
  6.   for(int j=0;j<img[i].length;j++){
  7.   int pixel = img[i][j];
  8.   //原图颜色不变
  9.   Color c = new Color(pixel);
  10.    gr.setColor(c);
  11.    //使用rectangle填充每一个点
  12.    gr.fillRect(i, j, 1,1);
  13.   }
  14.  }
  15.  }

d4a8f60c03e032b3f96a50bab0269b61.jpeg

黑白

主要是寻找一个值作为黑白分界线。

  1. //黑白
  2.  public void drawBw(String path, Graphics gr){
  3.  int [][] img = getImgPixel(path);
  4.  // 此处buffG为存储图片做准备
  5.  buffG = new BufferedImage(img.length, img[0].length, 1);
  6.  Graphics buff=buffG.getGraphics();
  8.  for(int i=0; i<img.length; i++){
  9.   for(int j=0; j<img[i].length; j++){
  10.   int pixel =img[i][j];
  11.   Color c = new Color(pixel);
  12.   int r=c.getRed(); int g=c.getGreen(); int b=c.getBlue();
  13.   //将小于某一值的颜色作为界限区分黑白
  14.   if(b<100){
  15.    buff.setColor(Color.BLACK);
  16.   }else {
  17.    buff.setColor(Color.white);
  18.   }
  19.   buff.fillRect(i,j,3,3);
  20.   }
  21.  }
  22.  gr.drawImage(buffG,0,0,null);
  23.  }

cc29e322f8cd10959c22b4c9ad633ff2.jpeg

马赛克 ：

马赛克不用遍历每一个点，主要目的是将像素点模糊，所以可以在原来遍历的基础上i++变成i+10, 每10个像素点获取一个。 然后再将每个像素点放大相应的倍数。

  1. //马赛克实现
  2.  public void drawPixel(String path, Graphics gr){
  3.  int[][] pixelArray = getImgPixel(path);
  4.  buffG = new BufferedImage(pixelArray.length, pixelArray[0].length, 1);
  5.  Graphics buff=buffG.getGraphics();
  6.  //减少像素数量
  7.  for(int i=0;i<pixelArray.length;i+=10){
  8.   for(int j=0;j<pixelArray[0].length;j+=10){
  9.   int pixel = pixelArray[i][j];
  10.   Color color = new Color(pixel);
  11.   buff.setColor(color);
  12.   //放大像素点大小
  13.   buff.fillRect(i, j, 10, 10);
  14.   }
  15.  }
  16.  gr.drawImage(buffG,0,0,null);
  17.  }

0e637847b4036edac0a53781c5991184.jpeg

灰度图

主要取原图颜色RGP的平均值设置为新颜色画出。

  1. //灰度图实现
  2.  public void drawGrayScale(String path, Graphics gr){
  3.  int[][] img = getImgPixel(path);
  4.  buffG = new BufferedImage(img.length, img[0].length, 1);
  5.  Graphics buff=buffG.getGraphics();
  7.  for(int i=0; i<img.length;i++){
  8.   for(int j=0;j<img[i].length;j++) {
  9.   int pixel =img[i][j];
  10.   Color c = new Color (pixel);
  11.   // 取rgp平均值
  12.   int r = c.getRed();
  13.   int g = c.getGreen();
  14.   int b = c.getBlue();
  15.   int sum = (r+g+b)/3;
  16.   Color newc= new Color(sum,sum,sum);
  17.   buff.setColor(newc);
  18.   buff.fillRect(i,j,1,1);
  19.   }
  20.  }
  21.  gr.drawImage(buffG,0,0,null);
  22.  }

ffd4e46a8c67ce8ff429b5be32ab7190.jpeg

去背景

只画大于某一值的颜色，原图绿色比较多，所以对g进行比较。

  1. //去背景实现
  2.  public void drawRemoveBg(String path, Graphics gr){
  3.  int[][] img = getImgPixel(path);
  4.  buffG = new BufferedImage(img.length, img[0].length, 1);
  5.  Graphics buff=buffG.getGraphics();
  6.  for(int i=0;i<img.length;i++){
  7.   for(int j=0;j<img[i].length;j++){
  8.   int pixel = img[i][j];
  9.   Color c = new Color(pixel);
  10.   //去背景，只画大于某一值的颜色去背景效果
  11.   int r=c.getRed();int g=c.getGreen();int b=c.getBlue();
  12.   if(g>150){
  13.    Color nc=new Color(r,g,b);
  14.    buff.setColor(nc);
  15.    buff.fillRect(i, j, 1,1);
  16.   }
  17.   }
  18.  }
  19.  gr.drawImage(buffG,0,0,null);
  20.  }

d7fb4c30ac92199c95610b2bcf6fd3fd.jpeg

网格化

与马赛克有点类似，改变填充方法为原点

  1. //网格化实现
  2.  public void drawGrid(String path, Graphics gr){
  3.  int [][] img = getImgPixel(path);
  4.  buffG = new BufferedImage(img.length, img[0].length, 1);
  5.  Graphics buff=buffG.getGraphics();
  7.  //减少像素数量
  8.  for(int i=0;i<img.length;i+=10){
  9.   for(int j=0;j<img[i].length;j+=10){
  10.   int pixel = img[i][j];
  11.   Color c = new Color(pixel);
  12.   int r=c.getRed(); int g=c.getGreen(); int b=c.getBlue();
  13.   Color nc = new Color(r,g,b);
  14.   buff.setColor(nc);
  15.   //放大像素数量
  16.   buff.fillOval(i, j, 8,8 );
  17.   }
  18.  }
  19.  gr.drawImage(buffG,0,0,null);
  20.  }

0b91139d5ade683d333fc670b24e9a48.jpeg

油画

像素点数量不变，主要是填充随机大小癿色块。

  1. //油画效果
  2.  public void drawPainting(String path, Graphics gr){
  3.  int[][] img =getImgPixel(path);
  4.  buffG = new BufferedImage(img.length, img[0].length, 1);
  5.  Graphics buff=buffG.getGraphics();
  6.  for(int i=0; i<img.length; i++){
  7.   for(int j=0; j<img[i].length; j++){
  8.   int pixel = img[i][j];
  9.   Color c = new Color(pixel);
  10.   buff.setColor(c);
  11.   ///填充随机大小癿色块
  12.   Random random =new Random();
  13.   int r = random.nextInt(20)+5;
  14.   buff.fillOval(i,j,r,r);
  15.   }
  16.  }
  17.  gr.drawImage(buffG,0,0,null);
  18.  }

77ad497056bcc4b7f1df8bedf31d63ed.jpeg

双图合并

选取两张图片，然后从2张图片中获取其长和宽的最小值。之后以更小的图片为大小进行处理，主要对颜色进行透明处理才能更好地得到合并效果。

  1. //双图
  2.  public void drawDouble(String path1, String path2, Graphics gr ){
  4.  //选取a,b两张照片, 给颜色不同权值
  5.  int[][] img1=getImgPixel(path1);
  6.  int[][] img2=getImgPixel(path2);
  7.  // 取其宽高癿最小值，防数组越界
  8.  int w =Math.min(img1.length,img2.length);
  9.  int h =Math.min(img1[0].length, img2.length);
  10.  buffG = new BufferedImage(w,h, 1);
  11.  Graphics buff=buffG.getGraphics();
  12.  //更大的图片在前循环
  13.  for(int i=0; i<w; i+=1){
  14.   for(int j=0;j<h;j+=1){
  15.   Color c1 = new Color(img1[i][j]);
  16.   Color c2 = new Color(img2[i][j]);
  17.   //透明处理
  18.   int r=(int)(c1.getRed()*0.7+c2.getRed()*0.3);
  19.   int g=(int)(c1.getGreen()*0.3+c2.getGreen()*0.7);
  20.   int b=(int)(c1.getBlue()*0.3+c2.getBlue()*0.7);
  21.   Color cn = new Color(r,g,b);
  22.   buff.setColor(cn);
  23.   buff.drawLine(i,j,i,j);
  24.   }
  25.  }
  26.  gr.drawImage(buffG,0,0,null);
  27.  }

fd201f52b0b6a648cc09a280f6cc2bf0.jpeg

卷积效果

卷积算法，就是对图像二维数组，乘以不同的卷积核，以获取不同的特征图像。

对一幅图像的卷积处理有如下三步：

１．将原图像转为二维数组

２．寻找合适的卷积核二维数组（百度之）

３．按卷积规则，相乘这两个二维数组，得到第三个二维数组即是。

  1. //卷积核癿二维数组：边缘化
  2.  float[][] kArray= {
  3.   {-1,-1,-1,-1,-1},
  4.    {-1,-1,-1,-1,-1},{-1,-1,25,-1,-1},
  5.    {-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1}};
  6.  /**
  7.  * 卷积计算
  8.  * @param src :图片数组
  9.  * @param filter :卷积核数组
  10.  * @return 计算后癿数组
  11.  */
  12.  public static int[][] valide(int[][] src,float[][] filter){
  13.  int[][]tem = new int[filter.length][filter[0].length];
  14.  int valideWidth = src[0].length - filter[0].length+1;
  15.  int valideheight = src.length - filter.length+1;
  16.  int[][] valide = new int[valideheight][valideWidth];
  17.  for(int i=0;i<valideheight;i+=1){
  18.   for(int j=0;j<valideWidth;j+=1){
  19.   for(int y=0;y<filter.length;y++){
  20.    for(int z=0;z<filter[0].length;z++){
  21.    tem[y][z] =(int)((src[i+y][j+z])*(filter[y][z]));
  22.    }
  23.   }
  24.   int kk=0;
  25.   for(int y=0;y<filter.length;y++){
  26.    for(int z=0;z<filter[0].length;z++){
  27.    kk += tem[y][z];
  28.    }
  29.   }
  30.   if(kk<0)kk=0; if(kk>255)kk=255;
  31.   valide[i][j]=(byte)kk;
  32.   }
  33.  }
  34.  return valide;
  35.  }
  37. //卷积效果
  38.  public void drawJJ(String path){
  39.  DrawMouse mouse= new DrawMouse();
  40.  int[][] ia= mouse.getImgPixel(path);
  41.  ia=valide(ia, kArray);
  42.  buffG = new BufferedImage(ia.length, ia[0].length, 1);
  43.  Graphics buff=buffG.getGraphics();
  44.  for(int i=0;i<ia.length;i++){
  45.   for(int j=0;j<ia[0].length;j++){
  46.   int pixel = ia[i][j];
  47.   Color color = new Color(pixel);
  48.   buff.setColor(color);
  49.   //放大像素点大小 保证减少的倍数与放大倍数相同，否则是网格化
  50.   buff.fillRect(i, j, 10, 10);
  51.   }
  52.  }
  53.  //在界面上画出ia数组图像，即卷积结果：
  54.  gr.drawImage(buffG,0,0,null);
  55.  }

afdd6b475685b35fec6060c939416e6d.jpeg

4.关于重绘

jframe 类中的 repaint()方法： 我的理解当窗体尺寸发生变化或者已经移动到屏幕外时或者需要刷新一下界面，此时应该使用重绘。

16f8d02fcabed3da281c5d94c74fffd2.jpeg

比如，我的代码是使用了动作监听器，每次点击具体的图像效果或是打开某张图片，那么此时就需要添加重汇到动作监听器中。

5.图片打开

主要使用JfileChooser类中的showOpenDialog对图片进行选择，会弹出文件选择器挑选所要打开的图像，并且对文件后缀进行过滤，只使用jpg文件。

  1. public void openFile(){
  2.  JFileChooser jfc = new JFileChooser();
  3.  jfc.setAcceptAllFileFilterUsed(false);//取消显示所有文件过滤选项
  4.  //后缀名过滤器
  5.  FileNameExtensionFilter filter = new FileNameExtensionFilter("(*.jpg)", "jpg");
  6.  jfc.setFileFilter(filter);
  7.  jfc.setDialogTitle("打开文件");
  8.  jfc.showOpenDialog(null);
  9.  File file = jfc.getSelectedFile();
  10.  if(file!=null){
  11.   fPath=file.getPath();
  12.   System.out.print(fPath);
  13.   drawImg(fPath, gr);
  14.  }else {
  15.   System.out.println("未选择文件");
  16.  }
  17.  }

6.图片保存

对文件进行保存，之前画在画布上的图片都储存在 BufferedImage buffG里，此时使用JFileChooser类中的showSaveDialog方法，然后选择要保存的路径以及图片名字。

  1. public void saveFile(){
  2.  JFileChooser jfc = new JFileChooser();
  3.  //后缀名过滤器
  4.  FileNameExtensionFilter filter = new FileNameExtensionFilter(
  5.    "(*.jpg)", "jpg");
  6.  jfc.setFileFilter(filter);
  7.  jfc.setDialogTitle("保存文件");
  8.  jfc.showSaveDialog(null);
  9.  File file = jfc.getSelectedFile();
  10.  try {
  11.   ImageIO.write(buffG,"jpg", file);
  12.   System.out.print("保存成功" );
  13.  } catch (IOException ex) {
  14.   ex.printStackTrace();
  15.  }
  16.  }

4ded022dbc7a38056548bf743282f634.jpeg

参考文章

https://www.mianshigee.com/note/detail/19827oms/

发表评论

表情：
评论列表 （有 0 条评论，117人围观）

还没有评论，来说两句吧...

相关阅读

    相关 图片像素

    片是由一个个方快（像素点）组成。而计算机中，每种颜色均可由RGB三种颜色分量合成。 所以，对于计算机来说，每一个像素点，计算机存储的是RGB三种颜色的值。 对于8bi...

    柔光的暖阳◎柔光的暖阳◎/ 0 赞/ 185 阅读