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

https://stackoverflow.com/questions/189943

06-07-2019
|

Question

Voici ce que je voudrais faire:

Je prends des photos avec une webcam à intervalles réguliers. Un peu comme un laps de temps. Cependant, si rien n’a vraiment changé, c’est-à-dire que l’image a plutôt la même apparence, 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.

La solution

Idée générale

Option 1: chargez les deux images sous forme de 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.

Questions

Vous devez d'abord répondre aux questions suivantes:

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 vous 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 luminosité / le contraste sont-ils les mêmes?)

Sinon, vous voudrez peut-être normaliser les 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 sur les couleurs 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 devez faire plus attention lorsque vous écrivez un tel code.
Y a-t-il des bords distincts dans l'image? Sont-ils susceptibles de bouger?

Si oui, vous pouvez appliquer tout 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.

Pensez à utiliser la norme de Manhattan (la somme des valeurs absolues) ou la norme zéro (le nombre d’éléments différents de zéro) 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 qui diffèrent.

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. Par souci 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 élément par élément:

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

Exécuter la main fonction:

if __name__ == "__main__":
    main()

Maintenant, vous pouvez mettre tout cela dans un script et le lancer sur deux images. Si nous comparons 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. le script de comparaison.py dans son intégralité.

Mise à jour: techniques pertinentes

Comme la question concerne une séquence vidéo, où les images sont susceptibles d'être presque les mêmes, et que vous recherchez quelque chose d'inhabituel, j'aimeraismentionner 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 un mouvement)
comparer des histogrammes ou d'autres statistiques au lieu d'images

Je vous recommande fortement de jeter un coup d'œil à & # 8220; Apprendre OpenCV & # 8221; livre, 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 & # 8805; 2.3 et son cv2 module Python.

La version la plus simple de la soustraction d’arrière-plan:

apprendre la valeur moyenne & # 956; et écart type & # 963; pour chaque pixel de l'arrière-plan
compare les valeurs de pixel actuelles à la plage de (& # 956; -2 & # 963;, & # 956; +2 & # 963;) ou (& # 956; - & # 963;, & # 956; + & # 963;)

Les versions plus avancées permettent de prendre en compte les séries temporelles pour chaque pixel et de gérer les scènes non statiques (comme le déplacement d'arbres ou d'herbe).

L’idée du flux optique est de prendre deux trames ou plus et d’attribuer le vecteur vitesse à chaque pixel (flux optique dense) ou à certains d’entre eux (flux optique épars). Pour estimer le flux optique clairsemé, vous pouvez utiliser la méthode Lucas-Kanade (il est également implémenté dans OpenCV). Évidemment, s’il ya 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 des histogrammes peut aider à détecter les changements soudains 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 haute, cela signifie que la deuxième image est corrompue et l’image est donc éliminée. Kullback & # 8211; Distance de Leibler , ou entropie mutuelle, sur les histogrammes des deux cadres:

$d (p, q) = \ sum_i p (i) \ log (p (i) / q ( i))$

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

Autres conseils

Une solution simple:

Encodez l'image au format jpeg et recherchez une modification substantielle de la 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 la 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 propose une formule pour la corrélation croisée normalisée . Des méthodes plus sophistiquées existent aussi, mais elles nécessitent un peu plus de travail.

À l'aide d'une syntaxe semblable à Numpy,

dist_euclidean = sqrt(sum((i1 - i2)^2)) / i1.size

dist_manhattan = sum(abs(i1 - i2)) / i1.size

dist_ncc = sum( (i1 - mean(i1)) * (i2 - mean(i2)) ) / (
  (i1.size - 1) * stdev(i1) * stdev(i2) )

en supposant 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 m'intéresse plus particulièrement à la question de savoir comment calculer si elles sont & "assez différentes &"; Je suppose que vous pouvez comprendre comment soustraire les pixels un par un.

Tout d'abord, je prendrais un tas d'images avec rien et je découvrirais le nombre maximal de pixels modifiés en raison des variations de capture, du bruit dans le système d'imagerie et des artefacts de compression JPEG. et des changements instantanés 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 " réel " test, 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 voudrait dire (approximativement) que ce 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 pixels contiennent des erreurs.

Ceci est principalement conçu comme un bon " triage & "; technique permettant d’identifier rapidement des images suffisamment proches pour ne pas nécessiter un examen plus approfondi. Les images qui & "; Échouent &"; peut alors davantage s’appliquer à 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.

J'exécute un projet open source, OpenImageIO , qui contient un utilitaire appelé " idiff quot; cela compare les différences avec des seuils comme celui-ci (même 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 d'images, avec & "Images de référence &"; cela peut avoir de petites différences d'une plate-forme à l'autre ou lorsque nous avons modifié légèrement les algorithmes, nous voulions donc une correspondance & dans la tolérance & "; opération.

La plupart des réponses fournies 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 application sur le Web 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

qui opère sur des images de même taille et au niveau pixel, mesure la différence de valeurs sur chaque canal: R, V, B (, A), prend la différence moyenne de ces canaux, puis les moyennes la différence 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 ... (RVB 0,0,0 vs 255, 0,0) et tous les autres pixels valent 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 très vieux message maintenant, mais destiné aux futurs StackOverflowers qui souhaitent également comparer des images en python).

Avez-vous déjà vu la question Algorithme permettant de rechercher des images similaires ? Consultez-le pour voir des suggestions.

Je suggérerais une transformation en ondelettes de vos cadres (j'ai écrit une extension C pour celle-ci en utilisant la transformation de Haar); ensuite, en comparant les indices des facteurs d’ondelettes les plus grands (proportionnellement) entre les deux images, vous devriez obtenir une approximation numérique de la similarité.

Je m'excuse s'il est trop tard pour répondre, mais depuis que 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:

Simplifiez les images (un 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.

La distance de déplacement de la Terre pourrait être exactement ce dont vous avez besoin. Il pourrait être abit lourd à mettre en œuvre en temps réel cependant.

Qu'en est-il du calcul de la Manhattan Distance 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 supérieure pour obtenir une seule valeur.

J'ai eu beaucoup de chance avec les images jpg prises avec le même appareil photo sur un trépied par (1) simplifiant grandement (comme passer de 3000 pixels de large à 100 pixels de large ou même moins) (2) aplatir chaque tableau jpg en un seul vecteur (3) images séquentielles à corrélation par paires avec un algorithme de corrélation simple pour obtenir le coefficient de corrélation (4) coefficient de corrélation quadratique pour obtenir le r-carré (c.-à-d. Fraction de la variabilité dans une image expliquée par la variation dans la suivante) (5) généralement dans mon application si r-square & Lt; 0.9, je dis que les deux images sont différentes et qu’il se passe quelque chose entre les deux.

C’est robuste et rapide dans mon implémentation (Mathematica 7)

Cela vaut la peine de jouer avec la partie de l'image qui vous intéresse et de la focaliser dessus en rognant toutes les images sur cette petite zone, faute de 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?

vous pouvez calculer l'histogramme des deux images, puis le coefficient de Bhattacharyya , C’est un algorithme très rapide et je l’ai utilisé pour détecter les changements de prises de vue dans une vidéo de cricket (en C avec openCV)

Découvrez comment les ondelettes 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) basée sur le 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.

J'ai eu le même problème et j'ai écrit un module python simple 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 directement ce score ou un pourcentage comparé à un diff noir / blanc complet.

Il contient également une fonction is_equal simple, 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 est peut-être utile pour les autres personnes aux prises avec le même problème.

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

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, telle que décrite ici , également fournit une solution similaire.

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()

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 d'exemple:
- 815.jpg
- 5.jpg

Je pense que vous pourriez simplement calculer la distance euclidienne (c'est-à-dire la somme des carrés des différences, pixel par pixel) entre la luminance des deux images et les considérer égales si cela tombe sous un 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 / combien 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.

De manière générale, 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:

Indicateur de différences visibles: algorithme d'é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 )

Évaluation de la qualité d'image: de la visibilité sur les erreurs à la similarité structurelle ( http: //www.cns.nyu.edu/pub/lcv/wang03-reprint.pdf )

FSIM: indice de similarité des fonctions 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 indiqué dans un autre document & "Évaluation de la qualité d'image basée sur la similarité de dégradé"! > quot; ( .org / paper / Image-Évaluation-basée-sur-le-gradient-liu-Lin / 2b819bef80c02d5d4cb56f27b202535e119df988 ).

Il existe de nombreuses autres approches. Jetez un coup d'œil à Google Scholar et cherchez quelque chose comme & "Différence visuelle &", & "Evaluation de la qualité d'image &"; Etc., etc., si vous êtes vraiment intéressé par cet art. .

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow