OpenCV #以图搜图：感知哈希算法（Perceptual hash algorithm）的原理与实验

1. 介绍

感知哈希算法（Perceptual Hash Algorithm，简称pHash） 是哈希算法的一种，主要用来做相似图片的搜索工作。

 

2. 原理

感知哈希算法（pHash）首先将原图像缩小成一个固定大小的像素图像，然后将图像转换为灰度图像，通过使用离散余弦变换（DCT）来获取频域信息。然后，根据DCT系数的均值生成一组哈希值。最后，利用两组图像的哈希值的汉明距离来评估图像的相似度。

魔法： 概括地讲，感知哈希算法一共可细分八步：

  1. 缩小图像： 将目标图像缩小为一个固定的大小，通常为32x32像素。作用是去除各种图像尺寸和图像比例的差异，只保留结构、明暗等基本信息，目的是确保图像的一致性，降低计算的复杂度。
  2. 图像灰度化： 将缩小的图像转换为灰度图像。
  3. 离散余弦变换（DCT）： 感知哈希算法的核心是应用离散余弦变换。DCT将图像从空间域（像素级别）转换为频域，得到32×32的DCT变换系数矩阵，以捕获图像的低频信息。
  4. 缩小DCT： 经过DCT变换后，图像的频率特征集中在图像的左上角，保留系数矩阵左上角的8×8系数子矩阵（因为虽然DCT的结果是32×32大小的矩阵，但左上角8×8的矩阵呈现了图片中的最低频率）。
  5. 计算灰度均值： 计算DCT变换后图像块的均值，以便后面确定每个块的明暗情况。
  6. 生成二进制哈希值： 如果块的DCT系数高于均值，表示为1，否则表示为0（由于我们只提取了DCT矩阵左上角的8×8系数子矩阵，所以，最后会得到一个64位的二进制值（8x8像素的灰度图像））。
  7. 生成哈希值： 由于64位二进制值太长，所以按每4个字符为1组，由2进制转成16进制。这样就转为一个长度为16的字符串。这个字符串也就是这个图像可识别的哈希值，也叫图像指纹，即这个图像所包含的特征。
  8. 哈希值比较： 通过比较两个图像的哈希值的汉明距离（Hamming Distance），就可以评估图像的相似度，距离越小表示图像越相似。

 

3. 实验

第一步：缩小图像

将目标图像缩小为一个固定的大小，通常为32x32像素。作用是去除各种图像尺寸和图像比例的差异，只保留结构、明暗等基本信息，目的是确保图像的一致性，降低计算的复杂度。

1）读取原图

# 测试图片路径
img_path = 'img_test/apple-01.jpg'# 通过OpenCV加载图像
img = cv2.imread(img_path)# 通道重排，从BGR转换为RGB
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

pHash-0001

2）缩放原图

使用 OpenCV 的 resize 函数将图像缩放为32x32像素。

# 缩小图像：使用OpenCV的resize函数将图像缩放为32x32像素，采用Cubic插值方法进行图像重采样
img_32 = cv2.resize(img, (32, 32), cv2.INTER_CUBIC)

pHash-0002
OpenCV 的 cv2.resize() 函数提供了4种插值方法，以根据图像的尺寸变化来进行图像重采样。

  1. cv2.INTER_NEAREST： 最近邻插值，也称为最近邻算法。它简单地使用最接近目标像素的原始像素的值。虽然计算速度快，但可能导致图像质量下降。
  2. cv2.INTER_LINEAR： 双线性插值，通过对最近的4个像素进行线性加权来估计目标像素的值。比最近邻插值更精确，但计算成本略高。
  3. cv2.INTER_CUBIC： 双三次插值，使用16个最近像素的加权平均值来估计目标像素的值。通常情况下，这是一个不错的插值方法，适用于图像缩小。
  4. cv2.INTER_LANCZOS4： Lanczos插值，一种高质量的插值方法，使用Lanczos窗口函数。通常用于缩小图像，以保留图像中的细节和纹理。

第二步：图像灰度化

将缩小的图像转换为灰度图像。

# 图像灰度化：将彩色图像转换为灰度图像。
img_gray = cv2.cvtColor(img_32, cv2.COLOR_BGR2GRAY)
print(f"缩放32x32的图像中每个像素的颜色=\n{img_gray}")

输出打印：

缩放32x32的图像中每个像素的颜色=
[[253 253 253 ... 253 253 253][253 253 253 ... 253 253 253][253 253 253 ... 253 253 253]...[253 253 253 ... 253 253 253][253 253 253 ... 253 253 253][253 253 253 ... 253 253 253]]

pHash-0003

第三步：离散余弦变换（DCT）

感知哈希算法的核心是应用离散余弦变换。DCT将图像从空间域（像素级别）转换为频域，得到32×32的DCT变换系数矩阵，以捕获图像的低频信息。这里我们使用 OpenCV 的 cv2.dct 函数来执行DCT。

# 离散余弦变换（DCT）：计算图像的DCT变换，得到32×32的DCT变换系数矩阵
img_dct = cv2.dct(np.float32(img_gray))
print(f"灰度图像离散余弦变换（DCT）={img_dct}")

这行代码执行了离散余弦变换（DCT），它将图像数据从空间域（像素级别）转换为频域，以便在频域上分析图像。

  • cv2.dct: 这是 OpenCV 库中的函数，用于执行离散余弦变换。DCT是一种数学变换，类似于傅里叶变换，它将图像分解为不同频率的分量。
  • np.float32(img_gray): 这是将灰度图像 img_gray 转换为32位浮点数的操作。DCT通常需要浮点数作为输入。
  • img_dct: 这是存储DCT变换后结果的变量。在执行DCT后，img_dct 将包含图像的频域表示。

基于DCT的图像感知哈希算法是一种能够有效感知图像全局特征的算法，将图片认为是一个二维信号，包含了表现大范围内的亮度变化小的低频部分与局部范围亮度变化剧烈的高频部分，而高频部分一般存在大量的冗余和相关性。通过DCT变换，可以将高能量信息集中到图像的左上角区域。可以理解为图像的特征频率区域。

# 离散余弦变换（DCT）：计算图像的DCT变换，得到32×32的DCT变换系数矩阵
img_dct = cv2.dct(np.float32(img_gray))
print(f"灰度图像离散余弦变换（DCT）={img_dct}")# 缩放DCT系数
dct_scaled = cv2.normalize(img_dct, None, 0, 255, cv2.NORM_MINMAX)
img_dct_scaled = dct_scaled.astype(np.uint8)# 显示DCT系数的图像
plt.imshow(img_dct_scaled, cmap='gray')
plt.show()

如下图，将图像进行DCT后得到其变换结果，图像左上角变化明显，而右下角几乎没有变化。
pHash-0004

第四步：缩小DCT

经过DCT变换后，图像的频率特征集中在图像的左上角，保留系数矩阵左上角的8×8系数子矩阵（因为虽然DCT的结果是32×32大小的矩阵，但左上角8×8的矩阵呈现了图片中的最低频率）。

备注： 这里为什么要缩放DCT？以及其它缩放方式有哪些？不同缩放方式结果有何不同？不进行缩放DCT会怎么样？等等问题，我们在文末对比解答。

# 离散余弦变换（DCT）：计算图像的DCT变换，得到32×32的DCT变换系数矩阵
img_dct = cv2.dct(np.float32(img_gray))
# print(f"灰度图像离散余弦变换（DCT）={img_dct}")# 缩放DCT：将DCT系数的大小显式地调整为8x8，然后它计算调整后的DCT系数的均值，并生成哈希值。
img_dct.resize(8, 8)# 缩放DCT系数
dct_scaled = cv2.normalize(dct_roi, None, 0, 255, cv2.NORM_MINMAX)
img_dct_scaled = dct_scaled.astype(np.uint8)# 显示DCT系数的图像
plt.imshow(img_dct_scaled, cmap='gray')
plt.show()

pHash-0005

第五步：计算灰度均值

计算DCT变换后图像块的均值，以便后面确定每个块的明暗情况。

# 计算灰度均值：计算DCT变换后图像块的均值
img_avg = np.mean(img_dct)
print(f"DCT变换后图像块的均值={img_avg}")

输出打印：

DCT变换后图像块的均值=7.814879417419434

第六步：生成二进制哈希值

如果块的DCT系数高于均值，表示为1，否则表示为0。

由于我们只提取了DCT矩阵左上角的8×8系数子矩阵（图片特征频率区域），所以，最后会得到一个64位的二进制值（8x8像素的灰度图像）。

# 生成二进制哈希值
img_hash_str = ''
for i in range(8):for j in range(8):if img_dct[i, j] > img_avg:img_hash_str += '1'else:img_hash_str += '0'
print(f"图像的二进制哈希值={img_hash_str}")

或者，使用等价的 lambda 表达式。效果一样。

img_hash_str = ""
for i in range(8):img_hash_str += ''.join(map(lambda i: '0' if i < img_avg else '1', img_dct[i]))
print(f"图像的二进制哈希值={img_hash_str}")

输出打印：

图像的二进制哈希值=1011000010001000100000100010000000001000000000001000000000000000

第七步：图像可识别的哈希值

由于64位二进制值太长，所以按每4个字符为1组，由2进制转成16进制。这样就转为一个长度为16的字符串。这个字符串也就是这个图像可识别的哈希值，也叫图像指纹，即这个图像所包含的特征。

# 生成图像可识别哈希值
img_hash = ''
for i in range(0, 64, 4):img_hash += ''.join('%x' % int(img_hash_str[i: i + 4], 2))
print(f"图像可识别的哈希值={img_hash}")

输出打印：

图像可识别的哈希值=b088822008008000

第八步：哈希值比较

通过比较两个图像的哈希值的汉明距离（Hamming Distance），就可以评估图像的相似度，距离越小表示图像越相似。

def hamming_distance(s1, s2):# 检查这两个字符串的长度是否相同。如果长度不同，它会引发 ValueError 异常，因为汉明距离只适用于等长的字符串if len(s1) != len(s2):raise ValueError("Input strings must have the same length")distance = 0for i in range(len(s1)):# 遍历两个字符串的每个字符，比较它们在相同位置上的值。如果发现不同的字符，将 distance 的值增加 1if s1[i] != s2[i]:distance += 1return distance

 

4. 测试

我们来简单测试一下基于感知哈希算法的以图搜图 – 基于一张原图找最相似图片，看看效果如何。
这里，我准备了10张图片，其中9张是苹果，但形态不一，1张是梨子。
pHash-0006
输出打印：

图片名称：img_test/apple-01.jpg，图片HASH：b080000088000000，与图片1的近似值（汉明距离）：0
图片名称：img_test/apple-02.jpg，图片HASH：a080000018000000，与图片1的近似值（汉明距离）：2
图片名称：img_test/apple-03.jpg，图片HASH：b020000080000000，与图片1的近似值（汉明距离）：2
图片名称：img_test/apple-04.jpg，图片HASH：a480000020000000，与图片1的近似值（汉明距离）：4
图片名称：img_test/apple-05.jpg，图片HASH：a400000044000000，与图片1的近似值（汉明距离）：5
图片名称：img_test/apple-06.jpg，图片HASH：f881000084000000，与图片1的近似值（汉明距离）：4
图片名称：img_test/apple-07.jpg，图片HASH：e408000090000000，与图片1的近似值（汉明距离）：6
图片名称：img_test/apple-08.jpg，图片HASH：cad9522236480010，与图片1的近似值（汉明距离）：13
图片名称：img_test/apple-09.jpg，图片HASH：b000000098000000，与图片1的近似值（汉明距离）：2
图片名称：img_test/pear-001.jpg，图片HASH：e0000000c8000000，与图片1的近似值（汉明距离）：3
耗时：0.08439445495605469

汉明距离：两个长度相同的字符串在相同位置上的字符不同的个数。
pHash-0007

简单的测试分析：

原图相似图片相似值（汉明距离）相似图片特点相似图片与原图Hash对比结果
图片01图片010自己自己与自己相似度100%
图片01图片02、03、092主体形状、位置、背景基本相似最相似。相同背景、相同物体、同相位置下最相似。
图片01图片pear-0013黄色的梨子意外相似。相似搜索并不能识别物体/内容。
图片01图片04、图片064原图像的180度旋转图；多主体比较相似。对于多主体、原图旋转变换相似搜索友好，因为经过DCT变换后，图像的能量特征集中在图像的左上角。
图片01图片055青苹果（2D）比较相似。对于2D的扁平相似图片搜索也相对友好。
图片01图片076背景差异、多色调勉强相似。对于背景差异、多色调的图片开始查找吃力。
图片01图片0810以上背景差异、多色调较难分辨。复杂背景差异、多色调的图片较难与原图相似。

10张测试图片中，汉明距离在5以内的有8张图片；汉明距离在10以外只有1张图片。
从抽样简单测试结果看，感知哈希算法表现更友好、更准确。

备注：如果汉明距离0，则表示这两张图片非常相似；如果汉明距离小于5，则表示有些不同，但比较相近；如果汉明距离大于10，则表明是完全不同的图片。

 

5. 总结

经过实验和测试，感知哈希算法的撸棒性更好。总体与均值哈希算法（aHash）差不多，区别在于二值化方式不一样。

特点： 传统
优点： 简单、相对准确、计算效率高；感知哈希考虑了图像的全局特征，对图像的尺寸和旋转变化具有一定的鲁棒性；适用于快速图像相似性搜索。
缺点： 对一些局部变化不够敏感；对于复杂、多色调的图像较难辨别，属于一种外观相似的相似度计算。

 

6. 实验代码

"""
以图搜图：感知哈希算法（Perceptual Hash Algorithm，简称pHash）的原理与实现
测试环境：win10 | python 3.9.13 | OpenCV 4.4.0 | numpy 1.21.1
实验时间：2023-10-22
"""import cv2
import time
import numpy as np
import matplotlib.pyplot as pltdef get_hash(img_path):# 读取图像：通过OpenCV的imread加载图像# 缩小图像：使用OpenCV的resize函数将图像缩放为32x32像素，采用Cubic插值方法进行图像重采样img = cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB)img = cv2.resize(img, (32, 32), cv2.INTER_CUBIC)# 图像灰度化：将彩色图像转换为灰度图像。img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)# print(f"缩放32x32的图像中每个像素的颜色=\n{img_gray}")# 离散余弦变换（DCT）：计算图像的DCT变换，得到32×32的DCT变换系数矩阵img_dct = cv2.dct(np.float32(img_gray))# print(f"灰度图像离散余弦变换（DCT）={img_dct}")# 缩放DCT：将DCT系数的大小显式地调整为8x8。然后它计算调整后的DCT系数的均值，并生成哈希值。# dct_roi = img_dct[0:8, 0:8]img_dct.resize(8, 8)# 计算灰度均值：计算DCT变换后图像块的均值img_avg = np.mean(img_dct)# print(f"DCT变换后图像块的均值={img_avg}")"""# # 生成二进制哈希值# img_hash_str = ''# for i in range(8):#     for j in range(8):#         if img_dct[i, j] > img_avg:#             img_hash_str += '1'#         else:#             img_hash_str += '0'# print(f"图像的二进制哈希值={img_hash_str}")# # 生成图像可识别哈希值# img_hash = ''# for i in range(0, 64, 4):#     img_hash += ''.join('%x' % int(img_hash_str[i: i + 4], 2))# print(f"图像可识别的哈希值={img_hash}")"""img_hash_str = ""for i in range(8):img_hash_str += ''.join(map(lambda i: '0' if i < img_avg else '1', img_dct[i]))# print(f"图像的二进制哈希值={img_hash_str}")# 生成图像可识别哈希值img_hash = ''.join(map(lambda x:'%x' % int(img_hash_str[x : x + 4], 2), range(0, 64, 4)))# print(f"图像可识别的哈希值={img_hash}")return img_hash# 汉明距离：计算两个等长字符串（通常是二进制字符串或位字符串）之间的汉明距离。用于确定两个等长字符串在相同位置上不同字符的数量。
def hamming_distance(s1, s2):# 检查这两个字符串的长度是否相同。如果长度不同，它会引发 ValueError 异常，因为汉明距离只适用于等长的字符串if len(s1) != len(s2):raise ValueError("Input strings must have the same length")distance = 0for i in range(len(s1)):# 遍历两个字符串的每个字符，比较它们在相同位置上的值。如果发现不同的字符，将 distance 的值增加 1if s1[i] != s2[i]:distance += 1return distance# --------------------------------------------------------- 测试 ---------------------------------------------------------time_start = time.time()img_1 = 'img_test/apple-01.jpg'
img_2 = 'img_test/apple-02.jpg'
img_3 = 'img_test/apple-03.jpg'
img_4 = 'img_test/apple-04.jpg'
img_5 = 'img_test/apple-05.jpg'
img_6 = 'img_test/apple-06.jpg'
img_7 = 'img_test/apple-07.jpg'
img_8 = 'img_test/apple-08.jpg'
img_9 = 'img_test/apple-09.jpg'
img_10 = 'img_test/pear-001.jpg'img_hash1 = get_hash(img_1)
img_hash2 = get_hash(img_2)
img_hash3 = get_hash(img_3)
img_hash4 = get_hash(img_4)
img_hash5 = get_hash(img_5)
img_hash6 = get_hash(img_6)
img_hash7 = get_hash(img_7)
img_hash8 = get_hash(img_8)
img_hash9 = get_hash(img_9)
img_hash10 = get_hash(img_10)distance1 = hamming_distance(img_hash1, img_hash1)
distance2 = hamming_distance(img_hash1, img_hash2)
distance3 = hamming_distance(img_hash1, img_hash3)
distance4 = hamming_distance(img_hash1, img_hash4)
distance5 = hamming_distance(img_hash1, img_hash5)
distance6 = hamming_distance(img_hash1, img_hash6)
distance7 = hamming_distance(img_hash1, img_hash7)
distance8 = hamming_distance(img_hash1, img_hash8)
distance9 = hamming_distance(img_hash1, img_hash9)
distance10 = hamming_distance(img_hash1, img_hash10)time_end = time.time()print(f"图片名称：{img_1}，图片HASH：{img_hash1}，与图片1的近似值（汉明距离）：{distance1}")
print(f"图片名称：{img_2}，图片HASH：{img_hash2}，与图片1的近似值（汉明距离）：{distance2}")
print(f"图片名称：{img_3}，图片HASH：{img_hash3}，与图片1的近似值（汉明距离）：{distance3}")
print(f"图片名称：{img_4}，图片HASH：{img_hash4}，与图片1的近似值（汉明距离）：{distance4}")
print(f"图片名称：{img_5}，图片HASH：{img_hash5}，与图片1的近似值（汉明距离）：{distance5}")
print(f"图片名称：{img_6}，图片HASH：{img_hash6}，与图片1的近似值（汉明距离）：{distance6}")
print(f"图片名称：{img_7}，图片HASH：{img_hash7}，与图片1的近似值（汉明距离）：{distance7}")
print(f"图片名称：{img_8}，图片HASH：{img_hash8}，与图片1的近似值（汉明距离）：{distance8}")
print(f"图片名称：{img_9}，图片HASH：{img_hash9}，与图片1的近似值（汉明距离）：{distance9}")
print(f"图片名称：{img_10}，图片HASH：{img_hash10}，与图片1的近似值（汉明距离）：{distance10}")print(f"耗时：{time_end - time_start}")

 

7. 疑难杂症

是否有很多问号？

为什么要缩放DCT？DCT缩放方式有哪些？不同DCT缩放方式有何不同？不进行DCT缩放效果会怎么样？

对于这些问题，我们来通过下面三组对比分析，一探究竟。

7.1 过程对比

方式一： DCT变换后，无DCT特征频率区域缩放
方式二： DCT变换后，将DCT系数显式调整为8x8
方式三： DCT变换后，只提取DCT系数左上角8x8像素
pHash-0008
从上图的DCT变换过程来看，从原图读取，到缩小到指定大小的像素图像，再到像素图像灰度化，对于图像的加工结果都是一样的。区别仅在于对灰度图像使用离散余弦变换（DCT）之后，对DCT系数的使用方式不一样。

7.2 结果对比

1）纵向对比

同一张图片使用不同DCT变换方式获得的哈希值结果：

方式一：离散余弦变换DCT变换后，无DCT特征频率区域缩放，获得图像的二进制哈希值=b3c3c682c9306640
方式二：离散余弦变换DCT变换后，将DCT系数显式调整为8x8，获得图像的二进制哈希值=b080000088000000
方式三：离散余弦变换DCT变换后，只提取DCT系数左上角8x8像素，获得图像的二进制哈希值=b088822008008000

从上述的DCT变换结果来看，同一张图片获得图像的二进制哈希值各不一样。

  • 方式一与方式二、方式三的结果相差较大。
  • 方式二与方式三的结果也不尽一致。

2）横向对比

不同图片使用相同DCT变换方式获得的哈希值结果：
pHash-0009
从上图的DCT变换结果来看，不同图片使用不同方式的DCT变换，最终查找的相似图片结果都不尽相同。

  • 从DCT变换方式维度看，方式二，将DCT系数显示调整为8x8的查找效果最好。方式三其次。方式一最次。
  • 从DCT变换方式的计算效率来看，方式二与方式三耗时相当，计算效率较高；而方式一，由于无DCT特征频率区域缩放，所以计算量最大，效率最次。

7.3 代码对比

"""
以图搜图：感知哈希算法（Perceptual Hash Algorithm，简称pHash）的原理与实现
测试环境：win10 | python 3.9.13 | OpenCV 4.4.0 | numpy 1.21.1
实验时间：2023-10-22
"""# ---------------------------------------------------------------------------------------------------------------------
# 测试：为什么要缩放DCT？DCT缩放方式有哪些？不同DCT缩放方式有何不同？不进行DCT缩放效果会怎么样？
# ---------------------------------------------------------------------------------------------------------------------import cv2
import time
import numpy as np
import matplotlib.pyplot as plt# DCT变换后：无特征频率区域缩放，使用整个32x32图像块的频率分布，计算整个DCT系数的均值，并根据这个均值生成哈希值。
def get_pHash1(img_path):img = cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB)# plt.imshow(img, cmap='gray')# plt.show()img = cv2.resize(img, (32, 32), cv2.INTER_CUBIC)# plt.imshow(img, cmap='gray')# plt.show()img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)# plt.imshow(img_gray, cmap='gray')# plt.show()img_dct = cv2.dct(np.float32(img_gray))# 显示DCT系数的图像# dct_scaled = cv2.normalize(img_dct, None, 0, 255, cv2.NORM_MINMAX)# img_dct_scaled = dct_scaled.astype(np.uint8)# plt.imshow(img_dct_scaled, cmap='gray')# plt.show()img_avg = np.mean(img_dct)# print(f"DCT变换后图像块的均值={img_avg}")img_hash_str = get_img_hash_binary(img_dct, img_avg)# print(f"图像的二进制哈希值={img_hash_str}")img_hash = get_img_hash(img_hash_str)return img_hash# DCT变换后：将DCT系数的大小显式地调整为8x8，使用8x8的DCT系数块的频率分布，计算调整后的DCT系数的均值，并生成哈希值。
def get_pHash2(img_path):img = cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB)# plt.imshow(img, cmap='gray')# plt.show()img = cv2.resize(img, (32, 32), cv2.INTER_CUBIC)# plt.imshow(img, cmap='gray')# plt.show()img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)# plt.imshow(img_gray, cmap='gray')# plt.show()img_dct = cv2.dct(np.float32(img_gray))img_dct.resize(8, 8)# 显示DCT系数的图像# dct_scaled = cv2.normalize(img_dct, None, 0, 255, cv2.NORM_MINMAX)# img_dct_scaled = dct_scaled.astype(np.uint8)# plt.imshow(img_dct_scaled, cmap='gray')# plt.show()img_avg = np.mean(img_dct)# print(f"DCT变换后图像块的均值={img_avg}")img_hash_str = get_img_hash_binary(img_dct, img_avg)# print(f"图像的二进制哈希值={img_hash_str}")img_hash = get_img_hash(img_hash_str)return img_hash# DCT变换后：只提取DCT系数的左上角8x8块的信息，然后计算这个块的均值。此法只考虑图像一小部分的频率分布，并生成哈希值。
def get_pHash3(img_path):img = cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB)# plt.imshow(img, cmap='gray')# plt.show()img = cv2.resize(img, (32, 32), cv2.INTER_CUBIC)# plt.imshow(img, cmap='gray')# plt.show()img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)# plt.imshow(img_gray, cmap='gray')# plt.show()img_dct = cv2.dct(np.float32(img_gray))dct_roi = img_dct[0:8, 0:8]# 显示DCT系数的图像# dct_scaled = cv2.normalize(dct_roi, None, 0, 255, cv2.NORM_MINMAX)# img_dct_scaled = dct_scaled.astype(np.uint8)# plt.imshow(img_dct_scaled, cmap='gray')# plt.show()img_avg = np.mean(dct_roi)# print(f"DCT变换后图像块的均值={img_avg}")img_hash_str = get_img_hash_binary(dct_roi, img_avg)# print(f"图像的二进制哈希值={img_hash_str}")img_hash = get_img_hash(img_hash_str)return img_hashdef get_img_hash_binary(img_dct, img_avg):img_hash_str = ''for i in range(8):img_hash_str += ''.join(map(lambda i: '0' if i < img_avg else '1', img_dct[i]))# print(f"图像的二进制哈希值={img_hash_str}")return img_hash_strdef get_img_hash(img_hash_str):img_hash = ''.join(map(lambda x:'%x' % int(img_hash_str[x : x + 4], 2), range(0, 64, 4)))# print(f"图像可识别的哈希值={img_hash}")return img_hash# 汉明距离：计算两个等长字符串（通常是二进制字符串或位字符串）之间的汉明距离。用于确定两个等长字符串在相同位置上不同字符的数量。
def hamming_distance(s1, s2):# 检查这两个字符串的长度是否相同。如果长度不同，它会引发 ValueError 异常，因为汉明距离只适用于等长的字符串if len(s1) != len(s2):raise ValueError("Input strings must have the same length")distance = 0for i in range(len(s1)):# 遍历两个字符串的每个字符，比较它们在相同位置上的值。如果发现不同的字符，将 distance 的值增加 1if s1[i] != s2[i]:distance += 1return distance# ======================================== 测试场景一 ========================================# img = 'img_test/apple-01.jpg'# img_hash1 = get_phash1(img)
# img_hash2 = get_phash2(img)
# img_hash3 = get_phash3(img)# print(f"方式一：DCT变换后，无DCT特征频率区域缩放，获得图像的二进制哈希值={img_hash1}")
# print(f"方式二：DCT变换后，将DCT系数显式调整为8x8，获得图像的二进制哈希值={img_hash2}")
# print(f"方式三：DCT变换后，只提取DCT系数左上角8x8像素，获得图像的二进制哈希值={img_hash3}")# ======================================== 测试场景二 ========================================time_start = time.time()img_1 = 'img_test/apple-01.jpg'
img_2 = 'img_test/apple-02.jpg'
img_3 = 'img_test/apple-03.jpg'
img_4 = 'img_test/apple-04.jpg'
img_5 = 'img_test/apple-05.jpg'
img_6 = 'img_test/apple-06.jpg'
img_7 = 'img_test/apple-07.jpg'
img_8 = 'img_test/apple-08.jpg'
img_9 = 'img_test/apple-09.jpg'
img_10 = 'img_test/pear-001.jpg'# ------------------------------------- 测试场景二：方式一 --------------------------------------# img_hash1 = get_pHash1(img_1)
# img_hash2 = get_pHash1(img_2)
# img_hash3 = get_pHash1(img_3)
# img_hash4 = get_pHash1(img_4)
# img_hash5 = get_pHash1(img_5)
# img_hash6 = get_pHash1(img_6)
# img_hash7 = get_pHash1(img_7)
# img_hash8 = get_pHash1(img_8)
# img_hash9 = get_pHash1(img_9)
# img_hash10 = get_pHash1(img_10)# ------------------------------------- 测试场景二：方式二 --------------------------------------img_hash1 = get_pHash2(img_1)
img_hash2 = get_pHash2(img_2)
img_hash3 = get_pHash2(img_3)
img_hash4 = get_pHash2(img_4)
img_hash5 = get_pHash2(img_5)
img_hash6 = get_pHash2(img_6)
img_hash7 = get_pHash2(img_7)
img_hash8 = get_pHash2(img_8)
img_hash9 = get_pHash2(img_9)
img_hash10 = get_pHash2(img_10)# ------------------------------------- 测试场景二：方式三 --------------------------------------# img_hash1 = get_pHash3(img_1)
# img_hash2 = get_pHash3(img_2)
# img_hash3 = get_pHash3(img_3)
# img_hash4 = get_pHash3(img_4)
# img_hash5 = get_pHash3(img_5)
# img_hash6 = get_pHash3(img_6)
# img_hash7 = get_pHash3(img_7)
# img_hash8 = get_pHash3(img_8)
# img_hash9 = get_pHash3(img_9)
# img_hash10 = get_pHash3(img_10)distance1 = hamming_distance(img_hash1, img_hash1)
distance2 = hamming_distance(img_hash1, img_hash2)
distance3 = hamming_distance(img_hash1, img_hash3)
distance4 = hamming_distance(img_hash1, img_hash4)
distance5 = hamming_distance(img_hash1, img_hash5)
distance6 = hamming_distance(img_hash1, img_hash6)
distance7 = hamming_distance(img_hash1, img_hash7)
distance8 = hamming_distance(img_hash1, img_hash8)
distance9 = hamming_distance(img_hash1, img_hash9)
distance10 = hamming_distance(img_hash1, img_hash10)time_end = time.time()print(f"图片名称：{img_1}，图片HASH：{img_hash1}，与图片1的近似值（汉明距离）：{distance1}")
print(f"图片名称：{img_2}，图片HASH：{img_hash2}，与图片1的近似值（汉明距离）：{distance2}")
print(f"图片名称：{img_3}，图片HASH：{img_hash3}，与图片1的近似值（汉明距离）：{distance3}")
print(f"图片名称：{img_4}，图片HASH：{img_hash4}，与图片1的近似值（汉明距离）：{distance4}")
print(f"图片名称：{img_5}，图片HASH：{img_hash5}，与图片1的近似值（汉明距离）：{distance5}")
print(f"图片名称：{img_6}，图片HASH：{img_hash6}，与图片1的近似值（汉明距离）：{distance6}")
print(f"图片名称：{img_7}，图片HASH：{img_hash7}，与图片1的近似值（汉明距离）：{distance7}")
print(f"图片名称：{img_8}，图片HASH：{img_hash8}，与图片1的近似值（汉明距离）：{distance8}")
print(f"图片名称：{img_9}，图片HASH：{img_hash9}，与图片1的近似值（汉明距离）：{distance9}")
print(f"图片名称：{img_10}，图片HASH：{img_hash10}，与图片1的近似值（汉明距离）：{distance10}")print(f"耗时：{time_end - time_start}")

如上代码，这三种方法获取到的图像二进制哈希值之所以不同，是因为它们在DCT变换后的处理方式不同：

  • get_pHash1 方法： 这种方法首先将图像进行灰度化，然后执行DCT变换。接着，它计算整个DCT系数的均值，并根据这个均值生成哈希值。这意味着它考虑了整个32x32图像块的频率分布。
  • get_pHash2 方法： 这种方法在执行DCT后，将DCT系数的大小显式地调整为8x8。然后它计算调整后的DCT系数的均值，并生成哈希值。这个方法只考虑了8x8的DCT系数块的频率分布。
  • get_pHash3 方法： 这种方法与 get_pHash2 类似，但它只提取了DCT系数的左上角8x8块的信息（即ROI，感兴趣区域），然后计算这个块的均值。这个方法只考虑了图像的一个小部分频率分布。

由于这些方法考虑的DCT系数区域不同，它们生成的哈希值会有差异。一般来说，get_pHash1 方法考虑了整个图像块的频率分布，因此哈希值可能更稳定，但它也可能受到图像整体性的影响。而 get_pHash2 和 get_pHash3 方法只考虑了一个小块的频率信息，所以哈希值可能更容易受到图像的局部特征影响。

选择哪种方法取决于你的应用需求。如果你希望更稳定的哈希值，get_pHash1 可能是一个不错的选择。如果你希望更灵敏地检测局部特征，get_pHash2 或 get_pHash3 可能更适合。

 

8. 系列书签

OpenCV #以图搜图：均值哈希算法（Average Hash Algorithm）原理与实验

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/118356.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

FPGA驱动步进电机-Sin曲线加速

FPGA驱动步进电机-Sin曲线加速

FPGA驱动步进电机-Sin曲线加速 基本实现原理实际仿真的波形程序 以下由特权同学的FPGA文档摘取 Sin 曲线控制 step 脉冲信号生成的功能框图如下所示。 基本实现原理 ①判断步进电机驱动的目标频率 stepper_delay_target 与当前频率 stepper_delay_current的值是否一致&#…
阅读更多...
360智慧生活旗舰产品率先接入“360智脑”能力实现升级

360智慧生活旗舰产品率先接入“360智脑”能力实现升级

10月25日&#xff0c;360智慧生活秋季新品及视觉云方案发布会在深圳召开。360智能硬件产品&#xff0c;诸如 360可视门铃、360智能摄像机、360行车记录仪、360儿童手表和家庭防火墙等&#xff0c;都在各自的行业有着举足轻重得地位&#xff0c;而这次发布的系列新品&#xff0c…
阅读更多...
2023高频前端面试题-vue

2023高频前端面试题-vue

1. 什么是 M V VM Model-View-ViewModel 模式 Model 层: 数据模型层 通过 Ajax、fetch 等 API 完成客户端和服务端业务模型的同步。 View 层: 视图层 作为视图模板存在&#xff0c;其实 View 就是⼀个动态模板。 ViewModel 层: 视图模型层 负责暴露数据给 View 层&…
阅读更多...
mysql 命令行安装

mysql 命令行安装

一、安装包下载 1、下载压缩包 &#xff08;1&#xff09;公众号获取 关注微信公众号【I am Walker】&#xff0c;回复“mysql”获取 &#xff08;2&#xff09;官网下载 安装地址MySQL :: Download MySQL Community Server ​ ​ 二、解压 下载完之后进行解压&…
阅读更多...
vscode代码快捷输入

vscode代码快捷输入

Vscode代码片段快捷输入 常用的代码片段为了避免重复输入,可以使用Vsco的中用户代码片段进行设置,这样就可以实现快捷输入. 操作流程 如下 打开vscode的设置 2. 找到用户代码片段 3. 选择模板 4. 然后写入代码片段即可 上面的代码片段可以设置多个,看自己 重点关注的是 prefi…
阅读更多...
勒索病毒最新变种.locked1勒索病毒来袭，如何恢复受感染的数据？

勒索病毒最新变种.locked1勒索病毒来袭，如何恢复受感染的数据？

引言&#xff1a; 在当今数字化时代&#xff0c;网络威胁不断进化&#xff0c;.locked1勒索病毒就是其中一种常见的恶意软件。这种病毒会加密您的文件&#xff0c;然后勒索赎金以解锁它们。本文将详细介绍.locked1勒索病毒&#xff0c;包括如何恢复被加密的数据文件和如何预防…
阅读更多...
微信小程序投票管理系统：打造智能、便捷的投票体验

微信小程序投票管理系统：打造智能、便捷的投票体验

前言 随着社交网络的兴起和移动互联网的普及&#xff0c;人们对于参与和表达意见的需求越来越强烈。在这个背景下&#xff0c;微信小程序投票管理系统应运而生。它为用户提供了一个智能、便捷的投票平台&#xff0c;使用户可以轻松创建和参与各种类型的投票活动。本文将详细介…
阅读更多...
嚼一嚼Halcon中的3D手眼标定

嚼一嚼Halcon中的3D手眼标定

文章目录 一、问题概述1、何为手眼标定&#xff1f;2、手眼标定的2种形式1&#xff09;眼在手上&#xff08;eye in hand&#xff09;&#xff1a;即相机固定在机械臂末端2&#xff09;眼在手外&#xff08;eye to hand&#xff09;&#xff1a;即相机固定在机械臂以外的地方 3…
阅读更多...
微信小程序：点击按钮出现右侧弹窗

微信小程序：点击按钮出现右侧弹窗

效果 代码 wxml <!-- 弹窗信息 --> <view class"popup-container" wx:if"{{showPopup}}"><view class"popup-content"><!-- 弹窗内容 --><text>这是一个右侧弹窗</text></view> </view> <…
阅读更多...
Linux：实用操作

Linux：实用操作

Linux&#xff1a;实用操作 1. 各类小技巧1.1 controlc(ctrl c) 强制停止1.2 可以通过快捷键&#xff1a;control d(ctrl d)&#xff0c;退出账户的登录1.3 历史命令搜索1.4 光标移动快捷键 2. 软件安装2.1 介绍2.2 yum命令(需要root权限)在这里插入图片描述 3. systemctl4.…
阅读更多...
Java CC 解析 SQL 语法示例

Java CC 解析 SQL 语法示例

示例&#xff1a;SimpleSelectParser 解析 select 11; 输出 2&#xff1b; 0&#xff09;总结 编写 JavaCC 模板&#xff0c;*.jj 文件。 编译生成代码文件。 移动代码文件到对应的包下。 调用生成的代码文件。 1&#xff09;JavaCC 模板 main/javacc/SimpleSelectParse…
阅读更多...
【疯狂Java】数组

【疯狂Java】数组

1、一维数组 (1)初始化 ①静态初始化&#xff1a;只指定元素&#xff0c;不指定长度 new 类型[] {元素1,元素2,...} int[] intArr; intArr new int[] {5,6,7,8}; ②动态初始化&#xff1a;只指定长度&#xff0c;不指定元素 new 类型[数组长度] int[] princes new in…
阅读更多...
【Overload游戏引擎细节分析】Lambert材质Shader分析

【Overload游戏引擎细节分析】Lambert材质Shader分析

一、经典光照模型&#xff1a;Phong模型 现实世界的光照是极其复杂的&#xff0c;而且会受到诸多因素的影响&#xff0c;这是以目前我们所拥有的处理能力无法模拟的。经典光照模型冯氏光照模型(Phong Lighting Model)通过单独计算光源成分得到综合光照效果&#xff0c;然后添加…
阅读更多...
城市正视图（Urban Elevations, ACM/ICPC World Finals 1992, UVa221）rust解法

城市正视图（Urban Elevations, ACM/ICPC World Finals 1992, UVa221）rust解法

如图5-4所示&#xff0c;有n&#xff08;n≤100&#xff09;个建筑物。左侧是俯视图&#xff08;左上角为建筑物编号&#xff0c;右下角为高度&#xff09;&#xff0c;右侧是从南向北看的正视图。 输入每个建筑物左下角坐标&#xff08;即x、y坐标的最小值&#xff09;、宽度…
阅读更多...
React之diff原理

React之diff原理

一、是什么 跟Vue一致&#xff0c;React通过引入Virtual DOM的概念&#xff0c;极大地避免无效的Dom操作&#xff0c;使我们的页面的构建效率提到了极大的提升 而diff算法就是更高效地通过对比新旧Virtual DOM来找出真正的Dom变化之处 传统diff算法通过循环递归对节点进行依…
阅读更多...
嵌入式中的MCU、ARM、DSP、FPGA

嵌入式中的MCU、ARM、DSP、FPGA

目录 “角色扮演” MCU ARM 特点 DSP 特点 FPGA 特点 应用 “角色扮演” MCU&#xff08;Microcontroller Unit&#xff09;、ARM&#xff08;Advanced RISC Machine&#xff09;、DSP&#xff08;Digital Signal Processor&#xff09;和FPGA&#xff08;Field-Progr…
阅读更多...
PHP 危险函数2-代码执行语句

PHP 危险函数2-代码执行语句

代码执行语句 eval() 不是函数&#xff0c;不能被动态调用&#xff0c;并且需要以 ;结束 直接输出&#xff0c;不执行 <?php$code"phpinfo();";echo $code;?>eval() 语句执行 <?php$code"phpinfo();";eval($code); // eval 不是函数&am…
阅读更多...
【TGRS 2023】RingMo: A Remote Sensing Foundation ModelWith Masked Image Modeling

【TGRS 2023】RingMo: A Remote Sensing Foundation ModelWith Masked Image Modeling

RingMo: A Remote Sensing Foundation Model With Masked Image Modeling, TGRS 2023 论文&#xff1a;https://ieeexplore.ieee.org/stamp/stamp.jsp?tp&arnumber9844015 代码&#xff1a;https://github.com/comeony/RingMo MindSpore/RingMo-Framework (gitee.com) …
阅读更多...
软件测试之【单元测试、系统测试、集成测试】

软件测试之【单元测试、系统测试、集成测试】

一、单元测试的概念 单元测试&#xff08;Unit Testing&#xff09;是对软件基本组成单元进行的测试&#xff0c;如函数&#xff08;function或procedure&#xff09;或一个类的方法&#xff08;method&#xff09;。当然这里的基本单元不仅仅指的是一个函数或者方法&#xff…
阅读更多...
Python：实现日历功能

Python：实现日历功能

背景 日常生活中&#xff0c;每天都要用到日历&#xff0c;日历成为我们生活中的必需品&#xff0c;那么如何制作日历呢&#xff0c;其实方法有很多&#xff0c;可以直接在excel中制作&#xff0c;也可以手画等等。 学习过编程的朋友&#xff0c;能否想到用Python编写一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023