| """Exact (SHA-256) and perceptual (DCT pHash on the cropped fundus disc) image fingerprints.""" |
| import hashlib |
|
|
| import numpy as np |
| from PIL import Image |
|
|
| _N = 32 |
| _DCT = np.cos(np.pi * (2 * np.arange(_N)[None, :] + 1) * np.arange(_N)[:, None] / (2 * _N)) |
|
|
|
|
| def sha256_file(path, chunk=1 << 20): |
| h = hashlib.sha256() |
| with open(path, "rb") as f: |
| while b := f.read(chunk): |
| h.update(b) |
| return h.hexdigest() |
|
|
|
|
| def crop_fundus(img, thresh=15): |
| """Crop to the bounding box of the illuminated fundus so black borders / padding don't dominate the hash.""" |
| a = np.asarray(img.convert("RGB")).max(axis=2) |
| ys, xs = np.nonzero(a > thresh) |
| if len(xs) < 100: |
| return img |
| return img.crop((xs.min(), ys.min(), xs.max() + 1, ys.max() + 1)) |
|
|
|
|
| def phash(img): |
| g = crop_fundus(img).convert("L").resize((_N, _N), Image.BILINEAR) |
| d = _DCT @ np.asarray(g, dtype=np.float64) @ _DCT.T |
| low = d[:8, :8].flatten()[1:] |
| bits = np.concatenate([[False], low > np.median(low)]) |
| return int("".join("1" if b else "0" for b in bits), 2) |
|
|
|
|
| def dhash(img): |
| g = np.asarray(crop_fundus(img).convert("L").resize((9, 8), Image.BILINEAR), dtype=np.int16) |
| bits = (g[:, 1:] > g[:, :-1]).flatten() |
| return int("".join("1" if b else "0" for b in bits), 2) |
|
|
|
|
| def fingerprint(path): |
| """Return dict with sha256, phash/dhash (hex), width, height, or an error string.""" |
| try: |
| sha = sha256_file(path) |
| with Image.open(path) as im: |
| im.load() |
| w, h = im.size |
| ph, dh = phash(im), dhash(im) |
| return {"sha256": sha, "phash": f"{ph:016x}", "dhash": f"{dh:016x}", "width": w, "height": h, "read_error": ""} |
| except Exception as e: |
| return {"sha256": "", "phash": "", "dhash": "", "width": 0, "height": 0, "read_error": repr(e)[:200]} |
|
|
|
|
| def near_duplicate_pairs(hashes, max_dist=6, max_bucket=5000): |
| """All index pairs with Hamming(phash) <= max_dist (max_dist <= 7). |
| |
| Pigeonhole: split 64 bits into 8 bytes; two hashes within distance 7 share at least one byte exactly, |
| so candidates come from equal-byte buckets. Huge buckets (e.g. blank images) are skipped and reported. |
| """ |
| assert max_dist <= 7 |
| h = np.array([int(x, 16) for x in hashes], dtype=np.uint64) |
| pairs, skipped = set(), 0 |
| for band in range(8): |
| key = (h >> np.uint64(8 * band)) & np.uint64(0xFF) |
| order = np.argsort(key, kind="stable") |
| ks = key[order] |
| bounds = np.flatnonzero(np.diff(ks)) + 1 |
| for grp in np.split(order, bounds): |
| if len(grp) < 2: |
| continue |
| if len(grp) > max_bucket: |
| skipped += 1 |
| continue |
| x = h[grp] |
| for s in range(0, len(grp), 512): |
| dist = np.bitwise_count(x[s:s + 512, None] ^ x[None, :]) |
| ii, jj = np.nonzero(dist <= max_dist) |
| for i, j in zip(grp[s + ii], grp[jj]): |
| if i != j: |
| pairs.add((int(min(i, j)), int(max(i, j)))) |
| return sorted(pairs), skipped |
|
|
