Método simple y rápido para comparar imágenes por similitud

Me enfrento a los mismos problemas recientemente, para resolver este problema(algoritmo simple y rápido para comparar dos imágenes) de una vez por todas, contribuyo con un módulo img_hash a opencv_contrib, puede encontrar los detalles en este enlace.

El módulo Img_hash proporciona seis algoritmos hash de imagen, bastante fáciles de usar.

Ejemplo de códigos

origen lena

blur lena

redimensionar lena

shift lena

#include <opencv2/core.hpp>
#include <opencv2/core/ocl.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/img_hash.hpp>
#include <opencv2/imgproc.hpp>

#include <iostream>

void compute(cv::Ptr<cv::img_hash::ImgHashBase> algo)
{
    auto input = cv::imread("lena.png");
    cv::Mat similar_img;

    //detect similiar image after blur attack
    cv::GaussianBlur(input, similar_img, {7,7}, 2, 2);
    cv::imwrite("lena_blur.png", similar_img);
    cv::Mat hash_input, hash_similar;
    algo->compute(input, hash_input);
    algo->compute(similar_img, hash_similar);
    std::cout<<"gaussian blur attack : "<<
               algo->compare(hash_input, hash_similar)<<std::endl;

    //detect similar image after shift attack
    similar_img.setTo(0);
    input(cv::Rect(0,10, input.cols,input.rows-10)).
            copyTo(similar_img(cv::Rect(0,0,input.cols,input.rows-10)));
    cv::imwrite("lena_shift.png", similar_img);
    algo->compute(similar_img, hash_similar);
    std::cout<<"shift attack : "<<
               algo->compare(hash_input, hash_similar)<<std::endl;

    //detect similar image after resize
    cv::resize(input, similar_img, {120, 40});
    cv::imwrite("lena_resize.png", similar_img);
    algo->compute(similar_img, hash_similar);
    std::cout<<"resize attack : "<<
               algo->compare(hash_input, hash_similar)<<std::endl;
}

int main()
{
    using namespace cv::img_hash;

    //disable opencl acceleration may(or may not) boost up speed of img_hash
    cv::ocl::setUseOpenCL(false);

    //if the value after compare <= 8, that means the images
    //very similar to each other
    compute(ColorMomentHash::create());

    //there are other algorithms you can try out
    //every algorithms have their pros and cons
    compute(AverageHash::create());
    compute(PHash::create());
    compute(MarrHildrethHash::create());
    compute(RadialVarianceHash::create());
    //BlockMeanHash support mode 0 and mode 1, they associate to
    //mode 1 and mode 2 of PHash library
    compute(BlockMeanHash::create(0));
    compute(BlockMeanHash::create(1));
}

En este caso, ColorMomentHash nos dan el mejor resultado

• ataque de desenfoque gaussiano: 0.567521
• shift attack: 0.229728
• redimensionar ataque: 0.229358

Pros y contras de cada algoritmo

El rendimiento de img_hash también es bueno

Comparación de velocidad con la biblioteca PHash (100 imágenes de ukbench)

Si desea conocer los umbrales recomendados para estos algoritmos, consulte este post ( http://qtandopencv.blogspot.my/2016/06/introduction-to-image-hash-module-of.html). Si te interesa saber cómo mido el rendimiento de los módulos img_hash(incluye velocidad y diferentes ataques), por favor comprueba esto link(http://qtandopencv.blogspot.my/2016/06/speed-up-image-hashing-of-opencvimghash.html).

¿La captura de pantalla contiene solo el icono? Si es así, la distancia L2 de las dos imágenes podría ser suficiente. Si la distancia L2 no funciona, el siguiente paso es probar algo simple y bien establecido, como: Lucas-Kanade. Que estoy seguro que está disponible en OpenCV.

Si puede estar seguro de tener una alineación precisa de su plantilla (el icono) con la región de prueba, entonces cualquier suma antigua de diferencias de píxeles funcionará.

Si la alineación solo va a estar un poco apagada, entonces puede pasar ambas imágenes con cv::GaussianBlur antes de encontrar la suma de diferencias de píxeles.

Si la calidad de la alineación es potencialmente pobre, entonces recomendaría un Histograma de Gradientes Orientados o uno de los convenientes de OpenCV algoritmos de detección de puntos clave/descriptores (como SIFTo SURF).

Si desea obtener un índice sobre la similitud de las dos imágenes, le sugiero que de las métricas el índice SSIM. Es más consistente con el ojo humano. Aquí hay un artículo sobre esto: Índice de Similitud Estructural

También se implementa en OpenCV, y se puede acelerar con GPU: OpenCV SSIM con GPU

Si para la coincidencia de imágenes idénticas-código para L2 distancia

// Compare two images by getting the L2 error (square-root of sum of squared error).
double getSimilarity( const Mat A, const Mat B ) {
if ( A.rows > 0 && A.rows == B.rows && A.cols > 0 && A.cols == B.cols ) {
    // Calculate the L2 relative error between images.
    double errorL2 = norm( A, B, CV_L2 );
    // Convert to a reasonable scale, since L2 error is summed across all pixels of the image.
    double similarity = errorL2 / (double)( A.rows * A.cols );
    return similarity;
}
else {
    //Images have a different size
    return 100000000.0;  // Return a bad value
}

Rápido. Pero no robusto a los cambios en la iluminación / punto de vista, etc. Fuente

Si desea comparar la imagen por similitud,le sugiero que utilice OpenCV. En OpenCV, hay pocas coincidencias de características y plantillas. Para la coincidencia de características, hay SURF, TAMIZ, detector RÁPIDO y así sucesivamente. Puede usar esto para detectar, describir y luego hacer coincidir la imagen. Después de eso, puede usar el índice específico para encontrar el número de coincidencia entre las dos imágenes.