Perceptual Hashing (pHash/dHash)

from PIL import Image
import numpy as np

def average_hash(image_path, hash_size=8):
    """
    Compute Average Hash for an image
    
    Args:
        image_path: Path to the image file
        hash_size: Size of the hash (default 8x8 = 64 bits)
    
    Returns:
        Binary hash as integer
    """
    # Open and convert to grayscale
    image = Image.open(image_path).convert('L')
    
    # Resize to hash_size x hash_size
    image = image.resize((hash_size, hash_size), Image.LANCZOS)
    
    # Convert to numpy array
    pixels = np.array(image)
    
    # Calculate average pixel value
    avg = pixels.mean()
    
    # Create binary hash
    hash_bits = []
    for pixel in pixels.flatten():
        hash_bits.append(1 if pixel > avg else 0)
    
    # Convert to integer
    hash_value = 0
    for i, bit in enumerate(hash_bits):
        hash_value |= bit << i
    
    return hash_value

def hamming_distance(hash1, hash2):
    """Calculate Hamming distance between two hashes"""
    return bin(hash1 ^ hash2).count('1')

def are_similar(image1_path, image2_path, threshold=5):
    """Check if two images are similar"""
    hash1 = average_hash(image1_path)
    hash2 = average_hash(image2_path)
    distance = hamming_distance(hash1, hash2)
    return distance <= threshold

# Usage example
similarity = are_similar('image1.jpg', 'image2.jpg', threshold=5)
print(f"Images are similar: {similarity}")

from PIL import Image
import numpy as np

def difference_hash(image_path, hash_size=8):
    """
    Compute Difference Hash for an image
    
    Args:
        image_path: Path to the image file
        hash_size: Size of the hash matrix
    
    Returns:
        Binary hash as integer
    """
    # Open and convert to grayscale
    image = Image.open(image_path).convert('L')
    
    # Resize to (hash_size+1) x hash_size for horizontal differences
    image = image.resize((hash_size + 1, hash_size), Image.LANCZOS)
    
    # Convert to numpy array
    pixels = np.array(image)
    
    # Calculate horizontal differences
    hash_bits = []
    for row in pixels:
        for i in range(len(row) - 1):
            # Compare adjacent pixels
            hash_bits.append(1 if row[i] > row[i + 1] else 0)
    
    # Convert to integer
    hash_value = 0
    for i, bit in enumerate(hash_bits):
        hash_value |= bit << i
    
    return hash_value

class ImageHasher:
    """Class for efficient image hashing and similarity detection"""
    
    def __init__(self, algorithm='dhash', hash_size=8):
        self.algorithm = algorithm
        self.hash_size = hash_size
        self.hash_cache = {}
    
    def hash_image(self, image_path):
        """Hash an image using the selected algorithm"""
        if image_path in self.hash_cache:
            return self.hash_cache[image_path]
        
        if self.algorithm == 'ahash':
            hash_value = average_hash(image_path, self.hash_size)
        elif self.algorithm == 'dhash':
            hash_value = difference_hash(image_path, self.hash_size)
        else:
            raise ValueError(f"Unknown algorithm: {self.algorithm}")
        
        self.hash_cache[image_path] = hash_value
        return hash_value
    
    def find_similar_images(self, target_image, image_list, threshold=5):
        """Find similar images from a list"""
        target_hash = self.hash_image(target_image)
        similar_images = []
        
        for image_path in image_list:
            image_hash = self.hash_image(image_path)
            distance = hamming_distance(target_hash, image_hash)
            
            if distance <= threshold:
                similar_images.append({
                    'path': image_path,
                    'distance': distance,
                    'similarity': 1 - (distance / (self.hash_size ** 2))
                })
        
        # Sort by similarity (lowest distance first)
        similar_images.sort(key=lambda x: x['distance'])
        return similar_images

# Usage example
hasher = ImageHasher(algorithm='dhash', hash_size=8)
similar = hasher.find_similar_images('target.jpg', 
                                   ['img1.jpg', 'img2.jpg', 'img3.jpg'], 
                                   threshold=5)