fast_dhash/

lib.rs

//! # Fast DHash
//!
//! A fast rust implementation of the perceptual hash [*dhash*](https://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html).
//!
//! The main difference with other rust implementations, and the reason it is called *fast*, is that it uses multi-threading and doesn't rely internally on the [*image*](https://docs.rs/image/latest/image/index.html) crate methods.
//!
//! ### Usage
//!
//! ```
//! use fast_dhash::Dhash;
//! use image::open;
//! use std::path::Path;
//!
//! let path = Path::new("../image.jpg");
//! let image = open(path);
//!
//! if let Ok(image) = image {
//!     let hash = Dhash::new(
//!         image.as_bytes(),
//!         image.width(),
//!         image.height(),
//!         image.color().channel_count(),
//!     );
//!     println!("hash: {}", hash);
//!     // hash: d6a288ac6d5cce14
//! }
//! ```
use serde::{Deserialize, Serialize};
use std::{fmt, num, str};

#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
pub struct Dhash {
    hash: u64,
}

impl Dhash {
    pub fn new(bytes: &[u8], width: u32, heigth: u32, channel_count: u8) -> Self {
        let mut grid = [[0f64; 9]; 8];

        let width = width as usize;
        let heigth = heigth as usize;
        let channel_count = channel_count as usize;

        let cell_width = width / 9;
        let cell_height = heigth / 8;

        if channel_count >= 3 {
            // NOTE: RGB(A) images implementation
            std::thread::scope(|s| {
                let mut handles = Vec::with_capacity(9);

                for y in 0..8 {
                    handles.push(s.spawn(move || {
                        let mut row = [0f64; 9];

                        for x in 0..9 {
                            let from = x * cell_width;
                            let to = from + cell_width;

                            let mut rs = 0f64;
                            let mut gs = 0f64;
                            let mut bs = 0f64;

                            for image_x in from..to {
                                let from = y * cell_height;
                                let to = from + cell_height;

                                for image_y in from..to {
                                    let i = (image_y * width + image_x) * channel_count;

                                    unsafe {
                                        rs += *bytes.get_unchecked(i) as f64;
                                        gs += *bytes.get_unchecked(i + 1) as f64;
                                        bs += *bytes.get_unchecked(i + 2) as f64;
                                    }
                                }
                            }

                            unsafe {
                                *row.get_unchecked_mut(x) += rs * 0.299 + gs * 0.587 + bs * 0.114;
                            }
                        }

                        (y, row)
                    }));
                }

                for handle in handles {
                    let (y, row) = handle.join().unwrap();
                    grid[y] = row;
                }
            });
        } else {
            // NOTE: Grayscale images implementation
            std::thread::scope(|s| {
                let mut handles = Vec::with_capacity(9);

                for y in 0..8 {
                    handles.push(s.spawn(move || {
                        let mut row = [0f64; 9];

                        for x in 0..9 {
                            let from = x * cell_width;
                            let to = from + cell_width;

                            let mut luma = 0f64;

                            for image_x in from..to {
                                let from = y * cell_height;
                                let to = from + cell_height;

                                for image_y in from..to {
                                    let i = (image_y * width + image_x) * channel_count;

                                    unsafe {
                                        luma += *bytes.get_unchecked(i) as f64;
                                    }
                                }
                            }

                            unsafe {
                                *row.get_unchecked_mut(x) += luma;
                            }
                        }

                        (y, row)
                    }));
                }

                for handle in handles {
                    let (y, row) = handle.join().unwrap();
                    grid[y] = row;
                }
            });
        }

        let mut bits = [false; 64];

        for y in 0..8 {
            for x in 0..8 {
                bits[y * 8 + x] = grid[y][x] > grid[y][x + 1];
            }
        }

        let mut hash: u64 = 0;

        for (i, &bit) in bits.iter().enumerate() {
            if bit {
                hash += 1 << i;
            }
        }

        Self { hash }
    }

    pub fn from_u64(hash: u64) -> Self {
        Self { hash }
    }

    pub fn hamming_distance(&self, other: &Self) -> u32 {
        (self.hash ^ other.hash).count_ones()
    }

    pub fn to_u64(&self) -> u64 {
        self.hash
    }
}

impl PartialEq for Dhash {
    fn eq(&self, other: &Self) -> bool {
        self.hamming_distance(other) < 11
    }
}

impl fmt::Display for Dhash {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:016x}", &self.hash)
    }
}

impl str::FromStr for Dhash {
    type Err = num::ParseIntError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match u64::from_str_radix(s, 16) {
            Ok(hash) => Ok(Self { hash }),
            Err(error) => Err(error),
        }
    }
}