使用OpenCV和Python比较图像的相似性
computer-vision
opencv
python
6
0

我正在尝试将一张图片与其他图片列表进行比较,并返回该列表中具有最高70%相似度的图片(例如Google搜索图片)。

我在这篇文章中获得了这段代码,并根据自己的情况进行了更改

# 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()

我的问题是,如何将图像与图像列表进行比较并仅获得相似图像?有什么方法可以做到这一点?

参考资料:
Stack Overflow
收藏
评论
共 4 个回答
高赞 时间 活跃

我建议您看一下图像之间推土机的距离(EMD)。该度量给人一种将标准化的灰度图像转换成另一幅图像有多难的感觉,但可以将其推广到彩色图像。可以在以下论文中找到对该方法的很好的分析:

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

它可以在整个图像和直方图上完成(这实际上比整个图像方法要快)。我不确定哪种方法可以对整个图像进行比较,但是对于直方图比较,可以使用cv.CalcEMD2函数。

唯一的问题是,此方法未定义相似性百分比,而是可以过滤的距离。

我知道这不是一个完整的算法,但仍然是它的基础,因此希望对您有所帮助。

编辑:

这是EMD原理上的一个欺骗。主要思想是拥有两个归一化矩阵(两个灰度图像除以它们的和),并定义一个流量矩阵,该矩阵描述了如何从第一个图像将灰度从一个像素移动到另一个像素以获得第二个图像(甚至可以定义对于非归一化,但更困难)。

用数学术语来说,流矩阵实际上是一个四维张量,它给出从旧图像的点(i,j)到新图像的点(k,l)的流,但是如果展平图像,则可以对其进行变换到普通矩阵,则很难阅读。

此流矩阵具有三个约束:每个项应为正,每行的总和应返回指定像素的相同值,每列的总和应返回起始像素的值。

鉴于此,您必须将转换成本降到最低,由(i,j)与(k,l)之间距离的每个流从(i,j)到(k,l)的乘积之和得出。

看起来有些复杂,所以这里是测试代码。逻辑是正确的,我不确定为什么scipy求解器会抱怨(您应该看一下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包含最小化的结果...但是正如我所说,我不确定为什么它抱怨奇异矩阵。

该算法的唯一问题是速度不是很快,因此无法按需执行,但是您必须耐心执行该数据集的创建并将结果存储在某处

收藏
评论

我写了一个程序,也许是在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:-

path[0] [0]中的path[0]仅用于提取动画GIF的第一帧;如果您对此类图像不感兴趣,则可以将其删除。)

将其应用于2张图像后,您将拥有2个(256位)指纹fp1fp2

然后,通过对这2个值进行XOR运算并计数设置为1的位,来计算这2个图像的相似性得分。要进行此位计数,可以使用以下答案中bitsoncount()函数:

# 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):使用纯Python整数进行XOR和位计数非常慢。

真的很抱歉,但是我找不到我的Python代码。现在我只有一个Go版本,但是我恐怕不能在这里发布它(紧密集成在其他代码中,可能有点丑陋,因为这是我在Go中的第一个认真的程序...)。

GQView / Geeqie中还有一个很好的“通过相似性查找”功能;它的来源在这里

收藏
评论

您正在处理一个巨大的问题,称为“基于内容的图像检索”或CBIR。这是一个庞大而活跃的领域。尽管有很多技术都具有不同程度的成功,但是还没有完成的算法或标准方法。

甚至Google图片搜索都无法做到这一点-还可以进行基于文本的图片搜索-例如,在页面中搜索与您搜索的文本相似的文本。 (而且我确信他们正在使用CBIR;这是许多图像处理研究人员的圣杯)

如果您的截止日期很紧迫,或者需要尽快完成工作并尽快工作...

以下是有关该主题的大量论文:

http://scholar.google.com/scholar?q=content+based+image+retrieval

通常,您需要做一些事情:

  1. 提取特征(在局部兴趣点或全局,或者以某种方式,SIFT,SURF,直方图等)
  2. 聚类/建立图像分布模型

这可能涉及特征描述符图像要点多实例学习 。等等

收藏
评论

为了在Python中更简单地实现“地球移动者的距离”(又名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)
收藏
评论
新手导航
  • 社区规范
  • 提出问题
  • 进行投票
  • 个人资料
  • 优化问题
  • 回答问题

关于我们

常见问题

内容许可

联系我们

@2020 AskGo
京ICP备20001863号