目录
大家都用google或baidu的识图功能,上面就是我搜索一幅图片的结果,该引擎实现相似图片搜素的关键技术叫做“感知哈希算法”(Perceptual hash algorithm),它的作用是对每张图片生成一个“指纹”(fingerprint)字符串,然后比较不同图片的指纹。结果越接近,就说明图片越相似。达到图片比较目的且利用信息指纹比较有三种算法,这些算法都很易懂,下面分别介绍一下:
1、基于低频的均值哈希
一张图片就是一个二维信号,它包含了不同频率的成分。如下图所示,亮度变化小的区域是低频成分,它描述大范围的信息。而亮度变化剧烈的区域(比如物体的边缘)就是高频的成分,它描述具体的细节。或者说高频可以提供图片详细的信息,而低频可以提供一个框架。
而一张大的,详细的图片有很高的频率,而小图片缺乏图像细节,所以都是低频的。所以我们平时的下采样,也就是缩小图片的过程,实际上是损失高频信息的过程。下面5张图依次是原图,放缩至64*64、32*32、16*16、8*8的图。
均值哈希算法主要是利用图片的低频信息,其工作过程如下:
(1)缩小尺寸:去除高频和细节的最快方法是缩小图片,将图片缩小到8x8的尺寸,总共64个像素。不要保持纵横比,只需将其变成8*8的正方形。这样就可以比较任意大小的图片,摒弃不同尺寸、比例带来的图片差异。
(2)简化色彩:将8*8的小图片转换成灰度图像。
(3)计算平均值:计算所有64个像素的灰度平均值。
(4)比较像素的灰度:将每个像素的灰度,与平均值进行比较。大于或等于平均值,记为1;小于平均值,记为0。
(5)计算hash值:将上一步的比较结果,组合在一起,就构成了一个64位的整数,这就是这张图片的指纹。组合的次序并不重要,只要保证所有图片都采用同样次序就行了。(我设置的是从左到右,从上到下用二进制保存)。
//均值Hash算法
string HashValue(Mat &src)
{
string rst(64,'\0');
Mat img;
if(src.channels()==3)
cvtColor(src,img,CV_BGR2GRAY);
else
img=src.clone();
/*第一步,缩小尺寸。
将图片缩小到8x8的尺寸,总共64个像素,去除图片的细节*/
resize(img,img,Size(8,8));
/* 第二步,简化色彩(Color Reduce)。
将缩小后的图片,转为64级灰度。*/
uchar *pData;
for(int i=0;i<img.rows;i++)
{
pData = img.ptr<uchar>(i);
for(int j=0;j<img.cols;j++)
{
pData[j]=pData[j]/4; }
}
/* 第三步,计算平均值。
计算所有64个像素的灰度平均值。*/
int average = mean(img).val[0];
/* 第四步,比较像素的灰度。
将每个像素的灰度,与平均值进行比较。大于或等于平均值记为1,小于平均值记为0*/
Mat mask= (img>=(uchar)average);
/* 第五步,计算哈希值。*/
int index = 0;
for(int i=0;i<mask.rows;i++)
{
pData = mask.ptr<uchar>(i);
for(int j=0;j<mask.cols;j++)
{
if(pData[j]==0)
rst[index++]='0';
else
rst[index++]='1';
}
}
return rst;
}
计算一个图片的hash指纹的过程就是这么简单。如果图片放大或缩小,或改变纵横比,结果值也不会改变。增加或减少亮度或对比度,或改变颜色,对hash值都不会太大的影响。最大的优点:计算速度快!这时候,比较两个图片的相似性,就是先计算这两张图片的hash指纹,也就是64位0或1值,然后计算不同位的个数(汉明距离)。如果这个值为0,则表示这两张图片非常相似,如果汉明距离小于5,则表示有些不同,但比较相近,如果汉明距离大于10则表明完全不同的图片。
2、增强版:pHash
均值哈希虽然简单,但受均值的影响非常大。例如对图像进行伽马校正或直方图均衡就会影响均值,从而影响最终的hash值。存在一个更健壮的算法叫pHash。它将均值的方法发挥到极致。使用离散余弦变换(DCT)来获取图片的低频成分。
离散余弦变换(DCT)是种图像压缩算法,它将图像从像素域变换到频率域。然后一般图像都存在很多冗余和相关性的,所以转换到频率域之后,只有很少的一部分频率分量的系数才不为0,大部分系数都为0(或者说接近于0)。下图的右图是对lena图进行离散余弦变换(DCT)得到的系数矩阵图。从左上角依次到右下角,频率越来越高,由图可以看到,左上角的值比较大,到右下角的值就很小很小了。换句话说,图像的能量几乎都集中在左上角这个地方的低频系数上面了。
pHash的工作过程如下:
(1)缩小尺寸:pHash以小图片开始,但图片大于8*8,32*32是最好的。这样做的目的是简化了DCT的计算,而不是减小频率。
(2)简化色彩:将图片转化成灰度图像,进一步简化计算量。
(3)计算DCT:计算图片的DCT变换,得到32*32的DCT系数矩阵。
(4)缩小DCT:虽然DCT的结果是32*32大小的矩阵,但我们只要保留左上角的8*8的矩阵,这部分呈现了图片中的最低频率。
(5)计算平均值:如同均值哈希一样,计算DCT的均值。
(6)计算hash值:这是最主要的一步,根据8*8的DCT矩阵,设置0或1的64位的hash值,大于等于DCT均值的设为”1”,小于DCT均值的设为“0”。组合在一起,就构成了一个64位的整数,这就是这张图片的指纹。
//pHash算法
string pHashValue(Mat &src)
{
Mat img ,dst;
string rst(64,'\0');
double dIdex[64];
double mean = 0.0;
int k = 0;
if(src.channels()==3)
{
cvtColor(src,src,CV_BGR2GRAY);
img = Mat_<double>(src);
}
else
{
img = Mat_<double>(src);
}
/* 第一步,缩放尺寸*/
resize(img, img, Size(8,8));
/* 第二步,离散余弦变换,DCT系数求取*/
dct(img, dst);
/* 第三步,求取DCT系数均值(左上角8*8区块的DCT系数)*/
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j)
{
dIdex[k] = dst.at<double>(i, j);
mean += dst.at<double>(i, j)/64;
++k;
}
}
/* 第四步,计算哈希值。*/
for (int i =0;i<64;++i)
{
if (dIdex[i]>=mean)
{
rst[i]='1';
}
else
{
rst[i]='0';
}
}
return rst;
}
结果并不能告诉我们真实性的低频率,只能粗略地告诉我们相对于平均值频率的相对比例。只要图片的整体结构保持不变,hash结果值就不变。能够避免伽马校正或颜色直方图被调整带来的影响。与均值哈希一样,pHash同样可以用汉明距离来进行比较。(只需要比较每一位对应的位置并算计不同的位的个数)
3、差异哈希算法(dHash)
相比pHash,dHash的速度要快的多,相比aHash,dHash在效率几乎相同的情况下的效果要更好,它是基于渐变实现的。
步骤:
1.缩小图片:收缩到9*8的大小,一遍它有72的像素点
2.转化为灰度图:把缩放后的图片转化为256阶的灰度图。(具体算法见平均哈希算法步骤)
3.计算差异值:dHash算法工作在相邻像素之间,这样每行9个像素之间产生了8个不同的差异,一共8行,则产生了64个差异值
4.获得指纹:如果左边的像素比右边的更亮,则记录为1,否则为0.
需要说明的是这种指纹算法不仅可以应用于图片搜索,同样适用于其他多媒体形式。除此之外,图片搜索特征提取方法有很多,很多算法还有许多可以改进的地方,比如对于人物可以先进行人脸识别,再在面部区域进行局部的哈希,或者背景是纯色的可以先过滤剪裁等等,最后在搜索的结果中还可以根据颜色、风景、产品等进行过滤。
均值哈希实现图像内容相似度比较完整JAVA代码
package com.robot.imagecheck.algorithm;
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.io.File;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Arrays;
import javax.imageio.ImageIO;
/**
* 均值哈希实现图像指纹比较
* @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
*/
private static BufferedImage toGray(BufferedImage src){
if(src.getType()==BufferedImage.TYPE_BYTE_GRAY){
return src;
}else{
// 图像转灰
BufferedImage grayImage = new BufferedImage(src.getWidth(), src.getHeight(),
BufferedImage.TYPE_BYTE_GRAY);
new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY), null).filter(src, grayImage);
return grayImage;
}
}
@Override
public String toString() {
return toString(true);
}
/**
* @param multiLine 是否分行
* @return
*/
public String toString(boolean multiLine) {
StringBuffer buffer=new StringBuffer();
int count=0;
for(byte b:this.binaryzationMatrix){
buffer.append(0==b?'0':'1');
if(multiLine&&++count%HASH_SIZE==0)
buffer.append('\n');
}
return buffer.toString();
}
@Override
public boolean equals(Object obj) {
if(obj instanceof FingerPrint){
return Arrays.equals(this.binaryzationMatrix,((FingerPrint)obj).binaryzationMatrix);
}else
return super.equals(obj);
}
/**
* 与指定的压缩格式指纹比较相似度
* @param compactValue
* @return
* @see #compare(FingerPrint)
*/
public float compareCompact(byte[] compactValue){
return compare(createFromCompact(compactValue));
}
/**
* @param hashValue
* @return
* @see #compare(FingerPrint)
*/
public float compare(String hashValue){
return compare(new FingerPrint(hashValue));
}
/**
* 与指定的指纹比较相似度
* @param hashValue
* @return
* @see #compare(FingerPrint)
*/
public float compare(byte[] hashValue){
return compare(new FingerPrint(hashValue));
}
/**
* 与指定图像比较相似度
* @param image2
* @return
* @see #compare(FingerPrint)
*/
public float compare(BufferedImage image2){
return compare(new FingerPrint(image2));
}
/**
* 比较指纹相似度
* @param src
* @return
* @see #compare(byte[], byte[])
*/
public float compare(FingerPrint src){
if(src.binaryzationMatrix.length!=this.binaryzationMatrix.length)
throw new IllegalArgumentException("length of hashValue is mismatch");
return compare(binaryzationMatrix,src.binaryzationMatrix);
}
/**
* 判断两个数组相似度,数组长度必须一致否则抛出异常
* @param f1
* @param f2
* @return 返回相似度(0.0~1.0)
*/
private static float compare(byte[] f1,byte[] f2){
if(f1.length!=f2.length)
throw new IllegalArgumentException("mismatch FingerPrint length");
int sameCount=0;
for(int i=0;i<f1.length;++i){
if(f1[i]==f2[i])++sameCount;
}
return (float)sameCount/f1.length;
}
public static float compareCompact(byte[] f1,byte[] f2){
return compare(uncompact(f1),uncompact(f2));
}
public static float compare(BufferedImage image1,BufferedImage image2){
return new FingerPrint(image1).compare(new FingerPrint(image2));
}
public static void main(String[] args) throws IOException {
//调用算法代码处理图片数据
FingerPrint fp1 = new FingerPrint(ImageIO.read(new File("d:\\data\\img\\1\\111.png")));
FingerPrint fp2 =new FingerPrint(ImageIO.read(new File("d:\\data\\img\\1\\222.png")));
System.out.println(fp1.toString(true));
//计算两张图片的相似度
System.out.printf("sim=%f",fp1.compare(fp2));
DecimalFormat df = new DecimalFormat("0.00%");
}
}
结果值越高就代表相似度越高,如果结果为1的话那基本上就是一张图片。
原文链接: