¿Cómo detecto que dos imágenes son "iguales" incluso si una tiene un recorte / relación ligeramente diferente?

Tengo dos imágenes diferentes:

en 100 px con o 400 px

y

en 100px de ancho o 400px

Como puede ver, los dos son claramente "iguales" desde el punto de vista humano. Ahora quiero detectar programáticamente que son lo mismo. He estado usando magia de imágenes a través de la gema de rubí llamada rmagickasí:

img1 = Magick::Image.from_blob(File.read("image_1.jpeg")).first
img2 = Magick::Image.from_blob(File.read("image_2.jpeg")).first

if img1.difference(img2).first < 4000.0 # I have found this to be a good threshold, but does not work for cropped images
  puts "they are the same!!!"
end

Si bien esto funciona bien para imágenes que tienen la misma relación / recorte, no es ideal cuando tienen un recorte ligeramente diferente y se ha redimensionado al mismo ancho.

¿Hay alguna manera de hacerlo para imágenes con diferentes recortes? Estoy interesado en una solución en la que pueda decir algo como: una imagen está contenida dentro de la otra y cubre en algún lugar, por ejemplo, el 90% de la misma.

PD. Puedo obtener las imágenes en mayor resolución si eso ayuda (por ejemplo, el doble)

Es posible que desee echar un vistazo a la coincidencia de características. La idea es encontrar características en dos imágenes y combinarlas. Este método se usa comúnmente para encontrar una plantilla (por ejemplo, un logotipo) en otra imagen. Una característica, en esencia, puede describirse como cosas que los humanos encontrarían interesantes en una imagen, como esquinas o espacios abiertos. Existen muchos tipos de técnicas de detección de características, sin embargo, mi recomendación es utilizar una transformación de características invariantes de escala (SIFT) como algoritmo de detección de características. SIFT es invariante para la traducción de imágenes, escalado, rotación, parcialmente invariable para los cambios de iluminación y robusto para la distorsión geométrica local. Esto parece coincidir con su especificación donde las imágenes pueden tener proporciones ligeramente diferentes.

Dadas sus dos imágenes proporcionadas, aquí hay un intento de hacer coincidir las características utilizando el comparador de características de FLANN . Para determinar si las dos imágenes son iguales, podemos basarlo en un umbral predeterminado que rastrea el número de coincidencias que pasan la prueba de relación descrita en Características de imagen distintivas de puntos clave invariables a escala por David G. Lowe . Una explicación simple de la prueba es que la prueba de proporción verifica si las coincidencias son ambiguas y deben eliminarse, puede tratarse como una técnica de eliminación atípica. Podemos contar el número de coincidencias que pasan esta prueba para determinar si las dos imágenes son iguales. Aquí están los resultados de coincidencia de características:

Matches: 42

Los puntos representan todas las coincidencias detectadas, mientras que las líneas verdes representan las "coincidencias buenas" que pasan la prueba de relación. Si no utiliza la prueba de razón, se dibujarán todos los puntos. De esta manera, puede usar este filtro como umbral para mantener solo las mejores características coincidentes.

Lo implementé en Python, no estoy muy familiarizado con Rails. Espero que esto ayude, buena suerte!

Código

import numpy as np
import cv2

# Load images
image1 = cv2.imread('1.jpg', 0)
image2 = cv2.imread('2.jpg', 0)

# Create the sift object
sift = cv2.xfeatures2d.SIFT_create(700)

# Find keypoints and descriptors directly
kp1, des1 = sift.detectAndCompute(image2, None)
kp2, des2 = sift.detectAndCompute(image1, None)

# FLANN parameters
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks=50)   # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params,search_params)
matches = flann.knnMatch(des1,des2,k=2)

# Need to draw only good matches, so create a mask
matchesMask = [[0,0] for i in range(len(matches))]

count = 0
# Ratio test as per Lowe's paper (0.7)
# Modify to change threshold 
for i,(m,n) in enumerate(matches):
    if m.distance < 0.15*n.distance:
        count += 1
        matchesMask[i]=[1,0]

# Draw lines
draw_params = dict(matchColor = (0,255,0),
                   # singlePointColor = (255,0,0),
                   matchesMask = matchesMask,
                   flags = 0)

# Display the matches
result = cv2.drawMatchesKnn(image2,kp1,image1,kp2,matches,None,**draw_params)
print('Matches:', count)
cv2.imshow('result', result)
cv2.waitKey()

Debido a que ImageMagick es una herramienta muy antigua, avanzada y con muchas funciones, sería difícil construir una interfaz que cubra la mayoría de las funciones. Por grandioso que sea, rmagick no (y tampoco los muchos intentos que ha hecho Python) se acerca a cubrir todas las características.

Me imagino que para muchos casos de uso, será lo suficientemente seguro y mucho más fácil simplemente ejecutar un método de línea de comando y leerlo. En rubí se verá así;

require 'open3'

def check_subimage(large, small)
    stdin, stdout, stderr, wait_thr = Open3.popen3("magick compare -subimage-search -metric RMSE #{large} #{small} temp.jpg")
    result = stderr.gets
    stderr.close
    stdout.close
    return result.split[1][1..-2].to_f < 0.2
end

if check_subimage('a.jpg', 'b.jpg')
    puts "b is a crop of a"
else
    puts "b is not a crop of a"
end

Cubriré cosas importantes y luego hablaré sobre notas adicionales.

El comando usa magick compare para verificar si la segunda imagen ( small) es una subimagen de la primera (large ). Esta función no comprueba que pequeño es estrictamente más pequeño que grande (altura y anchura). El número que puse para la similitud es 0.2 (error del 20%), y el valor de las imágenes que proporcionó es de aproximadamente 0.15. Es posible que desee afinar esto! Encuentro que las imágenes que son un subconjunto estricto obtienen menos de 0.01.

• Si desea menos errores (números más pequeños) en casos en los que tiene una superposición del 90% pero la segunda imagen tiene algunas cosas adicionales que la primera no, puede ejecutarla una vez, luego recortar la primera imagen grande donde está contenida la subimagen , ejecútelo nuevamente con la imagen recortada como la "pequeña" y la imagen original "pequeña" como la grande.
• Si realmente desea una interfaz orientada a objetos agradable en Ruby, rmagick utiliza la API MagicCore. Esto (enlace a documentos) comando es probablemente lo que desea usar para implementarlo, y puede abrir una pr para rickick o empaquetar el cext usted mismo.
• El uso de open3 iniciará un hilo ( ver documentos ). Cierre stderry stdoutno es "necesario" pero se supone que debes hacerlo.
• La imagen "temporal" que es el tercer argumento especifica un archivo para generar un análisis. Con un vistazo rápido, no pude encontrar una manera de no requerirlo, pero simplemente se sobrescribe automáticamente y podría ser bueno para guardarlo para la depuración. Para su ejemplo, se vería así;

• La salida completa está en el formato de 10092.6 (0.154003) @ 0,31. El primer número es el valor rmse de 655535, el segundo (que uso) es el porcentaje normalizado. Los dos últimos números representan la ubicación de la imagen original desde la que comienza la imagen pequeña.
• Como no hay una fuente objetiva de verdad sobre cuán "similares" son las imágenes, elegí RMSE (vea más opciones de métricas aquí ). Es una medida bastante común de las diferencias entre los valores. Un conteo de errores absolutos (AE) puede parecer una buena idea, sin embargo, parece que algunos softwares de recorte no conservan los píxeles perfectamente, por lo que es posible que tenga que ajustar el fuzz y no es un valor normalizado, por lo que tendría que comparar el conteo de errores con el tamaño de la imagen y demás.

Obtenga el histograma de ambas imágenes y compárelas. Esto funcionaría muy bien para recortar y Zoom a menos que haya un cambio demasiado drástico debido a esto.

Esto es mejor que el enfoque actual en el que está restando directamente las imágenes. Pero este enfoque todavía tiene pocos.

Por lo general, la coincidencia de plantillas tiene un buen resultado en estas situaciones. La coincidencia de plantillas es una técnica para encontrar áreas de una imagen que coinciden (son similares) a una imagen de plantilla (segunda imagen). Este algoritmo proporciona una puntuación para la mejor posición macthed en la imagen de origen (la segunda).

En opencv usando TM_CCOEFF_NORMED método , da el puntaje entre 0 y 1. Si el puntaje es 1, eso significa que la imagen de la plantilla es exactamente una parte (Rect) de la imagen de origen, pero si tiene un pequeño cambio en la iluminación o la perspectiva entre Las dos imágenes, la puntuación sería inferior a 1.

Ahora, al considerar un umbral para el puntaje de similitud, puede averiguar si son iguales o no. Ese umbral se puede obtener mediante alguna prueba y error en algunas imágenes de muestra. Probé sus imágenes y obtuve el puntaje 0.823863 . Aquí está el código (opencv C ++) y el área común entre las dos imágenes, obtenidas por la coincidencia:

Mat im2 = imread("E:/1/1.jpg", 1);
//Mat im2;// = imread("E:/1/1.jpg", 1);
Mat im1 = imread("E:/1/2.jpg", 1);

//im1(Rect(0, 0, im1.cols - 5, im1.rows - 5)).copyTo(im2);

int result_cols = im1.cols - im2.cols + 1;
int result_rows = im1.rows - im2.rows + 1;

Mat result = Mat::zeros(result_rows, result_cols, CV_32FC1);

matchTemplate(im1, im2, result, TM_CCOEFF_NORMED);

double minVal; double maxVal;
Point minLoc; Point maxLoc;
Point matchLoc;

minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc, Mat());

cout << minVal << " " << maxVal << " " << minLoc << " " << maxLoc << "\n";
matchLoc = maxLoc;

rectangle(im1, matchLoc, Point(matchLoc.x + im2.cols, matchLoc.y + im2.rows), Scalar::all(0), 2, 8, 0);
rectangle(result, matchLoc, Point(matchLoc.x + im2.cols, matchLoc.y + im2.rows), Scalar::all(0), 2, 8, 0);

imshow("1", im1);
imshow("2", result);
waitKey(0);

Considere el método find_similar_region . Use la menor de las dos imágenes como imagen de destino. Pruebe varios valores para los atributos de fuzz en la imagen y la imagen de destino.