Comment puis-je quantifier la différence entre deux images?
Voici ce que j'aimerais faire:
Je prends des photos avec une webcam à intervalles réguliers. Un peu comme un laps de temps. Toutefois, si rien n’a vraiment changé, c’est-à-dire que l’image est identique , je ne souhaite pas stocker le dernier instantané.
J'imagine qu'il existe un moyen de quantifier la différence et qu'il me faudrait déterminer de manière empirique un seuil.
Je recherche la simplicité plutôt que la perfection. J'utilise python.
Idée générale
Option 1: chargez les deux images en tant que tableaux (scipy.misc.imread) et calculez une différence élément par pixel (pixel par pixel). Calculez la norme de la différence.
Option 2: chargez les deux images. Calculez un vecteur de caractéristiques pour chacune d’elles (comme un histogramme). Calculez la distance entre les vecteurs de caractéristiques plutôt que les images.
Cependant, certaines décisions doivent être prises en premier.
Des questions
Vous devriez d'abord répondre à ces questions:
Les images ont-elles la même forme et la même dimension?
Sinon, vous devrez peut-être les redimensionner ou les rogner. La bibliothèque PIL aidera à le faire en Python.
S'ils sont pris avec les mêmes paramètres et le même appareil, ils sont probablement les mêmes.
Les images sont-elles bien alignées?
Si ce n'est pas le cas, vous voudrez peut-être d'abord utiliser la corrélation croisée pour trouver le meilleur alignement. SciPy a des fonctions pour le faire.
Si l'appareil photo et la scène sont immobiles, les images seront probablement bien alignées.
L'exposition des images est-elle toujours la même? (La légèreté/le contraste sont-ils les mêmes?)
Sinon, vous voudrez peut-être normaliser images.
Mais attention, dans certaines situations, cela peut faire plus de mal que de bien. Par exemple, un seul pixel brillant sur un fond sombre rendra l'image normalisée très différente.
Les informations de couleur sont-elles importantes?
Si vous souhaitez remarquer des changements de couleur, vous aurez un vecteur de valeurs de couleur par point, plutôt qu'une valeur scalaire comme dans une image en niveaux de gris. Vous avez besoin de plus d'attention lorsque vous écrivez un tel code.
Y a-t-il des bords distincts dans l'image? Sont-ils susceptibles de bouger?
Si c'est le cas, vous pouvez appliquer d'abord l'algorithme de détection des contours (par exemple, calculer le gradient avec la transformation de Sobel ou de Prewitt, appliquer un seuil), puis comparer les contours de la première image aux contours de la seconde.
Y a-t-il du bruit dans l'image?
Tous les capteurs polluent l'image avec une certaine quantité de bruit. Les capteurs à faible coût ont plus de bruit. Vous souhaiterez peut-être appliquer une réduction de bruit avant de comparer des images. Le flou est l'approche la plus simple (mais pas la meilleure).
Quel genre de changements voulez-vous remarquer?
Cela peut affecter le choix de la norme à utiliser pour la différence entre les images.
Envisagez d'utiliser la norme de Manhattan (la somme des valeurs absolues) ou la norme zéro (le nombre d'éléments non nuls) pour mesurer l'ampleur du changement de l'image. Le premier vous dira combien l'image est éteinte, le second n'indiquera que le nombre de pixels.
Exemple
Je suppose que vos images sont bien alignées, de la même taille et de la même forme, éventuellement avec une exposition différente. Pour des raisons de simplicité, je les convertis en niveaux de gris, même s’il s’agit d’images couleur (RVB).
Vous aurez besoin de ces importations:
import sys
from scipy.misc import imread
from scipy.linalg import norm
from scipy import sum, average
Fonction principale, lire deux images, convertir en niveaux de gris, comparer et 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 des tableaux 2D SciPy 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 couleur, imread renvoie un tableau 3D, canaux RVB moyens (dernier axe du tableau) pour obtenir une intensité. Nul 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 triviale, vous pouvez choisir de normaliser à [0,1] au lieu de [0,255]. arr est un tableau SciPy ici, donc toutes les opérations sont au niveau des éléments:
def normalize(arr):
rng = arr.max()-arr.min()
amin = arr.min()
return (arr-amin)*255/rng
Exécutez la fonction main:
if __== "__main__":
main()
Maintenant, vous pouvez mettre tout cela dans un script et exécuter deux images. Si on compare l'image à elle-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 brouillons l'image et la comparons à l'original, il y a une 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. Ensemble compare.py script.
Mise à jour: techniques pertinentes
Comme la question concerne une séquence vidéo, où les images sont probablement les mêmes, et que vous recherchez quelque chose d'inhabituel, j'aimerais mentionner quelques approches alternatives qui pourraient être pertinentes:
- soustraction et segmentation d'arrière-plan (pour détecter les objets de premier plan)
- flux optique clairsemé (pour détecter le mouvement)
- comparer des histogrammes ou d'autres statistiques au lieu d'images
Je vous recommande vivement de consulter le livre "Learning OpenCV", aux chapitres 9 (Parties d’image et segmentation) et 10 (Suivi et mouvement). Le premier apprend à utiliser la méthode de soustraction de fond, le second donne des informations sur les méthodes de flux optique. 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 Python.
La version la plus simple de la soustraction de fond:
- apprendre la valeur moyenne μ et l'écart type σ pour chaque pixel de l'arrière-plan
- comparer les valeurs de pixel actuelles à la plage de (μ-2σ, μ + 2σ) ou (μ-σ, μ + σ)
Des versions plus avancées permettent de prendre en compte les séries temporelles pour chaque pixel et de gérer des scènes non statiques (comme le déplacement d'arbres ou d'herbe).
L'idée du flux optique est de prendre deux ou plusieurs trames et d'attribuer le vecteur vitesse à chaque pixel (flux optique dense) ou à certains d'entre eux (flux optique clairsemé). Pour estimer le flux optique clairsemé, vous pouvez utiliser la méthode méthode Lucas-Kanade (elle est également implémentée dans OpenCV). Évidemment, s'il y a beaucoup de flux (moyenne élevée sur les valeurs maximales du champ de vélocité), quelque chose bouge dans le cadre et les images suivantes sont plus différentes.
La comparaison d'histogrammes peut aider à détecter des changements soudains entre des images consécutives. Cette approche a été utilisée dans Courbon et al, 201 :
Similarité des images consécutives. La distance entre deux images consécutives est mesurée. Si elle est trop haute, cela signifie que la deuxième image est corrompue et l’image est donc éliminée. Le distance de Kullback – Leibler , ou entropie mutuelle, sur les histogrammes des deux cadres:
où p et q sont les histogrammes des images. Le seuil est fixé à 0,2.
ne solution simple:
Encodez l'image au format jpeg et recherchez un changement substantiel dans taille du fichier.
J'ai implémenté quelque chose de similaire avec les vignettes vidéo, et j'ai eu beaucoup de succès et d'évolutivité.
Vous pouvez comparer deux images à l’aide des fonctions de PIL .
import Image
import ImageChops
im1 = Image.open("splash.png")
im2 = Image.open("splash2.png")
diff = ImageChops.difference(im2, im1)
L'objet diff est une image dans laquelle chaque pixel est le résultat de la soustraction des valeurs de couleur de ce pixel dans la deuxième image de la première image. En utilisant l’image diff, vous pouvez faire plusieurs choses. Le plus simple est la fonction diff.getbbox(). Il vous indiquera le rectangle minimal contenant toutes les modifications entre vos deux images.
Vous pouvez probablement implémenter des approximations des autres éléments mentionnés ici en utilisant également les fonctions de PIL.
Deux méthodes populaires et relativement simples sont: (a) la distance euclidienne déjà suggérée, ou (b) une corrélation croisée normalisée. La corrélation croisée normalisée a tendance à être sensiblement plus robuste aux changements d'éclairage que la simple corrélation croisée. Wikipedia donne une formule pour le corrélation croisée normalisée . Des méthodes plus sophistiquées existent aussi, mais elles nécessitent un peu plus de travail.
En utilisant une syntaxe semblable à Numpy,
dist_euclidean = sqrt (sum ((i1 - i2) ^ 2))/i1.size dist_manhattan = sum (abs (i1 - i2))/i1.size dist_ncc = somme ((i1 - moyenne (i1)) * (i2 - moyenne (i2)))/( (i1.size - 1) * stdev (i1) * stdev (i2))
en admettant que i1 et i2 sont des tableaux d'images 2D en niveaux de gris.
Une chose triviale à essayer:
Rééchantillonnez les deux images en petites vignettes (par exemple 64 x 64) et comparez les vignettes pixel par pixel à un certain seuil. Si les images d'origine sont presque identiques, les vignettes rééchantillonnées seront très similaires, voire identiques. Cette méthode prend en charge le bruit qui peut survenir en particulier dans les scènes peu éclairées. Cela peut même être mieux si vous passez en niveaux de gris.
Je traite spécifiquement de la question de savoir comment calculer si elles sont "suffisamment différentes". Je suppose que vous pouvez trouver comment soustraire les pixels un par un.
Tout d'abord, je prendrais un tas d'images avec rien en train de changer, et de connaître la quantité maximale de pixels pouvant être modifiés simplement à cause des variations de la capture, du bruit dans le système d’imagerie, des artefacts de compression JPEG et des modifications instantanées de l’éclairage. Vous constaterez peut-être que des différences de 1 ou 2 bits sont à prévoir, même lorsque rien ne bouge.
Ensuite, pour le test "réel", vous voulez un critère comme celui-ci:
- idem si pas plus de P pixels ne diffèrent de E.
Donc, peut-être que si E = 0,02, P = 1000, cela signifierait (approximativement) qu'il serait "différent" si un seul pixel change de plus de ~ 5 unités (en supposant des images 8 bits), ou si plus de 1000 les pixels avaient des erreurs du tout.
Ceci est principalement conçu comme une bonne technique de "triage" pour identifier rapidement les images suffisamment proches pour ne pas nécessiter un examen plus approfondi. Les images qui "échouent" peuvent alors davantage correspondre à une technique plus élaborée/coûteuse qui ne produirait pas de faux positifs si la caméra tremblait un peu, par exemple, ou qui était plus robuste aux changements d’éclairage.
Je lance un projet open source, OpenImageIO , qui contient un utilitaire appelé "idiff" qui compare les différences avec des seuils comme celui-ci (encore plus élaboré, en fait). Même si vous ne voulez pas utiliser ce logiciel, vous voudrez peut-être regarder la source pour voir comment nous l'avons fait. Il est assez utilisé dans le commerce et cette technique de seuillage a été développée pour pouvoir disposer d’une suite de tests pour les logiciels de rendu et de traitement des images, avec des "images de référence" pouvant présenter de légères différences d’une plate-forme à l’autre ou lors de modifications mineures. tha algorithmes, nous avons donc voulu une opération "match dans la tolérance".
La plupart des réponses données ne traitent pas des niveaux d'éclairage.
Je voudrais d’abord normaliser l’image à un niveau de lumière standard avant de faire la comparaison.
Un autre moyen simple et agréable de mesurer la similarité entre deux images:
import sys
from skimage.measure import compare_ssim
from skimage.transform import resize
from scipy.ndimage import imread
# get two images - resize both to 1024 x 1024
img_a = resize(imread(sys.argv[1]), (2**10, 2**10))
img_b = resize(imread(sys.argv[2]), (2**10, 2**10))
# score: {-1:1} measure of the structural similarity between the images
score, diff = compare_ssim(img_a, img_b, full=True)
print(score)
Si d'autres personnes sont intéressées par un moyen plus puissant de comparer la similarité d'images, je mets ensemble un tutoriel et Web app pour mesurer et visualiser des images similaires à l'aide de Tensorflow.
J'avais un problème similaire au travail: je réécrivais notre point de terminaison de transformation d'image et je voulais vérifier que la nouvelle version produisait le même résultat ou presque le même résultat que l'ancienne version. Alors j'ai écrit ceci:
https://github.com/nicolashahn/diffimg
Ce qui fonctionne sur des images de même taille et mesure, à un niveau par pixel, la différence de valeurs sur chaque canal: R, V, B (, A), prend la différence moyenne de ces canaux, puis effectue la moyenne sur tous les pixels et renvoie un rapport.
Par exemple, avec une image 10x10 de pixels blancs et la même image mais un pixel est passé au rouge, la différence à ce pixel est de 1/3 ou 0,33 ... (RGB 0,0,0 vs 255,0,0 ) et sur tous les autres pixels est égal à 0. Avec un total de 100 pixels, 0.33 .../100 = une différence d’image de 0,33%.
Je pense que cela fonctionnerait parfaitement pour le projet d’OP (je réalise que c’est un article très ancien, mais destiné aux futurs StackOverflowers qui souhaitent également comparer les images en python).
Avez-vous vu la question algorithme pour trouver des images similaires question? Vérifiez-le pour voir des suggestions.
Je suggérerais une transformation en ondelettes de vos cadres (j'ai écrit une extension C pour celle utilisant la transformation de Haar); ensuite, en comparant les indices des facteurs d'ondelettes les plus importants (proportionnellement) entre les deux images, vous devriez obtenir une approximation de similarité numérique.
Je m'excuse s'il est trop tard pour répondre, mais comme je fais quelque chose de similaire, je pensais pouvoir contribuer.
Peut-être qu'avec OpenCV, vous pourriez utiliser une correspondance de modèle. En supposant que vous utilisez une webcam comme vous l'avez dit:
- Simplifier les images (seuillage peut-être?)
- Appliquer le modèle correspondant et vérifier le max_val avec minMaxLoc
Astuce: max_val (ou min_val en fonction de la méthode utilisée) vous donnera des nombres, des nombres grands. Pour obtenir la différence en pourcentage, utilisez un modèle correspondant à la même image - le résultat sera votre 100%.
Pseudo-code à 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
J'espère que ça aide.
Distance terrestre pourrait être exactement ce dont vous avez besoin. Il pourrait être un peu lourd à mettre en œuvre en temps réel.
Qu'en est-il du calcul de la distance de Manhattan des deux images. Cela vous donne n * n valeurs. Vous pouvez ensuite faire quelque chose comme une moyenne de ligne pour réduire à n valeurs et une fonction sur celle-ci pour obtenir une seule valeur.
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 __== '__main__':
main()
sortie:
False
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.jpgles images d'exemple:
815.jpg
![815.jpg]()
5.jpg
![5.jpg]()
Découvrez comment les ondelettes de Haar sont implémentées par isk-daemon . Vous pouvez utiliser son code C++ imgdb pour calculer la différence entre les images à la volée:
isk-daemon est un serveur de base de données open source capable d'ajouter une recherche d'images visuelle à un contenu à tout site Web ou logiciel lié aux images.
Cette technologie permet aux utilisateurs de tout site Web ou logiciel lié aux images de dessiner sur un widget quelle image ils veulent trouver et de demander au site Web de leur répondre les images les plus similaires ou simplement de demander des photos plus similaires sur chaque page de détail.
Une approche un peu plus fondée sur les principes consiste à utiliser un descripteur global pour comparer des images, telles que Gist ou CENTRIST. Une fonction de hachage, comme décrit ici , fournit également une solution similaire.
J'ai eu le même problème et j'ai écrit un simple module python) qui compare deux images de même taille en utilisant ImageChops de pillow pour créer une image de diff noir/blanc et résume les valeurs de l'histogramme.
Vous pouvez obtenir soit directement ce score, soit un pourcentage comparé à un diff noir/blanc.
Il contient également une simple fonction is_equal, avec la possibilité de fournir un seuil flou sous (et y compris) que l'image passe de la même manière.
L’approche n’est pas très élaborée, mais elle pourrait peut-être être utile aux autres personnes aux prises avec le même problème.
vous pouvez calculer l'histogramme des deux images, puis calculer le coefficient de Bhattacharyya , il s'agit d'un algorithme très rapide et je l'ai utilisé pour détecter les changements de prise de vue dans une vidéo de cricket (en C avec openCV)
J'ai eu beaucoup de chance avec les images jpg prises avec le même appareil photo sur un trépied en (1) simplifiant grandement (comme aller de 3000 pixels de large à 100 pixels de large ou même moins) (2) en aplatissant chaque tableau jpg en un seul vecteur (3) images séquentielles à corrélation par paires avec un algorithme de corrélation simple pour obtenir un coefficient de corrélation (4) coefficient de corrélation au carré pour obtenir un carré (valeur de fraction de la variabilité dans une image expliquée par la variation dans la suivante) (5) généralement dans mon application si r carré <0.9, je dis que les deux images sont différentes et que quelque chose s'est passé entre les deux.
Ceci est robuste et rapide dans ma mise en œuvre (Mathematica 7)
Cela vaut la peine de jouer avec la partie de l'image qui vous intéresse et de vous concentrer sur celle-ci en réduisant toutes les images sur cette petite zone, sans quoi un changement lointain, mais important, nous manquera.
Je ne sais pas comment utiliser Python, mais je suis sûr que les corrélations aussi, non?
Je pense que vous pouvez simplement calculer la distance euclidienne (c'est-à-dire sqrt (somme des carrés de différences, pixel par pixel)) entre la luminance des deux images et les considérer égales si cela tombe sous un certain seuil empirique. Et vous feriez mieux de le faire en enveloppant une fonction C.
Il existe de nombreux paramètres permettant d’évaluer si deux images ressemblent/à quoi elles ressemblent.
Je n'entrerai dans aucun code ici, car je pense que ce devrait être un problème scientifique, autre qu'un problème technique.
Généralement, la question étant liée à la perception de l'homme sur les images, chaque algorithme prend en charge les traits du système visuel humain.
Les approches classiques sont:
Prédicteur de différences visibles: un algorithme d'évaluation de la fidélité de l'image ( https://www.spiedigitallibrary.org/fr/conference-proceedings-of-spie/1666/0000/Visible-differences-predictor--an-algorithme-) pour-the-assessment-of/10.1117/12.135952.short? SSO = 1 )
Évaluation de la qualité d'image: de la visibilité d'erreur à la similarité structurelle ( http://www.cns.nyu.edu/pub/lcv/wang03-reprint.pdf )
FSIM: Indice de similarité des fonctionnalités pour l'évaluation de la qualité d'image ( https://www4.comp.polyu.edu.hk/~cslzhang/IQA/TIP_IQA_FSIM.pdf )
Parmi eux, SSIM (Évaluation de la qualité d'image: de la visibilité d'erreur à la similarité structurelle) est le plus facile à calculer et ses frais généraux sont également faibles, comme l'indique un autre document intitulé "Évaluation de la qualité d'image basée sur la similarité de dégradé" ( https://www.semanticscholar.org/paper/Image-Quality-Assessment-Based-on-Gradient-Liu-Lin/2b819bef80c02d5d4cb56f27b202535e119df988 ).
Il y a beaucoup plus d'autres approches. Jetez un coup d'oeil à Google Scholar et cherchez quelque chose comme "différence visuelle", "évaluation de la qualité d'image", etc., si vous êtes intéressé/tenez vraiment à l'art.
Il existe une solution simple et rapide utilisant numpy en calculant l'erreur quadratique moyenne:
before = np.array(get_picture())
while True:
now = np.array(get_picture())
MSE = np.mean((now - before)**2)
if MSE > threshold:
break
before = now