robustmatcher.hpp

Go to the documentation of this file.

#ifndef __ROBUSTMATCHER_H__
#define __ROBUSTMATCHER_H__

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/calib3d/calib3d.hpp>

class RobustMatcher
{
public:
    RobustMatcher(void):
        matcher_(cv::NORM_HAMMING)
        {       
                // Variable initialization
        ratio_ = 0.65f;
        refineF_ = false;
        confidence_ = 0.99;
        distance_ = 3.0;
        }
        
    cv::Mat match(std::vector<cv::KeyPoint>& keypoints1, cv::Mat &descriptors1,
                  std::vector<cv::KeyPoint>& keypoints2, cv::Mat &descriptors2,
                  std::vector<cv::DMatch>& matches, bool doRansacTest = true,
                  bool doRatioTest = false, bool refineF = false)
        {
                cv::Mat F;
                
        // Matching from image 1 to image 2 based on k nearest neighbours (k=2)
        std::vector<std::vector<cv::DMatch> > matches12;
        matcher_.knnMatch(descriptors1, descriptors2, matches12, 2);
                
        // Matching from image 2 to image 1 based on k nearest neighbours (k=2)
        std::vector<std::vector<cv::DMatch> > matches21;
        matcher_.knnMatch(descriptors2, descriptors1, matches21, 2);
                
        // Remove matches for which NN ratio > threshold
        if(doRatioTest)
                {
            ratioTest(matches12);
            ratioTest(matches21);
                }
                
        // Remove non-symmetrical matches
                std::vector<cv::DMatch> symMatches;
        symmetryTest(matches12, matches21, symMatches);
                
        // Validate matches using RANSAC
        if(doRansacTest)
                {
            refineF_ = refineF;
                        F = ransacTest(symMatches, keypoints1, keypoints2, matches);
                }
                else
                        matches = symMatches;
                
                return F;
        }

        int ratioTest(std::vector<std::vector<cv::DMatch> >     &matches) 
        {
                int removed=0;
        for(std::vector<std::vector<cv::DMatch> >::iterator it = matches.begin(); it!= matches.end(); ++it)
                {
            // if 2 nearest neighbors have been identified
            if(it->size() > 1)
                        {
                                // check distance ratio
                if((*it)[0].distance/(*it)[1].distance > ratio_)
                                {
                    it->clear(); // remove match
                                        removed++;
                                }
                        } 
                        else 
            {   // does not have 2 neighbors
                it->clear(); // remove match
                                removed++;
                        }
                }
                return removed;
        }

    void symmetryTest(const std::vector<std::vector<cv::DMatch> >& matches1,
                      const std::vector<std::vector<cv::DMatch> >& matches2,
                      std::vector<cv::DMatch>& symMatches)
        {
                // for all matches image 1 -> image 2
        for(std::vector<std::vector<cv::DMatch> >::const_iterator it1= matches1.begin(); it1!= matches1.end(); ++it1)
                {
                        // ignore deleted matches
            if(it1->size() < 2)
                                continue;
                                
                        // for all matches image 2 -> image 1
            for(std::vector<std::vector<cv::DMatch> >::const_iterator it2= matches2.begin(); it2!= matches2.end(); ++it2)
                        {
                                // ignore deleted matches
                if(it2->size() < 2)
                                        continue;
                                // Match symmetry test
                if((*it1)[0].queryIdx ==(*it2)[0].trainIdx &&
                        (*it2)[0].queryIdx == (*it1)[0].trainIdx)
                                {
                                        // add symmetrical match
                    symMatches.push_back(cv::DMatch((*it1)[0].queryIdx, (*it1)[0].trainIdx, (*it1)[0].distance));
                                        break; // next match in image 1 -> image 2
                                }
                        }
                }
        }
        
    cv::Mat ransacTest(const std::vector<cv::DMatch>& matches,
                       const std::vector<cv::KeyPoint>& keypoints1,
                       const std::vector<cv::KeyPoint>& keypoints2,
                       std::vector<cv::DMatch>& outMatches)
        {
                cv::Mat nullMat;
                
        // 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
                if(points1.size() < 10)
                        return nullMat;
                std::vector<uchar> inliers(points1.size(),0);
        cv::Mat fundamental= cv::findFundamentalMat(cv::Mat(points1),cv::Mat(points2), inliers,
                                                    CV_FM_RANSAC, distance_, confidence_);
                
        // 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
                                outMatches.push_back(*itM);
                        }
                }
                
        if (refineF_)
                {
            // The F matrix will be recomputed with all accepted matches
            // Convert surviving keypoints into Point2f for final F computation
                        points1.clear();
                        points2.clear();
            for(std::vector<cv::DMatch>::const_iterator it = outMatches.begin(); it!= outMatches.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 8-point F from all accepted matches
                        if(points1.size() < 9)
                                return nullMat;
            fundamental= cv::findFundamentalMat(cv::Mat(points1),cv::Mat(points2), CV_FM_8POINT);
                }
                
        return fundamental;
        }

private:

    float ratio_;           
    bool refineF_;          
    double distance_;       
    double confidence_;     
    cv::BFMatcher matcher_; 
};

#endif