Vérification de la similitude des images avec OpenCV

si pour des images identiques (même taille / orientation )

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

Source

la solution de Sam devrait être suffisante. J'ai utilisé la combinaison de la différence d'histogramme et de la correspondance de gabarit parce que pas une méthode ne fonctionnait pour moi 100% des fois. J'ai donné moins d'importance à la méthode de l'histogramme. Voici comment j'ai implémenté dans un simple script python.

import cv2

class CompareImage(object):

    def __init__(self, image_1_path, image_2_path):
        self.minimum_commutative_image_diff = 1
        self.image_1_path = image_1_path
        self.image_2_path = image_2_path

    def compare_image(self):
        image_1 = cv2.imread(self.image_1_path, 0)
        image_2 = cv2.imread(self.image_2_path, 0)
        commutative_image_diff = self.get_image_difference(image_1, image_2)

        if commutative_image_diff < self.minimum_commutative_image_diff:
            print "Matched"
            return commutative_image_diff
        return 10000 //random failure value

    @staticmethod
    def get_image_difference(image_1, image_2):
        first_image_hist = cv2.calcHist([image_1], [0], None, [256], [0, 256])
        second_image_hist = cv2.calcHist([image_2], [0], None, [256], [0, 256])

        img_hist_diff = cv2.compareHist(first_image_hist, second_image_hist, cv2.HISTCMP_BHATTACHARYYA)
        img_template_probability_match = cv2.matchTemplate(first_image_hist, second_image_hist, cv2.TM_CCOEFF_NORMED)[0][0]
        img_template_diff = 1 - img_template_probability_match

        # taking only 10% of histogram diff, since it's less accurate than template method
        commutative_image_diff = (img_hist_diff / 10) + img_template_diff
        return commutative_image_diff


    if __name__ == '__main__':
        compare_image = CompareImage('image1/path', 'image2/path')
        image_difference = compare_image.compare_image()
        print image_difference

un peu hors sujet mais utile est l'approche pythonique numpy . Son robuste et rapide, mais ne compare pas les pixels et pas les objets ou les données que l'image Contient (et il nécessite des images de même taille et la forme):

une approche très simple et rapide pour faire cela sans openCV et n'importe quelle bibliothèque pour la vision d'ordinateur est de normaliser les tableaux d'image par

import numpy as np
picture1 = np.random.rand(100,100)
picture2 = np.random.rand(100,100)
picture1_norm = picture1/np.sqrt(np.sum(picture1**2))
picture2_norm = picture2/np.sqrt(np.sum(picture2**2))

après avoir défini les deux images (ou matrices) vous pouvez simplement additionner sur la multiplication des images que vous aimez comparer:

1) Si vous comparez des images similaires la somme retournera 1:

In[1]: np.sum(picture1_norm**2)
Out[1]: 1.0

2) S'ils ne sont pas similaires, vous obtiendrez une valeur entre 0 et 1 (un pourcentage si vous multipliez par 100):

In[2]: np.sum(picture2_norm*picture1_norm)
Out[2]: 0.75389941124629822

s'il vous plaît noter que si vous avez des images colorées, vous devez le faire dans les 3 dimensions ou tout simplement comparer une version avec un gris. Je dois souvent comparer des quantités énormes de photos contenu arbitraire et c'est vraiment un moyen rapide de le faire.