疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java图片上查找图片算法


 

  之前用按键精灵写过一些游戏辅助,里面有个函数叫FindPic,就上在屏幕范围查找给定的一张图片,返回查找到的坐标位置。

  现在,Java来实现这个函数类似的功能。

  算法描述:

  屏幕截图,得到图A,(查找的目标图片为图B);

  遍历图A的像素点,根据图B的尺寸,得到图B四个角映射到图A上的四个点;

  得到的四个点与图B的四个角像素点的值比较。如果四个点一样,执行步骤4;否则,回到步骤2继续;

  进一步对比,将映射范围内的全部点与图B全部的点比较。如果全部一样,则说明图片已找到;否则,回到步骤2继续;

  这里,像素之间的比较是通过BufferedImage对象获取每个像素的RGB值来比较的。如下,将BufferedImage转换为int二维数组:

  1 /**

  2 * 根据BufferedImage获取图片RGB数组

  3 * @param bfImage

  4 * @return

  5 */

  6 public static int[][] getImageGRB(BufferedImage bfImage) {

  7 int width = bfImage.getWidth();

  8 int height = bfImage.getHeight();

  9 int[][] result = new int[height][width];

  10 for (int h = 0; h < height; h++) {

  11 for (int w = 0; w < width; w++) {

  12 //使用getRGB(w, h)获取该点的颜色值是ARGB,而在实际应用中使用的是RGB,所以需要将ARGB转化成RGB,即bufImg.getRGB(w, h) & 0xFFFFFF。

  13 result[h][w] = bfImage.getRGB(w, h) & 0xFFFFFF;

  14 }

  15 }

  16 return result;

  17 }

  比较两个像素点的RGB值是否相同,是通过异或操作比较的(据说比==效率更高),如果异或操作后得到的值为0,说明两个像素点的RGB一样,否则不一样。

  下面附上算法完整java代码:

  1 package com.jebysun.test.imagefind;

  2

  3 import java.awt.AWTException;

  4 import java.awt.Rectangle;

  5 import java.awt.Robot;

  6 import java.awt.Toolkit;

  7 import java.awt.image.BufferedImage;

  8 import java.io.File;

  9 import java.io.IOException;

  10

  11 import javax.imageio.ImageIO;

  12 /**

  13 * 屏幕上查找指定图片

  14 * @author Jeby Sun

  15 * @date 2014-09-13

  16 * @website http://www.jebysun.com

  17 */

  18 public class ImageFindDemo {

  19

  20 BufferedImage screenShotImage; //屏幕截图

  21 BufferedImage keyImage; //查找目标图片

  22

  23 int scrShotImgWidth; //屏幕截图宽度

  24 int scrShotImgHeight; //屏幕截图高度

  25

  26 int keyImgWidth; //查找目标图片宽度

  27 int keyImgHeight; //查找目标图片高度

  28

  29 int[][] screenShotImageRGBData; //屏幕截图RGB数据

  30 int[][] keyImageRGBData; //查找目标图片RGB数据

  31

  32 int[][][] findImgData; //查找结果,目标图标位于屏幕截图上的坐标数据

  33

  34

  35 public ImageFindDemo(String keyImagePath) {

  36 screenShotImage = this.getFullScreenShot();

  37 keyImage = this.getBfImageFromPath(keyImagePath);

  38 screenShotImageRGBData = this.getImageGRB(screenShotImage);

  39 keyImageRGBData = this.getImageGRB(keyImage);

  40 scrShotImgWidth = screenShotImage.getWidth();

  41 scrShotImgHeight = screenShotImage.getHeight();

  42 keyImgWidth = keyImage.getWidth();

  43 keyImgHeight = keyImage.getHeight();

  44

  45 //开始查找

  46 this.findImage();

  47

  48 }

  49

  50 /**

  51 * 全屏截图

  52 * @return 返回BufferedImage

  53 */

  54 public BufferedImage getFullScreenShot() {

  55 BufferedImage bfImage = null;

  56 int width = (int) Toolkit.getDefaultToolkit().getScreenSize().getWidth();

  57 int height = (int) Toolkit.getDefaultToolkit().getScreenSize().getHeight();

  58 try {

  59 Robot robot = new Robot();

  60 bfImage = robot.createScreenCapture(new Rectangle(0, 0, width, height));

  61 } catch (AWTException e) {

  62 e.printStackTrace();

  63 }

  64 return bfImage;

  65 }

  66

  67 /**

  68 * 从本地文件读取目标图片

  69 * @param keyImagePath - 图片绝对路径

  70 * @return 本地图片的BufferedImage对象

  71 */

  72 public BufferedImage getBfImageFromPath(String keyImagePath) {

  73 BufferedImage bfImage = null;

  74 try {

  75 bfImage = ImageIO.read(new File(keyImagePath));

  76 } catch (IOException e) {

  77 e.printStackTrace();

  78 }

  79 return bfImage;

  80 }

  81

  82 /**

  83 * 根据BufferedImage获取图片RGB数组

  84 * @param bfImage

  85 * @return

  86 */

  87 public int[][] getImageGRB(BufferedImage bfImage) {

  88 int width = bfImage.getWidth();

  89 int height = bfImage.getHeight();

  90 int[][] result = new int[height][width];

  91 for (int h = 0; h < height; h++) {

  92 for (int w = 0; w < width; w++) {

  93 //使用getRGB(w, h)获取该点的颜色值是ARGB,而在实际应用中使用的是RGB,所以需要将ARGB转化成RGB,即bufImg.getRGB(w, h) & 0xFFFFFF。

  94 result[h][w] = bfImage.getRGB(w, h) & 0xFFFFFF;

  95 }

  96 }

  97 return result;

  98 }

  99

  100

  101 /**

  102 * 查找图片

  103 */

  104 public void findImage() {

  105 findImgData = new int[keyImgHeight][keyImgWidth][2];

  106 //遍历屏幕截图像素点数据

  107 for(int y=0; y

  108 for(int x=0; x

  109 //根据目标图的尺寸,得到目标图四个角映射到屏幕截图上的四个点,

  110 //判断截图上对应的四个点与图B的四个角像素点的值是否相同,

  111 //如果相同就将屏幕截图上映射范围内的所有的点与目标图的所有的点进行比较。

  112 if((keyImageRGBData[0][0]^screenShotImageRGBData[y][x])==0

  113 && (keyImageRGBData[0][keyImgWidth-1]^screenShotImageRGBData[y][x+keyImgWidth-1])==0

  114 && (keyImageRGBData[keyImgHeight-1][keyImgWidth-1]^screenShotImageRGBData[y+keyImgHeight-1][x+keyImgWidth-1])==0

  115 && (keyImageRGBData[keyImgHeight-1][0]^screenShotImageRGBData[y+keyImgHeight-1][x])==0) {

  116

  117 boolean isFinded = isMatchAll(y, x);

  118 //如果比较结果完全相同,则说明图片找到,填充查找到的位置坐标数据到查找结果数组。

  119 if(isFinded) {

  120 for(int h=0; h

  121 for(int w=0; w

  122 findImgData[h][w][0] = y+h;

  123 findImgData[h][w][1] = x+w;

  124 }

  125 }

  126 return;

  127 }

  128 }

  129 }

  130 }

  131 }

  132

  133 /**

  134 * 判断屏幕截图上目标图映射范围内的全部点是否全部和小图的点一一对应。

  135 * @param y - 与目标图左上角像素点想匹配的屏幕截图y坐标

  136 * @param x - 与目标图左上角像素点想匹配的屏幕截图x坐标

  137 * @return

  138 */

  139 public boolean isMatchAll(int y, int x) {

  140 int biggerY = 0;

  141 int biggerX = 0;

  142 int xor = 0;

  143 for(int smallerY=0; smallerY

  144 biggerY = y+smallerY;

  145 for(int smallerX=0; smallerX

  146 biggerX = x+smallerX;

  147 if(biggerY>=scrShotImgHeight || biggerX>=scrShotImgWidth) {

  148 return false;

  149 }

  150 xor = keyImageRGBData[smallerY][smallerX]^screenShotImageRGBData[biggerY][biggerX];

  151 if(xor!=0) {

  152 return false;

  153 }

  154 }

  155 biggerX = x;

  156 }

  157 return true;

  158 }

  159

  160 /**

  161 * 输出查找到的坐标数据

  162 */

  163 private void printFindData() {

  164 for(int y=0; y

  165 for(int x=0; x

  166 System.out.print("("+this.findImgData[y][x][0]+", "+this.findImgData[y][x][1]+")");

  167 }

  168 System.out.println();

  169 }

  170 }

  171

  172

  173 public static void main(String[] args) {

  174 String keyImagePath = "D:/key.png";

  175 ImageFindDemo demo = new ImageFindDemo(keyImagePath);

  176 demo.printFindData();

  177 }

  178

  179 }

  这种算法是精确比较,只要有一个像素点有差异,就会找不到图片。当然,如果想指定一个比较的精确度,我也有个思路,就是在算法步骤4比较映射范围内全部像素点的时候做个统计,如果90%的点都相同,那就是说精确度是0.9。