Comparer la similarité des images à l'aide d'OpenCV avec Python

Je vous suggère de prendre un coup d'oeil à la terre de déménageur à distance (EMD) entre les images.
Cette métrique donne un sentiment sur la façon dont il est difficile de transformer un normalisée en niveaux de gris de l'image en une autre, mais peut être généralisée pour les images en couleur. Une très bonne analyse de cette méthode peut être trouvée dans le document suivant:

robotics.stanford.edu/~rubner/documents/rubnerIjcv00.pdf

Il peut être fait à la fois sur l'ensemble de l'image et sur l'histogramme (qui est vraiment plus rapide que l'ensemble de la méthode de l'image). Je ne suis pas sûr de la méthode permettant une image de comparaison, mais pour l'histogramme de comparaison, vous pouvez utiliser le cv.CalcEMD2 fonction.

Le seul problème est que cette méthode ne permet pas de définir un pourcentage de similitude, mais une distance que vous pouvez filtrer sur.

Je sais que ce n'est pas un travail complet de l'algorithme, mais c'est toujours une base, donc j'espère que cela aide.

EDIT:

Voici une parodie de la façon dont les EMD fonctionne selon le principe d'. L'idée principale est d'avoir deux normalisé matrices (deux images en niveaux de gris, divisée par la somme), et la définition d'un flux de matrice qui décrivent la façon dont vous déplacez le gris d'un pixel à l'autre à partir de la première image pour obtenir la deuxième (il peut être défini, même pour les non normalisé un, mais il est plus difficile).

En termes mathématiques la matrice de flux est en fait un quadridimensional tenseur qui donne le flux à partir du point (i,j) de la vieille image du point (k,l) de la nouvelle, mais si vous aplatir vos images, vous pouvez le transformer en une matrice normale, juste un peu plus dur à lire.

Cette matrice de Flux a trois contraintes: chaque terme devrait être positif, de la somme de chaque ligne doit retourner la même valeur de la desitnation pixel et la somme de chaque colonne doit retourner la valeur du pixel de départ.

Compte tenu de ce que vous avez à minimiser le coût de la transformation, donné par la somme des produits de chaque flux de (i,j) (k,l) pour la distance entre (i,j) et (k,l).

Ça a l'air un peu compliqué dans les mots, voici donc le code de test. La logique est correcte, je ne suis pas sûr pourquoi, la scipy solveur se plaint à ce sujet (vous devriez peut-être regarder à openOpt ou quelque chose de similaire):

#original data, two 2x2 images, normalized
x = rand(2,2)
x/=sum(x)
y = rand(2,2)
y/=sum(y)
#initial guess of the flux matrix
# just the product of the image x as row for the image y as column
#This is a working flux, but is not an optimal one
F = (y.flatten()*x.flatten().reshape((y.size,-1))).flatten()
#distance matrix, based on euclidean distance
row_x,col_x = meshgrid(range(x.shape[0]),range(x.shape[1]))
row_y,col_y = meshgrid(range(y.shape[0]),range(y.shape[1]))
rows = ((row_x.flatten().reshape((row_x.size,-1)) - row_y.flatten().reshape((-1,row_x.size)))**2)
cols = ((col_x.flatten().reshape((row_x.size,-1)) - col_y.flatten().reshape((-1,row_x.size)))**2)
D = np.sqrt(rows+cols)
D = D.flatten()
x = x.flatten()
y = y.flatten()
#COST=sum(F*D)
#cost function
fun = lambda F: sum(F*D)
jac = lambda F: D
#array of constraint
#the constraint of sum one is implicit given the later constraints
cons  = []
#each row and columns should sum to the value of the start and destination array
cons += [ {'type': 'eq', 'fun': lambda F:  sum(F.reshape((x.size,y.size))[i,:])-x[i]}     for i in range(x.size) ]
cons += [ {'type': 'eq', 'fun': lambda F:  sum(F.reshape((x.size,y.size))[:,i])-y[i]} for i in range(y.size) ]
#the values of F should be positive
bnds = (0, None)*F.size
from scipy.optimize import minimize
res = minimize(fun=fun, x0=F, method='SLSQP', jac=jac, bounds=bnds, constraints=cons)

la variable res contient le résultat de la minimisation...mais comme je l'ai dit je ne suis pas sûr pourquoi elle se plaint d'une matrice singulière.

Le seul problème de cet algorithme est qu'il est pas très rapide, il n'est donc pas possible de le faire sur demande, mais vous avez à effectuer avec patience sur la création de la base de données et de les stocker quelque part les résultats

Vous vous embarquez sur un problème de masse, dénommé "content based image retrieval", ou CBIR. C'est un énorme et champ actif. Il n'y a pas terminé les algorithmes ou les approches standard et pourtant, bien qu'il existe beaucoup de techniques de tous avec plus ou moins de succès.

Même recherche d'images de Google de ne pas le faire (pour l'instant) - ils n'texte-image basée sur la recherche - par exemple, rechercher du texte dans une page, comme le texte recherché. (Et je suis sûr qu'ils sont de travail sur l'utilisation de CBIR; c'est le saint graal pour beaucoup de traitement d'image chercheurs)

Si vous disposez d'un délai serré ou besoin d'obtenir ce fait et de travail bientôt... aïe.

Voici une tonne de papiers sur le sujet:

http://scholar.google.com/scholar?q=content+base+image+récupération

Généralement vous aurez besoin de faire quelques petites choses:

1. Extrait de fonctionnalités (que ce soit au local de points d'intérêt, ou à l'échelle mondiale, ou en quelque sorte, SIFT, SURF, histogrammes, etc.)
2. Cluster /construire un modèle de l'image distributions

Cela peut impliquer fonction des descripteurs, image gist, plusieurs instances d'apprentissage. etc.