#WorkBuddy# 2,173 张图里藏着 6,918 对重复：文件 MD5 只抓到 2.57%，我用七步流水线把召回做到 100%

from PIL import Image

def load_L(path, normalize=True):
    """读图并转灰度；normalize=True 时按 EXIF Orientation 把像素摆正"""
    im = Image.open(path)
    o = 1
    if normalize:
        try:
            ex = im.getexif()
            if ex:
                o = ex.get(0x0112, 1)
        except Exception:
            o = 1
        # Orientation: 6=需顺时针90 3=需180 8=需逆时针90
        if o == 6:
            im = im.rotate(-90, expand=True)
        elif o == 3:
            im = im.rotate(180, expand=True)
        elif o == 8:
            im = im.rotate(90, expand=True)
    return im.convert("L")

def fold(h, h_mirror):
    """镜像折叠：取原图与镜像两个指纹的较小者作为规范指纹。
    X 与 mirror(X) 会得到同一个规范指纹，镜像对因此必然匹配。"""
    return min(h, h_mirror)

import numpy as np

def dct_matrix(k):
    x = np.arange(k)
    u = x.reshape((k, 1))
    M = np.cos(np.pi * (2 * x.reshape((1, k)) + 1) * u / (2 * k)) * np.sqrt(2.0 / k)
    M[0, :] /= np.sqrt(2.0)
    return M

M32 = dct_matrix(32)

def pack64(bits):
    return int.from_bytes(np.packbits(np.asarray(bits, dtype=np.uint8)).tobytes(), "big")

def three_hashes(g32):
    """输入 32×32 uint8 灰度，返回 aHash / dHash / pHash（各 64 bit）"""
    im32 = Image.fromarray(g32)
    g8 = np.asarray(im32.resize((8, 8), Image.LANCZOS), dtype=np.uint8)
    g9 = np.asarray(im32.resize((9, 8), Image.LANCZOS), dtype=np.uint8)
    a = pack64((g8 > g8.mean()).ravel())
    d = pack64((g9[:, 1:] > g9[:, :-1]).ravel())
    # pHash：32×32 DCT 取 9×9 低频块，丢弃 DC 分量以免疫整体亮度变化
    dct = M32 @ g32.astype(np.float64) @ M32.T
    low = dct[:9, :9].ravel()[1:65]
    p = pack64(low > np.median(low))
    return a, d, p

REGIONS = [1.0, 0.84, 0.71, 0.60]   # 相邻档 1.19 倍，覆盖常见的裁剪/缩放幅度

def region_gray(L, s):
    if s >= 1.0:
        return np.asarray(L.resize((32, 32), Image.LANCZOS), dtype=np.uint8)
    w, h = L.size
    nw, nh = int(w * s), int(h * s)
    x0, y0 = (w - nw) // 2, (h - nh) // 2
    return np.asarray(L.crop((x0, y0, x0 + nw, y0 + nh)).resize((32, 32), Image.LANCZOS),
                      dtype=np.uint8)

def c_dist(FA, I, J):
    """FA[区域][哈希][图]；16 种区域组合全部算一遍，取最小的三哈希平均汉明距离"""
    best = None
    for s in range(4):
        for t in range(4):
            acc = (np.bitwise_count(FA[s, 0, I] ^ FA[t, 0, J]).astype(np.float64)
                   + np.bitwise_count(FA[s, 1, I] ^ FA[t, 1, J]).astype(np.float64)
                   + np.bitwise_count(FA[s, 2, I] ^ FA[t, 2, J]).astype(np.float64)) / 3.0
            best = acc if best is None else np.minimum(best, acc)
    return best

def band_candidates(E, eid, n, bits=12, nband=5):
    """E[hh] 是所有 (区域, 图) 的指纹；eid 记录条目对应的图号。
    跨区域比较：区域 s 的图 i 与区域 t 的图 j 也能互为候选。"""
    cand = set()
    for hh in range(3):
        for b in range(nband):
            key = (E[hh] >> np.uint64(bits * b)) & np.uint64((1 << bits) - 1)
            order = np.argsort(key, kind="stable")
            ks = key[order]
            br = np.flatnonzero(np.diff(ks) != 0)
            starts = np.concatenate(([0], br + 1))
            ends = np.concatenate((br + 1, [len(ks)]))
            ids = eid[order]
            for st, en in zip(starts, ends):
                if 2 <= en - st <= 64:                 # 超大桶直接丢弃，防止退化
                    gg = ids[st:en]
                    for a in range(len(gg) - 1):
                        for b2 in range(a + 1, len(gg)):
                            ia, ib = int(gg[a]), int(gg[b2])
                            if ia != ib:
                                cand.add(min(ia, ib) * n + max(ia, ib))
    return cand

def c_l1(G32, I, J, chunk=4000):
    """32×32 灰度平均绝对差（先各自减均值做亮度归一），同样取 16 种区域组合的最小值"""
    out = np.empty(len(I), dtype=np.float64)
    for s0 in range(0, len(I), chunk):
        e = min(s0 + chunk, len(I))
        A = G32[:, I[s0:e]].astype(np.float32)
        B = G32[:, J[s0:e]].astype(np.float32)
        A -= A.mean(axis=(2, 3), keepdims=True)
        B -= B.mean(axis=(2, 3), keepdims=True)
        best = None
        for s in range(4):
            for t in range(4):
                v = np.minimum(np.abs(A[s] - B[t]).mean(axis=(1, 2)),
                               np.abs(A[s] - B[t][:, :, ::-1]).mean(axis=(1, 2)))
                best = v if best is None else np.minimum(best, v)
        out[s0:e] = best
    return out

# 判定：d<=t_accept 直接判重；t_accept<d<=t_reject 进灰区交给灰度复核
sel = cd <= t_accept
gzi = np.flatnonzero((cd > t_accept) & (cd <= t_reject))
sel[gzi] = c_l1(G32, ci[gzi], cj[gzi]) <= t_l1

# 提示词模板 · 图片查重与归档（可直接复制给 WorkBuddy）
#
# 任务：对目录 <PHOTO_DIR> 下的图片做感知哈希去重，不要删原图。
#
# 1. 指纹抽取：
#    - 先按 EXIF Orientation(0x0112) 把像素摆正，再转灰度；
#    - 对每张图取 4 个中心区域（1.0 / 0.84 / 0.71 / 0.60），各自缩到 32×32；
#    - 每个区域算 aHash / dHash / pHash（pHash 用 32×32 DCT 取 9×9 低频块并丢弃 DC）；
#    - 对原图和水平镜像各算一遍，规范指纹取两者中较小的那个（镜像折叠）。
#
# 2. 候选生成：把 4 个区域的指纹拼成一张条目表，用 12 bit × 5 段的分带索引找候选；
#    单桶超过 64 个条目直接丢弃。记录候选对数量与"候选召回上限"。
#
# 3. 判定：候选对在 16 种区域组合里取最小的三哈希平均汉明距离；
#    距离 ≤ t_accept 直接判重，t_accept < 距离 ≤ t_reject 进入灰区，
#    灰区用 32×32 灰度平均绝对差复核（复核前各自减去自身均值做亮度归一）。
#
# 4. 阈值标定：随机取 50% 的图片做标定集，t_accept 取"零误报的最大距离"，
#    t_reject 取真值距离 99.9 分位，t_l1 取灰区内 F1 最优点。没有真值时，
#    先用 (t_accept, t_reject, t_l1) = (8, 12, 10) 起步，再按实际结果微调。
#
# 5. 输出：用并查集合并成一个个组，每组保留拉普拉斯方差最大（最清晰）的一张，
#    其余移到 <PHOTO_DIR>/_duplicates/ 下，并写出 CSV 报告
#    （组号 / 保留文件 / 被移文件 / 组内距离 / 释放字节数）。
#
# 约束：不改动任何原图像素；移动前先做一次 dry-run 打印清单给我确认。