Comparer deux images à la manière de python/linux

Question

Essayer de résoudre un problème d'empêcher le téléchargement d'images en double.

J'ai deux fichiers JPG. En les regardant, je peux voir qu'ils sont en fait identiques. Mais pour une raison quelconque, ils ont une taille de fichier différente (l'un est tiré d'une sauvegarde, l'autre est un autre téléchargement) et donc ils ont une somme de contrôle md5 différente.

Comment puis-je comparer efficacement et en toute confiance deux images de la même manière qu'un humain serait capable de voir qu'elles sont clairement identiques ?

Exemple: http://static.peterbe.com/a.jpg et http://static.peterbe.com/b.jpg

Mise à jour

J'ai écrit ce script:

import math, operator
from PIL import Image
def compare(file1, file2):
    image1 = Image.open(file1)
    image2 = Image.open(file2)
    h1 = image1.histogram()
    h2 = image2.histogram()
    rms = math.sqrt(reduce(operator.add,
                           map(lambda a,b: (a-b)**2, h1, h2))/len(h1))
    return rms

if __name__=='__main__':
    import sys
    file1, file2 = sys.argv[1:]
    print compare(file1, file2)

Ensuite, j'ai téléchargé les deux images visuellement identiques et ai exécuté le script. Sortie:

58.9830484122

Est-ce que quelqu'un peut me dire quel devrait être le seuil approprié ?

Mise à jour II

La différence entre a.jpg et b.jpg est que le deuxième a été enregistré avec PIL:

b=Image.open('a.jpg')
b.save(open('b.jpg','wb'))

Cela applique apparemment quelques modifications de qualité très légères. J'ai maintenant résolu mon problème en appliquant le même enregistrement PIL au fichier en cours de téléchargement sans rien faire avec lui et maintenant cela fonctionne !

Answer 1

Il existe un projet OSS qui utilise WebDriver pour prendre des captures d'écran, puis compare les images pour voir s'il y a des problèmes (http://code.google.com/p/fighting-layout-bugs/)). Il le fait en ouvrant le fichier dans un flux, puis en comparant chaque bit.

Vous pouvez peut-être faire quelque chose de similaire avec PIL.

MODIFIER:

Après plus de recherches, j'ai trouvé

h1 = Image.open("image1").histogram()
h2 = Image.open("image2").histogram()

rms = math.sqrt(reduce(operator.add,
    map(lambda a,b: (a-b)**2, h1, h2))/len(h1))

sur http://snipplr.com/view/757/compare-two-pil-images-in-python/ and http://effbot.org/zone/pil-comparing-images.htm

Answer 2

De ici

La façon la plus rapide de déterminer si deux images ont exactement le même contenu est d'obtenir la différence entre les deux images, puis de calculer le rectangle englobant des régions non nulles dans cette image.

Si les images sont identiques, tous les pixels de l'image de différence sont nuls, et la fonction de rectangle englobant renvoie None.

from PIL import ImageChops

def equal(im1, im2):
    return ImageChops.difference(im1, im2).getbbox() is None

Answer 3

Je suppose que vous devriez décoder les images et faire une comparaison pixel par pixel pour voir si elles sont raisonnablement similaires.

Avec PIL et Numpy, vous pouvez le faire assez facilement :

import Image
import numpy
import sys

def main():
    img1 = Image.open(sys.argv[1])
    img2 = Image.open(sys.argv[2])

    if img1.size != img2.size or img1.getbands() != img2.getbands():
        return -1

    s = 0
    for band_index, band in enumerate(img1.getbands()):
        m1 = numpy.array([p[band_index] for p in img1.getdata()]).reshape(*img1.size)
        m2 = numpy.array([p[band_index] for p in img2.getdata()]).reshape(*img2.size)
        s += numpy.sum(numpy.abs(m1-m2))
    print s

if __name__ == "__main__":
    sys.exit(main())

Cela vous donnera une valeur numérique qui devrait être très proche de 0 si les images sont assez similaires.

Notez que les images qui sont déplacées / tournées seront signalées comme très différentes, car les pixels ne correspondent pas un par un.

Answer 4

En utilisant ImageMagick, vous pouvez simplement utiliser dans votre shell [ou appeler via la bibliothèque OS à partir d'un programme]

compare image1 image2 output

Cela créera une image de sortie avec les différences marquées

compare -metric AE -fuzz 5% image1 image2 output

Vous donnera un facteur de tolérance de 5% pour ignorer les différences de pixels mineures. Plus d'informations peuvent être obtenues ici

Answer 5

Le problème de savoir ce qui rend certaines caractéristiques de l'image plus importantes que d'autres est tout un programme scientifique. Je proposerais quelques alternatives en fonction de la solution que vous souhaitez:

• si votre problème est de voir s'il y a un basculement de bits dans vos JPEG, essayez d'imager l'image de différence (il y a peut-être eu une petite modification localement?),

• pour voir si les images sont globalement les mêmes, utilisez la distance de Kullback Leibler pour comparer vos histogrammes,

• pour voir si vous avez un changement qualitatif, avant d'appliquer d'autres réponses, filtrez votre image en utilisant les fonctions ci-dessous pour augmenter l'importance des fréquences de haut niveau:

code:

def FTfilter(image,FTfilter):
    from scipy.fftpack import fft2, fftshift, ifft2, ifftshift
    from scipy import real
    FTimage = fftshift(fft2(image)) * FTfilter
    return real(ifft2(ifftshift(FTimage)))
    #return real(ifft2(fft2(image)* FTfilter))

#### blanchiment
def olshausen_whitening_filt(size, f_0 = .78, alpha = 4., N = 0.01):
    """
    Renvoie le filtre de blanchiment utilisé par (Olshausen, 98)

    f_0 = 200 / 512

    /!\ vous aurez des problèmes en déblanchissant sans un passe-bas

    """
    from scipy import mgrid, absolute
    fx, fy = mgrid[-1:1:1j*size[0],-1:1:1j*size[1]]
    rho = numpy.sqrt(fx**2+fy**2)
    K_ols = (N**2 + rho**2)**.5 * low_pass(size, f_0 = f_0, alpha = alpha)
    K_ols /= numpy.max(K_ols)

    return  K_ols

def low_pass(size, f_0, alpha):
    """
    Renvoie le filtre passe-bas utilisé par (Olshausen, 98)

    paramètres provenant de Atick (p.240)
    f_0 = 22 c/d dans les primates : l'image complète est d'environ 45 deg
    alpha change l'aspect (1=diamant sur le vert et l'hor, 2 = anisotropique)

    """

    from scipy import mgrid, absolute
    fx, fy = mgrid[-1:1:1j*size[0],-1:1:1j*size[1]]
    rho = numpy.sqrt(fx**2+fy**2)
    low_pass = numpy.exp(-(rho/f_0)**alpha)

    return  low_pass

(copie éhontée depuis http://www.incm.cnrs-mrs.fr/LaurentPerrinet/Publications/Perrinet08spie )