Méthode Simple et rapide pour comparer des images pour la similitude

je fais face aux mêmes problèmes récemment, pour résoudre ce problème(algorithme simple et rapide pour comparer deux images) Une fois pour toutes, je contribue un module img_hash à opencv_contrib, vous pouvez trouver les détails de ce lien .

img_hash fournit six algorithmes de hachage d'image, assez faciles à utiliser.

Codes exemple

origine lena

flou lena

redimensionner lena

poste 151960920"

#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));
}

dans ce cas, ColorMomentHash nous donner le meilleur résultat

• flou gaussien attaque : 0.567521
• shift attaque : 0.229728
• redimensionner l'attaque: 0.229358

pour et contre de chaque algorithme

la performance de img_hash est bonne aussi

comparaison de la vitesse avec la bibliothèque PHash (100 images de ukbench)

si vous voulez connaître les seuils recommandés pour ces algorithmes, s'il vous plaît vérifier ce post ( http://qtandopencv.blogspot.my/2016/06/introduction-to-image-hash-module-of.html ). Si vous êtes intéressant sur la façon dont je mesure la performance des modules img_hash (inclure la vitesse et les différentes attaques), s'il vous plaît vérifier ce lien ( http://qtandopencv.blogspot.my/2016/06/speed-up-image-hashing-of-opencvimghash.html ).

la capture d'écran ne contient-elle que l'icône? Si c'est le cas, la distance L2 des deux images pourrait suffire. Si la distance L2 ne fonctionne pas, l'étape suivante est d'essayer quelque chose de simple et bien établi, comme: Lucas-Kanade . Qui je suis sûr est disponible en OpenCV.

si vous pouvez être sûr d'avoir un alignement précis de votre modèle (l'icône) sur la région de test, alors toute ancienne somme de différences de pixels fonctionnera.

si l'alignement ne va être qu'un tout petit peu désactivé, alors vous pouvez passer bas les deux images avec cv::GaussianBlur avant de trouver la somme des différences de pixels.

Si la qualité de l'alignement est potentiellement mauvaise alors je vous recommande soit un Histogramme de Gradients orientés ou de l'un des algorithmes de détection/descripteur de point de saisie d'OpenCV (tels que SIFT ou SURF ).

si vous voulez obtenir un indice sur la similarité des deux images, je vous suggère de la métrique l'indice SSIM. Il est plus cohérent avec l'œil humain. Voici un article à ce sujet: indice de similarité structurelle

il est mis en œuvre dans OpenCV aussi, et il peut être accéléré avec GPU: OpenCV SSIM avec GPU

Si pour l'appariement des images identiques - code pour les L2 de distance

// 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
}

Fast. Mais pas robuste aux changements d'éclairage/point de vue etc. Source

si vous voulez comparer l'image pour la similitude,je vous suggère D'utiliser OpenCV. Dans OpenCV, il y a peu d'appariement des fonctionnalités et des modèles. Pour l'appariement des caractéristiques, il y a SURF, SIFT, FAST et ainsi de suite. Vous pouvez l'utiliser pour détecter, décrire et ensuite en fonction de l'image. Après cela, vous pouvez utiliser l'index spécifique pour trouver le nombre de correspondance entre les deux images.