Comment puis-je quantifier la différence entre les deux images?

Idée générale

Option 1: Charger à la fois des images sous la forme de tableaux (scipy.misc.imread) et de calculer un élément-sage (pixel par pixel) de différence. Calculer la norme de la différence.

Option 2: Charger les deux images. Calculer certaines disposent d'vecteur pour chacun d'eux (comme un histogramme). Calculer la distance entre les fonction de vecteurs plutôt que des images.

Cependant, il ya quelques décisions à prendre en premier.

Questions

Vous devez répondre à ces questions d'abord:

• Sont des images de la même forme et la même dimension?

  Si non, vous devrez peut-être redimensionner ou recadrer. PIL bibliothèque aidera à le faire en Python.

  Si elles sont prises avec les mêmes paramètres et la même dispositif, ils sont probablement les mêmes.

• Images sont bien alignées?

  Si pas, vous pouvez exécuter l'inter-corrélation d'abord, pour trouver le meilleur alignement de la première. SciPy a des fonctions pour le faire.

  Si la caméra et la scène sont toujours, les images sont susceptibles d'être bien alignés.

• Est l'exposition des images toujours le même? (Est-luminosité/contraste le même?)

  Si pas, vous pouvez pour normaliser images.

  Mais attention, dans certaines situations, cela peut faire plus de mal que de bien. Par exemple, un pixel défectueux sur un fond sombre fera l'normalisé de l'image très différente.

• Est la couleur de l'information importante?

  Si vous voulez l'avis des changements de couleur, vous aurez un vecteur de valeurs de couleur par point, plutôt qu'une valeur scalaire comme en échelle de gris de l'image. Vous avez besoin plus d'attention lors de la rédaction d'un tel code.

• Sont là bords distincts dans l'image? Sont-ils susceptibles de se déplacer?

  Si oui, vous pouvez appliquer bord de l'algorithme de détection de la première (par exemple, calculer un gradient de Sobel ou de Prewitt transformer, appliquez un peu de seuil), puis de comparer les bords sur la première image, sur les bords de sur la deuxième.

• Est-il du bruit dans l'image?

  Tous les capteurs de polluer l'image avec une certaine quantité de bruit. Faible coût des capteurs ont le plus de bruit. Vous pouvez appliquer un peu de réduction de bruit avant de comparer les images. Le flou est plus simple (mais pas le meilleur) approche ici.

• Quels changements voulez-vous un avis?

  Cela peut influer sur le choix de la norme à utiliser pour la différence entre les images.

  Envisager l'utilisation de Manhattan norme (la somme des valeurs absolues) ou zéro norme (le nombre d'éléments n'est pas égale à zéro) pour mesurer combien l'image a changé. Les anciens vous diront combien l'image est désactivé, ce dernier sera seulement dire le nombre de pixels différents.

Exemple

Je suppose que vos images sont bien alignées, de la même taille et de la forme, peut-être avec différents niveaux d'exposition. Pour des raisons de simplicité, je les convertir en niveaux de gris, même si elles sont de couleur (RVB) des images.

Vous aurez besoin de ces importations:

import sys

from scipy.misc import imread
from scipy.linalg import norm
from scipy import sum, average

Principale fonction de lire les deux images, les convertir en niveaux de gris, de comparer et d'imprimer les résultats:

def main():
    file1, file2 = sys.argv[1:1+2]
    # read images as 2D arrays (convert to grayscale for simplicity)
    img1 = to_grayscale(imread(file1).astype(float))
    img2 = to_grayscale(imread(file2).astype(float))
    # compare
    n_m, n_0 = compare_images(img1, img2)
    print "Manhattan norm:", n_m, "/per pixel:", n_m/img1.size
    print "Zero norm:", n_0, "/per pixel:", n_0*1.0/img1.size

Comment comparer. img1 et img2 sont en 2D SciPy tableaux ici:

def compare_images(img1, img2):
    # normalize to compensate for exposure difference, this may be unnecessary
    # consider disabling it
    img1 = normalize(img1)
    img2 = normalize(img2)
    # calculate the difference and its norms
    diff = img1 - img2  # elementwise for scipy arrays
    m_norm = sum(abs(diff))  # Manhattan norm
    z_norm = norm(diff.ravel(), 0)  # Zero norm
    return (m_norm, z_norm)

Si le fichier est une image en couleur, imread retourne un tableau 3D, la moyenne des canaux RVB (le dernier tableau de l'axe) pour obtenir l'intensité. Pas besoin de le faire pour les images en niveaux de gris (par exemple .pgm):

def to_grayscale(arr):
    "If arr is a color image (3D array), convert it to grayscale (2D array)."
    if len(arr.shape) == 3:
        return average(arr, -1)  # average over the last axis (color channels)
    else:
        return arr

La normalisation est trivial, vous pouvez choisir de normaliser à [0,1] au lieu de [0,255]. arr est un SciPy tableau ici, de sorte que toutes les opérations sont l'élément de sage:

def normalize(arr):
    rng = arr.max()-arr.min()
    amin = arr.min()
    return (arr-amin)*255/rng

Exécuter le main fonction:

if __name__ == "__main__":
    main()

Maintenant vous pouvez mettre tout cela dans un script et l'exécuter à l'encontre de deux images. Si l'on compare l'image de lui-même, il n'y a pas de différence:

$ python compare.py one.jpg one.jpg
Manhattan norm: 0.0 / per pixel: 0.0
Zero norm: 0 / per pixel: 0.0

Si nous le flou de l'image et de la comparer à l'original, il y a une certaine différence:

$ python compare.py one.jpg one-blurred.jpg 
Manhattan norm: 92605183.67 / per pixel: 13.4210411116
Zero norm: 6900000 / per pixel: 1.0

P. S. Toute compare.py script.

Mise à jour: les techniques pertinentes

Que la question est à propos d'une séquence vidéo, où les images sont susceptibles d'être presque le même, et vous cherchez quelque chose d'inhabituel, je voudrais mentionner quelques approches alternatives qui pourraient être utiles:

• soustraction du bruit de fond et de la segmentation (pour détecter des objets au premier plan)
• éparses du flux optique (pour détecter le mouvement)
• la comparaison d'histogrammes ou de quelques autres statistiques au lieu des images

Je recommande fortement de prendre un coup d'oeil à “l'Apprentissage de l'utilisation d'OpenCV” livre, les Chapitres 9 (Image des pièces et de la segmentation) et 10 (Suivi et de mouvement). L'ancienne enseigne à utiliser soustraction d'arrière-plan de la méthode, ce dernier donne des informations sur le flux optique méthodes. Toutes les méthodes sont implémentées dans la bibliothèque OpenCV. Si vous utilisez Python, je suggère d'utiliser OpenCV ≥ 2.3, et son cv2 module Python.

La version la plus simple de la soustraction du bruit de fond:

• apprendre la valeur moyenne µ et d'écart type σ pour chaque pixel de l'arrière-plan
• comparer les valeurs des pixels de la gamme de l' (μ-2σ,μ+2σ) ou (µ-σ,μ+σ)

D'autres versions plus évoluées de les prendre en compte à la fois de la série pour chaque pixel et gérer les non-scènes statiques (comme le déplacement d'arbres ou de l'herbe).

L'idée de flux optique est de prendre deux ou plusieurs images, et d'attribuer vecteur de vélocité pour chaque pixel (dense flux optique) ou à certains d'entre eux (sparse flux optique). Pour estimer éparses du flux optique, vous pouvez utiliser Lucas-Kanade méthode (il est également mis en œuvre dans OpenCV). De toute évidence, si il y a beaucoup de débit (haute moyenne sur les valeurs maximales du champ de vitesse), alors quelque chose est en mouvement dans le cadre et à la suite des images sont de plus en plus différents.

La comparaison des histogrammes peut aider à détecter les changements brusques entre les images consécutives. Cette approche a été utilisée dans Courbon et al, 2010:

Similarité des images consécutives. La distance entre deux images consécutives est mesurée. Si elle est trop élevée, cela signifie que la deuxième image est corrompu et donc l'image est éliminé. Le Kullback–Leibler distance, mutuelle ou l'entropie, sur les histogrammes de la deux cadres:

où p et q sont les histogrammes des images est utilisé. Le seuil est fixé à 0,2.

Vous pouvez comparer deux images à l'aide de fonctions de PIL.

import Image
import ImageChops

im1 = Image.open("splash.png")
im2 = Image.open("splash2.png")

diff = ImageChops.difference(im2, im1)

La diff objet est une image dans laquelle chaque pixel est le résultat de la soustraction des valeurs de couleur de ce pixel dans la seconde image de la première image. À l'aide de la diff de l'image vous pouvez faire plusieurs choses. Le plus simple est le diff.getbbox() fonction. Il vous dira le minimum de rectangle qui contient toutes les modifications entre vos deux images.

Vous pouvez probablement mettre en œuvre des approximations des autres choses mentionnées ici à l'aide de fonctions de PIL ainsi.

Une chose banale à essayer:

Rééchantillonner les deux images pour les petites vignettes (par exemple, 64 x 64) et comparer les vignettes pixel-par-pixel avec un certain seuil. Si les images d'origine sont presque les mêmes, le nombre de vignettes seront très similaires, voire identiques. Cette méthode prend soin de bruit qui peut se produire en particulier dans les scènes à faible luminosité. Il peut même être préférable si vous pouvez aller en niveaux de gris.

La plupart des réponses données ne seront pas traiter avec des niveaux d'éclairage.

Je voudrais d'abord normaliser l'image d'un standard de lumière de niveau avant de faire la comparaison.

J'ai eu un problème similaire au travail, j'ai été la réécriture de notre image de transformation des systèmes d'extrémité et je voulais vérifier que la nouvelle version a été la production de la même ou presque la même sortie que l'ancienne version. J'ai donc écrit ceci:

https://github.com/nicolashahn/diffimg

Qui opère sur des images de la même taille, et au niveau des pixels, des mesures de la différence dans les valeurs des canaux: R, G, B, A), prend la moyenne de la différence de ces canaux, puis les moyennes de la différence sur tous les pixels, et renvoie un rapport.

Par exemple, avec un 10x10 image de pixels blancs, et la même image, mais d'un pixel a changé au rouge, la différence à ce pixel est de 1/3 ou 0,33... (RVB 0,0,0 vs 255,0,0) et à tous les autres pixels est de 0. Avec 100 pixels total de 0,33.../100 = a ~0.33% de différence dans l'image.

Je crois que cela fonctionnerait parfaitement pour des OP de projet (je réalise que c'est un très vieux post aujourd'hui, mais l'affichage pour l'avenir StackOverflowers qui veulent aussi de comparer des images en python).

Je m'excuse si c'est trop tard pour répondre, mais depuis que j'ai fait quelque chose de similaire, je pensais que je pouvais contribuer en quelque sorte.

Peut-être avec OpenCV vous pouvez utiliser le modèle de mise en correspondance. En supposant que vous êtes à l'aide d'une webcam comme vous l'avez dit:

1. Simplifier les images (seuillage peut-être?)
2. Appliquer un modèle d'appariement et de vérifier la max_val avec minMaxLoc

Astuce: max_val (ou min_val selon la méthode utilisée) va vous donner des chiffres, un grand nombre. Pour obtenir la différence de pourcentage, utiliser un modèle d'appariement avec la même image, le résultat sera à 100%.

Pseudo code pour illustrer:

previous_screenshot = ...
current_screenshot = ...

# simplify both images somehow

# get the 100% corresponding value
res = matchTemplate(previous_screenshot, previous_screenshot, TM_CCOEFF)
_, hundred_p_val, _, _ = minMaxLoc(res)

# hundred_p_val is now the 100%

res = matchTemplate(previous_screenshot, current_screenshot, TM_CCOEFF)
_, max_val, _, _ = minMaxLoc(res)

difference_percentage = max_val / hundred_p_val

# the tolerance is now up to you

Espère que cela aide.

Que sur le calcul de l' Distance Manhattan des deux images. Qui vous donne le n*n valeurs. Ensuite, vous pourriez faire quelque chose comme une ligne moyenne à réduire à n des valeurs et une fonction de plus que, pour obtenir une valeur unique.

vous pouvez calculer l'histogramme de la fois les images et ensuite calculer la Bhattacharyya Coefficient, c'est un très algorithme rapide et je l'ai utilisé pour détecter le tir des changements dans une cricket de la vidéo (en C à l'aide d'openCV)

J'ai eu le même problème et a écrit un simple module python qui compare deux de même taille des images à l'aide d'oreiller de ImageChops pour créer un noir/blanc diff image et résume l'histogramme des valeurs.

Vous pouvez obtenir ce score directement, ou un pourcentage de la valeur par rapport à un noir vs blanc diff.

Il contient également un simple is_equal fonction, avec la possibilité de fournir un floue-seuil à (et y compris) l'image passe comme égaux.

L'approche n'est pas très élaboré, mais peut-être est de les utiliser pour d'autres là aux prises avec le même problème.

https://pypi.python.org/pypi/imgcompare/

import os
from PIL import Image
from PIL import ImageFile
import imagehash
#just use to the size diferent picture
def compare_image(img_file1, img_file2):
if img_file1 == img_file2:
return True
fp1 = open(img_file1, 'rb')
fp2 = open(img_file2, 'rb')
img1 = Image.open(fp1)
img2 = Image.open(fp2)
ImageFile.LOAD_TRUNCATED_IMAGES = True
b = img1 == img2
fp1.close()
fp2.close()
return b
#through picturu hash to compare
def get_hash_dict(dir):
hash_dict = {}
image_quantity = 0
for _, _, files in os.walk(dir):
for i, fileName in enumerate(files):
with open(dir + fileName, 'rb') as fp:
hash_dict[dir + fileName] = imagehash.average_hash(Image.open(fp))
image_quantity += 1
return hash_dict, image_quantity
def compare_image_with_hash(image_file_name_1, image_file_name_2, max_dif=0):
"""
max_dif: The maximum hash difference is allowed, the smaller and more accurate, the minimum is 0.
recommend to use
"""
ImageFile.LOAD_TRUNCATED_IMAGES = True
hash_1 = None
hash_2 = None
with open(image_file_name_1, 'rb') as fp:
hash_1 = imagehash.average_hash(Image.open(fp))
with open(image_file_name_2, 'rb') as fp:
hash_2 = imagehash.average_hash(Image.open(fp))
dif = hash_1 - hash_2
if dif < 0:
dif = -dif
if dif <= max_dif:
return True
else:
return False
def compare_image_dir_with_hash(dir_1, dir_2, max_dif=0):
"""
max_dif: The maximum hash difference is allowed, the smaller and more accurate, the minimum is 0.
"""
ImageFile.LOAD_TRUNCATED_IMAGES = True
hash_dict_1, image_quantity_1 = get_hash_dict(dir_1)
hash_dict_2, image_quantity_2 = get_hash_dict(dir_2)
if image_quantity_1 > image_quantity_2:
tmp = image_quantity_1
image_quantity_1 = image_quantity_2
image_quantity_2 = tmp
tmp = hash_dict_1
hash_dict_1 = hash_dict_2
hash_dict_2 = tmp
result_dict = {}
for k in hash_dict_1.keys():
result_dict[k] = None
for dif_i in range(0, max_dif + 1):
have_none = False
for k_1 in result_dict.keys():
if result_dict.get(k_1) is None:
have_none = True
if not have_none:
return result_dict
for k_1, v_1 in hash_dict_1.items():
for k_2, v_2 in hash_dict_2.items():
sub = (v_1 - v_2)
if sub < 0:
sub = -sub
if sub == dif_i and result_dict.get(k_1) is None:
result_dict[k_1] = k_2
break
return result_dict
def main():
print(compare_image('image1\\815.jpg', 'image2\\5.jpg'))
print(compare_image_with_hash('image1\\815.jpg', 'image2\\5.jpg', 6))
r = compare_image_dir_with_hash('image1\\', image2\\', 10)
for k in r.keys():
print(k, r.get(k))
if __name__ == '__main__':
main()

• de sortie:

  Faux
  
  Vrai
  
  image2\5.jpg image1\815.jpg
  
  image2\6.jpg image1\819.jpg
  
  image2\7.jpg image1\900.jpg
  
  image2\8.jpg image1\998.jpg
  
  image2\9.jpg image1\1012.jpg

• les images de l'exemple:

  • 815.jpg
    
    
    

  • 5.jpg
    
    
    

Il y a beaucoup de métriques pour évaluer si deux images ressemblent/combien ils ressemblent.

Je n'entrerai pas dans le code ici, parce que je pense que cela devrait être un problème scientifique, d'autres que d'un problème technique.

Généralement, la question est liée à la perception sur les images, de sorte que chaque algorithme s'appuie sur le système visuel humain traits.

Approches classiques sont:

Différences visibles prédicteur: un algorithme pour l'évaluation de la fidélité de l'image (https://www.spiedigitallibrary.org/conference-proceedings-of-spie/1666/0000/Visible-differences-predictor--an-algorithm-for-the-assessment-of/10.1117/12.135952.short?SSO=1)

Image Évaluation de la Qualité: De l'Erreur de la Visibilité à la Similarité Structurelle (http://www.cns.nyu.edu/pub/lcv/wang03-reprint.pdf)

FSIM: UNE Caractéristique Indice de Similarité pour la Qualité de l'Image de l'Évaluation (https://www4.comp.polyu.edu.hk/~cslzhang/IQA/TIP_IQA_FSIM.pdf)

Parmi eux, SSIM (Image Évaluation de la Qualité: De l'Erreur de la Visibilité à la Similarité Structurelle ) est le plus facile à calculer et de ses frais généraux est aussi petit, comme rapporté dans un autre document "Image de la Qualité de l'Évaluation Basée sur le Gradient de Similitude" (https://www.semanticscholar.org/paper/Image-Quality-Assessment-Based-on-Gradient-Liu-Lin/2b819bef80c02d5d4cb56f27b202535e119df988).

Il y a beaucoup plus d'autres approches. Jetez un oeil à Google Scholar et la recherche de quelque chose comme "différence visuelle", "la qualité de l'image de" l'évaluation, etc, si vous êtes intéressé/se soucient vraiment de l'art.