2

我试图找到 2 个图像之间的基本矩阵，然后使用 RANSAC 对其进行转换。我首先使用 SIFT 检测关键点，然后应用 RANSAC：

img1 = cv2.imread("im0.png", 0) # queryImage
img2 = cv2.imread("im1.png", 0)  # trainImage

    # Initiate SIFT detector
sift = sift = cv2.xfeatures2d.SIFT_create()

    # find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)

src = np.float32([points.pt for points in kp1]).reshape(-1, 1, 2)
dst = np.float32([points.pt for points in kp2]).reshape(-1, 1, 2)

H, masked = cv2.findHomography(src, dst, cv2.RANSAC, 5.0)

但是，当我尝试执行此操作时，我只收到如下所示的错误：

Traceback (most recent call last):
File "sift2.py", line 29, in <module>
M, mask = cv2.findHomography(src, dst, cv2.RANSAC, 5.0)
cv2.error: /tmp/opencv3-20161119-29160-138ov36/modules/calib3d/src/fundam.cpp:349: error: (-215) src.checkVector(2) == dst.checkVector(2) in function findHomography

而当我按照此链接中的教程进行操作时：http: //docs.opencv.org/3.0-beta/doc/py_tutorials/py_feature2d/py_feature_homography/py_feature_homography.html，代码运行没有错误。

任何帮助表示赞赏！

4

1 回答 1

1

你没有注意或不理解他们在解释什么。我建议您阅读完整的教程。您从未将 SIFT 在一张图像中找到的关键点与 SIFT 在第二张图像中找到的关键点进行匹配。

import cv2
import numpy as np
#import matplotlib.pyplot as plt

#explicit is better than implicit cv2.IMREAD_GRAYSCALE is better than 0
img1 = cv2.imread("img0.png", cv2.IMREAD_GRAYSCALE) # queryImage
img2 = cv2.imread("img1.png", cv2.IMREAD_GRAYSCALE)  # trainImage
#CV doesn't hold hands, do the checks.
if (img1 is None) or (img2 is None):
    raise IOError("No files {0} and {1} found".format("img0.png", "img1.png"))

# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create() 

kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)

确保像检查图像一样检查 SIFT。特别是如果你打算用它来编写一个应用程序，因为在旧的 cv 版本中它是cv2.SIFT().

现在你的问题的症结在于 SIFT 只找到整洁的关键点及其描述符。它们不会自动与第二张图像进行比较。我们需要自己做。SIFT 的真正作用在本教程中得到了很好的解释。如有疑问，请抽签！或打印。SIFT 实际给出的结果应该是相当明显的。matplotlib在脚本开始时取消注释导入。

tmp1 = cv2.drawKeypoints(img1, kp1)
tmp2 = cv2.drawKeypoints(img2, kp2)
plt.imshow(tmp1)
plt.show()
plt.imshow(tmp2)
plt.show()

这是实际比较图像的部分。它遍历关键点并根据一些距离计算比较最近的 k (2) 个邻居的描述符。技术细节有点模糊，但在本教程中解释得很清楚。这是您的示例中没有的部分。

index_params = dict(algorithm = 0, trees = 5)
search_params = dict(checks = 50)
flann = cv2.FlannBasedMatcher(index_params, search_params)

matches = flann.knnMatch(des1, des2, k=2)
matches = np.asarray(matches)

现在我们可以在两个图像中创建点列表并计算透视变换。再说一遍，CV 不会照看孩子，如果没有至少 4 分，就无法找到视角 - 进行检查并为自己提出比 CV 做得更好的错误。未来的自己会心存感激。匹配项作为元组列表返回[(a,aa), (b,bb)...]，我们只想要单个字母（关键点），将列表转换为 numpy 数组并使用切片比在他们的示例中使用 for 循环更快（我猜，在怀疑 - 测试）。

if len(matches[:,0]) >= 4:
    src = np.float32([ kp1[m.queryIdx].pt for m in matches[:,0] ]).reshape(-1,1,2)
    dst = np.float32([ kp2[m.trainIdx].pt for m in matches[:,0] ]).reshape(-1,1,2)

    H, masked = cv2.findHomography(src, dst, cv2.RANSAC, 5.0)
else:
    raise AssertionError("Can't find enough keypoints.")

这适用于他们在 OpenCv 2.4.9 中的示例图像，我希望它可以直接转移到 CV3，但我无法检查。对于他们的示例谷物图像，我得到：

>>> H
array([[  4.71257834e-01,  -1.93882419e-01,   1.18225742e+02],
       [  2.47062711e-02,   3.79364095e-01,   1.60925457e+02],
       [ -1.21517456e-04,  -4.95488261e-04,   1.00000000e+00]])

这似乎在合理范围内。

已发布评论的答案，不能放在另一条评论中。

他们做的事情和我们一样，只是更明确一点。要查看会发生什么，您需要密切注意发布链接中的以下几行：

  • 第 244-255 行定义了可用算法的名称
  • 第 281-284 行选择检测器、描述符和匹配器算法
  • 第 289-291 行实例化检测器、描述符和匹配器算法
  • 在第 315 行找到第一个图像关键点
  • 在第 316 行计算第一个图像关键点描述符
  • 在第 328 行找到第二个图像关键点
  • 在第 329 行计算第二个图像关键点描述符
  • 在第 330 行，匹配第一和第二图像关键点和描述符
  • 然后完成一些透视变换

我们做同样的事情 -> 首先我们找到关键点并计算它们的描述符，然后我们匹配它们。他们找到关键点，然后计算描述符（2 行），但在 python 中，该ALG.detectAndCompute方法已经返回关键点和描述符，因此不需要像他们那样进行单独的调用。检查一下，在第一次循环迭代中，i=0这意味着i*4+n = n你有：

 static const char* ddms[] =
 {
    "ORBX_BF", "ORB", "ORB", "BruteForce-Hamming",
    // 0         1      2          3
    //shortened for brevity
      0
    //4
    ....

意思就是

const char* name = ddms[i*4];               // --> ORBX_BF
const char* detector_name = ddms[i*4+1];    // --> ORB
const char* descriptor_name = ddms[i*4+2];  // --> ORB
const char* matcher_name = ddms[i*4+3];     // --> BruteForce_Hamming

..... // shortened

Ptr<FeatureDetector> detector = FeatureDetector::create(detector_name);
Ptr<DescriptorExtractor> descriptor = DescriptorExtractor::create(descriptor_name);
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(matcher_name);

在python中对应于

orb = cv2.ORB_create()
detector = orb.detect    # the pythonic way would be to just call 
descriptor = orb.compute # orb.detectAndCompute
matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)

所以他们做了和我做的所有相同的步骤，这就是示例所做的，除了他们使用 ORB 检测器和描述符计算器以及 BruteForceMatcher 和规范的汉明作为距离测量。请参阅ORB 教程和BFMatcher 教程。

我只是将 SIFT 检测器和描述符计算器与 FlannBasedMatcher 一起使用，这是唯一的区别。所有其他步骤都相同。

于 2017-03-02T04:34:34.013 回答