Struct ImageFingerprint 

pub struct ImageFingerprint { /* private fields */ }

A perceptual fingerprint containing multiple hash layers for robust comparison.

Fingerprints are deterministic and comparable across platforms. The structure includes exact hashing for identical detection and perceptual hashing for similarity detection with resistance to resizing, compression, and cropping.

Binary layout

#[repr(C)] with no padding bytes (168 bytes total: 32 + 8 + 128). Implements bytemuck::Pod / bytemuck::Zeroable so a &[ImageFingerprint] can be zero-copy cast to &[u8] for mmap-based persistence:

use imgfprint::ImageFingerprint;
bytemuck::cast_slice(fps)

Copy is derived because bytemuck::Pod requires it; the trade-off is that move-by-value silently memcpys 168 bytes. Prefer borrowing (&ImageFingerprint) in hot loops where this matters.

Implementations

impl ImageFingerprint

pub fn exact_hash(&self) -> &[u8; 32]

Returns the BLAKE3 hash of the original image bytes.

Two images with identical byte content will have matching exact hashes. Use this for exact deduplication before perceptual comparison.

pub const fn format_version() -> u32

Returns the on-disk format version this fingerprint was computed under.

Equal to crate::FORMAT_VERSION. Persist alongside fingerprint bytes (or in a sidecar manifest) and refuse comparison across mismatched versions to guard against algorithm-version drift.

pub fn global_hash(&self) -> u64

Returns the global perceptual hash from the center 32x32 region.

This hash captures the overall structure of the image and is robust to minor changes in compression and color adjustments. The algorithm used (PHash or DHash) depends on which was specified when creating the fingerprint.

pub fn block_hashes(&self) -> &[u64; 16]

Returns the 16 block-level perceptual hashes from a 4x4 grid.

Block hashes enable crop-resistant comparison by matching partial regions between images. Each hash covers a 64x64 pixel region.

pub fn distance(&self, other: &ImageFingerprint) -> u32

Computes the Hamming distance between this and another fingerprint’s global hash.

Returns a value from 0 (identical) to 64 (completely different).

pub fn is_similar(&self, other: &ImageFingerprint, threshold: f32) -> bool

Checks if this fingerprint is similar to another within a threshold.

Arguments

• other - The fingerprint to compare against
• threshold - Similarity threshold from 0.0 to 1.0 (default: 0.8)

Panics

Panics in debug mode if threshold is not in [0.0, 1.0]. In release mode, out-of-range or NaN thresholds return false (never similar).

Example

// Use ImageFingerprinter::fingerprint() to create fingerprints first
use imgfprint::ImageFingerprinter;

let fp1 = ImageFingerprinter::fingerprint(&std::fs::read("image1.jpg")?).unwrap();
let fp2 = ImageFingerprinter::fingerprint(&std::fs::read("image2.jpg")?).unwrap();

if fp1.is_similar(&fp2, 0.8) {
    println!("Images are similar!");
}

Trait Implementations

impl Clone for ImageFingerprint

fn clone(&self) -> ImageFingerprint

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ImageFingerprint

impl Debug for ImageFingerprint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ImageFingerprint

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ImageFingerprint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the fingerprint as hex: exact:global:block0,block1,...,block15

impl Eq for ImageFingerprint

impl Hash for ImageFingerprint

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ImageFingerprint

fn eq(&self, other: &ImageFingerprint) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Pod for ImageFingerprint

impl Serialize for ImageFingerprint

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ImageFingerprint

impl Zeroable for ImageFingerprint

fn zeroed() -> Self

Calls zeroed.