Aquí es lo que me gustaría hacer:

Estoy tomando fotos con una cámara web a intervalos regulares. Como una especie de time lapse cosa. Sin embargo, si no ha cambiado nada, es decir, la imagen bastante se ve el mismo, no quiero guardar la instantánea más reciente.

Me imagino que hay alguna manera de cuantificar la diferencia, y yo tendría que determinar empíricamente un umbral.

Estoy buscando la simplicidad en vez de la perfección.
Estoy usando python.

InformationsquelleAutor carrier | 2008-10-10

22 Comentarios

  1. 248

    Idea General

    Opción 1: Cargar imágenes como matrices (scipy.misc.imread) y calcular un elemento sabio (píxel a píxel) de diferencia. Calcular la norma de la diferencia.

    Opción 2: Carga de ambas imágenes. Calcular algunas disponen de vector para cada uno de ellos (como un histograma). Calcular la distancia entre la función de los vectores en lugar de imágenes.

    Sin embargo, hay algunas decisiones que tomar primero.

    Preguntas

    Debe responder a estas preguntas primero:

    • Son imágenes de la misma forma y dimensión?

      Si no, puede que necesite cambiar el tamaño o recortar. PIL biblioteca ayudará a hacerlo en Python.

      Si se toman con la misma configuración y el mismo dispositivo, es probable que sean de la misma.

    • Son imágenes bien alineados?

      Si no, puede que desee ejecutar de correlación cruzada en primer lugar, para encontrar la mejor alineación de la primera. SciPy tiene funciones para hacerlo.

      Si la cámara y la escena aún, las imágenes son propensos a estar bien alineados.

    • Es la exposición de las imágenes siempre el mismo? (Es la luminosidad/contraste de la misma?)

      Si no, puede que desee para normalizar imágenes.

      Pero cuidado, en algunas situaciones esto puede hacer más mal que bien. Por ejemplo, un solo pixel brillante sobre un fondo oscuro hará que la normalizado imagen muy diferente.

    • Es el color de la información importante?

      Si quieres notar los cambios de color, usted tendrá un vector de valores de color de cada punto, en lugar de un valor escalar como en escala de grises de la imagen. Necesita más atención al escribir dicho código.

    • Hay distintos bordes de la imagen? Es probable que se mueva?

      Si sí, usted puede solicitar borde algoritmo de detección de primera (por ejemplo, calcular el gradiente con Sobel o Prewitt, transformar, aplicar un poco de umbral), a continuación, compare los bordes en la primera imagen a los bordes en el segundo.

    • Hay ruido en la imagen?

      Todos los sensores contaminar la imagen con cierta cantidad de ruido. Sensores de bajo coste más ruido. Puede solicitar algunos de reducción de ruido antes de comparar imágenes. Blur es el más simple (pero no el mejor) enfoque aquí.

    • ¿Qué tipo de cambios ¿quieres ver?

      Esto puede afectar a la elección de la norma a utilizar para la diferencia entre las imágenes.

      Considerar el uso de Manhattan norma (la suma de los valores absolutos) o cero norma (el número de elementos no es igual a cero) para medir la cantidad de la imagen ha cambiado. A la primera se le diga lo mucho que la imagen está apagado, éste le indicará sólo el número de píxeles de diferentes.

    Ejemplo

    Puedo asumir que sus imágenes están bien alineados, el mismo tamaño y forma, posiblemente con diferente exposición. Para la simplicidad, convertir a escala de grises, incluso si son de color (RGB) de las imágenes.

    Tendrá la importación de estos productos:

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

    Función principal, la lectura de dos imágenes, convertir a escala de grises, comparar y resultados de impresión:

    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

    Cómo comparar. img1 y img2 son 2D SciPy matrices aquí:

    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 el archivo es una imagen en color, imread devuelve una matriz 3D, el promedio de los canales RGB (la última matriz de ejes) para obtener la intensidad. No es necesario hacerlo para imágenes en escala de grises (por ejemplo,.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

    Normalización es trivial, usted puede elegir para normalizar a [0,1] en lugar de [0,255]. arr es un SciPy matriz de aquí, así que todas las operaciones se elemento-sabio:

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

    Ejecutar el main función:

    if __name__ == "__main__":
        main()

    Ahora usted puede poner todo esto en un script y ejecutar en contra de dos imágenes. Si comparamos la imagen de sí mismo, no hay ninguna diferencia:

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

    Si nos desenfoque de la imagen y comparar con el original, hay algunas diferencias:

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

    Actualización: las técnicas pertinentes

    Como la pregunta es acerca de una secuencia de vídeo, en el que los marcos son propensos a ser casi el mismo, y busca algo inusual, me gustaría mencionar algunos de los planteamientos alternativos que pueden ser relevantes:

    • la sustracción de fondo y la segmentación (para detectar los objetos en primer plano)
    • dispersas de flujo óptico (para detectar movimiento)
    • la comparación de histogramas o algunas otras estadísticas en lugar de imágenes

    Recomiendo echar un vistazo a «el Aprendizaje de OpenCV» libro, los Capítulos 9 (Imagen piezas y segmentación) y 10 (Seguimiento y movimiento). El ex enseña a utilizar de Fondo método de sustracción, la última le da algo de información sobre el flujo óptico métodos. Todos los métodos se implementan en la biblioteca OpenCV. Si el uso de Python, yo sugiero usar OpenCV ≥ 2.3, y su cv2 módulo de Python.

    La versión más simple de la sustracción de fondo:

    • aprender el valor de media µ y desviación estándar σ para cada píxel del fondo
    • comparar actual de los valores de los píxeles para el rango de (μ-2σ,μ+2σ) o (µ-σ,μ+σ)

    Versiones más avanzadas asegúrese de tomar en cuenta las series de tiempo para cada píxel y manejar no escenas estáticas (como el movimiento de los árboles o hierba).

    La idea de flujo óptico es tomar dos o más fotogramas, y asignar el vector de velocidad para cada píxel (denso flujo óptico) o a algunos de ellos (escaso flujo óptico). A escasa estimación de flujo óptico, usted puede usar Lucas-Kanade método (también es implementado en OpenCV). Obviamente, si hay una gran cantidad de flujo (alto promedio de más de valores máximos de la velocidad), entonces algo se está moviendo en el marco, y las imágenes posteriores son más diferentes.

    La comparación de los histogramas pueden ayudar a detectar cambios bruscos entre fotogramas consecutivos. Este enfoque fue utilizado en Courbon et al, 2010:

    Similitud de fotogramas consecutivos. La distancia entre dos frames consecutivos se mide. Si es demasiado alto, esto significa que el segundo fotograma está dañado y por lo tanto la imagen es eliminada. El De Kullback–Leibler distancia, o la entropía, en los histogramas de los dos marcos:

    ¿Cómo puedo cuantificar la diferencia entre las dos imágenes?

    donde p y q son los histogramas de los marcos se utilizan. El umbral se fija en 0.2.

    • Tengo un RuntimeWarning: invalid value encountered in double_scalarsen la línea 44 (return (arr-amin)*255/rng) y un ValueError: array must not contain infs or NaNs en la línea 30 (z_norm = norm(diff.ravel(), 0))
    • es que si rng es igual a cero. Sólo añadir un cheque y un conjunto de rng = 1
  2. 74

    Una solución simple:

    Codificar la imagen como un jpeg y buscar un cambio sustancial en tamaño de archivo.

    He implementado algo similar con las miniaturas de vídeo, y tuvo un gran éxito y la escalabilidad.

    • Esta es una muy fácil solución y es mucho mejor que cualquier píxel-sabio comparación. Si hay un poco de ruido en su webcam de la imagen o si la imagen está girada por un pixel, a continuación, una comparación directa recoger todos estos cambios de sentido. Una actuación más eficaz sería para calcular el coseno discreta transformación y, a continuación, compare las imágenes en el dominio de la frecuencia. El uso de la compresión JPEG, como esta usted obtiene la mayor parte de los beneficios sin bucear en la teoría de Fourier.
    • ¿Tiene algún ejemplo de código?
    • Gusta. A pesar de que otras soluciones también funciona, esto tiene una gran ventaja para el común de la situación: ¿qué ocurre si no desea guardar la «base» de la imagen? sólo tienes que guardar el tamaño del archivo como un hash y, a continuación, comparar los números con la sustracción. En mi caso tengo 4 imágenes, uno de ellos es muy similar, y los otros 3 son absolutamente diferentes. Sólo la escala de las mismas dimensiones, a jpg y restar. Realmente Agradable.
    • podría por favor proporcionar una referencia a algún tipo de código/publicación arbitrada que utiliza esta sencilla solución? Estoy usando esta idea en conjunto con homomórfica de cifrado para un pequeño proyecto y me gustaría algún tipo de referencia además de esta gran respuesta.
  3. 55

    Puede comparar dos imágenes utilizando las funciones de PIL.

    import Image
    import ImageChops
    
    im1 = Image.open("splash.png")
    im2 = Image.open("splash2.png")
    
    diff = ImageChops.difference(im2, im1)

    El diff objeto es una imagen en la que cada píxel es el resultado de la resta de los valores de color del píxel en la segunda imagen de la primera imagen. Utilizando el diff de la imagen usted puede hacer varias cosas. La más simple es la diff.getbbox() función. Se le indicará el mínimo rectángulo que contiene todos los cambios entre las dos imágenes.

    Usted probablemente puede implementar aproximaciones de las otras cosas que se mencionan aquí el uso de las funciones de PIL así.

    • Quiero guardar la imagen de diferencia . significa que el diff objeto de que se mantenga la diferencia de imágenes. el ujo de hacer guardarlo ?
    • usted puede llamar a save() en diff objeto especificando el nombre de la imagen. como este : diff.guardar(«diff.png») va a salvar a diferencia de la imagen para usted.
  4. 19

    Dos populares y métodos relativamente sencillos son: (a) la distancia Euclidiana ya se ha sugerido, o (b) normalizado de correlación cruzada. Normalizado de correlación cruzada tiende a ser notablemente más robusto a cambios de luz que una simple correlación cruzada. Wikipedia da una fórmula para la normalizado de correlación cruzada. Métodos más sofisticados que existen, pero requieren un poco más de trabajo.

    El uso de numpy-como la sintaxis,

    dist_euclidean = sqrt(sum((i1 - i2)^2)) /i1.tamaño 
    
    dist_manhattan = sum(abs(i1 - i2)) /i1.tamaño 
    
    dist_ncc = suma( (i1 - media(i1)) * (i2 - media(i2)) ) /( 
    (i1.tamaño - 1) * desvest(i1) * desvest(i2) ) 
    

    suponiendo que i1 y i2 son 2D imagen en escala de grises de matrices.

  5. 13

    Una cosa trivial probar:

    Remuestrear imágenes de ambos a miniaturas pequeñas (por ejemplo, 64 x 64) y comparar las miniaturas de píxel por píxel con un cierto umbral. Si las imágenes originales son casi los mismos, la remuestreada miniaturas va a ser muy similar o incluso exactamente el mismo. Este método toma el cuidado de ruido que pueden producirse especialmente en escenas de poca luz. Puede ser incluso mejor si usted va en escala de grises.

    • pero ¿cómo se comparan los píxeles?
    • Una vez que usted tiene las miniaturas, usted puede comparar simplemente los píxeles uno por uno. Calcular la «distancia» de los valores RGB, si usted está trabajando en el color o la diferencia entre los tonos de gris si usted está en escala de grises.
    • «comparar los píxeles uno por uno». ¿Qué significa eso? Si el test falla si UNO de los 64^2 píxel por píxel pruebas de falla?
    • Lo que quiero decir por «comparar las miniaturas de píxel por píxel con un cierto umbral» es venir para arriba con un fuzzy algoritmo para comparar los píxeles. Si el cálculo de la diferencia (depende del algoritmo fuzzy) supera un cierto umbral, las imágenes no son «el mismo».
    • Ejemplo muy simple, sin el «algoritmo fuzzy»: bucle paralelo a través de cada píxel (comparar pixel# n de la imagen#1 píxel# n de la imagen#2), y añadir la diferencia en valor a una variable
    • Este método puede no funcionar con un ruidoso fuente de la imagen como una webcam.

  6. 7

    Estoy abordar específicamente la cuestión de cómo calcular si son «bastante diferentes». Supongo que usted puede averiguar cómo restar los píxeles uno por uno.

    Primer lugar, me gustaría tener un montón de imágenes con nada cambiando, y averiguar la cantidad máxima que cualquier píxel de cambios debido a variaciones en la captura, el ruido en el sistema de imágenes, JPEG artefactos de compresión, y de un momento a cambios en la iluminación. Tal vez usted encontrará que 1 o 2 bits diferencias están a la espera, incluso cuando no se mueve nada.

    A continuación, para el «real» de la prueba, usted quiere un criterio como este:

    • mismo si hasta P píxeles se diferencian por no más de E.

    Así, tal vez, si E = 0.02, P = 1000, que significaría (aproximadamente) que sería «diferente» si un solo píxel cambios por más de ~5 unidades (suponiendo que las imágenes de 8 bits), o si más de 1000 píxeles había ningún error en todo.

    Esto está pensado principalmente como un buen «triage» técnica para identificar rápidamente las imágenes que están lo suficientemente cerca como para no necesitar un examen más detenido. Las imágenes que «no» puede entonces más a una más elaborada/técnica costosa, que no tiene falsos positivos si la cámara sacudió bits, por ejemplo, o era más robusto a cambios de luz.

    Puedo ejecutar un proyecto de código abierto, OpenImageIO, que contiene una utilidad llamada «idiff» que compara las diferencias con los umbrales de como esta (aún más elaborada, en realidad). Incluso si usted no desea utilizar este software, usted puede desear mirar en la fuente para ver cómo lo hicimos. Se utiliza comercialmente un poco y en este umbral, la técnica se ha desarrollado de tal forma que podamos tener un conjunto de pruebas para la representación y el software de procesamiento de imágenes, con «imágenes de referencia» que podría haber pequeñas diferencias de plataforma a plataforma o como hemos hecho ajustes menores a tha algoritmos, así que queríamos un «partido dentro de la tolerancia de la operación».

  7. 5

    La mayoría de las respuestas dadas no tratar con los niveles de iluminación.

    Primer lugar, normalizar la imagen de un estándar de nivel de luz antes de hacer la comparación.

    • Si usted está tomando imágenes periódicas y distinción pares adyacentes, usted probablemente puede permitirse el lujo de mantener la primera vez que alguien enciende las luces.
  8. 4

    Otra buena manera simple para medir la similitud entre dos imágenes:

    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 otros están interesados en una forma más poderosa para comparar la semejanza de la imagen, puse una tutorial y web aplicación para la medición y la visualización de imágenes similares utilizando Tensorflow.

    • Sí, skimage es realmente agradable de usar para esta aplicación. Yo uso from skimage.measure import compare_ssim, compare_mse mucho. skimage.medir docs.
  9. 4

    He tenido un problema similar en el trabajo, yo estaba reescribiendo nuestra imagen de transformar extremo y quería comprobar que la nueva versión estaba produciendo el mismo o casi el mismo resultado que en la versión anterior. Así que escribí esto:

    https://github.com/nicolashahn/diffimg

    Que opera en las imágenes del mismo tamaño, y en cada nivel de píxel, mide la diferencia en los valores de cada canal: R, G, B, a), se toma el promedio de la diferencia de los canales, y luego se calcula el promedio de la diferencia sobre todos los píxeles, y devuelve una relación.

    Por ejemplo, con un 10×10 imagen de píxeles en blanco, y la misma imagen pero de un píxel ha cambiado a rojo, la diferencia en ese píxel es de 1/3 o… 0.33 RGB (0,0,0 vs 255,0,0) y en el resto de los píxeles es de 0. Con 100 píxeles en total, el 0,33…/100 = a ~0.33% de diferencia en la imagen.

    Creo que esto iba a funcionar a la perfección para la OP del proyecto (me doy cuenta de que este es un viejo post ahora, pero la publicación de futuro StackOverflowers que también quieren comparar imágenes en python).

  10. 3

    Has visto el Algoritmo para la búsqueda de imágenes similares pregunta? Echa un vistazo para ver las sugerencias.

    Sugeriría una transformación wavelet de sus fotogramas (he escrito un C extensión para que el uso de Haar de transformación); luego, la comparación de los índices de los más grandes (proporcionalmente) wavelet de los factores entre las dos imágenes, usted debe obtener un número de similitud de aproximación.

  11. 2

    Me disculpo si este es demasiado tarde para responder, pero desde que he estado haciendo algo similar pensé que podría contribuir de alguna manera.

    Tal vez con OpenCV usted podría utilizar la plantilla de la coincidencia. Asumiendo que usted está utilizando una cámara web como usted dijo:

    1. Simplificar las imágenes (umbralización tal vez?)
    2. Aplicar plantilla de contrastación y verificación de la max_val con minMaxLoc

    Sugerencia: max_val (o min_val según el método utilizado) le dará los números, los grandes números. Para obtener la diferencia en el porcentaje de uso de la plantilla de la coincidencia con la misma imagen, el resultado será el 100%.

    Pseudo código para ejemplificar:

    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

    Espero que ayude.

  12. 1

    Lo que sobre el cálculo de la Manhattan Distancia de las dos imágenes. Que le da n*n valores. Entonces se podría hacer algo así como una fila de media para reducir a valores n y una función más que la de obtener un solo valor.

  13. 1

    He tenido mucha suerte con jpg las imágenes tomadas con la misma cámara en un trípode
    (1) simplificando mucho (como pasar de 3000 píxeles de ancho a 100 píxeles de ancho o incluso menos)
    (2) el aplanamiento de cada uno de los jpg de la matriz en un vector único
    (3) pares de correlación de imágenes secuenciales con un simple correlato algoritmo para obtener el coeficiente de correlación de
    (4) el cuadrado el coeficiente de correlación para obtener r-cuadrado (he.e fracción de la variabilidad en una imagen se explica por la variación en la siguiente)
    (5) en general, en mi aplicación si r-cuadrado < 0.9, yo digo que las dos imágenes son diferentes y algo pasó en el medio.

    Este es robusto y rápido en mi aplicación (Mathematica 7)

    Vale la pena jugar con la parte de la imagen que te interesa y centrándose en que por el cultivo de todas las imágenes a esa pequeña área, de lo contrario un lejano-de-la-cámara, pero el cambio importante que se puede perder.

    No sé cómo usar Python, pero estoy seguro de que lo hace correlaciones, demasiado, no?

  14. 1

    puede calcular el histograma de tanto en las imágenes y, a continuación, calcular la Bhattacharyya Coeficiente De, este es un algoritmo rápido y lo he utilizado para detectar el disparo de cambios en un grillo de vídeo (en C usando openCV)

    • Podría usted calcular el coeficiente en las imágenes de sí mismos?
    • Usted tendrá que calcular los histogramas de las imágenes (con el bin tamaño del histograma según los requisitos).
  15. 1

    Echa un vistazo a cómo Wavelets Haar son implementados por isk-daemon. Usted podría utilizar es imgdb código C++ para calcular la diferencia entre las imágenes sobre la marcha:

    isk-demonio es una fuente abierta de servidor de base de datos capaz de añadir basada en el contenido (visual) búsqueda de imágenes a cualquier imagen relacionada con el sitio web o el software.

    Esta tecnología permite a los usuarios de cualquier imagen relacionada con el sitio web o software para dibujar en un widget de la imagen que quieren encontrar y tener el sitio web de contestar a la mayoría de imágenes similares o simplemente solicitar más fotos similares en cada detalle de la imagen de la página.

  16. 1

    Yo tenía el mismo problema y escribió un simple módulo de python que compara dos del mismo tamaño de las imágenes utilizando la almohada del ImageChops para crear un negro/blanco diff de la imagen y resume el histograma de los valores.

    Usted puede obtener este puntaje directamente, o a un valor de porcentaje en comparación con un completo negro vs blanco diff.

    También contiene un simple is_equal función, con la posibilidad de suministrar un fuzzy-umbral bajo (e incluyendo) la imagen pasa igual.

    El enfoque no es muy elaborado, pero tal vez es de uso para otros ahí fuera luchando con el mismo problema.

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

  17. 1

    Un poco más basada en los principios del enfoque es el uso de descriptores globales para comparar las imágenes, tales como GIST o CENTRISTA. Una función hash, como se describe aquí, también proporciona una solución similar.

  18. 1
    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 salida:

      Falso

      Cierto

      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

    • el ejemplo de las imágenes:

      • 815.jpg


        ¿Cómo puedo cuantificar la diferencia entre las dos imágenes?

      • 5.jpg


        ¿Cómo puedo cuantificar la diferencia entre las dos imágenes?

  19. 0

    Creo que simplemente puede calcular la distancia euclidiana (es decir, sqrt(suma de los cuadrados de las diferencias, pixel por pixel)) entre la luminancia de las dos imágenes, y los consideran iguales si esto cae bajo empírico umbral. Y que mejor que hacer un ajuste de una función de C.

  20. 0

    Hay muchas métricas que hay para evaluar si dos imágenes parecen/cuánto se parecen.

    No voy a entrar en ningún tipo de código aquí, porque creo que debe ser un problema científico, que no sea un problema técnico.

    Por lo general, la pregunta está relacionada con la percepción de las imágenes, por lo que cada algoritmo tiene su soporte en el sistema visual humano rasgos.

    Enfoques clásicos son:

    Diferencias visibles predictor: un algoritmo para la evaluación de la fidelidad de la imagen (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)

    De Evaluación de la Calidad de la imagen: a partir De Error Visibilidad a la Similitud Estructural (http://www.cns.nyu.edu/pub/lcv/wang03-reprint.pdf)

    FSIM: UNA Función del Índice de Similitud de Imagen para la Evaluación de la Calidad (https://www4.comp.polyu.edu.hk/~cslzhang/IQA/TIP_IQA_FSIM.pdf)

    Entre ellos, SSIM (Imagen de la Evaluación de la Calidad: a partir De Error Visibilidad a la Similitud Estructural ) es el más fácil de calcular y su carga es también pequeño, como se informó en otro papel «de la Imagen de la Evaluación de la Calidad Basado en Gradiente de Similitud» (https://www.semanticscholar.org/paper/Image-Quality-Assessment-Based-on-Gradient-Liu-Lin/2b819bef80c02d5d4cb56f27b202535e119df988).

    Hay muchos otros enfoques. Echa un vistazo a Google Scholar y buscar algo como «la diferencia visual», «la imagen de la evaluación de la calidad», etc, si usted está interesado/realmente se preocupan por el art.

  21. 0

    Hay una sencilla y rápida solución con numpy calculando el error cuadrático:

    before = np.array(get_picture())
    while True:
    now = np.array(get_picture())
    MSE = np.mean((now - before)**2)
    if  MSE > threshold:
    break
    before = now

Dejar respuesta

Please enter your comment!
Please enter your name here