Python 使用Opencv实现图像特征检测与匹配

柔情只为你懂 2022-05-22 01:08 538阅读 0赞

-————-欢迎加入学习交流QQ群：657341423

特征检测是计算机对一张图像中最为明显的特征进行识别检测并将其勾画出来。大多数特征检测都会涉及图像的角点、边和斑点的识别、或者是物体的对称轴。
角点检测 是由Opencv的cornerHarris函数实现，其他函数参数说明如下：

  1. cv2.cornerHarris(src=gray, blockSize=9, ksize=23, k=0.04)
  2. # cornerHarris参数：
  3. # src - 数据类型为 float32 的输入图像。
  4. # blockSize - 角点检测中要考虑的领域大小。
  5. # ksize - Sobel 求导中使用的窗口大小
  6. # k - Harris 角点检测方程中的自由参数,取值参数为 [0,04,0.06].

以国际象棋为例，这是计算机视觉最为常见的分析对象，如图所示：
这里写图片描述
角点检测代码如下：

  1. import cv2
  2. import numpy as np
  4. img = cv2.imread('chess_board.png')
  5. gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  6. # cornerHarris函数图像格式为 float32 ，因此需要将图像转换 float32 类型
  7. gray = np.float32(gray)
  8. # cornerHarris参数：
  9. # src - 数据类型为 float32 的输入图像。
  10. # blockSize - 角点检测中要考虑的领域大小。
  11. # ksize - Sobel 求导中使用的窗口大小
  12. # k - Harris 角点检测方程中的自由参数,取值参数为 [0,04,0.06].
  13. dst = cv2.cornerHarris(src=gray, blockSize=9, ksize=23, k=0.04)
  14. # 变量a的阈值为0.01 * dst.max()，如果dst的图像值大于阈值，那么该图像的像素点设为True，否则为False
  15. # 将图片每个像素点根据变量a的True和False进行赋值处理，赋值处理是将图像角点勾画出来
  16. a = dst>0.01 * dst.max()
  17. img[a] = [0, 0, 255]
  18. # 显示图像
  19. while (True):
  20.   cv2.imshow('corners', img)
  21.   if cv2.waitKey(120) & 0xff == ord("q"):
  22.     break
  23.   cv2.destroyAllWindows()

运行代码，结果如图所示：
这里写图片描述

但有时候，图像的像素大小对角点存在一定的影响。比如图像越小，角点看上去趋向近似一条直线，这样很容易造成角点的丢失。如果按照上述的检测方法，会造成角点检测结果不相符，因此引入DoG和SIFT算法进行检测。Opencv的SIFT类是DoG和SIFT算法组合。
DoG是对同一图像使用不同高斯滤波器所得的结果。
SIFT是通过一个特征向量来描述关键点周围区域的情况。
我们以下图为例：
这里写图片描述

  1. import cv2
  2. # 读取图片并灰度处理
  3. imgpath = 'varese.jpg'
  4. img = cv2.imread(imgpath)
  5. gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  6. # 创建SIFT对象
  7. sift = cv2.xfeatures2d.SIFT_create()
  8. # 将图片进行SURF计算，并找出角点keypoints，keypoints是检测关键点
  9. # descriptor是描述符，这是图像一种表示方式，可以比较两个图像的关键点描述符，可作为特征匹配的一种方法。
  10. keypoints, descriptor = sift.detectAndCompute(gray, None)
  12. # cv2.drawKeypoints() 函数主要包含五个参数：
  13. # image: 原始图片
  14. # keypoints：从原图中获得的关键点，这也是画图时所用到的数据
  15. # outputimage：输出
  16. # color：颜色设置，通过修改（b,g,r）的值,更改画笔的颜色，b=蓝色，g=绿色，r=红色。
  17. # flags：绘图功能的标识设置，标识如下：
  18. # cv2.DRAW_MATCHES_FLAGS_DEFAULT  默认值
  19. # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
  20. # cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG
  21. # cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS
  22. img = cv2.drawKeypoints(image=img, outImage=img, keypoints = keypoints, flags=cv2.DRAW_MATCHES_FLAGS_DEFAULT, color = (51, 163, 236))
  24. # 显示图片
  25. cv2.imshow('sift_keypoints', img)
  26. while (True):
  27.   if cv2.waitKey(120) & 0xff == ord("q"):
  28.     break
  29. cv2.destroyAllWindows()

运行代码，结果如图所示：
这里写图片描述

除了SIFT算法检测之外，还有SURF特征检测算法，比SIFT算法快，并吸收了SIFT算法的思想。SURF采用Hessian算法检测关键点，而SURF是提取特征，这个与SIFT很像。Opencv的SURF类是Hessian算法和SURF算法组合。我们根据SIFT的代码进行修改，代码如下：

  1. import cv2
  2. # 读取图片并灰度处理
  3. imgpath = 'varese.jpg'
  4. img = cv2.imread(imgpath)
  5. gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  6. # 创建SURF对象，对象参数float(4000)为阈值，阈值越高，识别的特征越小。
  7. sift = cv2.xfeatures2d.SURF_create(float(4000))
  8. # 将图片进行SURF计算，并找出角点keypoints，keypoints是检测关键点
  9. # descriptor是描述符，这是图像一种表示方式，可以比较两个图像的关键点描述符，可作为特征匹配的一种方法。
  10. keypoints, descriptor = sift.detectAndCompute(gray, None)
  12. # cv2.drawKeypoints() 函数主要包含五个参数：
  13. # image: 原始图片
  14. # keypoints：从原图中获得的关键点，这也是画图时所用到的数据
  15. # outputimage：输出
  16. # color：颜色设置，通过修改（b,g,r）的值,更改画笔的颜色，b=蓝色，g=绿色，r=红色。
  17. # flags：绘图功能的标识设置，标识如下：
  18. # cv2.DRAW_MATCHES_FLAGS_DEFAULT  默认值
  19. # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
  20. # cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG
  21. # cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS
  22. img = cv2.drawKeypoints(image=img, outImage=img, keypoints = keypoints, flags=cv2.DRAW_MATCHES_FLAGS_DEFAULT, color = (51, 163, 236))
  24. # 显示图片
  25. cv2.imshow('sift_keypoints', img)
  26. while (True):
  27.   if cv2.waitKey(120) & 0xff == ord("q"):
  28.     break
  29. cv2.destroyAllWindows()

上述代码我们只修改sift = cv2.xfeatures2d.SURF_create(float(4000))即可实现SURF特征检测算法。运行结果如图所示：
这里写图片描述

对比SURF和SIFT算法，ORB算法更处于起步阶段，在2011年才首次发布。但比前两者的速度更快。ORB基于FAST关键点检测和BRIEF的描述符技术相结合，因此我们先了解FAST和BRIEF。
FAST：特征检测算法。
BRIEF：只是一个描述符，这是图像一种表示方式，可以比较两个图像的关键点描述符，可作为特征匹配的一种方法。
暴力匹配：比较两个描述符并产生匹配结果。
在上述的例子中，我们只是将检测的关键点进行勾画，在这例子中，将使用ORB检测关键点之外，还将两图进行匹配，匹配的图像如下：
这里写图片描述
实现方法：首先分别对两图进行ORB处理，然后将两图的关键点进行暴力匹配。具体代码如下：
# ORB算法实现特征检测+暴力匹配

  1. import numpy as np
  2. import cv2
  3. from matplotlib import pyplot as plt
  5. # 读取图片内容
  6. img1 = cv2.imread('aa.jpg',0)
  7. img2 = cv2.imread('bb.png',0)
  9. # 使用ORB特征检测器和描述符，计算关键点和描述符
  10. orb = cv2.ORB_create()
  11. kp1, des1 = orb.detectAndCompute(img1,None)
  12. kp2, des2 = orb.detectAndCompute(img2,None)
  15. # 暴力匹配BFMatcher，遍历描述符，确定描述符是否匹配，然后计算匹配距离并排序
  16. # BFMatcher函数参数：
  17. # normType：NORM_L1, NORM_L2, NORM_HAMMING, NORM_HAMMING2。
  18. # NORM_L1和NORM_L2是SIFT和SURF描述符的优先选择，NORM_HAMMING和NORM_HAMMING2是用于ORB算法
  19. bf = cv2.BFMatcher(normType=cv2.NORM_HAMMING, crossCheck=True)
  20. matches = bf.match(des1,des2)
  21. matches = sorted(matches, key = lambda x:x.distance)
  22. # matches是DMatch对象，具有以下属性：
  23. # DMatch.distance - 描述符之间的距离。 越低越好。
  24. # DMatch.trainIdx - 训练描述符中描述符的索引
  25. # DMatch.queryIdx - 查询描述符中描述符的索引
  26. # DMatch.imgIdx - 训练图像的索引。
  28. # 使用plt将两个图像的匹配结果显示出来
  29. img3 = cv2.drawMatches(img1=img1,keypoints1=kp1,img2=img2,keypoints2=kp2, matches1to2=matches, outImg=img2, flags=2)
  30. plt.imshow(img3),plt.show()

运行结果如图所示：
这里写图片描述
# SURF和SIFT算法+暴力匹配
暴力匹配BFMatcher是一种匹配方法，只要提供两个关键点即可实现匹配。若将上述例子改为SURF和SIFT算法，只需修改以下代码：

  1. 将orb = cv2.ORB_create()改为
  2. orb = cv2.xfeatures2d.SURF_create(float(4000))
  4. 将bf = cv2.BFMatcher(normType=cv2.NORM_HAMMING, crossCheck=True)改为
  5. bf = cv2.BFMatcher(normType=cv2.NORM_L1, crossCheck=True)

# 获取匹配关键点的坐标位置
在上述例子中，matches是DMatch对象，DMatch是以列表的形式表示，每个元素代表两图能匹配得上的点。如果想获取某个点的坐标位置，在上述例子添加以下代码：

  1. # 由于匹配顺序是：matches = bf.match(des1,des2)，先des1后des2。
  2. # 因此，kp1的索引由DMatch对象属性为queryIdx决定，kp2的索引由DMatch对象属性为trainIdx决定
  4. # 获取aa.jpg的关键点位置
  5. x,y = kp1[matches[0].queryIdx].pt
  6. cv2.rectangle(img1, (int(x),int(y)), (int(x) + 5, int(y) + 5), (0, 255, 0), 2)
  7. cv2.imshow('a', img1)
  9. # 获取bb.png的关键点位置
  10. x,y = kp2[matches[0].trainIdx].pt
  11. cv2.rectangle(img2, (int(x1),int(y1)), (int(x1) + 5, int(y1) + 5), (0, 255, 0), 2)
  12. cv2.imshow('b', img2)
  14. # 使用plt将两个图像的第一个匹配结果显示出来
  15. img3 = cv2.drawMatches(img1=img1,keypoints1=kp1,img2=img2,keypoints2=kp2, matches1to2=matches[:1], outImg=img2, flags=2)
  16. plt.imshow(img3),plt.show()

运行结果如图所示：
这里写图片描述

上述讲到的暴力匹配是使用BFMatcher匹配器实现的，然后由match函数实现匹配。接下来讲解K-最近邻匹配（KNN），并在BFMatcher匹配下实现。在所有机器学习的算法中，KNN可能是最为简单的算法。针对上述例子，改为KNN匹配，实现代码如下：

  1. import numpy as np
  2. import cv2
  3. from matplotlib import pyplot as plt
  5. # 读取图片内容
  6. img1 = cv2.imread('aa.jpg',0)
  7. img2 = cv2.imread('bb.png',0)
  9. # 使用ORB特征检测器和描述符，计算关键点和描述符
  10. orb = cv2.ORB_create()
  11. kp1, des1 = orb.detectAndCompute(img1,None)
  12. kp2, des2 = orb.detectAndCompute(img2,None)
  14. # 暴力匹配BFMatcher，遍历描述符，确定描述符是否匹配，然后计算匹配距离并排序
  15. # BFMatcher函数参数：
  16. # normType：NORM_L1, NORM_L2, NORM_HAMMING, NORM_HAMMING2。
  17. # NORM_L1和NORM_L2是SIFT和SURF描述符的优先选择，NORM_HAMMING和NORM_HAMMING2是用于ORB算法
  18. bf = cv2.BFMatcher(normType=cv2.NORM_HAMMING, crossCheck=True)
  19. # knnMatch 函数参数k是返回符合匹配的个数，暴力匹配match只返回最佳匹配结果。
  20. matches = bf.knnMatch(des1,des2,k=1)
  22. # 使用plt将两个图像的第一个匹配结果显示出来
  23. # 若使用knnMatch进行匹配，则需要使用drawMatchesKnn函数将结果显示
  24. img3 = cv2.drawMatchesKnn(img1=img1,keypoints1=kp1,img2=img2,keypoints2=kp2, matches1to2=matches, outImg=img2, flags=2)
  25. plt.imshow(img3),plt.show()

最后是介绍FLANN匹配，相对暴力匹配BFMatcher来讲，这匹配算法比较准确、快速和使用方便。FLANN具有一种内部机制，可以根据数据本身选择最合适的算法来处理数据集。值得注意的是，FLANN匹配器只能使用SURF和SIFT算法。
FLANN实现方式如下：

  1. import numpy as np
  2. import cv2
  3. from matplotlib import pyplot as plt
  5. queryImage = cv2.imread('aa.jpg',0)
  6. trainingImage = cv2.imread('bb.png',0)
  8. # 只使用SIFT 或 SURF 检测角点
  9. sift = cv2.xfeatures2d.SIFT_create()
  10. # sift = cv2.xfeatures2d.SURF_create(float(4000))
  11. kp1, des1 = sift.detectAndCompute(queryImage,None)
  12. kp2, des2 = sift.detectAndCompute(trainingImage,None)
  14. # 设置FLANN匹配器参数
  15. # algorithm设置可参考https://docs.opencv.org/3.1.0/dc/d8c/namespacecvflann.html
  16. indexParams = dict(algorithm=0, trees=5)
  17. searchParams = dict(checks=50)
  18. # 定义FLANN匹配器
  19. flann = cv2.FlannBasedMatcher(indexParams,searchParams)
  20. # 使用 KNN 算法实现匹配
  21. matches = flann.knnMatch(des1,des2,k=2)
  23. # 根据matches生成相同长度的matchesMask列表，列表元素为[0,0]
  24. matchesMask = [[0,0] for i in range(len(matches))]
  26. # 去除错误匹配
  27. for i,(m,n) in enumerate(matches):
  28.     if m.distance < 0.7*n.distance:
  29.         matchesMask[i] = [1,0]
  31. # 将图像显示
  32. # matchColor是两图的匹配连接线，连接线与matchesMask相关
  33. # singlePointColor是勾画关键点
  34. drawParams = dict(matchColor = (0,255,0),
  35.                    singlePointColor = (255,0,0),
  36.                    matchesMask = matchesMask,
  37.                    flags = 0)
  38. resultImage = cv2.drawMatchesKnn(queryImage,kp1,trainingImage,kp2,matches,None,**drawParams)
  39. plt.imshow(resultImage,),plt.show()

运行结果如图所示：
这里写图片描述

FLANN的单应性匹配，单应性是一个条件，该条件表面当两幅图像中的一副出像投影畸变时，他们还能匹配。FLANN的单应性实现代码如下：

  1. import numpy as np
  2. import cv2
  3. from matplotlib import pyplot as plt
  5. MIN_MATCH_COUNT = 10
  7. img1 = cv2.imread('tattoo_seed.jpg',0)
  8. img2 = cv2.imread('hush.jpg',0)
  10. # 使用SIFT检测角点
  11. sift = cv2.xfeatures2d.SIFT_create()
  12. # 获取关键点和描述符
  13. kp1, des1 = sift.detectAndCompute(img1,None)
  14. kp2, des2 = sift.detectAndCompute(img2,None)
  16. # 定义FLANN匹配器
  17. index_params = dict(algorithm = 1, trees = 5)
  18. search_params = dict(checks = 50)
  19. flann = cv2.FlannBasedMatcher(index_params, search_params)
  20. # 使用KNN算法匹配
  21. matches = flann.knnMatch(des1,des2,k=2)
  23. # 去除错误匹配
  24. good = []
  25. for m,n in matches:
  26.     if m.distance < 0.7*n.distance:
  27.         good.append(m)
  29. # 单应性
  30. if len(good)>MIN_MATCH_COUNT:
  31.     # 改变数组的表现形式，不改变数据内容，数据内容是每个关键点的坐标位置
  32.     src_pts = np.float32([ kp1[m.queryIdx].pt for m in good ]).reshape(-1,1,2)
  33.     dst_pts = np.float32([ kp2[m.trainIdx].pt for m in good ]).reshape(-1,1,2)
  34.     # findHomography 函数是计算变换矩阵
  35.     # 参数cv2.RANSAC是使用RANSAC算法寻找一个最佳单应性矩阵H，即返回值M
  36.     # 返回值：M 为变换矩阵，mask是掩模
  37.     M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC,5.0)
  38.     # ravel方法将数据降维处理，最后并转换成列表格式
  39.     matchesMask = mask.ravel().tolist()
  40.     # 获取img1的图像尺寸
  41.     h,w = img1.shape
  42.     # pts是图像img1的四个顶点
  43.     pts = np.float32([[0,0],[0,h-1],[w-1,h-1],[w-1,0]]).reshape(-1,1,2)
  44.     # 计算变换后的四个顶点坐标位置
  45.     dst = cv2.perspectiveTransform(pts,M)
  47.     # 根据四个顶点坐标位置在img2图像画出变换后的边框
  48.     img2 = cv2.polylines(img2,[np.int32(dst)],True,(255,0,0),3, cv2.LINE_AA)
  50. else:
  51.     print("Not enough matches are found - %d/%d") % (len(good),MIN_MATCH_COUNT)
  52.     matchesMask = None
  54. # 显示匹配结果
  55. draw_params = dict(matchColor = (0,255,0), # draw matches in green color
  56.                    singlePointColor = None,
  57.                    matchesMask = matchesMask, # draw only inliers
  58.                    flags = 2)
  59. img3 = cv2.drawMatches(img1,kp1,img2,kp2,good,None,**draw_params)
  60. plt.imshow(img3, 'gray'),plt.show()

运行结果如下所示：
这里写图片描述

单应性实际应用
从上述的例子可以看到，单应性是在两图片匹配的时候，其中某一图片发生变换处理，变换后图像会呈现一种立体空间的视觉效果，图像发生变换程度称为变换矩阵。以下例子将图像中的书本替换成其他书本，例子中所使用图片如下：
70 10
这里写图片描述
这里写图片描述
我们根据图1和图2计算变换矩阵，然后通过变换矩阵将图3进行变换，最后将图3加入到图1中，实现图片替换。实现代码如下：

  1. import numpy as np
  2. import cv2
  3. from matplotlib import pyplot as plt
  5. img1 = cv2.imread('logo.jpg',0)
  6. img2 = cv2.imread('book.jpg',0)
  8. # 使用SIFT检测角点
  9. sift = cv2.xfeatures2d.SIFT_create()
  10. # 获取关键点和描述符
  11. kp1, des1 = sift.detectAndCompute(img1,None)
  12. kp2, des2 = sift.detectAndCompute(img2,None)
  14. # 定义FLANN匹配器
  15. index_params = dict(algorithm = 1, trees = 5)
  16. search_params = dict(checks = 50)
  17. flann = cv2.FlannBasedMatcher(index_params, search_params)
  18. # 使用KNN算法匹配
  19. matches = flann.knnMatch(des1,des2,k=2)
  21. # 去除错误匹配
  22. good = []
  23. for m,n in matches:
  24.     if m.distance < 0.7*n.distance:
  25.         good.append(m)
  27. # 单应性实际应用
  28. # 改变数组的表现形式，不改变数据内容，数据内容是每个关键点的坐标位置
  29. src_pts = np.float32([ kp1[m.queryIdx].pt for m in good ]).reshape(-1,1,2)
  30. dst_pts = np.float32([ kp2[m.trainIdx].pt for m in good ]).reshape(-1,1,2)
  31. # findHomography 函数是计算变换矩阵
  32. # 参数cv2.RANSAC是使用RANSAC算法寻找一个最佳单应性矩阵H，即返回值M
  33. # 返回值：M 为变换矩阵，mask是掩模
  34. M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC,5.0)
  35. # 获取img1的图像尺寸
  36. h,w = img1.shape
  37. # pts是图像img1的四个顶点
  38. pts = np.float32([[0,0],[0,h-1],[w-1,h-1],[w-1,0]]).reshape(-1,1,2)
  39. # 计算变换后的四个顶点坐标位置
  40. dst = cv2.perspectiveTransform(pts,M)
  42. # 图片替换
  43. img3 = cv2.imread('aa.png',0)
  44. # 降维处理
  45. b = np.int32(dst).reshape(4, 2)
  46. x,y = img2.shape
  47. # 根据变换矩阵将图像img3进行变换处理
  48. res = cv2.warpPerspective(img3, M, (y,x))
  49. img_temp = img2.copy()
  50. # 将图像img2的替换区域进行填充处理
  51. cv2.fillConvexPoly(img_temp, b, 0)
  52. # 将变换后的img3图像替换到图像img2
  53. cv2.imshow('bb',img_temp)
  54. res = img_temp + res
  55. cv2.imshow('aa',res)
  56. plt.imshow(res),plt.show()

运行结果如图所示：
这里写图片描述
从结果可以看到，替换后的图像周边出现黑色线条，这是正常的现象。在上图最左边的图bb可以看到，黑色区域是由图1和图2检测匹配所得的结果，如果匹配结果会存在一定的误差，这个误差是由多个因素所导致的。

在实际中，我们根据一张图片在众多的图片中查找匹配率最高的图片。如果按照上面的例子，也可以实现，但每次匹配时都需要重新检测图片的特征数据，这样会导致程序运行效率。因此，我们可以将图片的特征数据进行保存，每次匹配时，只需读取特征数据进行匹配即可。我们以下图为例：
这里写图片描述
这里写图片描述
我们根据图1在图2中查找最佳匹配的图片。首先获取图2的全部图片的特征数据，将代码保存在features.py：

  1. import cv2
  2. import numpy as np
  3. from os import walk
  4. from os.path import join
  6. def create_descriptors(folder):
  7.     files = []
  8.     for (dirpath, dirnames, filenames) in walk(folder):
  9.         files.extend(filenames)
  10.     for f in files:
  11.         if '.jpg' in f:
  12.             save_descriptor(folder, f, cv2.xfeatures2d.SIFT_create())
  14. def save_descriptor(folder, image_path, feature_detector):
  15.     # 判断图片是否为npy格式
  16.     if image_path.endswith("npy"):
  17.         return
  18.     # 读取图片并检查特征
  19.     img = cv2.imread(join(folder,image_path), 0)
  20.     keypoints, descriptors = feature_detector.detectAndCompute(img, None)
  21.     # 设置文件名并将特征数据保存到npy文件
  22.     descriptor_file = image_path.replace("jpg", "npy")
  23.     np.save(join(folder, descriptor_file), descriptors)
  25. if __name__=='__main__':
  26.     path = 'E:\\anchors'
  27.     create_descriptors(path)

运行代码，结果如图所示：
这里写图片描述
我们将图片的特征数据保存在npy文件。下一步是根据图1与这些特征数据文件进行匹配，从而找出最佳匹配的图片。代码存在matching.py：

  1. from os.path import join
  2. from os import walk
  3. import numpy as np
  4. import cv2
  6. query = cv2.imread('tattoo_seed.jpg', 0)
  7. folder = 'E:\\anchors'
  8. descriptors = []
  9. # 获取特征数据文件名
  10. for (dirpath, dirnames, filenames) in walk(folder):
  11.     for f in filenames:
  12.         if f.endswith("npy"):
  13.             descriptors.append(f)
  14.     print(descriptors)
  16. # 使用SIFT算法检查图像的关键点和描述符
  17. sift = cv2.xfeatures2d.SIFT_create()
  18. query_kp, query_ds = sift.detectAndCompute(query, None)
  20. # 创建FLANN匹配器
  21. index_params = dict(algorithm=0, trees=5)
  22. search_params = dict(checks=50)
  23. flann = cv2.FlannBasedMatcher(index_params, search_params)
  25. potential_culprits = {}
  26. for d in descriptors:
  27.     # 将图像query与特征数据文件的数据进行匹配
  28.     matches = flann.knnMatch(query_ds, np.load(join(folder, d)), k=2)
  29.     # 清除错误匹配
  30.     good = []
  31.     for m, n in matches:
  32.         if m.distance < 0.7 * n.distance:
  33.             good.append(m)
  34.     # 输出每张图片与目标图片的匹配数目
  35.     print("img is %s ! matching rate is (%d)" % (d, len(good)))
  36.     potential_culprits[d] = len(good)
  38. # 获取最多匹配数目的图片
  39. max_matches = None
  40. potential_suspect = None
  41. for culprit, matches in potential_culprits.items():
  42.     if max_matches == None or matches > max_matches:
  43.         max_matches = matches
  44.         potential_suspect = culprit
  46. print("potential suspect is %s" % potential_suspect.replace("npy", "").upper())

代码运行后，输出结果如图所示：
这里写图片描述
从输出的结果可以看到，图1与图2的hush.jpg最为匹配，如图所示：
这里写图片描述

发表评论

表情：
评论列表 （有 0 条评论，538人围观）

还没有评论，来说两句吧...

相关阅读