Enum sn0int_std::gfx::HashAlg

pub enum HashAlg {
    Mean,
    Gradient,
    VertGradient,
    DoubleGradient,
    Blockhash,
    Median,
    // 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

Median

The Median hashing algorithm.

This is a variation of the Mean hashing algorithm that uses the median instead of the mean for filtering. This variation is discussed in the further reading section, and an implementation can be found here https://github.com/JohannesBuchner/imagehash/blob/4de9becdb13ecad67b7393cc17b5a44ea1c61b6b/imagehash.py#L193:

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

Trait Implementations

impl Clone for HashAlg

pub fn clone(&self) -> HashAlg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HashAlg

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

Formats the value using the given formatter.

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

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<HashAlg> for HashAlg

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

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

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

This method tests for !=.

impl Serialize for HashAlg

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

Serialize this value into the given Serde serializer.

impl Copy for HashAlg

impl Eq for HashAlg

impl StructuralEq for HashAlg

impl StructuralPartialEq for HashAlg