Question

我正在开展一个项目，我将使用单应性作为分类器中的功能。我的问题在于自动计算单应性，我使用SIFT描述符来找到两个图像之间的点，在这两个图像上计算单应性，但SIFT给我的结果很差，因此我不能在我的工作中使用它们。

我正在使用OpenCV 2.4.3。

起初我使用的是SURF，但我有类似的结果，我决定使用速度较慢但更精确的SIFT。我的第一个猜测是我的数据集中的图像分辨率太低但我在最先进的数据集上运行我的算法（指向04）并且我获得了几乎相同的结果，所以问题在于我做什么而不是我的数据集。

每个图像中找到的SIFT关键点之间的匹配是使用FlannBased匹配器完成的，我尝试了BruteForce，但结果几乎完全相同。

这是我找到的匹配示例（来自Pointing 04数据集的图像） Matches of my algorithm

上图显示了我的程序找到的匹配程度有多差。只有1分是正确的匹配。我需要（至少）4次正确匹配我必须做的事情。

以下是我使用的代码：

这是从每个图像中提取SIFT描述符的函数

void extract_sift(const Mat &img, vector<KeyPoint> &keypoints, Mat &descriptors, Rect* face_rec) {

        // Create masks for ROI on the original image
    Mat mask1 = Mat::zeros(img.size(), CV_8U);  // type of mask is CV_8U

    Mat roi1(mask1, *face_rec);
    roi1 = Scalar(255, 255, 255);

    // Extracts keypoints in ROIs only
    Ptr<DescriptorExtractor> featExtractor;
    Ptr<FeatureDetector> featDetector;
    Ptr<DescriptorMatcher> featMatcher;

    featExtractor = new SIFT(); 
    featDetector = FeatureDetector::create("SIFT"); 

    featDetector->detect(img,keypoints,mask1); 
    featExtractor->compute(img,keypoints,descriptors); 

}

这是匹配两个图像描述符

的函数

void match_sift(const Mat &img1, const Mat &img2, const vector<KeyPoint> &kp1,
            const vector<KeyPoint> &kp2, const Mat &descriptors1, const Mat &descriptors2,
            vector<Point2f> &p_im1, vector<Point2f> &p_im2) {

//  Matching descriptor vectors using FLANN matcher
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
std::vector< DMatch > matches;
matcher->match( descriptors1, descriptors2, matches );

double max_dist = 0; double min_dist = 100;

// Quick calculation of max and min distances between keypoints
for( int i = 0; i < descriptors1.rows; ++i ){
    double dist = matches[i].distance;
    if( dist < min_dist ) min_dist = dist;
    if( dist > max_dist ) max_dist = dist;
 }

 // Draw only the 4 best matches
 std::vector< DMatch > good_matches;

 // XXX: DMatch has no sort method, maybe a more efficent min extraction algorithm can be used here?
 double min=matches[0].distance;
 int min_i = 0;
 for( int i = 0; i < (matches.size()>4?4:matches.size()); ++i ) {
     for(int j=0;j<matches.size();++j)
         if(matches[j].distance < min) {
            min = matches[j].distance;
            min_i = j;
         }
    good_matches.push_back( matches[min_i]);
    matches.erase(matches.begin() + min_i);
    min=matches[0].distance;
    min_i = 0;
 }

  Mat img_matches;
  drawMatches( img1, kp1, img2, kp2,
               good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
               vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
  imwrite("imgMatch.jpeg",img_matches);
  imshow("",img_matches);
  waitKey();

  for( int i = 0; i < good_matches.size(); i++ )
  {
    // Get the points from the best matches
    p_im1.push_back( kp1[ good_matches[i].queryIdx ].pt );
    p_im2.push_back( kp2[ good_matches[i].trainIdx ].pt );
  }
}

这些函数在这里调用：

extract_sift(dataset[i].img,dataset[i].keypoints,dataset[i].descriptors,face_rec);

[...]

//  Extract keypoints from i+1 image and calculate homography
    extract_sift(dataset[i+1].img,dataset[i+1].keypoints,dataset[i+1].descriptors,face_rec);
    dataset[front].points_r.clear(); // XXX: dunno if clearing the points every time is the best way to do it..
    match_sift(dataset[front].img,dataset[i+1].img,dataset[front].keypoints,dataset[i+1].keypoints,
        dataset[front].descriptors,dataset[i+1].descriptors,dataset[front].points_r,dataset[i+1].points_r);

    dataset[i+1].H = findHomography(dataset[front].points_r,dataset[i+1].points_r, RANSAC);

非常感谢任何有关如何提高匹配性能的帮助。

Answer 1

您显然在代码中使用了“最佳四点”w.r.t.比赛的距离。换句话说，如果两个描述符非常相似，则认为匹配有效。我认为这是错误的。你试图画出所有的比赛吗？其中许多应该是错的，但许多也应该是好的。

匹配的距离只是说明两个点的相似程度。这并不能说明匹配是否是几何相干的。选择最佳匹配应该考虑几何。

我将如何做：

检测角落（您已经这样做了）
找到matches（您已经这样做了）
使用matches

findHomography(...)

findHomography(...)会告诉您哪些是内部因素。这些是你的good_matches。

SIFT匹配产生非常差的结果

1 个答案: