Imgfprint

https://docs.rs/imgfprint
Admin
High-performance, deterministic image fingerprinting library that provides perceptual hashing with...
Tokens:302,989
Snippets:3,107
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Searches for Similarity

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.Similarity.html?search=

Demonstrates common search patterns for similarity. These examples illustrate how to query for specific types or transformations.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Example: Checking Image Similarity

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprint.html?search=

Demonstrates how to create ImageFingerprints using `ImageFingerprinter::fingerprint` and then compare them for similarity using `is_similar`.

```rust
// 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!");
}
```

--------------------------------

### Example Search: u32 to bool

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/error.rs.html?search=

Illustrates a search pattern for a type conversion from u32 to bool.

```rust
u32 -> bool
```

--------------------------------

### Dummy EmbeddingProvider Implementation

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/trait.EmbeddingProvider.html

A basic example of implementing the EmbeddingProvider trait. This dummy provider returns a fixed embedding and is useful for testing or as a starting point.

```rust
use imgfprint::{EmbeddingProvider, Embedding, ImgFprintError};

struct DummyProvider;

impl EmbeddingProvider for DummyProvider {
    fn embed(&self, _image: &[u8]) -> Result<Embedding, ImgFprintError> {
        // In a real implementation, this would call an external API
        // or run a local model to generate embeddings
        Embedding::new(vec![0.1, 0.2, 0.3, 0.4])
    }
}
```

--------------------------------

### Example: Using is_similar for Image Comparison

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprint.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create two `ImageFingerprint` instances from image files and then use the `is_similar` method to check if they are perceptually alike within a specified threshold.

```rust
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!");
}
```

--------------------------------

### Example Search: std::vec

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/error.rs.html?search=

Demonstrates a common search pattern for the standard library's Vec type.

```rust
std::vec
```

--------------------------------

### Example Search: Option<T> map

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/error.rs.html?search=

Shows a search pattern for mapping over an Option<T> with a function that transforms T to U.

```rust
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Get Format Version

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprint.rs.html?search=

Returns the on-disk format version used for fingerprint computation. Essential for guarding against algorithm-version drift.

```rust
pub const fn format_version() -> u32 {
    crate::FORMAT_VERSION
}
```

--------------------------------

### Getting the Format Version

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=

Returns the on-disk format version associated with the fingerprint. This should be persisted and checked to prevent comparisons across different algorithm versions.

```rust
pub const fn format_version() -> u32 {
    crate::FORMAT_VERSION
}

```

--------------------------------

### Test RGBA Image Handling

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/lib.rs.html

Demonstrates the handling of RGBA images by the fingerprinting library. This test case is a starting point for verifying support for images with an alpha channel.

```rust
    #[test]
    fn test_rgba_image_handling() {
        use image::Rgba;
        let img: ImageBuffer<image::Rgba<u8>, Vec<u8>> = ImageBuffer::from_fn(300, 300, |x, y| {

```

--------------------------------

### Dummy EmbeddingProvider Implementation

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/trait.EmbeddingProvider.html?search=std%3A%3Avec

An example implementation of the EmbeddingProvider trait. This dummy provider returns a static embedding and is useful for testing or as a starting point for real implementations.

```rust
use imgfprint::{EmbeddingProvider, Embedding, ImgFprintError>;

struct DummyProvider;

impl EmbeddingProvider for DummyProvider {
    fn embed(&self, _image: &[u8]) -> Result<Embedding, ImgFprintError> {
        // In a real implementation, this would call an external API
        // or run a local model to generate embeddings
        Embedding::new(vec![0.1, 0.2, 0.3, 0.4])
    }
}
```

--------------------------------

### init

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.Embedding.html

Initializes a new instance with the given initializer.

```APIDOC
## unsafe fn init(init: <T as Pointable>::Init) -> usize

### Description
Initializes a with the given initializer.

### Method
`init`
```

--------------------------------

### Get Embedding Length

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.Embedding.html?search=

Illustrates how to get the dimensionality (number of elements) of the embedding vector using the `len()` method.

```rust
use imgfprint::Embedding;

let embedding = Embedding::new(vec![0.1, 0.2, 0.3, 0.4])?;
assert_eq!(embedding.len(), 4);
```

--------------------------------

### type_id

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.Embedding.html

Gets the TypeId of the Embedding instance.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`
```

--------------------------------

### Initializing FingerprinterContext

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprinter.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating a new instance of `FingerprinterContext`.

```rust
let ctx = FingerprinterContext::new();
let _ = ctx;
```

--------------------------------

### ImageFingerprinter type_id

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprinter.html?search=std%3A%3Avec

Gets the `TypeId` of the ImageFingerprinter instance.

```APIDOC
## ImageFingerprinter type_id

### Description
Gets the `TypeId` of `self`.

### Method
N/A (associated function)

### Endpoint
N/A

### Parameters
None

### Response
#### Success Response
- **TypeId**: The unique type identifier of the instance.
```

--------------------------------

### Initializing FingerprinterContext with Default

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprinter.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating a new instance of `FingerprinterContext` using its default implementation.

```rust
let ctx = FingerprinterContext::default();
let _ = ctx;
```

--------------------------------

### Preprocessor Initialization with CPU Extensions

Source: https://docs.rs/imgfprint/latest/src/imgfprint/imgproc/preprocess.rs.html?search=

Initializes a `Preprocessor` struct, creating a `Resizer` and configuring it with detected CPU extensions for optimized image resizing.

```Rust
pub fn new() -> Self {
    let mut resizer = Resizer::new();

    // Use cached CPU extensions detection
    let cpu_extensions = get_cpu_extensions();
    if cpu_extensions != CpuExtensions::None {
        resizer.set_cpu_extensions(cpu_extensions);
    }

    Self { resizer, dst_buffer: Vec::new(), gray_buffer: Vec::new() }
}
```

--------------------------------

### Getting the DHash Fingerprint

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=

Retrieves a reference to the DHash-based fingerprint.

```rust
pub fn dhash(&self) -> &ImageFingerprint {
    &self.dhash
}

```

--------------------------------

### Getting the PHash Fingerprint

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=

Retrieves a reference to the PHash-based fingerprint.

```rust
pub fn phash(&self) -> &ImageFingerprint {
    &self.phash
}

```

--------------------------------

### Getting the AHash Fingerprint

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=

Retrieves a reference to the AHash-based fingerprint.

```rust
pub fn ahash(&self) -> &ImageFingerprint {
    &self.ahash
}

```

--------------------------------

### Initialize Preprocessor with Optimal CPU Extensions

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/imgproc/preprocess.rs.html

Creates a new preprocessor instance, initializing the internal resizer with optimal CPU extensions detected for the current platform. This ensures efficient image processing operations.

```Rust
pub fn new() -> Self {
    let mut resizer = Resizer::new();

    // Use cached CPU extensions detection
    let cpu_extensions = get_cpu_extensions();
    if cpu_extensions != CpuExtensions::None {

```

--------------------------------

### CloneToUninit

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.Embedding.html?search=u32+-%3E+bool

This is a nightly-only experimental API for performing copy-assignment from self to an uninitialized destination.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit`

### Parameters
- `dest` (*mut u8): A mutable pointer to the destination memory location.

### Safety
This function is unsafe as it involves raw pointer manipulation.
```

--------------------------------

### impl<T> Any for T

Source: https://docs.rs/imgfprint/latest/imgfprint/struct.ImageFingerprinter.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides the `type_id` method to get the `TypeId` of an object.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Response
- **TypeId**: The unique identifier for the type of `self`.
```

--------------------------------

### Preprocessor::new

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/imgproc/preprocess.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new preprocessor with optimal CPU extensions. This constructor initializes the preprocessor with a Resizer configured with the best available CPU extensions for the current platform, ensuring optimal performance for image processing tasks.

```APIDOC
## Preprocessor::new

### Description
Creates a new `Preprocessor` instance. It initializes an internal `Resizer` with the optimal CPU extensions detected for the current platform, leveraging SIMD acceleration where available (e.g., AVX2, SSE4.1, NEON) for efficient image resizing and processing.

### Method
Associated function (constructor)

### Function Signature
```rust
pub fn new() -> Self
```

### Returns
A new `Preprocessor` instance configured for optimal performance.
```

--------------------------------

### type_id

Source: https://docs.rs/imgfprint/latest/imgfprint/struct.ImageFingerprinter.html

Gets the TypeId of the object. This is a blanket implementation for any type.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
(Implicitly called via trait method)

### Parameters
None
```

--------------------------------

### type_id

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprinter.html

Gets the `TypeId` of `self`. This is part of the `Any` trait implementation.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
- `self`: A reference to the object.

### Response
- `TypeId`: The unique identifier for the type of `self`.
```

--------------------------------

### Initialize Preprocessor with Pre-allocated Buffers in Rust

Source: https://docs.rs/imgfprint/latest/src/imgfprint/imgproc/preprocess.rs.html

Initializes the `Preprocessor` struct, setting up the image resizer and pre-allocating capacity for destination RGB and grayscale buffers to optimize performance and reduce runtime allocations.

```Rust
Self {
            resizer,
            dst_buffer: Vec::with_capacity((NORMALIZED_SIZE * NORMALIZED_SIZE * 3) as usize),
            gray_buffer: Vec::with_capacity((NORMALIZED_SIZE * NORMALIZED_SIZE) as usize),
        }
```

--------------------------------

### deref_mut

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.Embedding.html

Dereferences a pointer to get a mutable reference to the value.

```APIDOC
## unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

### Description
Mutably dereferences the given pointer.

### Method
`deref_mut`
```

--------------------------------

### Test Preprocessor Initialization

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/imgproc/preprocess.rs.html

Verifies that a new `Preprocessor` instance is created with empty internal buffers.

```rust
    #[test]
    fn test_preprocessor_new() {
        let preprocessor = Preprocessor::new();
        assert!(preprocessor.dst_buffer.is_empty());
        assert!(preprocessor.gray_buffer.is_empty());
    }
```

--------------------------------

### deref

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.Embedding.html

Dereferences a pointer to get an immutable reference to the value.

```APIDOC
## unsafe fn deref<'a>(ptr: usize) -> &'a T

### Description
Dereferences the given pointer.

### Method
`deref`
```

--------------------------------

### ImageFingerprinter init

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprinter.html?search=std%3A%3Avec

Initializes an ImageFingerprinter with the given initializer.

```APIDOC
## ImageFingerprinter init

### Description
Initializes a with the given initializer.

### Method
`unsafe fn init(init: <T as Pointable>::Init) -> usize`

### Endpoint
N/A

### Parameters
- **init** (<T as Pointable>::Init): The initializer value.

### Response
#### Success Response
- **usize**: The pointer to the initialized memory.
```

--------------------------------

### Get DHash Fingerprint

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Returns a reference to the DHash-based image fingerprint.

```rust
pub fn dhash(&self) -> &ImageFingerprint {
        &self.dhash
    }

```

--------------------------------

### imgfprint Hashing Algorithms Overview

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/hash/mod.rs.html?search=

Introduces the perceptual hashing algorithms available in the imgfprint crate: ahash, phash, and dhash. Explains their characteristics and the common interface for hash comparison.

```rust
1//! Perceptual hashing algorithms.
//! 
//! This module contains implementations of three hash algorithms:
//! - [`ahash`](ahash): Average-based hashing (fastest)
//! - [`phash`](phash): DCT-based hashing (most robust)
//! - [`dhash`](dhash): Gradient-based hashing (good for crops)
//! 
//! Each algorithm produces a 64-bit hash that can be compared using
//! Hamming distance. See [`HashAlgorithm`](algorithms::HashAlgorithm) for details.
10
11pub mod ahash;
12pub mod algorithms;
13pub mod dhash;
14pub mod phash;

```

--------------------------------

### Get AHash Fingerprint

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Returns a reference to the AHash-based image fingerprint.

```rust
pub fn ahash(&self) -> &ImageFingerprint {
        &self.ahash
    }

```

--------------------------------

### TypeId

Source: https://docs.rs/imgfprint/latest/imgfprint/struct.ImageFingerprinter.html?search=

Gets the TypeId of an object. This is useful for runtime type identification.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
Implicit (method call on an object)

### Parameters
None

### Return Value
- **TypeId**: The unique identifier for the type of `self`.
```

--------------------------------

### Compute Fingerprint from File Path with Preprocessing

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.FingerprinterContext.html

Reads an image from disk and computes its multi-algorithm fingerprint with a tunable `PreprocessConfig`. The same config gates both the pre-read file-size check and the decode-time guards.

```rust
pub fn fingerprint_path_with_preprocess<P: AsRef<Path>>( &mut self, path: P, preprocess: &PreprocessConfig, ) -> Result<MultiHashFingerprint, ImgFprintError>
```

--------------------------------

### imgfprint/hash/mod.rs Module Documentation

Source: https://docs.rs/imgfprint/latest/src/imgfprint/hash/mod.rs.html?search=

This is the main documentation for the hash module, outlining the available hashing algorithms and their properties. It serves as an entry point for understanding the perceptual hashing capabilities of the library.

```rust
1//! Perceptual hashing algorithms.
//! 
//! This module contains implementations of three hash algorithms:
//! - [`ahash`](ahash): Average-based hashing (fastest)
//! - [`phash`](phash): DCT-based hashing (most robust)
//! - [`dhash`](dhash): Gradient-based hashing (good for crops)
//! 
//! Each algorithm produces a 64-bit hash that can be compared using
//! Hamming distance. See [`HashAlgorithm`](algorithms::HashAlgorithm) for details.
11
12pub mod ahash;
13pub mod algorithms;
14pub mod dhash;
15pub mod phash;

```

--------------------------------

### Get PHash Fingerprint

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprint.rs.html?search=std%3A%3Avec

Retrieves a reference to the PHash-based image fingerprint.

```rust
/// Returns the PHash-based fingerprint.
    #[inline]
    #[must_use]
    pub fn phash(&self) -> &ImageFingerprint {
        &self.phash
    }
```

--------------------------------

### Get DHash Fingerprint

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Retrieves a reference to the DHash-based fingerprint component.

```rust
/// Returns the DHash-based fingerprint.
    #[inline]
    #[must_use]
    pub fn dhash(&self) -> &ImageFingerprint {
        &self.dhash
    }

```

--------------------------------

### Customizing MultiHash Comparison Configuration

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprint.rs.html?search=

Demonstrates how to create a custom `MultiHashConfig` to adjust the weights of different hashing algorithms for image fingerprint comparison. This allows for tuning the comparison sensitivity based on specific needs, such as prioritizing PHash.

```rust
use imgfprint::{ImageFingerprinter, MultiHashConfig};

# fn run(a: &[u8], b: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
// PHash-only scoring — useful when AHash/DHash aren't trusted on this corpus.
let cfg = MultiHashConfig {
    ahash_weight: 0.0,
    phash_weight: 1.0,
    dhash_weight: 0.0,
    ..MultiHashConfig::default()
};

let fp1 = ImageFingerprinter::fingerprint(a)?;
let fp2 = ImageFingerprinter::fingerprint(b)?;
let sim = fp1.compare_with_config(&fp2, &cfg);
# let _ = sim;
# Ok(())
# }
```

--------------------------------

### Get AHash Fingerprint

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Retrieves a reference to the AHash-based fingerprint component.

```rust
/// Returns the AHash-based fingerprint.
    #[inline]
    #[must_use]
    pub fn ahash(&self) -> &ImageFingerprint {
        &self.ahash
    }

```

--------------------------------

### Initialize Preprocessor with CPU Extensions

Source: https://docs.rs/imgfprint/latest/src/imgfprint/imgproc/preprocess.rs.html?search=std%3A%3Avec

Initializes the image preprocessor, safely setting CPU extensions based on detected hardware support. This ensures that SIMD instructions are only used when available, preventing undefined behavior.

```rust
unsafe {
                resizer.set_cpu_extensions(cpu_extensions);
            }
```

--------------------------------

### imgfprint Hash Algorithms Overview

Source: https://docs.rs/imgfprint/latest/src/imgfprint/hash/mod.rs.html?search=std%3A%3Avec

Introduces the perceptual hashing algorithms available in the imgfprint crate: ahash, phash, and dhash. Explains their characteristics and the use of Hamming distance for comparison.

```rust
1//! Perceptual hashing algorithms.
2//!
3//! This module contains implementations of three hash algorithms:
4//! - [`ahash`](ahash): Average-based hashing (fastest)
5//! - [`phash`](phash): DCT-based hashing (most robust)
6//! - [`dhash`](dhash): Gradient-based hashing (good for crops)
7//!
8//! Each algorithm produces a 64-bit hash that can be compared using
9//! Hamming distance. See [`HashAlgorithm`](algorithms::HashAlgorithm) for details.
10
11pub mod ahash;
12pub mod algorithms;
13pub mod dhash;
14pub mod phash;
```

--------------------------------

### Get DHash Fingerprint

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.MultiHashFingerprint.html?search=

Returns the DHash-based fingerprint component of the MultiHashFingerprint.

```rust
pub fn dhash(&self) -> &ImageFingerprint
```

--------------------------------

### Customizing Fingerprint Comparison with MultiHashConfig

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Demonstrates how to create a custom `MultiHashConfig` to adjust the weights of different hashing algorithms (AHash, PHash, DHash) and the balance between global and block-level hashes. This is useful for tuning comparison sensitivity for specific image datasets or use cases. The example shows how to disable AHash and DHash to rely solely on PHash.

```rust
use imgfprint::{ImageFingerprinter, MultiHashConfig};

# fn run(a: &[u8], b: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
// PHash-only scoring — useful when AHash/DHash aren't trusted on this corpus.
let cfg = MultiHashConfig {
    ahash_weight: 0.0,
    phash_weight: 1.0,
    dhash_weight: 0.0,
    ..MultiHashConfig::default()
};

let fp1 = ImageFingerprinter::fingerprint(a)?;
let fp2 = ImageFingerprinter::fingerprint(b)?;
let sim = fp1.compare_with_config(&fp2, &cfg);
# let _ = sim;
# Ok(())
# }

```

--------------------------------

### Get PHash Fingerprint

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.MultiHashFingerprint.html?search=

Returns the PHash-based fingerprint component of the MultiHashFingerprint.

```rust
pub fn phash(&self) -> &ImageFingerprint
```

--------------------------------

### Get AHash Fingerprint

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.MultiHashFingerprint.html?search=

Returns the AHash-based fingerprint component of the MultiHashFingerprint.

```rust
pub fn ahash(&self) -> &ImageFingerprint
```

--------------------------------

### imgfprint/hash Module Overview

Source: https://docs.rs/imgfprint/latest/src/imgfprint/hash/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides an overview of the perceptual hashing algorithms available in the imgfprint/hash module.

```rust
//! Perceptual hashing algorithms.
//!
//! This module contains implementations of three hash algorithms:
//! - [`ahash`](ahash): Average-based hashing (fastest)
//! - [`phash`](phash): DCT-based hashing (most robust)
//! - [`dhash`](dhash): Gradient-based hashing (good for crops)
//!
//! Each algorithm produces a 64-bit hash that can be compared using
//! Hamming distance. See [`HashAlgorithm`](algorithms::HashAlgorithm) for details.

pub mod ahash;
pub mod algorithms;
pub mod dhash;
pub mod phash;

```

--------------------------------

### ImageFingerprinter deref_mut

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprinter.html?search=std%3A%3Avec

Dereferences the given pointer to get a mutable reference to an ImageFingerprinter.

```APIDOC
## ImageFingerprinter deref_mut

### Description
Mutably dereferences the given pointer.

### Method
`unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T`

### Endpoint
N/A

### Parameters
- **ptr** (usize): The pointer to dereference.

### Response
#### Success Response
- **&'a mut T**: A mutable reference to the ImageFingerprinter.
```

--------------------------------

### Read Image from Disk and Fingerprint with Preprocessing

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprinter.rs.html?search=u32+-%3E+bool

Reads an image from disk and computes its multi-algorithm fingerprint with a tunable PreprocessConfig. This function allows for customized preprocessing before fingerprinting.

```rust
pub fn fingerprint_path_with_preprocess<P: AsRef<Path>>(
    path: P,
    preprocess: &PreprocessConfig,
) -> Result<MultiHashFingerprint, ImgFprintError> {
    let bytes = read_image_file(path.as_ref(), preprocess)?;
    Self::fingerprint_with_preprocess(&bytes, preprocess)
}
```

--------------------------------

### ImageFingerprinter deref

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprinter.html?search=std%3A%3Avec

Dereferences the given pointer to get an immutable reference to an ImageFingerprinter.

```APIDOC
## ImageFingerprinter deref

### Description
Dereferences the given pointer.

### Method
`unsafe fn deref<'a>(ptr: usize) -> &'a T`

### Endpoint
N/A

### Parameters
- **ptr** (usize): The pointer to dereference.

### Response
#### Success Response
- **&'a T**: An immutable reference to the ImageFingerprinter.
```

--------------------------------

### Get Fingerprint by Algorithm

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.MultiHashFingerprint.html?search=

Retrieves the fingerprint for a specific hash algorithm from the MultiHashFingerprint.

```rust
pub fn get(&self, algorithm: HashAlgorithm) -> &ImageFingerprint
```

--------------------------------

### Compute Multi-Algorithm Fingerprint from File Path with Preprocessing

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprinter.html

Reads an image from disk and computes its multi-algorithm fingerprint with a tunable PreprocessConfig. Handles file reading and preprocessing.

```rust
pub fn fingerprint_path_with_preprocess<P: AsRef<Path>>(
    path: P,
    preprocess: &PreprocessConfig,
) -> Result<MultiHashFingerprint, ImgFprintError>
```

--------------------------------

### Get Fingerprint by Algorithm

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Retrieves the ImageFingerprint for a specified HashAlgorithm (AHash, PHash, DHash).

```rust
pub fn get(&self, algorithm: HashAlgorithm) -> &ImageFingerprint {
        match algorithm {
            HashAlgorithm::AHash => &self.ahash,
            HashAlgorithm::PHash => &self.phash,
            HashAlgorithm::DHash => &self.dhash,
        }
    }

```

--------------------------------

### Test Default Preprocess Configuration

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/imgproc/decode.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Verifies that the default `PreprocessConfig` values are correctly set.

```rust
#[test]
fn test_preprocess_config_default() {
    let cfg = PreprocessConfig::default();
    assert_eq!(cfg.max_dimension, DEFAULT_MAX_DIMENSION);
    assert_eq!(cfg.min_dimension, DEFAULT_MIN_DIMENSION);
    assert_eq!(cfg.max_input_bytes, DEFAULT_MAX_INPUT_BYTES);
}
```

--------------------------------

### Get Format Version

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Returns the constant format version associated with the fingerprint computation.

```rust
pub const fn format_version() -> u32 {
        crate::FORMAT_VERSION
    }

```

--------------------------------

### Creating a Test Image

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprinter.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Generates a simple RGB PNG image buffer for testing purposes. The image content is based on pixel coordinates.

```rust
fn create_test_image(width: u32, height: u32) -> Vec<u8> {
    let img: ImageBuffer<Rgb<u8>, Vec<u8>> = ImageBuffer::from_fn(width, height, |x, y| {
        Rgb([(x % 256) as u8, (y % 256) as u8, 128])
    });
    let mut buf = Vec::new();
    img.write_to(&mut std::io::Cursor::new(&mut buf), image::ImageFormat::Png)
        .unwrap();
    buf
}
```

--------------------------------

### Get Exact Hash

Source: https://docs.rs/imgfprint/latest/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Retrieves a reference to the 32-byte BLAKE3 hash of the original image.

```rust
pub fn exact_hash(&self) -> &[u8; 32] {
        &self.exact
    }

```

--------------------------------

### FingerprinterContext Initialization Tests

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprinter.rs.html?search=u32+-%3E+bool

Tests for the `new` and `default` methods of `FingerprinterContext` to ensure proper initialization.

```rust
    #[test]
    fn test_fingerprinter_context_new() {
        let ctx = FingerprinterContext::new();
        let _ = ctx;
    }

    #[test]
    fn test_fingerprinter_context_default() {
        let ctx = FingerprinterContext::default();
        let _ = ctx;
    }
```

--------------------------------

### Pointable::deref

Source: https://docs.rs/imgfprint/latest/imgfprint/struct.ImageFingerprinter.html

Dereferences the given pointer to get an immutable reference. This is an unsafe operation.

```APIDOC
## unsafe fn deref<'a>(ptr: usize) -> &'a T

### Description
Dereferences the given pointer.

### Method
(Implicitly called via trait method)

### Parameters
* **ptr** (usize) - The pointer to dereference.
```

--------------------------------

### Compute Fingerprint from File Path with Preprocessing

Source: https://docs.rs/imgfprint/0.4.2/imgfprint/struct.ImageFingerprinter.html?search=u32+-%3E+bool

Reads an image from a file path and computes its multi-algorithm fingerprint with tunable preprocessing. Combines file reading and preprocessing for fingerprint generation.

```rust
pub fn fingerprint_path_with_preprocess<P: AsRef<Path>>( path: P, preprocess: &PreprocessConfig, ) -> Result<MultiHashFingerprint, ImgFprintError>
```

--------------------------------

### Pointable::init

Source: https://docs.rs/imgfprint/latest/imgfprint/struct.ImageFingerprinter.html

Initializes a with the given initializer. This is an unsafe operation.

```APIDOC
## unsafe fn init(init: <T as Pointable>::Init) -> usize

### Description
Initializes a with the given initializer.

### Method
(Implicitly called via trait method)

### Parameters
* **init** (<T as Pointable>::Init) - The initializer for the object.
```

--------------------------------

### Get Fingerprint by Algorithm

Source: https://docs.rs/imgfprint/0.4.2/src/imgfprint/core/fingerprint.rs.html?search=u32+-%3E+bool

Returns the ImageFingerprint for a specified HashAlgorithm (AHash, PHash, or DHash).

```rust
/// Returns the fingerprint for a specific algorithm.
    #[must_use]
    pub fn get(&self, algorithm: HashAlgorithm) -> &ImageFingerprint {
        match algorithm {
            HashAlgorithm::AHash => &self.ahash,
            HashAlgorithm::PHash => &self.phash,
            HashAlgorithm::DHash => &self.dhash,
        }
    }

```
Tokens:
Raw