我正在尝试将图片与其他图片列表进行比较，并返回此列表中的一系列图片（如Google搜索图片），其相似度高达70％。
我在this post中获取此代码并更改我的上下文
# Load the images
img =cv2.imread(MEDIA_ROOT + "/uploads/imagerecognize/armchair.jpg")
# Convert them to grayscale
imgg =cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# SURF extraction
surf = cv2.FeatureDetector_create("SURF")
surfDescriptorExtractor = cv2.DescriptorExtractor_create("SURF")
kp = surf.detect(imgg)
kp, descritors = surfDescriptorExtractor.compute(imgg,kp)
# Setting up samples and responses for kNN
samples = np.array(descritors)
responses = np.arange(len(kp),dtype = np.float32)
# kNN training
knn = cv2.KNearest()
knn.train(samples,responses)
modelImages = [MEDIA_ROOT + "/uploads/imagerecognize/1.jpg", MEDIA_ROOT + "/uploads/imagerecognize/2.jpg", MEDIA_ROOT + "/uploads/imagerecognize/3.jpg"]
for modelImage in modelImages:
# Now loading a template image and searching for similar keypoints
template = cv2.imread(modelImage)
templateg= cv2.cvtColor(template,cv2.COLOR_BGR2GRAY)
keys = surf.detect(templateg)
keys,desc = surfDescriptorExtractor.compute(templateg, keys)
for h,des in enumerate(desc):
des = np.array(des,np.float32).reshape((1,128))
retval, results, neigh_resp, dists = knn.find_nearest(des,1)
res,dist = int(results[0][0]),dists[0][0]
if dist<0.1: # draw matched keypoints in red color
color = (0,0,255)
else: # draw unmatched in blue color
#print dist
color = (255,0,0)
#Draw matched key points on original image
x,y = kp[res].pt
center = (int(x),int(y))
cv2.circle(img,center,2,color,-1)
#Draw matched key points on template image
x,y = keys[h].pt
center = (int(x),int(y))
cv2.circle(template,center,2,color,-1)
cv2.imshow('img',img)
cv2.imshow('tm',template)
cv2.waitKey(0)
cv2.destroyAllWindows()
我的问题是，如何将图像与图像列表进行比较并获得相似的图像？有没有办法做到这一点？
答案 0 :(得分：24)
我建议你看一下图片之间地球移动器的距离（EMD）。 该度量标准给出了将标准化灰度图像转换为另一种灰度图像有多难的感觉，但可以概括为彩色图像。可以在以下论文中找到对此方法的非常好的分析：
robotics.stanford.edu/~rubner/papers/rubnerIjcv00.pdf
可以在整个图像和直方图上完成（这比整个图像方法更快）。我不确定哪种方法可以进行完整的图像比较，但是对于直方图比较，您可以使用 cv.CalcEMD2 函数。
唯一的问题是此方法没有定义相似度的百分比，而是可以过滤的距离。
我知道这不是一个完整的算法，但它仍然是它的基础，所以我希望它有所帮助。
以下是EMD原则上如何工作的恶搞。主要思想是有两个归一化矩阵（两个灰度图像除以它们的总和），并定义一个磁通矩阵，描述如何将灰色从第一个图像从一个像素移动到另一个像素以获得第二个像素（它甚至可以定义）对于非标准化的，但更难的。）
在数学术语中，流矩阵实际上是一个四维张量，它给出了从旧图像的点（i，j）到新图像的点（k，l）的流量，但如果你展平你的图像你可以将它转换为普通矩阵，只是更难阅读。
此流矩阵有三个约束：每个项应为正，每行的总和应返回相同的desitnation像素值，每列的总和应返回起始像素的值。
鉴于此，你必须最小化转换的成本，由（i，j）到（k，l）的每个流的乘积之和给出（i，j）和（k之间的距离） 1）。
单词看起来有点复杂，所以这里是测试代码。逻辑是正确的，我不确定为什么scipy solver抱怨它（你应该看看openOpt或类似的东西）：
#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)
变量res包含最小化的结果......但正如我所说，我不确定为什么它会抱怨奇异矩阵。
这个算法的唯一问题是速度不是很快，所以不可能按需执行，但你必须耐心地创建数据集并存储结果
答案 1 :(得分：10)
您正在着手解决一个大问题，即“基于内容的图像检索”或CBIR。这是一个庞大而活跃的领域。虽然有很多技术都有不同程度的成功，但还没有完成的算法或标准方法。
即使谷歌图片搜索还没有这样做（还） - 他们进行基于文本的图像搜索 - 例如，搜索页面中与您搜索的文本类似的文本。 （而且我确信他们正在努力使用CBIR;它是许多图像处理研究人员的圣杯）
如果你有一个紧迫的截止日期或者需要完成这项工作并且很快就会工作......哎呀。
以下是关于该主题的大量论文：
http://scholar.google.com/scholar?q=content+based+image+retrieval
一般来说，你需要做一些事情：
这可能涉及feature descriptors，image gists，multiple instance learning。等
答案 2 :(得分：10)
我写了一个程序，用2年前使用Python / Cython做一些非常相似的事情。后来我把它改写为Go以获得更好的性能。基本想法来自findimagedupes IIRC。
它基本上为每个图像计算“指纹”，然后比较这些指纹以匹配相似的图像。
通过将图像大小调整为160x160，将其转换为灰度，添加一些模糊，对其进行标准化，然后将其调整为16x16单色来生成指纹。最后你有256位输出：这是你的指纹。使用convert：
convert path[0] -sample 160x160! -modulate 100,0 -blur 3x99 \
-normalize -equalize -sample 16x16 -threshold 50% -monochrome mono:-
（[0]中的path[0]用于仅提取动画GIF的第一帧;如果您对此类图片不感兴趣，则可以将其删除。）
将此应用于2张图片后，您将获得2个（256位）指纹，fp1和fp2。
然后通过对这两个值进行异或并计算设置为1的位来计算这两个图像的相似性得分。为了进行这种位计数，您可以使用this answer中的bitsoncount()函数：< / p>
# fp1 and fp2 are stored as lists of 8 (32-bit) integers
score = 0
for n in range(8):
score += bitsoncount(fp1[n] ^ fp2[n])
score将是0到256之间的数字，表示您的图像有多相似。在我的应用程序中，我将其除以2.56（标准化为0-100），我发现标准化分数为20或更低的图像通常是相同的。
如果你想实现这个方法并用它来比较大量的图像，我强烈建议你尽可能多地使用Cython（或者只是普通的C）：XORing和比特计数非常慢用纯Python整数。
我真的很抱歉，但我找不到我的Python代码了。现在我只有一个Go版本，但我担心我不能在这里发布（紧密集成在其他代码中，可能有点难看，因为这是我在Go中的第一个认真的程序...）。
在GQView / Geeqie中还有一个非常好的“通过相似性找到”功能;它的来源是here。
答案 3 :(得分：1)
为了在Python中更简单地实现Earth Mover的距离（也就是Wasserstein距离），你可以使用Scipy：
from scipy.stats import wasserstein_distance
from scipy.ndimage import imread
import numpy as np
def get_histogram(img):
'''
Get the histogram of an image. For an 8-bit, grayscale image, the
histogram will be a 256 unit vector in which the nth value indicates
the percent of the pixels in the image with the given darkness level.
The histogram's values sum to 1.
'''
h, w = img.shape
hist = [0.0] * 256
for i in range(h):
for j in range(w):
hist[img[i, j]] += 1
return np.array(hist) / (h * w)
a = imread('a.jpg')
b = imread('b.jpg')
a_hist = get_histogram(a)
b_hist = get_histogram(b)
dist = wasserstein_distance(a_hist, b_hist)
print(dist)