java指纹识别以及谷歌图片识别技术源码

本文实例为大家分享了java指纹识别和图片识别源代码，供大家参考，具体内容如下

主类： 

import java.awt.image.bufferedimage;
import java.util.arraylist;
import java.util.list;

public class similarimagesearch {

  /**
   * @param args
   */
  public static void main(string[] args) {
    list<string> hashcodes = new arraylist<string>();
    
    string filename = imagehelper.path + "\\images\\";
    string hashcode = null;
    
    for (int i = 0; i < 6; i++)
    {
      hashcode = producefingerprint(filename + "example" + (i + 1) + ".jpg");
      hashcodes.add(hashcode);
    }    
    system.out.println("resources: ");
    system.out.println(hashcodes);
    system.out.println();
    
    string sourcehashcode = producefingerprint(filename + "source.jpg");
    system.out.println("source: ");
    system.out.println(sourcehashcode);
    system.out.println();
    
    for (int i = 0; i < hashcodes.size(); i++)
    {
      int difference = hammingdistance(sourcehashcode, hashcodes.get(i));
      system.out.print("汉明距离:"+difference+"   ");
      if(difference==0){
        system.out.println("source.jpg图片跟example"+(i+1)+".jpg一样");
      }else if(difference<=5){
        system.out.println("source.jpg图片跟example"+(i+1)+".jpg非常相似");
      }else if(difference<=10){
        system.out.println("source.jpg图片跟example"+(i+1)+".jpg有点相似");
      }else if(difference>10){
        system.out.println("source.jpg图片跟example"+(i+1)+".jpg完全不一样");
      }
    }
    
  }

  /**
   * 计算"汉明距离"（hamming distance）。
   * 如果不相同的数据位不超过5，就说明两张图片很相似；如果大于10，就说明这是两张不同的图片。
   * @param sourcehashcode 源hashcode
   * @param hashcode 与之比较的hashcode
   */
  public static int hammingdistance(string sourcehashcode, string hashcode) {
    int difference = 0;
    int len = sourcehashcode.length();
    
    for (int i = 0; i < len; i++) {
      if (sourcehashcode.charat(i) != hashcode.charat(i)) {
        difference ++;
      }
    }
    
    return difference;
  }

  /**
   * 生成图片指纹
   * @param filename 文件名
   * @return 图片指纹
   */
  public static string producefingerprint(string filename) {
    bufferedimage source = imagehelper.readpngimage(filename);// 读取文件

    int width = 8;
    int height = 8;
    
    // 第一步，缩小尺寸。
    // 将图片缩小到8x8的尺寸，总共64个像素。这一步的作用是去除图片的细节，只保留结构、明暗等基本信息，摒弃不同尺寸、比例带来的图片差异。
    bufferedimage thumb = imagehelper.thumb(source, width, height, false);
    
    // 第二步，简化色彩。
    // 将缩小后的图片，转为64级灰度。也就是说，所有像素点总共只有64种颜色。
    int[] pixels = new int[width * height];
    for (int i = 0; i < width; i++) {
      for (int j = 0; j < height; j++) {
        pixels[i * height + j] = imagehelper.rgbtogray(thumb.getrgb(i, j));
      }
    }
    
    // 第三步，计算平均值。
    // 计算所有64个像素的灰度平均值。
    int avgpixel = imagehelper.average(pixels);
    
    // 第四步，比较像素的灰度。
    // 将每个像素的灰度，与平均值进行比较。大于或等于平均值，记为1；小于平均值，记为0。
    int[] comps = new int[width * height];
    for (int i = 0; i < comps.length; i++) {
      if (pixels[i] >= avgpixel) {
        comps[i] = 1;
      } else {
        comps[i] = 0;
      }
    }
    
    // 第五步，计算哈希值。
    // 将上一步的比较结果，组合在一起，就构成了一个64位的整数，这就是这张图片的指纹。组合的次序并不重要，只要保证所有图片都采用同样次序就行了。
    stringbuffer hashcode = new stringbuffer();
    for (int i = 0; i < comps.length; i+= 4) {
      int result = comps[i] * (int) math.pow(2, 3) + comps[i + 1] * (int) math.pow(2, 2) + comps[i + 2] * (int) math.pow(2, 1) + comps[i + 2];
      hashcode.append(binarytohex(result));
    }
    
    // 得到指纹以后，就可以对比不同的图片，看看64位中有多少位是不一样的。
    return hashcode.tostring();
  }

  /**
   * 二进制转为十六进制
   * @param int binary
   * @return char hex
   */
  private static char binarytohex(int binary) {
    char ch = ' ';
    switch (binary)
    {
    case 0:
      ch = '0';
      break;
    case 1:
      ch = '1';
      break;
    case 2:
      ch = '2';
      break;
    case 3:
      ch = '3';
      break;
    case 4:
      ch = '4';
      break;
    case 5:
      ch = '5';
      break;
    case 6:
      ch = '6';
      break;
    case 7:
      ch = '7';
      break;
    case 8:
      ch = '8';
      break;
    case 9:
      ch = '9';
      break;
    case 10:
      ch = 'a';
      break;
    case 11:
      ch = 'b';
      break;
    case 12:
      ch = 'c';
      break;
    case 13:
      ch = 'd';
      break;
    case 14:
      ch = 'e';
      break;
    case 15:
      ch = 'f';
      break;
    default:
      ch = ' ';
    }
    return ch;
  }

}

工具类： 

import java.awt.alphacomposite;
import java.awt.color;
import java.awt.font;
import java.awt.graphics2d;
import java.awt.image;
import java.awt.renderinghints;
import java.awt.geom.affinetransform;
import java.awt.image.bufferedimage;
import java.awt.image.colormodel;
import java.awt.image.writableraster;
import java.io.file;
import java.io.fileinputstream;
import java.io.filenotfoundexception;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;

import javax.imageio.imageio;

import com.sun.image.codec.jpeg.imageformatexception;
import com.sun.image.codec.jpeg.jpegcodec;
import com.sun.image.codec.jpeg.jpegimagedecoder;
import com.sun.image.codec.jpeg.jpegimageencoder;

/**
 * 图片工具类，主要针对图片水印处理
 * 
 * @author 025079
 * @version [版本号, 2011-11-28]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public class imagehelper {

 // 项目根目录路径
 public static final string path = system.getproperty("user.dir");
 
 /**
 * 生成缩略图 <br/>
 * 保存:imageio.write(bufferedimage, imgtype[jpg/png/...], file);
 * 
 * @param source
 *      原图片
 * @param width
 *      缩略图宽
 * @param height
 *      缩略图高
 * @param b
 *      是否等比缩放
 * */
 public static bufferedimage thumb(bufferedimage source, int width,
  int height, boolean b) {
 // targetw，targeth分别表示目标长和宽
 int type = source.gettype();
 bufferedimage target = null;
 double sx = (double) width / source.getwidth();
 double sy = (double) height / source.getheight();

 if (b) {
  if (sx > sy) {
  sx = sy;
  width = (int) (sx * source.getwidth());
  } else {
  sy = sx;
  height = (int) (sy * source.getheight());
  }
 }

 if (type == bufferedimage.type_custom) { // handmade
  colormodel cm = source.getcolormodel();
  writableraster raster = cm.createcompatiblewritableraster(width,
   height);
  boolean alphapremultiplied = cm.isalphapremultiplied();
  target = new bufferedimage(cm, raster, alphapremultiplied, null);
 } else
  target = new bufferedimage(width, height, type);
 graphics2d g = target.creategraphics();
 // smoother than exlax:
 g.setrenderinghint(renderinghints.key_rendering,
  renderinghints.value_render_quality);
 g.drawrenderedimage(source, affinetransform.getscaleinstance(sx, sy));
 g.dispose();
 return target;
 }

 /**
 * 图片水印
 * 
 * @param imgpath
 *      待处理图片
 * @param markpath
 *      水印图片
 * @param x
 *      水印位于图片左上角的 x 坐标值
 * @param y
 *      水印位于图片左上角的 y 坐标值
 * @param alpha
 *      水印透明度 0.1f ~ 1.0f
 * */
 public static void watermark(string imgpath, string markpath, int x, int y,
  float alpha) {
 try {
  // 加载待处理图片文件
  image img = imageio.read(new file(imgpath));

  bufferedimage image = new bufferedimage(img.getwidth(null),
   img.getheight(null), bufferedimage.type_int_rgb);
  graphics2d g = image.creategraphics();
  g.drawimage(img, 0, 0, null);

  // 加载水印图片文件
  image src_biao = imageio.read(new file(markpath));
  g.setcomposite(alphacomposite.getinstance(alphacomposite.src_atop,
   alpha));
  g.drawimage(src_biao, x, y, null);
  g.dispose();

  // 保存处理后的文件
  fileoutputstream out = new fileoutputstream(imgpath);
  jpegimageencoder encoder = jpegcodec.createjpegencoder(out);
  encoder.encode(image);
  out.close();
 } catch (exception e) {
  e.printstacktrace();
 }
 }

 /**
 * 文字水印
 * 
 * @param imgpath
 *      待处理图片
 * @param text
 *      水印文字
 * @param font
 *      水印字体信息
 * @param color
 *      水印字体颜色
 * @param x
 *      水印位于图片左上角的 x 坐标值
 * @param y
 *      水印位于图片左上角的 y 坐标值
 * @param alpha
 *      水印透明度 0.1f ~ 1.0f
 */

 public static void textmark(string imgpath, string text, font font,
  color color, int x, int y, float alpha) {
 try {
  font dfont = (font == null) ? new font("宋体", 20, 13) : font;

  image img = imageio.read(new file(imgpath));

  bufferedimage image = new bufferedimage(img.getwidth(null),
   img.getheight(null), bufferedimage.type_int_rgb);
  graphics2d g = image.creategraphics();

  g.drawimage(img, 0, 0, null);
  g.setcolor(color);
  g.setfont(dfont);
  g.setcomposite(alphacomposite.getinstance(alphacomposite.src_atop,
   alpha));
  g.drawstring(text, x, y);
  g.dispose();
  fileoutputstream out = new fileoutputstream(imgpath);
  jpegimageencoder encoder = jpegcodec.createjpegencoder(out);
  encoder.encode(image);
  out.close();
 } catch (exception e) {
  system.out.println(e);
 }
 }
 
 /**
 * 读取jpeg图片
 * @param filename 文件名
 * @return bufferedimage 图片对象
 */
 public static bufferedimage readjpegimage(string filename)
 {
 try {
  inputstream imagein = new fileinputstream(new file(filename));
  // 得到输入的编码器，将文件流进行jpg格式编码
  jpegimagedecoder decoder = jpegcodec.createjpegdecoder(imagein);
  // 得到编码后的图片对象
  bufferedimage sourceimage = decoder.decodeasbufferedimage();
  
  return sourceimage;
 } catch (filenotfoundexception e) {
  e.printstacktrace();
 } catch (imageformatexception e) {
  e.printstacktrace();
 } catch (ioexception e) {
  e.printstacktrace();
 }
 
 return null;
 }
 
 /**
 * 读取jpeg图片
 * @param filename 文件名
 * @return bufferedimage 图片对象
 */
 public static bufferedimage readpngimage(string filename)
 {
 try {
  file inputfile = new file(filename); 
     bufferedimage sourceimage = imageio.read(inputfile);
  return sourceimage;
 } catch (filenotfoundexception e) {
  e.printstacktrace();
 } catch (imageformatexception e) {
  e.printstacktrace();
 } catch (ioexception e) {
  e.printstacktrace();
 }
 
 return null;
 }
 
 /**
 * 灰度值计算
 * @param pixels 像素
 * @return int 灰度值
 */
 public static int rgbtogray(int pixels) {
 // int _alpha = (pixels >> 24) & 0xff;
 int _red = (pixels >> 16) & 0xff;
 int _green = (pixels >> 8) & 0xff;
 int _blue = (pixels) & 0xff;
 return (int) (0.3 * _red + 0.59 * _green + 0.11 * _blue);
 }
 
 /**
 * 计算数组的平均值
 * @param pixels 数组
 * @return int 平均值
 */
 public static int average(int[] pixels) {
 float m = 0;
 for (int i = 0; i < pixels.length; ++i) {
  m += pixels[i];
 }
 m = m / pixels.length;
 return (int) m;
 }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。