Perceptual Hashing And Duplicate Review

When you open car.jpg, you see a car. The computer first sees bytes:

FF D8 FF E0 00 10 4A 46 49 46 ...

A JPEG decoder turns those compressed bytes into a grid of pixels. An RGB pixel contains red, green, and blue channel values. A two-by-two image might decode as:

What does a single pixel become in grayscale?

Grayscale is not “delete two numbers and keep one.” A decoder combines red, green, and blue according to how strongly they contribute to perceived brightness. A useful approximation is:

RGB to luminance

L≈0.299R + 0.587G + 0.114B

Green contributes most to this brightness estimate; blue contributes least.

For the red pixel [255,0,0], the luminance is approximately 0.299×255 = 76. For green [0,255,0], it is approximately 150. Both were fully saturated colours, yet green becomes much brighter in grayscale. Once RGB becomes one number, the original hue cannot be reconstructed.

Decoded RGBGrayscaledHash 9×8

1250 × 1250 × 3

The picture is still visually rich. No perceptual fingerprint exists yet.

Move through the actual preprocessing intermediates. Every step makes later comparisons cheaper by making some earlier questions impossible to answer.

Two files can contain different bytes and decode to almost the same pixels. JPEG quality 85 and quality 95 choose different compression approximations. Resizing changes the pixel count. PNG and JPEG use different formats. An exact hash reads bytes, so every change matters. A perceptual hash decodes the image and intentionally forgets detail.

PreviousNext transformation

1file bytesFF D8 …

→

2RGB pixelsH×W×3

→

3grayscaleH×W

→

4small structure9×8 / 32×32

→

5fingerprint64 bits

The file has not been decoded yet. Exact hashes operate here; perceptual hashes continue through the pipeline.

---

ClusterLens asks ImageHash for hash_size=8. The result contains 8×8 yes/no decisions.

To compare fingerprints, XOR each bit pair. XOR is 1 exactly where the bits differ. Then count the ones.

Distance zero means equal fingerprints, not necessarily equal pixels or bytes. Billions of possible images are being squeezed into only (2^{64}) fingerprint values. Collisions are unavoidable.

A = B4 hexadecimal = 1011 0100 binary
B = A6 hexadecimal = 1010 0110 binary

                       1011 0100
XOR                    1010 0110
                       ---------
                       0001 0010

dHash means difference hash. For an 8×8 fingerprint, ImageHash converts to grayscale, resizes to 9 columns by 8 rows, and compares each pixel with the pixel immediately to its right. Nine columns create eight horizontal gaps; eight rows times eight gaps gives 64 bits.

For one row:

pixels:       10   14   13   20   19
right > left?  1    0    1    0
bits:          1    0    1    0

The toy row teaches the operation. The next artifact performs it on the actual car fixture. Select a row to inspect its nine measured brightness values and eight resulting decisions.

9×8 row

row 1

Each output bit belongs to the gap between two adjacent cells, not to either pixel by itself.

The previous article described the opposite comparison direction. Either convention can form a consistent fingerprint, but a tutorial must match its implementation. ImageHash uses pixels[:, 1:] > pixels[:, :-1]: right brighter than left.

Because [10,14] and [100,140] create the same bit, moderate brightness changes often survive. A flip reverses gradients, while a crop relocates structure. dHash is fast and transparent; it is not crop- or rotation-invariant.

A wavelet transform splits an image into one coarse approximation and several detail regions:

Then LL can be decomposed again, like stepping closer to the picture.

The labels describe the filters, not four smaller crops. LL combines low-frequency behaviour horizontally and vertically. LH, HL, and HH retain different changes between neighbouring regions. Recursing into LL asks the overview question again at a coarser scale.

ImageHash’s default wHash uses Haar wavelets, removes the maximum-level LL component, takes a lower-scale coefficient block, compares values with their median, and emits bits.

One Haar split by hand

Start with [10,14,20,24]. Pairwise averages describe coarse content and differences describe detail:

averages:     [(10+14)/2, (20+24)/2] = [12, 22]
differences:  [(10-14)/2, (20-24)/2] = [-2, -2]

coarsest average: (12+22)/2 = 17
coarse contrast:  (12-22)/2 = -5

A two-dimensional Haar transform performs analogous horizontal and vertical operations, producing LL/LH/HL/HH. pHash asks which cosine patterns explain the image; wHash asks how averages and detail behave across scales.

Transformation

dHashbrightness directions

pHashDCT composition

wHashwavelet structure

All three methods process the same edited source and still produce different distances because they ask different visual questions.

Hash	What it remembers	Typical weakness
dHash	horizontal brightness direction	flip, crop, rotation
pHash	low-frequency composition	crop and layout collision
wHash	multi-scale wavelet structure	coarse-structure collision

No hash wins everywhere. The correct comparison is a measured transformation matrix on images resembling the intended collection.

---

A candidate passes when its Hamming distance is at most a threshold, conventionally written as the Greek letter tau, τ.

Think of an airport security gate. The scanner produces measurements; a policy decides which measurements trigger inspection. Calling a candidate “duplicate” at distance eight is not a new fact discovered by mathematics. It is the consequence of choosing a gate at eight.

The controlled experiment labels every derived edit of the same source as positive and pairs of different base images as negative. This deliberately counts a crop or flip as the same origin even when a global hash cannot recognize it.

Before reading the totals, inspect a single labelled pair. “Actual” comes from the experiment label; “decision” comes from the selected hash and threshold.

Example Hash pHashdHashwHashThreshold

8

actual relationship

measured distance

gate decision

confusion cell

A confusion matrix is just many pair-level decisions counted together.

There is no universal “0–4 is definitely duplicate” range. The useful threshold changes with algorithm, width, edits, data, and downstream review cost.

precision = 70 / (70 + 10) = 0.875
recall    = 70 / (70 + 20) = 0.778

ClusterLens stores all three families but the request chooses phash, dhash, or whash:

query_value = int(query_hash, 16)
candidate_value = int.from_bytes(candidate_blob, "big")
distance = (query_value ^ candidate_value).bit_count()
if distance <= max_distance:
    keep(candidate)

The old article incorrectly took the minimum of three distances. Combining families requires a separate policy: OR/minimum improves recall, AND/maximum improves strictness, and voting requires calibration. None is the current query path.

For distances pHash=4, dHash=15, wHash=13, and threshold 8, minimum/OR accepts because one family passes. Maximum/AND rejects because two fail. A two-of-three vote also rejects. None is mathematical truth; each defines a different product policy. ClusterLens avoids hiding that choice by selecting and recording one backend.

Try those policies directly. This is a hypothetical dry run, deliberately separate from the actual single-backend ClusterLens path.

Global hashes summarize the whole frame. ORB instead detects repeatable keypoints, estimates orientation across an image pyramid, constructs binary descriptors around them, and matches descriptors between images. A crop may move the global summary while preserving the corner of a headlight.

Those terms need unpacking:

• A keypoint is an image location with a distinctive neighbourhood, often a corner or textured junction. A blank sky is a poor keypoint because many nearby patches look the same.
• An image pyramid contains smaller copies of the image. Detecting across scales helps the same headlight corner survive when one file is resized.
• Orientation estimates which way the local patch points. ORB rotates its description into that orientation so modest rotation is less disruptive.
• A descriptor is a compact binary description of brightness comparisons around one keypoint. ClusterLens receives 32 bytes, or 256 bits, per retained ORB keypoint.

The keypoint picture below is an actual OpenCV run. The circles are not objects the model recognized. They mark locally distinctive locations at different scales.

Previous conceptNext concept

1 · Find distinctive locations

Corners and textured junctions are easier to find again than smooth regions.

retained keypoints

descriptor matrix

Follow one local observation from detection to matching.

ClusterLens asks for at most 600 features per grayscale image. BFMatcher uses Hamming distance with crossCheck=True: a match survives only when both descriptors select one another as their best match.

Without cross-check, query descriptor Q7 might choose candidate descriptor C2 even though C2 prefers a completely different query descriptor. With cross-check, a pair survives only if Q7 → C2 and C2 → Q7. This removes some ambiguous matches, though repeated windows can still fool both directions.

Transformation

query descriptors

candidate descriptors

matches

average distance

ORB score

OpenCV produced these values with the same settings and formula as ClusterLens.

The code does not fit a homography or run RANSAC. Mutual nearest descriptors can still be geometrically inconsistent. ORB here is a reranking signal, not verification proof.

match ratio    = 60 / max(100, 80) = 0.60
distance score = 1 - 24/96         = 0.75

ORB score
= 0.6(0.60) + 0.4(0.75)
= 0.36 + 0.30
= 0.66

The review builder removes the query itself and sorts by perceptual distance and reranked score. It can export a decision:

{
  "keeper_path": "query.jpg",
  "duplicate_path": "candidate.jpg",
  "action": "trash",
  "hash_distance": 0,
  "source_files_changed": false
}

trash records an intention. The export does not move either source file.

A responsible review screen should help a person answer two separate questions: “Are these the same underlying item?” and “If so, which file should survive?” Similarity alone cannot choose the keeper. Resolution, file size, capture time, edit history, path, and user intent may matter. A smaller JPEG can be the duplicate while the larger original is the keeper; in another workflow the edited JPEG may be the valuable deliverable.

Not duplicateRecord tagRecord trash decision

No decision recorded. Source files remain untouched.

The experimental UI calls selected perceptual-hash distance zero “Exact.” That means equal selected 64-bit fingerprints, not equal file bytes. A safe label is “identical pHash” unless SHA-256 or byte comparison was also performed.

For the displayed pair, the actual pHash distance is zero while SHA-256 differs. That single counterexample is enough to disprove the claim “pHash distance zero means exact file.” The correct evidence ladder is:

same SHA-256 / bytes   → byte-identical file evidence
pHash distance 0       → identical 64-bit pHash fingerprint
small pHash distance   → candidate under the chosen policy
human review           → product decision with context

The final lab follows one actual query through the complete stack. Unlike the earlier policy examples, its distances and scores are loaded from the reproducible evidence artifact. At every stage it also states the strongest claim the evidence permits.

The seven stages are:

1. discover and freeze file identities;
2. reuse or compute indexed fingerprints;
3. choose one backend and threshold;
4. XOR/popcount eligible candidates;
5. rerank survivors with embeddings;
6. optionally blend ORB evidence;
7. show evidence and record a human decision without changing source files.

Notice how the claim becomes stronger only when new evidence arrives. Discovery proves a file was found. A pHash gate supports “candidate under pHash policy.” An embedding supports learned visual similarity. ORB supports local descriptor correspondence. None of those, individually or combined, authorizes deletion. The final human step records intent; a separate, explicitly authorized file operation would still be required to mutate the collection.

SHA-256         → proves identical bytes
perceptual hash → proposes visually similar candidates
embedding       → ranks learned visual similarity
ORB             → adds local correspondence
metadata        → helps choose a keeper
human review    → authorizes an action

The main lesson is not “pHash finds duplicates.” It is:

Every representation forgets information. A safe duplicate tool makes that loss visible, combines independent evidence carefully, and never turns an approximate candidate into an irreversible decision without authority.

This page renders loading…, generated loading… with ImageHash loading… and OpenCV loading….