OpenCV #以图搜图:感知哈希算法(Perceptual hash algorithm)的原理与实验

news2024/9/25 17:16:58

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 = 0
    for i in range(len(s1)):
        # 遍历两个字符串的每个字符,比较它们在相同位置上的值。如果发现不同的字符,将 distance 的值增加 1
        if s1[i] != s2[i]:
            distance += 1
    return 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 plt

def 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 = 0
    for i in range(len(s1)):
        # 遍历两个字符串的每个字符,比较它们在相同位置上的值。如果发现不同的字符,将 distance 的值增加 1
        if s1[i] != s2[i]:
            distance += 1
    return 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_hash

def 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_str

def 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 = 0
    for i in range(len(s1)):
        # 遍历两个字符串的每个字符,比较它们在相同位置上的值。如果发现不同的字符,将 distance 的值增加 1
        if s1[i] != s2[i]:
            distance += 1
    return 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.coloradmin.cn/o/1133774.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

嵌入式算法——傅里叶变换算法

文章引注 https://mp.weixin.qq.com/s/5VIpNWci9YLY3m4gcYd6-w 摘要 傅里叶变换的核心在于&#xff0c;“任何连续周期信号可以由一组适当的正弦曲线组合而成”&#xff0c;在这个基础上对信号的中特定频率的正弦波进行分解或者重组&#xff0c;基于频率方面分析波形。 1、傅…

java _JDBC 开发

目录 一.封装JDBCUtiles 二.事务 三.批处理 四.数据库连接池 C3P0 Druidf(德鲁伊&#xff09;阿里 五.Apache-DBUtiles 六.Apache-DBUtils 七.DAO 和增删改查 通用方法 - BasicDao 一.封装JDBCUtiles 说明&#xff1a;在jdbc操作中&#xff0c;获取连接和释放资源&#…

民宿如何经营与管理?【民宿小程序】

随着旅游业的快速发展&#xff0c;越来越多的人选择经营民宿&#xff0c;将自己的房屋开放给旅客入住。然而&#xff0c;要成功经营一家民宿&#xff0c;并保持良好的运营状态&#xff0c;需要有效的管理和营销策略。在这个过程中&#xff0c;民宿小程序能够发挥重要作用。 民宿…

Python---练习:for循环 求1-100的和/所有偶数的和

案例&#xff1a; 使用for循环&#xff0c;求1 ~ 100的和 之前用while循环&#xff0c;做过算出1--100的和。 相关链接&#xff1a; Python--练习&#xff1a;使用while循环求1..100的和-CSDN博客 结合着看看for循环怎么实现。 思考&#xff1a; 先把for循环的基本语法写…

使用udevil自动挂载U盘或者USB移动硬盘

最近在折腾用树莓派&#xff08;实际上是平替香橙派orangepi zero3&#xff09;搭建共享文件服务器&#xff0c;有一个问题很重要&#xff0c;如何在系统启动时自动挂载USB移动硬盘。 1 使用/etc/fstab 最开始尝试了用/etc/fstab文件下增加:"/dev/sda1 /home/orangepi/s…

Unity 中忽略图片透明度的 Image 组件的修改版本

只需将此组件添加到画布中的空对象即可。请注意&#xff0c;仅支持简单 图像类型。 using System.Collections.Generic; using UnityEngine; using UnityEngine.Sprites; using UnityEngine.UI; #if UNITY_2017_4 || UNITY_2018_2_OR_NEWER using UnityEngine.U2D; #endif#if U…

分类预测 | MATLAB实现SSA-CNN-BiGRU-Attention数据分类预测(SE注意力机制)

分类预测 | MATLAB实现SSA-CNN-BiGRU-Attention数据分类预测&#xff08;SE注意力机制&#xff09; 目录 分类预测 | MATLAB实现SSA-CNN-BiGRU-Attention数据分类预测&#xff08;SE注意力机制&#xff09;分类效果基本描述模型描述程序设计参考资料 分类效果 基本描述 1.MATLA…

微信小程序如何跳转页面

1.wx.navigateTo&#xff1a;用于跳转到其他页面&#xff0c;并保留当前页面。通过该 API 跳转后&#xff0c;可以通过返回按钮回到原页面。 wx.navigateTo({url: /pages/otherPage/otherPage })2.wx.redirectTo&#xff1a;用于跳转到其他页面&#xff0c;并关闭当前页面。通…

上初三的小伙子做了个windows12网页版

某天逛GitHub突然刷到这个仓库&#xff0c;好奇的点了进去&#xff0c;读完md我懵了&#xff0c;作者才初三&#xff1f;wtf&#xff0c;现在内卷到这个程度了吗&#xff01;而且start还不低有5.2k。 效果展示 新的版本有很多变化&#xff0c;仅供参考&#xff0c;请以实物为准…

SpringBoot 自动配置@EnableAutoConfiguration

自动配置vs自动装配 Spring有两个名字听起来相似的概念&#xff1a;一个是自动装配&#xff0c;一个是自动配置。他们两个只是听起来相似&#xff0c;实际根本不同。自动装配是autowire&#xff0c;自动配置是autoconfiguration&#xff0c;他们之间没有任何关系&#xff0c;概…

ARM 版 OpenEuler 22.03 部署 KubeSphere v3.4.0 不完全指南

作者&#xff1a;运维有术 前言 知识点 定级&#xff1a;入门级KubeKey 安装部署 ARM 版 KubeSphere 和 KubernetesARM 版 KubeSphere 和 Kubernetes 常见问题 实战服务器配置 (个人云上测试服务器) 主机名IPCPU内存系统盘数据盘用途ks-master-1172.16.33.1661650200KubeSp…

翻页电子相册如何制作?看到就是赚到

在日常生活中&#xff0c;我们拿起手机随手一拍&#xff0c;即可记录美丽瞬间。但随着手机里的照片越来越多&#xff0c;这时该怎么办呢&#xff1f;相信很多小伙伴会选择把照片装订成相册&#xff0c;不过&#xff0c;时间一长也都成了压箱底&#xff0c;无人翻看。但除了这一…

sheng的学习笔记-【中】【吴恩达课后测验】Course 3 - 结构化机器学习项目 - 第一周测验

课程3_第1周_测验题 目录&#xff1a;目录 要解决的问题 ① 这个例子来源于实际项目&#xff0c;但是为了保护机密性&#xff0c;我们会对细节进行保护。 ② 现在你是和平之城的著名研究员&#xff0c;和平之城的人有一个共同的特点&#xff1a;他们害怕鸟类。 ③ 为了保护…

MyBatis-Plus 通过updateById更新日期null

date类型的字段为 一、需求&#xff1a; 有时候需要将页面日期重新赋值空&#xff0c;但是Mybatis Plus 默认情况下&#xff0c;baseMapper.updateById方法&#xff0c;当doman中字段值为null&#xff0c;后端并会不更新这个字段 解决方法&#xff1a; 对应的实体类的属性加…

浅谈智能制造

智能制造 如今&#xff0c;同一版本同一型号的手机&#xff0c;几乎是一模一样的。当我们说去选购商品&#xff0c;其实是在有限的型号中选择我们需要的那一款。可是&#xff0c;人的需求千变万化&#xff0c;为什么偏偏要归结到几个固定的型号上去呢&#xff1f;每个人不应该…

2023/10/25MySQL学习

外键约束 在子表添加外键后,不能在主表删除或更新记录,因为存在外键关联 删除外键,注意外键名称时我们添加外键时起的名称 使用cascade操作后,可以操作主表数据,并且子表的外键也会对应改变 set null的话,删除主表对应主键信息后,子表对应外键信息变为空 多表关系 创建中间表 可…

JavaScript进阶 第四天笔记——深浅拷贝、this绑定、防抖节流

JavaScript 进阶 - 第4天 深浅拷贝 浅拷贝 首先浅拷贝和深拷贝只针对引用类型 浅拷贝&#xff1a;拷贝的是地址 常见方法&#xff1a; 拷贝对象&#xff1a;Object.assgin() / 展开运算符 {…obj} 拷贝对象拷贝数组&#xff1a;Array.prototype.concat() 或者 […arr] 如…

NSSCTF做题第9页(3)

[GKCTF 2020]CheckIN 代码审计 这段代码定义了一个名为ClassName的类&#xff0c;并在脚本的最后创建了一个ClassName类的实例。 在ClassName类的构造函数中&#xff0c;首先通过调用$this->x()方法获取了请求参数$_REQUEST中的值&#xff0c;并将其赋值给$this->code属性…

Android [SPI,AutoSerivce,ServiceLoader]

记录一下在Android中使用SPI的过程。 1.项目gralde文件。 plugins {id kotlin-kapt } dependencies {implementation com.google.auto.service:auto-service:1.0-rc7 kapt "com.google.auto.service:auto-service:1.0-rc7" } 这个AutoServ…

【Qt】绘图与绘图设备

文章目录 绘图设备QPainter绘图实例案例1案例2-高级设置案例3&#xff1a;利用画家画资源图片 点击按钮移动图片 QtPaintDevice实例Pixmap绘图设备QImage 绘图设备QPicture 绘图设备 QPainter绘图 Qt 的绘图系统允许使用相同的 API 在屏幕和其它打印设备上进行绘制。整个绘图系…