这阵子发现我的图像数据库中有不少内容一样的图像需要剔除，这些内容一样的图像可能尺寸不一样，通道数也可能不一样(灰度/彩色)，如下三张图内容完全一样，只是亮度或色彩通道数不同， 
于是想到了用google或baidu的识图功能所用到的“感知哈希算法”来搜索数据库内容一样的图像。
通过这篇文章搞清楚了“感知哈希算法”的基本原理，
《三种基于感知哈希算法的相似图像检索技术》，发现原理很简单，很适合我等粗人，呵呵，于是在java下实现了这个算法的代码 ：
java实现
package net.gdface.image;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
import java.util.Arrays;
/**
* 均值哈希实现图像指纹比较
* @author guyadong
*
*/
public final class FingerPrint {
/**
* 图像指纹的尺寸,将图像resize到指定的尺寸，来计算哈希数组
*/
private static final int HASH_SIZE=16;
/**
* 保存图像指纹的二值化矩阵
*/
private final byte[] binaryzationMatrix;
public FingerPrint(byte[] hashValue) {
if(hashValue.length!=HASH_SIZE*HASH_SIZE)
throw new IllegalArgumentException(String.format("length of hashValue must be %d",HASH_SIZE*HASH_SIZE ));
this.binaryzationMatrix=hashValue;
}
public FingerPrint(String hashValue) {
this(toBytes(hashValue));
}
public FingerPrint (BufferedImage src){
this(hashValue(src));
}
private static byte[] hashValue(BufferedImage src){
BufferedImage hashImage = resize(src,HASH_SIZE,HASH_SIZE);
byte[] matrixGray = (byte[]) toGray(hashImage).getData().getDataElements(0, 0, HASH_SIZE, HASH_SIZE, null);
return binaryzation(matrixGray);
}
/**
* 从压缩格式指纹创建{@link FingerPrint}对象
* @param compactValue
* @return
*/
public static FingerPrint createFromCompact(byte[] compactValue){
return new FingerPrint(uncompact(compactValue));
}
public static boolean validHashValue(byte[] hashValue){
if(hashValue.length!=HASH_SIZE)
return false;
for(byte b:hashValue){
if(0!=b&&1!=b)return false;
}
return true;
}
public static boolean validHashValue(String hashValue){
if(hashValue.length()!=HASH_SIZE)
return false;
for(int i=0;i<hashValue.length();++i){
if('0'!=hashValue.charAt(i)&&'1'!=hashValue.charAt(i))return false;
}
return true;
}
public byte[] compact(){
return compact(binaryzationMatrix);
}
/**
* 指纹数据按位压缩
* @param hashValue
* @return
*/
private static byte[] compact(byte[] hashValue){
byte[] result=new byte[(hashValue.length+7)>>3];
byte b=0;
for(int i=0;i<hashValue.length;++i){
if(0==(i&7)){
b=0;
}
if(1==hashValue[i]){
b|=1<<(i&7);
}else if(hashValue[i]!=0)
throw new IllegalArgumentException("invalid hashValue,every element must be 0 or 1");
if(7==(i&7)||i==hashValue.length-1){
result[i>>3]=b;
}
}
return result;
}
/**
* 压缩格式的指纹解压缩
* @param compactValue
* @return
*/
private static byte[] uncompact(byte[] compactValue){
byte[] result=new byte[compactValue.length<<3];
for(int i=0;i<result.length;++i){
if((compactValue[i>>3]&(1<<(i&7)))==0)
result[i]=0;
else
result[i]=1;
}
return result;
}
/**
* 字符串类型的指纹数据转为字节数组
* @param hashValue
* @return
*/
private static byte[] toBytes(String hashValue){
hashValue=hashValue.replaceAll("\s", "");
byte[] result=new byte[hashValue.length()];
for(int i=0;i<result.length;++i){
char c = hashValue.charAt(i);
if('0'==c)
result[i]=0;
else if('1'==c)
result[i]=1;
else
throw new IllegalArgumentException("invalid hashValue String");
}
return result;
}
/**
* 缩放图像到指定尺寸
* @param src
* @param width
* @param height
* @return
*/
private static BufferedImage resize(Image src,int width,int height){
BufferedImage result = new BufferedImage(width, height,
BufferedImage.TYPE_3BYTE_BGR);
Graphics g = result.getGraphics();
try{
g.drawImage(src.getScaledInstance(width, height, Image.SCALE_SMOOTH), 0, 0, null);
}finally{
g.dispose();
}
return result;
}
/**
* 计算均值
* @param src
* @return
*/
private static int mean(byte[] src){
long sum=0;
// 将数组元素转为无符号整数
for(byte b:src)sum+=(long)b&0xff;
return (int) (Math.round((float)sum/src.length));
}
/**
* 二值化处理
* @param src
* @return
*/
private static byte[] binaryzation(byte[]src){
byte[] dst = src.clone();
int mean=mean(src);
for(int i=0;i<dst.length;++i){
// 将数组元素转为无符号整数再比较
dst[i]=(byte) (((int)dst[i]&0xff)>=mean?1:0);
}
return dst;
}
/**
* 转灰度图像
* @param src
* @return
*/