关闭

java指纹识别+谷歌图片识别技术

标签: java指纹识别+谷歌图片识别技术
656人阅读 评论(0) 收藏 举报
分类:

转载自:http://blog.csdn.net/yjflinchong/article/details/7469213

java指纹识别+谷歌图片识别技术

前阵子在阮一峰的博客上看到了这篇《相似图片搜索原理》博客,就有一种冲动要将这些原理实现出来了。


写了图片识别的一个demo

提供源码下载,免费下载地址:http://download.csdn.net/detail/yjflinchong/4239243

去试试效果吧

要源码的,请留下邮箱。我尽量发到各位邮箱中。

本人三年JAVA开发,寻求牛人加入Q群53141769


Google "相似图片搜索":你可以用一张图片,搜索互联网上所有与它相似的图片。

打开Google图片搜索页面:


点击使用上传一张angelababy原图:


点击搜索后,Google将会找出与之相似的图片,图片相似度越高就越排在前面。如:


这种技术的原理是什么?计算机怎么知道两张图片相似呢?

根据Neal Krawetz博士的解释,实现相似图片搜素的关键技术叫做"感知哈希算法"(Perceptualhash algorithm),它的作用是对每张图片生成一个"指纹"(fingerprint)字符串,然后比较不同图片的指纹。结果越接近,就说明图片越相似。

 

以下是一个最简单的Java实现:

 

预处理:读取图片

  1. BufferedImage source = ImageHelper.readPNGImage(filename);// 读取文件  

第一步,缩小尺寸。

将图片缩小到8x8的尺寸,总共64个像素。这一步的作用是去除图片的细节,只保留结构、明暗等基本信息,摒弃不同尺寸、比例带来的图片差异。

  1. /** 
  2.      * 生成缩略图 <br/> 
  3.      * 保存:ImageIO.write(BufferedImage, imgType[jpg/png/...], File); 
  4.      *  
  5.      * @param source 
  6.      *            原图片 
  7.      * @param width 
  8.      *            缩略图宽 
  9.      * @param height 
  10.      *            缩略图高 
  11.      * @param b 
  12.      *            是否等比缩放 
  13.      * */  
  14.     public static BufferedImage thumb(BufferedImage source, int width,  
  15.             int height, boolean b) {  
  16.         // targetW,targetH分别表示目标长和宽  
  17.         int type = source.getType();  
  18.         BufferedImage target = null;  
  19.         double sx = (double) width / source.getWidth();  
  20.         double sy = (double) height / source.getHeight();  
  21.   
  22.         if (b) {  
  23.             if (sx > sy) {  
  24.                 sx = sy;  
  25.                 width = (int) (sx * source.getWidth());  
  26.             } else {  
  27.                 sy = sx;  
  28.                 height = (int) (sy * source.getHeight());  
  29.             }  
  30.         }  
  31.   
  32.         if (type == BufferedImage.TYPE_CUSTOM) { // handmade  
  33.             ColorModel cm = source.getColorModel();  
  34.             WritableRaster raster = cm.createCompatibleWritableRaster(width,  
  35.                     height);  
  36.             boolean alphaPremultiplied = cm.isAlphaPremultiplied();  
  37.             target = new BufferedImage(cm, raster, alphaPremultiplied, null);  
  38.         } else  
  39.             target = new BufferedImage(width, height, type);  
  40.         Graphics2D g = target.createGraphics();  
  41.         // smoother than exlax:  
  42.         g.setRenderingHint(RenderingHints.KEY_RENDERING,  
  43.                 RenderingHints.VALUE_RENDER_QUALITY);  
  44.         g.drawRenderedImage(source, AffineTransform.getScaleInstance(sx, sy));  
  45.         g.dispose();  
  46.         return target;  
  47.     }  



第二步,简化色彩。

将缩小后的图片,转为64级灰度。也就是说,所有像素点总共只有64种颜色。

  1. // 第二步,简化色彩。  
  2.         // 将缩小后的图片,转为64级灰度。也就是说,所有像素点总共只有64种颜色。  
  3.         int[] pixels = new int[width * height];  
  4.         for (int i = 0; i < width; i++) {  
  5.             for (int j = 0; j < height; j++) {  
  6.                 pixels[i * height + j] = ImageHelper.rgbToGray(thumb.getRGB(i, j));  
  7.             }  
  8.         }  



第三步,计算平均值。

计算所有64个像素的灰度平均值。

  1. // 第三步,计算平均值。  
  2.     // 计算所有64个像素的灰度平均值。  
  3.     int avgPixel = ImageHelper.average(pixels);  



第四步,比较像素的灰度。

将每个像素的灰度,与平均值进行比较。大于或等于平均值,记为1;小于平均值,记为0。

  1. // 第四步,比较像素的灰度。  
  2.         // 将每个像素的灰度,与平均值进行比较。大于或等于平均值,记为1;小于平均值,记为0。  
  3.         int[] comps = new int[width * height];  
  4.         for (int i = 0; i < comps.length; i++) {  
  5.             if (pixels[i] >= avgPixel) {  
  6.                 comps[i] = 1;  
  7.             } else {  
  8.                 comps[i] = 0;  
  9.             }  
  10.         }  



第五步,计算哈希值。

将上一步的比较结果,组合在一起,就构成了一个64位的整数,这就是这张图片的指纹。组合的次序并不重要,只要保证所有图片都采用同样次序就行了。

  1. // 第五步,计算哈希值。  
  2.         // 将上一步的比较结果,组合在一起,就构成了一个64位的整数,这就是这张图片的指纹。组合的次序并不重要,只要保证所有图片都采用同样次序就行了。  
  3.         StringBuffer hashCode = new StringBuffer();  
  4.         for (int i = 0; i < comps.length; i+= 4) {  
  5.             int result = comps[i] * (int) Math.pow(23) + comps[i + 1] * (int) Math.pow(22) + comps[i + 2] * (int) Math.pow(21) + comps[i + 2];  
  6.             hashCode.append(binaryToHex(result));  
  7.         }  



得到指纹以后,就可以对比不同的图片,看看64位中有多少位是不一样的。在理论上,这等同于计算"汉明距离"(Hammingdistance)。如果不相同的数据位不超过5,就说明两张图片很相似;如果大于10,就说明这是两张不同的图片。

  1. for (int i = 0; i < hashCodes.size(); i++)  
  2.        {  
  3.         int difference = hammingDistance(sourceHashCode, hashCodes.get(i));  
  4.         System.out.print("汉明距离:"+difference+"     ");  
  5.         if(difference==0){  
  6.             System.out.println("source.jpg图片跟example"+(i+1)+".jpg一样");  
  7.         }else if(difference<=5){  
  8.             System.out.println("source.jpg图片跟example"+(i+1)+".jpg非常相似");  
  9.         }else if(difference<=10){  
  10.             System.out.println("source.jpg图片跟example"+(i+1)+".jpg有点相似");  
  11.         }else if(difference>10){  
  12.             System.out.println("source.jpg图片跟example"+(i+1)+".jpg完全不一样");  
  13.         }  
  14.        }  



你可以将几张图片放在一起,也计算出他们的汉明距离对比,就可以看看两张图片是否相似。

 

这种算法的优点是简单快速,不受图片大小缩放的影响,缺点是图片的内容不能变更。如果在图片上加几个文字,它就认不出来了。所以,它的最佳用途是根据缩略图,找出原图。

 

实际应用中,往往采用更强大的pHash算法和SIFT算法,它们能够识别图片的变形。只要变形程度不超过25%,它们就能匹配原图。这些算法虽然更复杂,但是原理与上面的简便算法是一样的,就是先将图片转化成Hash字符串,然后再进行比较。


以上内容大部分直接从阮一峰的网站上复制过来,想看原著的童鞋可以去在最上面的链接点击进去看。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:87197次
    • 积分:1405
    • 等级:
    • 排名:千里之外
    • 原创:31篇
    • 转载:166篇
    • 译文:0篇
    • 评论:8条
    最新评论