图像重复检测：从感知哈希（pHash）开始构建

package main

import (
    "image"
    "image/color"
    "image/draw"
    "math"
)

// LoadImageFromFile 模拟从文件加载图片
func LoadImageFromFile(filePath string) (image.Image, error) {
    // 实际实现需要使用 image/jpeg, image/png 等库解码图片
    // 这里仅为示例，假设已加载图片
    return image.NewRGBA(image.Rect(0, 0, 100, 100)), nil // 示例图片
}

// ResizeAndGrayscale 将图片缩放并转换为灰度图
// 目标尺寸通常为8x8或32x32
func ResizeAndGrayscale(img image.Image, targetSize int) *image.Gray {
    // 创建一个新的灰度图像画布
    smallGray := image.NewGray(image.Rect(0, 0, targetSize, targetSize))

    // 实际缩放和灰度转换需要更复杂的图像处理库
    // 例如：github.com/nfnt/resize 或自定义像素插值
    // 这里仅为概念性演示，直接将原始图像的平均亮度映射到小图
    bounds := img.Bounds()
    for y := 0; y < targetSize; y++ {
        for x := 0; x < targetSize; x++ {
            // 简化处理：从原图对应区域取样并转换为灰度
            // 实际应进行插值缩放
            srcX := int(float64(x) / float64(targetSize) * float64(bounds.Dx()))
            srcY := int(float64(y) / float64(targetSize) * float64(bounds.Dy()))
            r, g, b, _ := img.At(srcX, srcY).RGBA()
            grayVal := uint8((0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)) / 256)
            smallGray.SetGray(x, y, color.Gray{Y: grayVal})
        }
    }
    return smallGray
}

// CalculateAverage 计算灰度图像的平均亮度
func CalculateAverage(grayImg *image.Gray) float64 {
    sum := 0.0
    bounds := grayImg.Bounds()
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            sum += float64(grayImg.GrayAt(x, y).Y)
        }
    }
    return sum / float64(bounds.Dx()*bounds.Dy())
}

// GeneratePerceptualHash 生成感知哈希指纹
func GeneratePerceptualHash(grayImg *image.Gray) string {
    avg := CalculateAverage(grayImg)
    hash := ""
    bounds := grayImg.Bounds()
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            if float64(grayImg.GrayAt(x, y).Y) >= avg {
                hash += "1"
            } else {
                hash += "0"
            }
        }
    }
    return hash
}

// HammingDistance 计算两个哈希值之间的汉明距离
func HammingDistance(hash1, hash2 string) int {
    if len(hash1) != len(hash2) {
        panic("Hashes must be of the same length")
    }
    distance := 0
    for i := 0; i < len(hash1); i++ {
        if hash1[i] != hash2[i] {
            distance++
        }
    }
    return distance
}

func main() {
    // 示例流程
    img1, _ := LoadImageFromFile("image1.jpg")
    img2, _ := LoadImageFromFile("image2.jpg")

    // 1. 缩放并灰度化 (例如，8x8)
    targetSize := 8
    grayImg1 := ResizeAndGrayscale(img1, targetSize)
    grayImg2 := ResizeAndGrayscale(img2, targetSize)

    // 2. 生成哈希
    hash1 := GeneratePerceptualHash(grayImg1)
    hash2 := GeneratePerceptualHash(grayImg2)

    // 3. 计算汉明距离
    dist := HammingDistance(hash1, hash2)

    println("Hash 1:", hash1)
    println("Hash 2:", hash2)
    println("Hamming Distance:", dist)

    // 根据距离判断是否为重复图片
    if dist < 10 { // 阈值需要根据实际情况调整
        println("Images are likely duplicates or very similar.")
    } else {
        println("Images are likely different.")
    }
}