感知哈希算法

感知哈希算法(Perceptual hash algorithm )是哈希算法的一类，通常用来进行图像相似检索。

常用的有三种：均值哈希(aHash)，感知哈希(pHash)，差异化哈希(dHash)

aHash：平均值哈希。速度比较快，但是常常不太精确。
pHash：感知哈希。精确度比较高，但是速度方面较差一些。
dHash：差异值哈希。Amazing！精确度较高，且速度也非常快。

1. 基于低频的均值哈希(aHash)

一张图片就是一个二维信号，它包含了不同频率的成分。如下图所示，亮度变化小的区域是低频成分，它描述大范围的信息。而亮度变化剧烈的区域（比如物体的边缘）就是高频的成分，它描述具体的细节。或者说高频可以提供图片详细的信息，而低频可以提供一个框架。
class="lazyload" data-src="https://cdn.nlark.com/yuque/0/2019/png/283236/1562749582502-2bee275c-a810-4816-8e4f-b74a47495c9c.png#align=left&display=inline&height=215&margin=%5Bobject%20Object%5D&name=&originHeight=215&originWidth=707&size=0&status=done&style=none&width=707"
而一张大的，详细的图片有很高的频率，而小图片缺乏图像细节，所以都是低频的。所以我们平时的下采样，也就是缩小图片的过程，实际上是损失高频信息的过程。

class="lazyload" data-src="https://cdn.nlark.com/yuque/0/2019/png/283236/1562749627606-986f7034-bc7b-4661-b92a-aaf161089a4d.png#align=left&display=inline&height=139&margin=%5Bobject%20Object%5D&name=&originHeight=139&originWidth=352&size=0&status=done&style=none&width=352"
均值哈希算法主要是利用图片的低频信息，其工作过程如下：

（1）缩小尺寸：去除高频和细节的最快方法是缩小图片，将图片缩小到8x8的尺寸，总共64个像素。不要保持纵横比，只需将其变成8*8的正方形。这样就可以比较任意大小的图片，摒弃不同尺寸、比例带来的图片差异。

（2）简化色彩：将8*8的小图片转换成灰度图像。

（3）计算平均值：计算所有64个像素的灰度平均值。

（4）比较像素的灰度：将每个像素的灰度，与平均值进行比较。大于或等于平均值，记为1；小于平均值，记为0。

（5）计算hash值：将上一步的比较结果，组合在一起，就构成了一个64位的整数，这就是这张图片的指纹。组合的次序并不重要，只要保证所有图片都采用同样次序就行了。(我设置的是从左到右，从上到下用二进制保存)。

如果图片放大或缩小，或改变纵横比，结果值也不会改变。增加或减少亮度或对比度，或改变颜色，对 hash 值都不会太大的影响。最大的优点：计算速度快！

均值哈希 python 版本：

def get_ahash(img):
    image = cv2.resize(img,(8,8),interpolation=cv2.INTER_AREA) # step1: resize img
    """resize img 8x8
    	interpolation参数用于告诉函数怎么插值计算输出图像的像素值。
        INTER_AREA在缩小和放大图像时，是完全不一样的。
        详解参阅：https://zhuanlan.zhihu.com/p/38493205
    """
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # step2: 将8*8的小图片转换成灰度图像（色彩空间转化 BGR↔Gray的转换）

    average = np.mean(image) # step3: 计算所有64个像素的灰度平均值。
    image[np.where(image<=average)] = 0
    """
    step4:比较像素的灰度：将每个像素的灰度，与平均值进行比较。大于或等于平均值，记为1；小于平均值，记为0。
    """
    image[np.where(image>average)] = 1
    image = image.astype('uint8')
    image=image.flatten() # 生成：图片的指纹，flatten函数返回一个折叠成 一维 的数组。
    return image

2. 增强版：pHash

均值哈希虽然简单，但受均值的影响非常大。例如对图像进行伽马校正或直方图均衡就会影响均值，从而影响最终的 hash 值。存在一个更健壮的算法叫 pHash。它将均值的方法发挥到极致。使用离散余弦变换(DCT)来获取图片的低频成分。
离散余弦变换（DCT）是种图像压缩算法，它将图像从像素域变换到频率域。然后一般图像都存在很多冗余和相关性的，所以转换到频率域之后，只有很少的一部分频率分量的系数才不为 0，大部分系数都为 0（或者说接近于 0）。下图的右图是对 lena 图进行离散余弦变换（DCT）得到的系数矩阵图。从左上角依次到右下角，频率越来越高，由图可以看到，左上角的值比较大，到右下角的值就很小很小了。换句话说，图像的能量几乎都集中在左上角这个地方的低频系数上面了。
class="lazyload" data-src="https://cdn.nlark.com/yuque/0/2019/png/283236/1562751740655-5d3d708e-2d61-448f-b138-28e4f02ce484.png#align=left&display=inline&height=272&margin=%5Bobject%20Object%5D&name=&originHeight=272&originWidth=610&size=0&status=done&style=none&width=610"
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 python 版本：

def get_phash2(img):
    img=cv2.resize(img,(32,32),interpolation=cv2.INTER_AREA) # step1:resize img 32x32
    img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) # step2: 将图片转化成灰度图像，进一步简化计算量。
    h,w=img.shape
    img_2=np.zeros((h,w),dtype=np.float32)
    img_2[:h,:w]=img
    img_dct=cv2.dct(cv2.dct(img_2)) # step3: 计算图片的DCT变换，得到32*32的DCT系数矩阵。
    image=img_dct[:8,:8] # step4: 缩小DCT：虽然DCT的结果是32*32大小的矩阵，但我们只要保留左上角的8*8的矩阵，这部分呈现了图片中的最低频率。
    average = np.mean(image) #step5: 计算平均值：如同均值哈希一样，计算DCT的均值。
    image_val=image.copy()
    image[np.where(image_val<=average)] = 0
    """
    	setp6:计算hash值：这是最主要的一步，根据8*8的DCT矩阵，设置0或1的64位的hash值，大于等于DCT均值的设为”1”，小于DCT均值的设为“0”。组合在一起，就构成了一个64位的整数，这就是这张图片的指纹。
    """
    image[np.where(image_val>average)] = 1
    image = image.astype('uint8')
    image=image.flatten()
    return image

3. 差异哈希算法（dHash）

相比 pHash，dHash 的速度要快的多，相比 aHash，dHash 在效率几乎相同的情况下的效果要更好，它是基于渐变实现的。
dHash 的工作过程如下：

(1) 缩小图片：收缩到9*8的大小，缩小后有72的像素点。

(2) 转化为灰度图：把缩放后的图片转化为256阶的灰度图。（具体算法见平均哈希算法步骤）

(3) 计算差异值：dHash算法工作在相邻像素之间，这样每行9个像素之间产生了8个不同的差异，一共8行，则产生了64个差异值。

(4) 获得指纹：如果左边的像素比右边的更亮，则记录为1，否则为0.

需要说明的是这种指纹算法不仅可以应用于图片搜索，同样适用于其他多媒体形式。除此之外，图片搜索特征提取方法有很多，很多算法还有许多可以改进的地方，比如对于人物可以先进行人脸识别，再在面部区域进行局部的哈希，或者背景是纯色的可以先过滤剪裁等等，最后在搜索的结果中还可以根据颜色、风景、产品等进行过滤。

dHash python 版本：

def get_dhash(self,img):
    img=cv2.resize(img,(9,8),interpolation=cv2.INTER_AREA) # step1: 缩小图片：收缩到9*8的大小，它有72的像素点。
    img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) # step2: 转化为灰度图.
	"""
    step3: 计算差异值：dHash算法工作在相邻像素之间，这样每行9个像素之间产生了8个不同的差异，一共8行，则产生了64个差异值。
    """
    image=np.zeros([8,8])
    image[np.where(img[:,:-1]>=img[:,1:])]=1 # step4: 获得指纹：如果左边的像素比右边的更亮，则记录为1，否则为0.
    image = image.astype('uint8')
    image = image.flatten()
    return image