SIFT匹配产生非常差的结果

Question

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

我正在使用OpenCV 2.4.3.

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

在每个图像中找到的SIFT关键点之间的匹配是使用FlannBased匹配器完成的,我尝试了BruteForce,但结果再次大致相同.

这是我找到的匹配示例(来自Pointing 04数据集的图像)

上图显示了我的程序找到的匹配程度有多差.只有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

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

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

我将这样做:

1. 检测角落(你已经这样做了)
2. 找到matches(你已经这样做了)
3. 尝试使用matches(不要过滤它们之前!)在两个图像之间找到单应变换findHomography(...)
4. findHomography(...)会告诉你哪些是内部因素.那是你的good_matches.