Enum img_hash::HashAlg

pub enum HashAlg {
    Mean,
    Gradient,
    VertGradient,
    DoubleGradient,
    Blockhash,
    // some variants omitted
}

Hash algorithms implemented by this crate.

Implemented primarily based on the high-level descriptions on the blog Hacker Factor written by Dr. Neal Krawetz: http://www.hackerfactor.com/

Note that hash_width and hash_height in these docs refer to the parameters of HasherConfig::hash_size().

Choosing an Algorithm

Each algorithm has different performance characteristics

Variants

Mean

The Mean hashing algorithm.

The image is converted to grayscale, scaled down to hash_width x hash_height, the mean pixel value is taken, and then the hash bits are generated by comparing the pixels of the descaled image to the mean.

This is the most basic hash algorithm supported, resistant only to changes in resolution, aspect ratio, and overall brightness.

Further Reading: http://www.hackerfactor.com/blog/?/archives/432-Looks-Like-It.html

Gradient

The Gradient hashing algorithm.

The image is converted to grayscale, scaled down to (hash_width + 1) x hash_height, and then in row-major order the pixels are compared with each other, setting bits in the hash for each comparison. The extra pixel is needed to have hash_width comparisons per row.

This hash algorithm is as fast or faster than Mean (because it only traverses the hash data once) and is more resistant to changes than Mean.

Further Reading: http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html

VertGradient

The Vertical-Gradient hashing algorithm.

Equivalent to Gradient but operating on the columns of the image instead of the rows.

DoubleGradient

The Double-Gradient hashing algorithm.

An advanced version of Gradient; resizes the grayscaled image to (width / 2 + 1) x (height / 2 + 1) and compares columns in addition to rows.

This algorithm is slightly slower than Gradient (resizing the image dwarfs the hash time in most cases) but the extra comparison direction may improve results (though you might want to consider increasing hash_size to accommodate the extra comparisons).

Blockhash

The Blockhash.io algorithm.

Compared to the other algorithms, this does not require any preprocessing steps and so may be significantly faster at the cost of some resilience.

The algorithm is described in a high level here: https://github.com/commonsmachinery/blockhash-rfc/blob/master/main.md

Trait Implementations

impl Clone for HashAlg

fn clone(&self) -> HashAlg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for HashAlg

impl Debug for HashAlg

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HashAlg

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Eq for HashAlg

impl PartialEq<HashAlg> for HashAlg

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl Serialize for HashAlg

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

Serialize this value into the given Serde serializer.

impl StructuralEq for HashAlg

impl StructuralPartialEq for HashAlg