基于感知哈希的图像去重：构建你的图片画廊索引

1. 引言：图片去重的重要性

在管理个人或商业图片画廊时，重复图片是一个常见且令人头疼的问题。它们不仅占用宝贵的存储空间，还可能导致用户体验下降，例如在浏览时反复看到相同的图片。传统的重复文件检测方法，如基于md5或sha-1等加密哈希算法，虽然能精确识别完全相同的二进制文件，但对于经过轻微修改（如裁剪、缩放、压缩或添加水印）的图片则无能为力。为了解决这一问题，我们需要一种能够识别视觉上相似而非字节上完全相同的图片的技术——感知哈希（perceptual hashing）应运而生。

2. 感知哈希（pHash）核心原理

感知哈希（pHash）是一种根据图像的视觉内容生成“指纹”（哈希值）的技术。与传统的加密哈希不同，pHash的目标是使视觉上相似的图像拥有相似的哈希值，即使它们的像素数据不完全相同。这种“模糊匹配”的能力是实现图片去重和相似图片搜索的关键。

其核心思想在于：

• 关注视觉特征而非精确数据： pHash算法通过提取图像的低频信息（如整体结构、颜色分布等），忽略高频细节（如噪点、微小差异），从而对图像内容进行概括。
• 哈希值的相似性： 两个视觉上相似的图像，其pHash值之间的差异（通常通过汉明距离衡量）会很小；而视觉上差异很大的图像，其pHash值差异则会很大。

3. pHash 算法详解

pHash算法有多种变体，其中一种简单而有效的实现方式，常被称为“平均哈希”（aHash）或“差值哈希”（dHash），其基本步骤如下：

3.1 步骤一：缩小尺寸与灰度化

首先，将原始图像缩小到一个非常小的固定尺寸，例如8x8像素。这一步的目的是：

• 去除高频细节： 缩小尺寸会模糊图像，去除掉图像中不重要的细节和噪音，只保留其最主要的视觉特征。
• 标准化处理： 所有图像都被处理成相同大小，方便后续的比较。
• 降低计算复杂度： 减少需要处理的像素数量。

随后，将缩小后的图像转换为灰度图。这是因为在许多场景下，我们更关心图像的结构和亮度信息，而不是精确的颜色信息。

3.2 步骤二：计算平均值（针对aHash）或像素差异（针对dHash）

• 对于平均哈希 (aHash)： 计算这64个灰度像素的平均值。
• 对于差值哈希 (dHash)： 比较相邻像素的亮度值。例如，可以比较每一行中相邻像素的亮度，或者比较一个像素与其右侧和下方像素的亮度。这里我们以dHash为例，因为它通常对图像内容的变化更敏感。对于一个8x8的图像，我们可以得到7x8=56个水平差异，或者8x7=56个垂直差异。更常见的做法是比较每行相邻像素的亮度，生成一个8x7的矩阵。

3.3 步骤三：生成哈希位

• 对于平均哈希 (aHash)： 遍历这64个灰度像素。如果某个像素的亮度值大于或等于步骤二中计算出的平均值，则对应的哈希位为1；否则为0。最终得到一个64位的二进制哈希值。
• 对于差值哈希 (dHash)： 遍历步骤二中生成的像素差异矩阵。如果一个像素的亮度值大于其相邻像素（例如右侧像素），则对应的哈希位为1；否则为0。这样可以生成一个56位（8x7）的二进制哈希值。

通过上述步骤，每张图片都会生成一个固定长度的二进制哈希值，这个值就是图片的“感知指纹”。

3.4 步骤四：哈希比较：汉明距离

要判断两张图片是否相似，只需计算它们各自的感知哈希值之间的汉明距离（Hamming Distance）。汉明距离是指两个等长二进制串中对应位置上不同位的数量。

Unreal Images

免费的AI图片库

下载

例如： 哈希A: 10110100 哈希B: 10100101 汉明距离: 3 (第4、5、8位不同)

通常，如果两个哈希值的汉明距离在一个预设的阈值（例如，5到10之间）内，就可以认为这两张图片是相似的。这个阈值需要根据实际应用场景和对相似度的容忍度进行调整。

4. Golang 实现思路与示例

虽然Golang可能没有直接的pHash库，但其标准库提供了强大的图像处理能力，足以实现上述算法。

4.1 图像处理基础

Golang的image包及其子包（如image/jpeg, image/png等）可以用来读取和解码各种格式的图片。image/draw包则提供了图像缩放、裁剪和灰度转换等功能。

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/draw"
    _ "image/jpeg" // 导入以支持JPEG
    _ "image/png"  // 导入以支持PNG
    "os"
)

// loadImage 从文件加载图像
func loadImage(filePath string) (image.Image, error) {
    file, err := os.Open(filePath)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
        return nil, err
    }
    return img, nil
}

// resizeAndGrayscale 将图像缩放到指定尺寸并转换为灰度图
func resizeAndGrayscale(img image.Image, width, height int) *image.Gray {
    // 创建一个新的灰度图像作为目标
    grayImg := image.NewGray(image.Rect(0, 0, width, height))

    // 使用draw.Src来绘制（缩放）原始图像到灰度图像
    // 这会自动处理颜色转换和缩放
    draw.CatmullRom.Scale(grayImg, grayImg.Bounds(), img, img.Bounds(), draw.Src, nil)

    return grayImg
}

// calculateDHash 计算图像的dHash
func calculateDHash(img image.Image) (uint64, error) {
    // 1. 缩小尺寸到9x8并灰度化 (dHash通常使用9x8或8x9来比较8x8的差异)
    // 这里我们用9x8，以便比较8x8的水平差异
    resizedGray := resizeAndGrayscale(img, 9, 8) // 9列8行

    var hash uint64
    bitIndex := 0

    // 2. 比较相邻像素的亮度值
    // 遍历每一行，比较当前像素和它右边的像素
    for y := 0; y < 8; y++ {
        for x := 0; x < 8; x++ { // 比较 x 和 x+1
            // 获取当前像素和右侧像素的灰度值
            // 注意：GrayAt返回的是一个color.Gray结构体，其Y字段是灰度值
            p1 := resizedGray.GrayAt(x, y).Y
            p2 := resizedGray.GrayAt(x+1, y).Y

            if p1 > p2 {
                hash |= (1 << bitIndex)
            }
            bitIndex++
        }
    }

    // dHash 通常是64位或56位。这里我们生成了8x8=64位。
    return hash, nil
}

// hammingDistance 计算两个uint64哈希值的汉明距离
func hammingDistance(hash1, hash2 uint64) int {
    diff := hash1 ^ hash2 // 异或操作，不同位为1
    count := 0
    for diff > 0 {
        diff &= (diff - 1) // Brian Kernighan's algorithm
        count++
    }
    return count
}

func main() {
    // 示例用法
    imgPath1 := "image1.jpg" // 替换为你的图片路径
    imgPath2 := "image2.jpg" // 替换为你的图片路径 (可能是原图的修改版或完全不同)

    img1, err := loadImage(imgPath1)
    if err != nil {
        fmt.Printf("加载图片 %s 失败: %v\n", imgPath1, err)
        return
    }

    img2, err := loadImage(imgPath2)
    if err != nil {
        fmt.Printf("加载图片 %s 失败: %v\n", imgPath2, err)
        return
    }

    hash1, err := calculateDHash(img1)
    if err != nil {
        fmt.Printf("计算哈希 %s 失败: %v\n", imgPath1, err)
        return
    }
    hash2, err := calculateDHash(img2)
    if err != nil {
        fmt.Printf("计算哈希 %s 失败: %v\n", imgPath2, err)
        return
    }

    dist := hammingDistance(hash1, hash2)

    fmt.Printf("图片1哈希: %016x\n", hash1)
    fmt.Printf("图片2哈希: %016x\n", hash2)
    fmt.Printf("汉明距离: %d\n", dist)

    threshold := 10 // 相似度阈值，可根据实际情况调整
    if dist <= threshold {
        fmt.Println("两张图片可能相似。")
    } else {
        fmt.Println("两张图片不相似。")
    }
}

代码说明：

• loadImage: 负责从文件加载图像。
• resizeAndGrayscale: 将图像缩放到指定尺寸并转换为灰度图。draw.CatmullRom.Scale提供了高质量的缩放。
• calculateDHash: 实现了dHash算法的核心逻辑。它将图像缩放到9x8像素的灰度图，然后比较每行相邻像素的亮度，生成一个64位的哈希值。
• hammingDistance: 计算两个uint64哈希值之间的汉明距离。
• main函数展示了如何加载两张图片，计算它们的哈希，并判断它们是否相似。

5. 注意事项与优化

5.1 准确性与局限性

• 非100%准确： 感知哈希旨在识别视觉上的相似性，而非二进制上的精确匹配。它可能无法识别经过大幅度裁剪、旋转或艺术化处理（如滤镜、风格迁移）的相似图片。
• 阈值选择： 汉明距离的阈值选择至关重要。过低可能导致漏报（未识别出相似图片），过高可能导致误报（将不相似图片判为相似）。需要根据实际需求进行实验和调整。
• 算法选择： 除了dHash，还有aHash（平均哈希）、pHash（更复杂的DCT变换哈希）等。不同的算法对不同类型的图像变化有不同的鲁棒性。dHash通常简单且效果不错。

5.2 性能考量与索引结构

• 大规模图片库： 对于拥有数百万甚至更多图片的画廊，简单地将每张新图片与所有现有图片的哈希进行比较是不可行的（O(N) 或 O(N^2) 复杂度）。
• 索引优化：
  • 哈希树/哈希桶： 可以将哈希值相近的图片存储在一起。
  • LSH (Locality Sensitive Hashing)： 局部敏感哈希是一种更高级的技术，它将高维数据映射到低维空间，使得相似的项在映射后仍然相似，从而可以更快地找到近似邻居。
  • 数据库索引： 将哈希值存储在数据库中，并为哈希列建立索引，可以加速查询。但对于模糊匹配，需要特殊的数据结构或查询方式。
  • 近似最近邻 (ANN) 算法： 如Faiss、Annoy等库，专门用于在大规模数据集中高效查找近似最近邻。虽然这些库通常针对向量搜索，但感知哈希值可以视为一种紧凑的向量。

5.3 其他感知哈希算法

• aHash (Average Hash)： 计算灰度图像的平均亮度，然后比较每个像素与平均值的关系。
• dHash (Difference Hash)： 比较相邻像素的亮度差异。对平移和裁剪有较好的鲁棒性。
• pHash (Perceptual Hash - DCT based)： 使用离散余弦变换（DCT）来提取图像的频率特征，通常比aHash和dHash更鲁棒，但计算也更复杂。

6. 总结

感知哈希（pHash）为图片画廊的重复图片检测提供了一个实用且易于理解的起点。通过将图像转化为简洁的二进制指纹，我们能够有效地识别视觉上相似的图片，从而优化存储和提升用户体验。尽管Golang标准库没有直接提供pHash功能，但其强大的图像处理能力足以让我们从零开始构建一个功能完备的感知哈希系统。在实际应用中，根据图片库的规模和对准确性的要求，可能需要进一步探索更复杂的哈希算法和索引优化策略，以实现更高效、更鲁棒的图像去重解决方案。