A more constrained and friendlier fork of ImageHash.

imha is constrained to not use numpy and keep dependencies to a minimum. This keeps the package simpler and also easier to be installed on limited environments. imha also offers more customization for parametrizing the hash computation and a better engineered hash representation that can be easily converted to different types and representations.

>>> from PIL import Image
>>> import imha
>>> hash1 = imha.average_hash(Image.open("photo1.jpg"))
>>> hash1.bin()
'1111111111010111100100011000000110000001110010011111111111111111'
>>> hash1.hex()
'ffd7918181c9ffff'
>>> hash1.uint()
18435363585078722559
>>> bytes(hash1)
b'\xff\xd7\x91\x81\x81\xc9\xff\xff'
>>> int(hash1)
-11380488630829057
>>> len(hash1)  # hash length in bits
64
>>> hash2 = imha.average_hash(Image.open("photo2.jpg"))
>>> hash2.hex()
'9f172786e71f1e00'
>>> hash1 == hash2
False
>>> hash1 - hash2  # hamming distance between hashes
33

• Generate the same hash values as ImageHash.
• Require only the pillow package.
• Be compatible with currently supported Python versions.

def average_hash(image, size=(8, 8))

Compute Average Hash.

Computes hash with width*height bits.

Arguments:

• image: Source image.
• size: Tuple with width and height to resize the image to. (Default value = (8, 8))

def dhash(image, size=(9, 8), *, skip_corners=False)

Compute Difference Hash by row.

Computes row hash with (width-1)*height bits. Enabling skip_corners reduces the hash length by 4 bits. This means a 64-bits hash can be generated with size=(9, 8) or a 16-bit hash be generated with either size=(5, 4) or size=(6, 4), skip_corners=True for example.

Arguments:

• image: Source image.
• size: Tuple with width and height to resize the image to. (Default value = (9, 8))
• skip_corners: Ignore the four corners. (Default value = False)

def dhash_vertical(image, size=(8, 9), *, skip_corners=False)

Compute Difference Hash by column.

Computes col hash with width*(height-1) bits. Enabling skip_corners reduces the hash length by 4 bits. This means a 64-bits hash can be generated with size=(8, 9) or a 16-bit hash be generated with either size=(4, 5) or size=(5, 5), skip_corners=True for example.

Arguments:

• image: Source image.
• size: Tuple with width and height to resize the image to. (Default value = (8, 9))
• skip_corners: Ignore the four corners. (Default value = False)

class Hash()

Represents a hash object.

The hash value can be converted to various types and representations using the built-in functions and provided methods. The hamming distance between hashes can be computed by subtracting one hash from another.

def __init__(value, len_)

Create hash object.

Arguments:

• value: The hash as an unsigned integer value.
• len_: The hash length in bits.

def bin()

Return the hash binary representation.

def hex()

Return the hash hexadecimal representation.

def uint()

Return the hash as an unsigned integer value.

def __len__()

Return len(self), the hash length in bits.

def __sub__(other)

Return self - other, the hamming distance between hashes.

def __eq__(other)

Return self == other.

def __hash__()

Return hash(self).

def __bytes__()

Return bytes(self), the hash as bytes.

def __int__()

Return int(self), the hash as a signed integer value.

def __index__()

Return integer for bin(self), hex(self) and oct(self).

def __repr__()

Return repr(self).

def __str__()

Return str(self).