surf特征+FLANN特征匹配+knn筛选匹配点+单应性矩阵映射

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <opencv2/core/core.hpp>
#include "opencv2/nonfree/features2d.hpp"
#include<opencv2/legacy/legacy.hpp>
#include <opencv2/highgui/highgui.hpp>
using namespace cv;
using namespace std;
int main( )
{
  Mat img_1 = imread( "C:\\temp\\PyramidPattern.jpg", CV_LOAD_IMAGE_GRAYSCALE );
  Mat img_2 = imread( "C:\\temp\\PyramidPatternTest.bmp", CV_LOAD_IMAGE_GRAYSCALE );
  if( !img_1.data || !img_2.data )
  { return -1; }
  //-- Step 1: Detect the keypoints using SURF Detector
  int minHessian = 400;
  SurfFeatureDetector detector( minHessian );
  vector<KeyPoint> keypoints_1, keypoints_2;
  detector.detect( img_1, keypoints_1 );
  detector.detect( img_2, keypoints_2 );
  //-- Step 2: Calculate descriptors (feature vectors)
  SurfDescriptorExtractor extractor;
  Mat descriptors_1, descriptors_2;
  extractor.compute( img_1, keypoints_1, descriptors_1 );
  extractor.compute( img_2, keypoints_2, descriptors_2 );
  //-- Step 3: Matching descriptor vectors using FLANN matcher
  FlannBasedMatcher matcher;
  vector< DMatch > matches;
  vector<vector<DMatch>> m_knnMatches;
  matches.clear();
  const float minRatio=1.f / 1.5f;
  matcher.knnMatch(descriptors_1,descriptors_2,m_knnMatches,2);
  for (int i=0; i<m_knnMatches.size(); i++)
  {
    const DMatch& bestMatch=m_knnMatches[i][0];
    const DMatch& betterMatch=m_knnMatches[i][1];
    float distanceRatio=bestMatch.distance/betterMatch.distance;
    if (distanceRatio<minRatio)
    {
      matches.push_back(bestMatch);
    }
  }
  vector< DMatch > good_matches;
  if(!matches.size())
  {
    cout<<"matches is empty! "<<endl;
    return -1;
  }
  else if (matches.size()<4)
  {
    cout<<matches.size()<<" points matched is not enough "<<endl;
  }
  else //单应性矩阵的计算最少得使用4个点
  {
    for( int i = 0; i < matches.size(); i++ )
    { 
      good_matches.push_back(matches[i]);
    }  
    Mat img_matches;
    drawMatches( img_1, keypoints_1, img_2, keypoints_2, 
      good_matches, img_matches, Scalar::all(-1), Scalar::all(-1), 
      vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS ); 
    //☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
    //-- Localize the object from img_1 in img_2 
    vector<Point2f> obj;
    vector<Point2f> scene;
    for( int i = 0; i < good_matches.size(); i++ )
    {
      //-- Get the keypoints from the good matches
      obj.push_back( keypoints_1[ good_matches[i].queryIdx ].pt );
      scene.push_back( keypoints_2[ good_matches[i].trainIdx ].pt ); 
    }
    Mat H = findHomography( obj, scene, CV_RANSAC );
    //-- Get the corners from the image_1 ( the object to be "detected" )
    vector<Point2f> obj_corners(4);
    obj_corners[0]=cvPoint(0,0);
    obj_corners[1]=cvPoint( img_1.cols, 0 );
    obj_corners[2]=cvPoint(img_1.cols,img_1.rows);
    obj_corners[3]=cvPoint(0,img_1.rows);
    vector<Point2f> scene_corners(4);
    perspectiveTransform( obj_corners, scene_corners, H); 
    for( int i = 0; i < 4; i++ )
    {
      /* 作用和perspectiveTransform一样
      double x = obj_corners[i].x; 
      double y = obj_corners[i].y;
      double Z = 1./( H.at<double>(2,0)*x + H.at<double>(2,1)*y + H.at<double>(2,2) );
      double X = ( H.at<double>(0,0)*x + H.at<double>(0,1)*y + H.at<double>(0,2) )*Z;
      double Y = ( H.at<double>(1,0)*x + H.at<double>(1,1)*y + H.at<double>(1,2) )*Z;
      scene_corners[i] = cvPoint( cvRound(X) + img_1.cols, cvRound(Y) );*/
      scene_corners[i].x+=img_1.cols;
    } 
    line( img_matches, scene_corners[0], scene_corners[1], Scalar(0, 255, 0), 2 );
    line( img_matches, scene_corners[1], scene_corners[2], Scalar( 0, 255, 0), 2 );
    line( img_matches, scene_corners[2], scene_corners[3], Scalar( 0, 255, 0), 2 );
    line( img_matches, scene_corners[3], scene_corners[0], Scalar( 0, 255, 0), 2 );
    imshow( "Good Matches & Object detection", img_matches );
  }
  waitKey(0);
  return 0;
}