web-dev-qa-db-ja.com

OpenCVを使用した特徴点のマッチングの改善

ステレオ画像の特徴点を一致させたい。すでにさまざまなアルゴリズムを使用して特徴点を見つけて抽出しましたが、今では適切なマッチングが必要です。この場合、検出と抽出にFASTアルゴリズムを使用し、特徴点のマッチングにBruteForceMatcherを使用しています。

一致するコード：

vector< vector<DMatch> > matches;
//using either FLANN or BruteForce
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(algorithmName);
matcher->knnMatch( descriptors_1, descriptors_2, matches, 1 );

//just some temporarily code to have the right data structure
vector< DMatch > good_matches2;
good_matches2.reserve(matches.size());  
for (size_t i = 0; i < matches.size(); ++i)
{ 
    good_matches2.Push_back(matches[i][0]);     
}

間違った一致がたくさんあるので、最小距離と最大距離を計算し、あまりにも悪い一致をすべて削除します。

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

//find the "good" matches
vector< DMatch > good_matches;
for( int i = 0; i < descriptors_1.rows; i++ )
{
    if( good_matches2[i].distance <= 5*min_dist )
    {
        good_matches.Push_back( good_matches2[i]); 
    }
}

問題は、多くの誤った一致を取得するか、いくつかの正しい一致のみを取得することです（以下の画像を参照）。

many matches with bad results
（ソース： codemax.de ）

only a few good matches
（ソース： codemax.de ）

それはプログラミングの問題ではなく、むしろ一致するものだと思います。私が理解している限り、BruteForceMatcherは（FeatureExtractorに格納されている）特徴点の視覚距離のみを考慮し、私の場合は重要なローカル距離（x＆y位置）を考慮します。も。この問題の経験やマッチング結果を改善するための良いアイデアはありますか？

[〜＃〜] edit [〜＃〜]

コードを変更し、50のベストマッチが得られるようにしました。この後、指定されたエリアにあるかどうかを確認するために最初の一致を調べます。そうでない場合は、指定されたエリア内で一致が見つかるまで次の一致を取得します。

vector< vector<DMatch> > matches;
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(algorithmName);
matcher->knnMatch( descriptors_1, descriptors_2, matches, 50 );

//look if the match is inside a defined area of the image
double tresholdDist = 0.25 * sqrt(double(leftImageGrey.size().height*leftImageGrey.size().height + leftImageGrey.size().width*leftImageGrey.size().width));

vector< DMatch > good_matches2;
good_matches2.reserve(matches.size());  
for (size_t i = 0; i < matches.size(); ++i)
{ 
    for (int j = 0; j < matches[i].size(); j++)
    {
    //calculate local distance for each possible match
    Point2f from = keypoints_1[matches[i][j].queryIdx].pt;
    Point2f to = keypoints_2[matches[i][j].trainIdx].pt;        
    double dist = sqrt((from.x - to.x) * (from.x - to.x) + (from.y - to.y) * (from.y - to.y));
    //save as best match if local distance is in specified area
    if (dist < tresholdDist)
    {
        good_matches2.Push_back(matches[i][j]);
        j = matches[i].size();
    }
}

これ以上一致するものはないと思いますが、これにより、さらに誤った一致を削除することができます。

less but better features
（ソース： codemax.de ）

c++opencvmatchingfeature-detection
27
filla2003

すべての特徴検出アルゴリズムを比較することで、適切な組み合わせが見つかり、より多くの一致が得られました。現在、機能の検出にはFAST、機能の抽出にはSIFT、マッチングにはBruteForceを使用しています。チェックと組み合わせて、一致が定義された領域内にあるかどうか、私は多くの一致を取得します、画像を参照してください：

a lot of good matches with FAST and SIFT
（ソース： codemax.de ）

関連するコード：

Ptr<FeatureDetector> detector;
detector = new DynamicAdaptedFeatureDetector ( new FastAdjuster(10,true), 5000, 10000, 10);
detector->detect(leftImageGrey, keypoints_1);
detector->detect(rightImageGrey, keypoints_2);

Ptr<DescriptorExtractor> extractor = DescriptorExtractor::create("SIFT");
extractor->compute( leftImageGrey, keypoints_1, descriptors_1 );
extractor->compute( rightImageGrey, keypoints_2, descriptors_2 );

vector< vector<DMatch> > matches;
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce");
matcher->knnMatch( descriptors_1, descriptors_2, matches, 500 );

//look whether the match is inside a defined area of the image
//only 25% of maximum of possible distance
double tresholdDist = 0.25 * sqrt(double(leftImageGrey.size().height*leftImageGrey.size().height + leftImageGrey.size().width*leftImageGrey.size().width));

vector< DMatch > good_matches2;
good_matches2.reserve(matches.size());  
for (size_t i = 0; i < matches.size(); ++i)
{ 
    for (int j = 0; j < matches[i].size(); j++)
    {
        Point2f from = keypoints_1[matches[i][j].queryIdx].pt;
        Point2f to = keypoints_2[matches[i][j].trainIdx].pt;

        //calculate local distance for each possible match
        double dist = sqrt((from.x - to.x) * (from.x - to.x) + (from.y - to.y) * (from.y - to.y));

        //save as best match if local distance is in specified area and on same height
        if (dist < tresholdDist && abs(from.y-to.y)<5)
        {
            good_matches2.Push_back(matches[i][j]);
            j = matches[i].size();
        }
    }
}
24
filla2003

高品質の特徴一致を決定する別の方法は、David Loweが [〜＃〜] sift [〜＃〜] （説明については20ページ）の論文で提案した比率テストです。このテストでは、最良一致と2番目に一致するものの比率を計算することにより、不十分な一致を拒否します。比率がしきい値を下回る場合、一致は低品質であるとして破棄されます。

std::vector<std::vector<cv::DMatch>> matches;
cv::BFMatcher matcher;
matcher.knnMatch(descriptors_1, descriptors_2, matches, 2);  // Find two nearest matches
vector<cv::DMatch> good_matches;
for (int i = 0; i < matches.size(); ++i)
{
    const float ratio = 0.8; // As in Lowe's paper; can be tuned
    if (matches[i][0].distance < ratio * matches[i][1].distance)
    {
        good_matches.Push_back(matches[i][0]);
    }
}
27
Aurelius

比率テストに加えて、次のことができます。

対称一致のみを使用します。

void symmetryTest(const std::vector<cv::DMatch> &matches1,const std::vector<cv::DMatch> &matches2,std::vector<cv::DMatch>& symMatches)
{
    symMatches.clear();
    for (vector<DMatch>::const_iterator matchIterator1= matches1.begin();matchIterator1!= matches1.end(); ++matchIterator1)
    {
        for (vector<DMatch>::const_iterator matchIterator2= matches2.begin();matchIterator2!= matches2.end();++matchIterator2)
        {
            if ((*matchIterator1).queryIdx ==(*matchIterator2).trainIdx &&(*matchIterator2).queryIdx ==(*matchIterator1).trainIdx)
            {
                symMatches.Push_back(DMatch((*matchIterator1).queryIdx,(*matchIterator1).trainIdx,(*matchIterator1).distance));
                break;
            }
        }
    }
}

そして、そのステレオ画像はransacテストを使用しているため：

void ransacTest(const std::vector<cv::DMatch> matches,const std::vector<cv::KeyPoint>&keypoints1,const std::vector<cv::KeyPoint>& keypoints2,std::vector<cv::DMatch>& goodMatches,double distance,double confidence,double minInlierRatio)
{
    goodMatches.clear();
    // Convert keypoints into Point2f
    std::vector<cv::Point2f> points1, points2;
    for (std::vector<cv::DMatch>::const_iterator it= matches.begin();it!= matches.end(); ++it)
    {
        // Get the position of left keypoints
        float x= keypoints1[it->queryIdx].pt.x;
        float y= keypoints1[it->queryIdx].pt.y;
        points1.Push_back(cv::Point2f(x,y));
        // Get the position of right keypoints
        x= keypoints2[it->trainIdx].pt.x;
        y= keypoints2[it->trainIdx].pt.y;
        points2.Push_back(cv::Point2f(x,y));
    }
    // Compute F matrix using RANSAC
    std::vector<uchar> inliers(points1.size(),0);
    cv::Mat fundemental= cv::findFundamentalMat(cv::Mat(points1),cv::Mat(points2),inliers,CV_FM_RANSAC,distance,confidence); // confidence probability
    // extract the surviving (inliers) matches
    std::vector<uchar>::const_iterator
    itIn= inliers.begin();
    std::vector<cv::DMatch>::const_iterator
    itM= matches.begin();
    // for all matches
    for ( ;itIn!= inliers.end(); ++itIn, ++itM)
    {
        if (*itIn)
        { // it is a valid match
            goodMatches.Push_back(*itM);
        }
    }
}
7
András Kovács