图片批量去重---（均值哈希、插值哈希、感知哈希、三/单通道直方图）

最新推荐文章于 2025-07-04 14:47:23 发布

原创最新推荐文章于 2025-07-04 14:47:23 发布 · 826 阅读

13 ·

CC 4.0 BY-SA版权

文章标签：

#均值算法 #哈希算法 #直方图 #图片去重

数据 / 脚本处理专栏收录该内容

8 篇文章

订阅专栏

一、整体步骤

本脚本中，关键步骤包括以下步骤：

1、图片加载：

脚本会遍历指定的图片目录，将所有图片加载到内存中。

2、图像预处理：

比较之前，通常需要对图片进行预处理，如调整大小、灰度化或直方图均衡化，以消除颜色、尺寸等因素的影响。

3、相似度计算：

图像相似度的衡量有很多种方法，如像素级别的差异（均方误差）、结构相似度指数 (SSIM)、归一化互信息(NMI)或者哈希算法（如PCA-SIFT、BRIEF等）。OpenCV提供了部分功能来实现这些算法，例如`cv2.compareHist`可以用于直方图比较。

4、阈值设置：

根据实际需求，设定一个相似度阈值，低于这个阈值的图片被认为是重复的。该阈值可能需要通过实验调整以达到最佳效果。

5、比较与去重：

脚本会比较每一对图片的相似度，如果超过阈值，则认为这两张图片是重复的，移动到指定目录。这里可能使用一种数据结构（如字典或集合）来记录已检查过的图片，避免不必要的比较。

二、原理解析

2.1 均值哈希

1.缩放：图片缩放为8*8，保留结构，除去细节。
2.灰度化：转换为灰度图。
3.求平均值：计算灰度图所有像素的平均值。
4.比较：像素值大于平均值记作1，相反记作0，总共64位。
5.生成hash：将上述步骤生成的1和0按顺序组合起来既是图片的指纹（hash）。
6.对比指纹：将两幅图的指纹对比，计算汉明距离，即两个64位的hash值有多少位是不一样的，不相同位数越少，图片越相似。

2.2 插值哈希

缩小图像：将输入图像调整为10x10像素（可自己设置），以便进行后续的差值计算。
灰度化：将彩色图像转换为灰度图像。
计算差异值：比较相邻像素的灰度值，如果左边的像素比右边的更亮，则记录为1，否则为0。每行10个像素通过左右像素的两两比较，会产生10个不同的差异值，一共10行，则会产生100个差异值。
生成哈希值：将64位的二进制值按每4个字符为1组，转换成16进制，生成一个长度为16的字符串。
哈希值比较：通过比较两个图像的哈希值的汉明距离（Hamming Distance），评估图像的相似度，距离越小表示图像越相似。

2.3 感知哈希

均值哈希算法过于严格，不够精确，更适合搜索缩略图，为了获得更精确的结果可以选择感知哈希算法，它采用的是DCT（离散余弦变换）来降低频率的方法。

1. 缩小图片：32 * 32是一个较好的大小，这样方便DCT计算
2. 转化为灰度图：把缩放后的图片转化为灰度图。
3. 计算DCT: DCT把图片分离成分率的集合
4.缩小DCT：DCT计算后的矩阵是32 * 32，保留左上角的8 * 8，这些代表图片的最低频率。
5.计算平均值：计算缩小DCT后的所有像素点的平均值。
6.进一步减小DCT：大于平均值记录为1，反之记录为0.
7.得到信息指纹：组合64个信息位，顺序随意保持一致性。
8.最后比对两张图片的指纹，获得汉明距离即可。

2.4 直方图对比

直方图距离通过比较图像的灰度直方图来衡量相似性，直方图相似度值越大，图像越相似。

最后，附上整体代码，只需替换图片路径、选择使用哪种方法、调整阈值即可使用：


import cv2
import numpy as np
import os
import shutil
from PIL import Image


# 均值哈希算法
def aHash(img,shape=(10,10)):
    # 缩放为10*10
    img = cv2.resize(img, shape)
    # 转换为灰度图
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # s为像素和初值为0，hash_str为hash值初值为''
    s = 0
    hash_str = ''
    # 遍历累加求像素和
    for i in range(shape[0]):
        for j in range(shape[1]):
            s = s + gray[i, j]
    # 求平均灰度
    avg = s / 100
    # 灰度大于平均值为1相反为0生成图片的hash值
    for i in range(shape[0]):
        for j in range(shape[1]):
            if gray[i, j] > avg:
                hash_str = hash_str + '1'
            else:
                hash_str = hash_str + '0'
    return hash_str

# 差值哈希算法
def dHash(img,shape=(10,10)):
    # 缩放10*11
    img = cv2.resize(img, (shape[0]+1, shape[1]))
    # 转换灰度图
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    hash_str = ''
    # 每行前一个像素大于后一个像素为1，相反为0，生成哈希
    for i in range(shape[0]):
        for j in range(shape[1]):
            if gray[i, j] > gray[i, j + 1]:
                hash_str = hash_str + '1'
            else:
                hash_str = hash_str + '0'
    return hash_str


# 感知哈希算法(pHash)
def pHash(img,shape=(10,10)):
    # 缩放32*32
    img = cv2.resize(img, (32, 32))  # , interpolation=cv2.INTER_CUBIC

    # 转换为灰度图
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 将灰度图转为浮点型，再进行dct变换
    dct = cv2.dct(np.float32(gray))
    # opencv实现的掩码操作
    dct_roi = dct[0:10, 0:10]

    hash = []
    avreage = np.mean(dct_roi)
    for i in range(dct_roi.shape[0]):
        for j in range(dct_roi.shape[1]):
            if dct_roi[i, j] > avreage:
                hash.append(1)
            else:
                hash.append(0)
    return hash


# 通过得到RGB每个通道的直方图来计算相似度
def classify_hist_with_split(image1, image2, size=(256, 256)):
    # 将图像resize后，分离为RGB三个通道，再计算每个通道的相似值
    image1 = cv2.resize(image1, size)
    image2 = cv2.resize(image2, size)
    sub_image1 = cv2.split(image1)
    sub_image2 = cv2.split(image2)
    sub_data = 0
    for im1, im2 in zip(sub_image1, sub_image2):
        sub_data += calculate(im1, im2)
    sub_data = sub_data / 3
    return sub_data


# 计算单通道的直方图的相似值
def calculate(image1, image2):
    hist1 = cv2.calcHist([image1], [0], None, [256], [0.0, 255.0])
    hist2 = cv2.calcHist([image2], [0], None, [256], [0.0, 255.0])
    # 计算直方图的重合度
    degree = 0
    for i in range(len(hist1)):
        if hist1[i] != hist2[i]:
            degree = degree + (1 - abs(hist1[i] - hist2[i]) / max(hist1[i], hist2[i]))
        else:
            degree = degree + 1
    degree = degree / len(hist1)
    return degree

# Hash值对比
def cmpHash(hash1, hash2,shape=(10,10)):
    n = 0
    # hash长度不同则返回-1代表传参出错
    if len(hash1)!=len(hash2):
        return -1
    # 遍历判断
    for i in range(len(hash1)):
        # 相等则n计数+1，n最终为相似度
        if hash1[i] == hash2[i]:
            n = n + 1
    return n/(shape[0]*shape[1])



if __name__ == '__main__':
 
    load_path = r'images_full'  # 要去重的文件夹
    save_path = r'img_dir_repeat'  # 空文件夹，用于存储检测到的重复的照片
    os.makedirs(save_path, exist_ok=True)
 
    # 获取图片列表 file_map，字典{文件路径filename : 文件大小image_size}
    file_map = {}
    image_size = 0
    # 遍历filePath下的文件、文件夹（包括子目录）
    for parent, dirnames, filenames in os.walk(load_path):
        # for dirname in dirnames:
        # print('parent is %s, dirname is %s' % (parent, dirname))
        for filename in filenames:
            image_size = os.path.getsize(os.path.join(parent, filename))
            file_map.setdefault(os.path.join(parent, filename), image_size)
 
    # 获取的图片列表按 文件大小image_size 排序
    file_map = sorted(file_map.items(), key=lambda d: d[1], reverse=False)
    file_list = []
    for filename, image_size in file_map:
        file_list.append(filename)
 
    # 取出重复的图片
    file_repeat = []
    for currIndex, _ in enumerate(file_list):
        dir_image1 = cv2.imread(file_list[currIndex])
        dir_image2 = cv2.imread(file_list[currIndex + 1])
        hash1 = aHash(dir_image1)    # 此处可替换不同的方法 
        hash2 = aHash(dir_image2)    # 此处可替换不同的方法 
        result = cmpHash(hash1, hash2)
        if (result >= 0.7):    # 阈值设置0.7，可以自己调节
            file_repeat.append(file_list[currIndex + 1])
            print("\n相同的图片：", file_list[currIndex], file_list[currIndex + 1])
        else:
            print('\n不同的图片：', file_list[currIndex], file_list[currIndex + 1])
        currIndex += 1
        if currIndex >= len(file_list) - 1:
            break
 
    # 将重复的图片移动到新的文件夹，实现对原文件夹降重
    for image in file_repeat:
        shutil.move(image, save_path)
        print("正在移除重复照片：", image)