Come posso quantificare la differenza tra due immagini?

StackOverflow https://stackoverflow.com/questions/189943

Domanda

Ecco cosa vorrei fare:

Scatto foto con la webcam a intervalli regolari.Una specie di time lapse.Tuttavia, se in realtà non è cambiato nulla, almeno il quadro generale è cambiato sembra lo stesso, non voglio memorizzare l'ultima istantanea.

Immagino che ci sia un modo per quantificare la differenza e dovrei determinare empiricamente una soglia.

Cerco la semplicità piuttosto che la perfezione.Sto usando Python.

È stato utile?

Soluzione

Idea generale

Opzione 1: carica entrambe le immagini come matrici (scipy.misc.imread) e calcola una differenza di elemento (pixel per pixel). Calcola la norma della differenza.

Opzione 2: carica entrambe le immagini. Calcola un vettore caratteristica per ciascuno di essi (come un istogramma). Calcola la distanza tra i vettori delle caratteristiche anziché le immagini.

Tuttavia, ci sono alcune decisioni da prendere per prime.

Domande

Dovresti prima rispondere a queste domande:

  • Le immagini hanno la stessa forma e dimensione?

    In caso contrario, potrebbe essere necessario ridimensionarli o ritagliarli. La libreria PIL aiuterà a farlo in Python.

    Se sono presi con le stesse impostazioni e lo stesso dispositivo, sono probabilmente gli stessi.

  • Le immagini sono ben allineate?

    In caso contrario, potresti voler eseguire prima la correlazione incrociata per trovare prima il miglior allineamento. SciPy ha funzioni per farlo.

    Se la fotocamera e la scena sono ferme, è probabile che le immagini siano ben allineate.

  • L'esposizione delle immagini è sempre la stessa? (La luminosità / il contrasto sono uguali?)

    Altrimenti, potresti voler per normalizzare immagini.

    Ma fai attenzione, in alcune situazioni questo può fare più male che bene. Ad esempio, un singolo pixel luminoso su uno sfondo scuro renderà l'immagine normalizzata molto diversa.

  • Le informazioni sul colore sono importanti?

    Se vuoi notare cambiamenti di colore, avrai un vettore di valori di colore per punto, piuttosto che un valore scalare come nell'immagine in scala di grigi. Hai bisogno di più attenzione quando scrivi questo codice.

  • Ci sono bordi distinti nell'immagine? È probabile che si muovano?

    In caso affermativo, è possibile applicare prima l'algoritmo di rilevamento dei bordi (ad es. calcolare il gradiente con trasformazione Sobel o Prewitt, applicare una soglia), quindi confrontare i bordi della prima immagine con i bordi della seconda.

  • C'è rumore nell'immagine?

    Tutti i sensori inquinano l'immagine con una certa quantità di rumore. I sensori a basso costo hanno più rumore. Potresti voler applicare una riduzione del rumore prima di confrontare le immagini. Blur è l'approccio più semplice (ma non il migliore) qui.

  • Che tipo di modifiche vuoi notare?

    Ciò può influire sulla scelta della norma da utilizzare per la differenza tra le immagini.

    Prendi in considerazione l'utilizzo della norma Manhattan (la somma dei valori assoluti) o della norma zero (il numero di elementi non uguale a zero) per misurare quanto l'immagine è cambiata. Il primo ti dirà quanto l'immagine è spenta, il secondo dirà solo quanti pixel differiscono.

Esempio

Suppongo che le tue immagini siano ben allineate, delle stesse dimensioni e forma, possibilmente con diversa esposizione. Per semplicità, li converto in scala di grigi anche se sono immagini a colori (RGB).

Sono necessarie queste importazioni: 

import sys

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

Funzione principale, leggi due immagini, converti in scala di grigi, confronta e stampa i risultati: 

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

Come confrontare. img1 e img2 sono array 2D SciPy qui: 

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)

Se il file è un'immagine a colori, imread restituisce un array 3D, canali RGB medi (l'ultimo asse dell'array) per ottenere intensità. Non è necessario farlo per le immagini in scala di grigi (ad es. .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 normalizzazione è banale, puoi scegliere di normalizzare a [0,1] invece di [0,255]. arr è un array SciPy qui, quindi tutte le operazioni sono elementari: 

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

Esegui la funzione main: 

if __name__ == "__main__":
    main()

Ora puoi mettere tutto in uno script ed eseguire due immagini. Se confrontiamo l'immagine con se stessa, non c'è differenza: 

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

Se sfociamo l'immagine e confrontiamo l'originale, c'è qualche differenza: 

$ 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. Intero script compare.py .

Aggiornamento: tecniche pertinenti

Poiché la domanda riguarda una sequenza video, in cui i frame sono probabilmente gli stessi e cerchi qualcosa di insolito, mi piacerebbemenzionare alcuni approcci alternativi che possono essere pertinenti:

  • sottrazione e segmentazione dello sfondo (per rilevare oggetti in primo piano)
  • flusso ottico sparso (per rilevare il movimento)
  • confrontando gli istogrammi o alcune altre statistiche invece delle immagini

Consiglio vivamente di dare un'occhiata a & # 8220; Imparare OpenCV & # 8221; libro, Capitoli 9 (Parti dell'immagine e segmentazione) e 10 (Tracciamento e movimento). Il primo insegna a utilizzare il metodo di sottrazione di sfondo, il secondo fornisce alcune informazioni sui metodi di flusso ottico. Tutti i metodi sono implementati nella libreria OpenCV. Se usi Python, ti suggerisco di usare OpenCV & # 8805; 2.3 e il suo cv2 modulo Python.

La versione più semplice della sottrazione in background:

  • impara il valore medio & # 956; e deviazione standard & # 963; per ogni pixel dello sfondo
  • confronta i valori correnti dei pixel con l'intervallo di (& # 956; -2 & # 963;, & # 956; +2 & # 963;) o (& # 956; - # 963 &; &; &, # 956 + # 963;)

Le versioni più avanzate tengono conto delle serie temporali per ogni pixel e gestiscono scene non statiche (come spostare alberi o erba).

L'idea del flusso ottico è di prendere due o più fotogrammi e assegnare il vettore di velocità a ogni pixel (flusso ottico denso) o ad alcuni di essi (flusso ottico rado). Per stimare il flusso ottico sparso, puoi usare Metodo Lucas-Kanade (it è implementato anche in OpenCV). Ovviamente, se c'è molto flusso (alta media su valori massimi del campo di velocità), allora qualcosa si sta muovendo nel frame e le immagini successive sono più diverse.

Il confronto degli istogrammi può aiutare a rilevare improvvisi cambiamenti tra fotogrammi consecutivi. Questo approccio è stato utilizzato in Courbon et al, 2010 :

  

Somiglianza di frame consecutivi. Viene misurata la distanza tra due frame consecutivi. Se è troppo alto, significa che il secondo fotogramma è danneggiato e quindi l'immagine viene eliminata. La Kullback & # 8211; Leibler distance , o mutua entropia, sugli istogrammi dei due fotogrammi:

     

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

     

dove p e q sono utilizzati gli istogrammi dei frame. La soglia è fissata su 0.2.

Altri suggerimenti

Una soluzione semplice:

Codifica l'immagine come jpeg e cerca una modifica sostanziale nella dimensione del file .

Ho implementato qualcosa di simile con le miniature dei video e ho avuto molto successo e scalabilità.

Puoi confrontare due immagini usando le funzioni di PIL . 

import Image
import ImageChops

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

diff = ImageChops.difference(im2, im1)

L'oggetto diff è un'immagine in cui ogni pixel è il risultato della sottrazione dei valori di colore di quel pixel nella seconda immagine dalla prima immagine. Usando l'immagine diff puoi fare diverse cose. La più semplice è la funzione diff.getbbox(). Ti dirà il rettangolo minimo che contiene tutte le modifiche tra le tue due immagini.

Probabilmente puoi implementare approssimazioni delle altre cose menzionate qui usando anche le funzioni di PIL.

Due metodi popolari e relativamente semplici sono: (a) la distanza euclidea già suggerita, o (b) correlazione incrociata normalizzata. La correlazione incrociata normalizzata tende ad essere notevolmente più robusta rispetto ai cambiamenti di illuminazione rispetto alla semplice correlazione incrociata. Wikipedia fornisce una formula per la correlazione incrociata normalizzata . Esistono anche metodi più sofisticati, ma richiedono un po 'più di lavoro.

Uso della sintassi simile al 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) )

supponendo che i1 e i2 siano array di immagini in scala di grigi 2D.

Una cosa banale da provare:

Ricampiona entrambe le immagini in piccole miniature (ad esempio 64 x 64) e confronta le miniature pixel per pixel con una certa soglia. Se le immagini originali sono quasi le stesse, le miniature ricampionate saranno molto simili o addirittura esattamente le stesse. Questo metodo si occupa del rumore che può verificarsi soprattutto nelle scene in condizioni di scarsa illuminazione. Potrebbe anche essere meglio se vai in scala di grigi.

Sto affrontando specificamente la questione su come calcolare se sono "abbastanza diversi".Presumo che tu possa capire come sottrarre i pixel uno per uno.

Per prima cosa, prenderei un sacco di immagini Niente cambiando e scopri la quantità massima di variazione di ciascun pixel solo a causa di variazioni nell'acquisizione, rumore nel sistema di imaging, artefatti di compressione JPEG e cambiamenti momento per momento nell'illuminazione.Forse scoprirai che ci sono differenze di 1 o 2 bit anche quando non si muove nulla.

Quindi per il test "reale", vuoi un criterio come questo:

  • lo stesso se fino a P pixel differiscono di non più di E.

Quindi, forse, se E = 0,02, P = 1000, ciò significherebbe (approssimativamente) che sarebbe "diverso" se un singolo pixel cambiasse di più di ~ 5 unità (assumendo immagini a 8 bit), o se più di 1000 i pixel presentavano errori.

Questa è intesa principalmente come una buona tecnica di "triage" per identificare rapidamente immagini sufficientemente vicine da non richiedere ulteriori esami.Le immagini che "falliscono" potrebbero quindi dipendere da una tecnica più elaborata/costosa che non avrebbe falsi positivi se la fotocamera tremasse un po', ad esempio, o fosse più resistente ai cambiamenti di illuminazione.

Gestisco un progetto open source, OpenImageIO, che contiene un'utilità chiamata "idiff" che confronta le differenze con soglie come questa (anche più elaborata, per la verità).Anche se non vuoi utilizzare questo software, potresti voler guardare la fonte per vedere come l'abbiamo fatto.È usata parecchio a livello commerciale e questa tecnica di soglia è stata sviluppata in modo da poter avere una suite di test per il software di rendering ed elaborazione delle immagini, con "immagini di riferimento" che potrebbero presentare piccole differenze da piattaforma a piattaforma o quando abbiamo apportato piccole modifiche a gli algoritmi, quindi volevamo un'operazione di "corrispondenza entro la tolleranza".

La maggior parte delle risposte fornite non riguarda i livelli di illuminazione.

Prima di fare il confronto vorrei normalizzare l'immagine ad un livello di luce standard.

Un altro modo carino e semplice per misurare la somiglianza tra due immagini: 

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)

Se altri sono interessati a un modo più efficace per confrontare la somiglianza delle immagini, metto insieme un tutorial e web app per misurare e visualizzare immagini simili usando tensorflow.

Ho avuto un problema simile al lavoro, stavo riscrivendo il nostro endpoint di trasformazione delle immagini e volevo verificare che la nuova versione producesse lo stesso o quasi lo stesso output della versione precedente. Quindi ho scritto questo:

https://github.com/nicolashahn/diffimg

Che opera su immagini della stessa dimensione e a livello di pixel, misura la differenza di valori su ciascun canale: R, G, B (, A), prende la differenza media di quei canali e quindi esegue la media la differenza su tutti i pixel e restituisce un rapporto.

Ad esempio, con un'immagine 10x10 di pixel bianchi e la stessa immagine ma un pixel è diventato rosso, la differenza in quel pixel è 1/3 o 0,33 ... (RGB 0,0,0 vs 255, 0,0) e per tutti gli altri pixel è 0. Con un totale di 100 pixel, 0,33 ... / 100 = una differenza di ~ 0,33% nell'immagine.

Credo che funzionerebbe perfettamente per il progetto di OP (mi rendo conto che questo è un post molto vecchio ora, ma che sto postando per i futuri StackOverflowers che vogliono anche confrontare le immagini in Python).

Hai visto la Algorithm per trovare immagini simili ? Dai un'occhiata per vedere i suggerimenti.

Suggerirei una trasformazione wavelet dei tuoi frame (ho scritto un'estensione C per quello usando la trasformazione Haar); quindi, confrontando gli indici dei maggiori fattori wavelet (proporzionali) tra le due immagini, dovresti ottenere un'approssimazione numerica della somiglianza.

Mi scuso se è troppo tardi per rispondere, ma dato che ho fatto qualcosa di simile ho pensato di poter contribuire in qualche modo.

Forse con OpenCV potresti usare la corrispondenza dei template. Supponendo che stai usando una webcam come hai detto:

  1. Semplifica le immagini (soglia forse?)
  2. Applica la corrispondenza del modello e controlla max_val con minMaxLoc

Suggerimento: max_val (o min_val a seconda del metodo utilizzato) ti darà numeri, numeri grandi. Per ottenere la differenza in percentuale, utilizza la corrispondenza del modello con la stessa immagine: il risultato sarà il tuo 100%.

Codice pseudo per esemplificare: 

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

Spero che sia d'aiuto.

distanza dai movimenti della Terra potrebbe essere esattamente ciò di cui hai bisogno. Tuttavia, potrebbe essere abit pesante da implementare in tempo reale.

Che dire del calcolo della Manhattan Distance delle due immagini. Questo ti dà n * n valori. Quindi potresti fare qualcosa come una media di riga per ridurre a n valori e una funzione su quello per ottenere un singolo valore.

Ho avuto molta fortuna con le immagini jpg scattate con la stessa fotocamera su un treppiede (1) semplificando notevolmente (come passare da 3000 pixel di larghezza a 100 pixel di larghezza o anche meno) (2) appiattire ogni array jpg in un singolo vettore (3) immagini sequenziali correlate in coppia con un semplice algoritmo correlato per ottenere il coefficiente di correlazione (4) quadrato coefficiente di correlazione per ottenere r-quadrato (cioè frazione di variabilità in un'immagine spiegata dalla variazione nella successiva) (5) generalmente nella mia applicazione se r-square & Lt; 0.9, dico che le due immagini sono diverse e qualcosa è accaduto nel mezzo.

Questo è solido e veloce nella mia implementazione (Mathematica 7)

Vale la pena giocare con la parte dell'immagine che ti interessa e concentrarti su di essa ritagliando tutte le immagini in quella piccola area, altrimenti ci mancherà un cambiamento distante dalla fotocamera ma importante.

Non so come usare Python, ma sono sicuro che fa anche correlazioni no?

puoi calcolare l'istogramma di entrambe le immagini e quindi calcolare il Bhattacharyya Coefficient , questo è un algoritmo molto veloce e l'ho usato per rilevare i cambiamenti di tiro in un video di cricket (in C usando openCV)

Scopri come Haar Wavelets sono implementate da isk-daemon . Puoi usare il suo codice C ++ imgdb per calcolare la differenza tra le immagini al volo:

  

isk-daemon è un server di database open source in grado di aggiungere la ricerca di immagini (visive) basata sul contenuto a qualsiasi sito Web o software relativo alle immagini.

     

Questa tecnologia consente agli utenti di qualsiasi sito Web o software relativo alle immagini di disegnare su un widget l'immagine che desiderano trovare e fare in modo che il sito Web risponda alle immagini più simili o richieda semplicemente più foto simili in ogni pagina dei dettagli dell'immagine.

Ho avuto lo stesso problema e ho scritto un semplice modulo in pitone che confronta due immagini della stessa dimensione usando ImageChops del cuscino per creare un'immagine diff bianco / nero e riassumere i valori dell'istogramma.

Puoi ottenere direttamente questo punteggio o un valore percentuale rispetto a una differenza tra nero e bianco

Contiene anche una semplice funzione is_equal, con la possibilità di fornire una soglia fuzzy al di sotto (e compresa) l'immagine passa come uguale.

L'approccio non è molto elaborato, ma forse è utile per altri là fuori alle prese con lo stesso problema.

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

Un approccio un po 'più basato sui principi è quello di utilizzare un descrittore globale per confrontare immagini, come GIST o CENTRIST. Una funzione hash, come descritto qui , anche fornisce una soluzione simile. 

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

  • uscita:

    False
    vero
    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

  • le immagini di esempio:

    • 815.jpg
      815.jpg

    • 5.jpg
      5.jpg

Penso che potresti semplicemente calcolare la distanza euclidea (cioè sqrt (somma dei quadrati delle differenze, pixel per pixel)) tra la luminanza delle due immagini e considerarle uguali se questa scende al di sotto di una soglia empirica. E sarebbe meglio farlo avvolgendo una funzione C.

Ci sono molte metriche là fuori per valutare se due immagini sembrano / quanto sembrano.

Non inserirò nessun codice qui, perché penso che dovrebbe essere un problema scientifico, diverso da un problema tecnico.

In generale, la domanda è correlata alla percezione umana sulle immagini, quindi ogni algoritmo ha il suo supporto sui tratti del sistema visivo umano.

Gli approcci classici sono:

Predittore di differenze visibili: un algoritmo per la valutazione della fedeltà dell'immagine ( 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 )

Valutazione della qualità dell'immagine: dalla visibilità dell'errore alla somiglianza strutturale ( http: //www.cns.nyu.edu/pub/lcv/wang03-reprint.pdf )

FSIM: un indice di somiglianza di funzionalità per la valutazione della qualità delle immagini ( https : //www4.comp.polyu.edu.hk/~cslzhang/IQA/TIP_IQA_FSIM.pdf )

Tra questi, SSIM (valutazione della qualità dell'immagine: dalla visibilità dell'errore alla somiglianza strutturale) è il più semplice da calcolare e anche il suo sovraccarico è piccolo, come riportato in un altro documento " Valutazione della qualità dell'immagine basata sulla somiglianza del gradiente quot; ( https: // .org / carta / immagine-Qualità-valutazione-Based-on-Gradient-Liu-Lin / 2b819bef80c02d5d4cb56f27b202535e119df988 ).

Esistono molti altri approcci. Dai un'occhiata a Google Scholar e cerca qualcosa come & Quot; differenza visiva & Quot ;, & Quot; valutazione della qualità dell'immagine & Quot ;, ecc., Se sei interessato / ti interessa davvero l'arte .

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top