imagehash

A Python Perceptual Image Hashing Module

3,119

328

3,119

View on GitHub

Top Related Projects

imagehash

1,984

🌄 Perceptual image hashing for PHP

Quick Overview

ImageHash is a Python library for perceptual image hashing. It provides functions to generate hash values for images, which can be used for tasks like finding duplicate or similar images, even if they have been slightly modified or resized. The library supports various hashing algorithms and offers both command-line and programmatic interfaces.

Pros

Easy to use with a simple API
Supports multiple hashing algorithms (average, perceptual, difference, wavelet)
Can handle various image formats (PNG, JPEG, etc.)
Includes both command-line and programmatic interfaces

Cons

Limited documentation and examples
May not be suitable for very large-scale image processing tasks
Depends on external libraries (PIL, scipy, numpy) which may increase installation complexity
Not actively maintained (last update was in 2021)

Code Examples

Generating an average hash for an image:

import imagehash
from PIL import Image

hash = imagehash.average_hash(Image.open('path/to/image.jpg'))
print(hash)

Comparing two images using perceptual hash:

import imagehash
from PIL import Image

hash1 = imagehash.phash(Image.open('image1.jpg'))
hash2 = imagehash.phash(Image.open('image2.jpg'))
similarity = hash1 - hash2
print(f"Images are {similarity} bits different")

Using the command-line interface to find similar images:

find . -name '*.jpg' | xargs imagehash

Getting Started

To get started with ImageHash, follow these steps:

Install the library using pip:
```
pip install ImageHash
```
Import the library in your Python script:
```
import imagehash
from PIL import Image
```

Generate a hash for an image:

image_path = 'path/to/your/image.jpg'
hash = imagehash.average_hash(Image.open(image_path))
print(f"Image hash: {hash}")

Compare two images:

image1_path = 'path/to/image1.jpg'
image2_path = 'path/to/image2.jpg'
hash1 = imagehash.average_hash(Image.open(image1_path))
hash2 = imagehash.average_hash(Image.open(image2_path))
difference = hash1 - hash2
print(f"Image difference: {difference} bits")

Competitor Comparisons

imagehash

1,984

🌄 Perceptual image hashing for PHP

Pros of imagehash (jenssegers)

Supports multiple hashing algorithms (average, difference, perception, wavelet)
Provides a convenient CLI tool for quick image comparison
Offers easy integration with Laravel framework

Cons of imagehash (jenssegers)

Less actively maintained compared to imagehash (JohannesBuchner)
Fewer advanced features and optimizations
Limited documentation and examples

Code Comparison

imagehash (jenssegers):

use Jenssegers\ImageHash\ImageHash;

$hasher = new ImageHash();
$hash = $hasher->hash('path/to/image.jpg');

imagehash (JohannesBuchner):

import imagehash
from PIL import Image

hash = imagehash.average_hash(Image.open('path/to/image.jpg'))

Both libraries provide simple ways to generate image hashes, but they differ in language and implementation. The jenssegers/imagehash library is PHP-based and offers a more object-oriented approach, while JohannesBuchner/imagehash is Python-based and provides a functional interface. The choice between them may depend on your preferred programming language and project requirements.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

=========== ImageHash

An image hashing library written in Python. ImageHash supports:

Average hashing
Perceptual hashing
Difference hashing
Wavelet hashing
HSV color hashing (colorhash)
Crop-resistant hashing

|CI|_ |Coveralls|_

Rationale

Image hashes tell whether two images look nearly identical. This is different from cryptographic hashing algorithms (like MD5, SHA-1) where tiny changes in the image give completely different hashes. In image fingerprinting, we actually want our similar inputs to have similar output hashes as well.

The image hash algorithms (average, perceptual, difference, wavelet) analyse the image structure on luminance (without color information). The color hash algorithm analyses the color distribution and black & gray fractions (without position information).

Installation

Based on PIL/Pillow Image, numpy and scipy.fftpack (for pHash) Easy installation through pypi_::

pip install imagehash

Basic usage

>>> from PIL import Image
>>> import imagehash
>>> hash = imagehash.average_hash(Image.open('tests/data/imagehash.png'))
>>> print(hash)
ffd7918181c9ffff
>>> otherhash = imagehash.average_hash(Image.open('tests/data/peppers.png'))
>>> print(otherhash)
9f172786e71f1e00
>>> print(hash == otherhash)
False
>>> print(hash - otherhash)  # hamming distance
33

Each algorithm can also have its hash size adjusted (or in the case of colorhash, its :code:binbits). Increasing the hash size allows an algorithm to store more detail in its hash, increasing its sensitivity to changes in detail.

The demo script find_similar_images illustrates how to find similar images in a directory.

Source hosted at GitHub: https://github.com/JohannesBuchner/imagehash

References

Average hashing (aHashref_)
Perceptual hashing (pHashref_)
Difference hashing (dHashref_)
Wavelet hashing (wHashref_)
Crop-resistant hashing (crop_resistant_hashref_)

.. _aHashref: https://www.hackerfactor.com/blog/index.php?/archives/432-Looks-Like-It.html .. _pHashref: https://www.hackerfactor.com/blog/index.php?/archives/432-Looks-Like-It.html .. _dHashref: https://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html .. _wHashref: https://fullstackml.com/2016/07/02/wavelet-image-hash-in-python/ .. _pypi: https://pypi.python.org/pypi/ImageHash .. _crop_resistant_hashref: https://ieeexplore.ieee.org/document/6980335

Examples

To help evaluate how different hashing algorithms behave, below are a few hashes applied to two datasets. This will let you know what images an algorithm thinks are basically identical.

Example 1: Icon dataset

Source: 7441 free icons on GitHub (see examples/github-urls.txt).

The following pages show groups of images with the same hash (the hashing method sees them as the same).

phash <https://johannesbuchner.github.io/imagehash/index3.html>__ (or with z-transform <https://johannesbuchner.github.io/imagehash/index9.html>__)
dhash <https://johannesbuchner.github.io/imagehash/index4.html>__ (or with z-transform <https://johannesbuchner.github.io/imagehash/index10.html>__)
colorhash <https://johannesbuchner.github.io/imagehash/index7.html>__
average_hash <https://johannesbuchner.github.io/imagehash/index2.html>__ (with z-transform <https://johannesbuchner.github.io/imagehash/index8.html>__)

The hashes use hashsize=8; colorhash uses binbits=3. You may want to adjust the hashsize or require some manhattan distance (hash1 - hash2 < threshold).

Example 2: Art dataset

Source: 109259 art pieces from https://www.parismuseescollections.paris.fr/en/recherche/image-libre/.

The following pages show groups of images with the same hash (the hashing method sees them as the same).

phash <https://johannesbuchner.github.io/imagehash/art3.html>__ (or with z-transform <https://johannesbuchner.github.io/imagehash/art9.html>__)
dhash <https://johannesbuchner.github.io/imagehash/art4.html>__ (or with z-transform <https://johannesbuchner.github.io/imagehash/art10.html>__)
colorhash <https://johannesbuchner.github.io/imagehash/art7.html>__
average_hash <https://johannesbuchner.github.io/imagehash/art2.html>__ (with z-transform <https://johannesbuchner.github.io/imagehash/art8.html>__)

For understanding hash distances, check out these excellent blog posts:

Storing hashes

As illustrated above, hashes can be turned into strings. The strings can be turned back into a ImageHash object as follows.

For single perceptual hashes::

>>> original_hash = imagehash.phash(Image.open('tests/data/imagehash.png'))
>>> hash_as_str = str(original_hash)
>>> print(hash_as_str)
ffd7918181c9ffff
>>> restored_hash = imagehash.hex_to_hash(hash_as_str)
>>> print(restored_hash)
ffd7918181c9ffff
>>> assert restored_hash == original_hash
>>> assert str(restored_hash) == hash_as_str

For crop_resistant_hash::

>>> original_hash = imagehash.crop_resistant_hash(Image.open('tests/data/imagehash.png'), min_segment_size=500, segmentation_image_size=1000)
>>> hash_as_str = str(original_hash)
>>> restored_hash = imagehash.hex_to_multihash(hash_as_str)
>>> assert restored_hash == original_hash
>>> assert str(restored_hash) == hash_as_str

For colorhash::

>>> original_hash = imagehash.colorhash(Image.open('tests/data/imagehash.png'), binbits=3)
>>> hash_as_str = str(original_hash)
>>> restored_hash = imagehash.hex_to_flathash(hash_as_str, hashsize=3)

Efficient database search

For storing the hashes in a database and using fast hamming distance searches, see pointers at https://github.com/JohannesBuchner/imagehash/issues/127 (a blog post on how to do this would be a great contribution!)

@KDJDEV points to https://github.com/KDJDEV/imagehash-reverse-image-search-tutorial and writes: In this tutorial I use PostgreSQL and this extension <https://github.com/fake-name/pg-spgist_hamming>_, and show how you can create a reverse image search using hashes generated by this library.

Changelog

4.3: typing annotations by @Avasam @SpangleLabs and @nh2
4.2: Cropping-Resistant image hashing added by @SpangleLabs
4.1: Add examples and colorhash
4.0: Changed binary to hex implementation, because the previous one was broken for various hash sizes. This change breaks compatibility to previously stored hashes; to convert them from the old encoding, use the "old_hex_to_hash" function.
3.5: Image data handling speed-up
3.2: whash now also handles smaller-than-hash images
3.0: dhash had a bug: It computed pixel differences vertically, not horizontally. I modified it to follow dHashref_. The old function is available as dhash_vertical.
2.0: Added whash
1.0: Initial ahash, dhash, phash implementations.

Contributing

Pull requests and new features are warmly welcome.

If you encounter a bug or have a question, please open a GitHub issue. You can also try Stack Overflow.

Other projects

https://github.com/commonsmachinery/blockhash-python
https://github.com/acoomans/instagram-filters
https://pippy360.github.io/transformationInvariantImageSearch/
https://www.phash.org/
https://pypi.org/project/dhash/
https://github.com/thorn-oss/perception (based on imagehash code, depends on opencv)
https://docs.opencv.org/3.4/d4/d93/group__img__hash.html

.. |CI| image:: https://github.com/JohannesBuchner/imagehash/actions/workflows/testing.yml/badge.svg .. _CI: https://github.com/JohannesBuchner/imagehash/actions/workflows/testing.yml

.. |Coveralls| image:: https://coveralls.io/repos/github/JohannesBuchner/imagehash/badge.svg .. _Coveralls: https://coveralls.io/github/JohannesBuchner/imagehash

Top Related Projects

imagehash

1,984

🌄 Perceptual image hashing for PHP

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot