SURF

#include <iostream>
#include "opencv2/core/core.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/nonfree/nonfree.hpp"
#include "opencv2/nonfree/features2d.hpp"
#include<opencv2/legacy/legacy.hpp>
using namespace std;
using namespace cv;
char *path1="D:\\1.jpg";
char *path2="D:\\2.jpg";
 
int main()
{
    Mat src1=imread(path1,0);
 
    /*namedWindow("image",CV_WINDOW_AUTOSIZE);
    imshow("image", src1);
    waitKey(0);*/
 
    Mat src2=imread(path2,0);
    SurfFeatureDetector detector(400);
    vector<KeyPoint> keypoint1,keypoint2;
    detector.detect(src1,keypoint1);
    detector.detect(src2,keypoint2);
 
    SurfDescriptorExtractor extractor;
    Mat descriptor1,descriptor2;
    extractor.compute(src1,keypoint1,descriptor1);
    extractor.compute(src2,keypoint2,descriptor2);
 
	/*
    BruteForceMatcher<L2<float>> matcher;
    vector<DMatch>matches;
    matcher.match(descriptor1,descriptor2,matches);
 
    namedWindow("matches",1);
    Mat img_matches;
    drawMatches(src1,keypoint1,src2,keypoint2,matches,img_matches);
    imshow("matches",img_matches);
	*/

	  //-- Step 3: Matching descriptor vectors using FLANN matcher
	  FlannBasedMatcher matcher;
	  std::vector< DMatch > matches;
	  matcher.match( descriptor1, descriptor2, matches );

	  double max_dist = 0; double min_dist = 100;

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

	  printf("-- Max dist : %f \n", max_dist );
	  printf("-- Min dist : %f \n", min_dist );
  
	  //-- Draw only "good" matches (i.e. whose distance is less than 2*min_dist )
	  //-- PS.- radiusMatch can also be used here.
	  std::vector< DMatch > good_matches;

	  for( int i = 0; i < descriptor1.rows; i++ )
	  { if( matches[i].distance < 2*min_dist )
		{ good_matches.push_back( matches[i]); }
	  }  

	  //-- Draw only "good" matches
	  Mat img_matches;
	  drawMatches( src1, keypoint1, src2, keypoint2, 
				   good_matches, img_matches, Scalar::all(-1), Scalar::all(-1), 
				   vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS ); 

	  //-- Show detected matches
	  imshow( "Good Matches", img_matches );

			//-- Localize the object from img_1 in img_2 
	  std::vector<Point2f> obj;
	  std::vector<Point2f> scene;

	  for( int i = 0; i < good_matches.size(); i++ )
	  {
		//-- Get the keypoints from the good matches
		obj.push_back( keypoint1[ good_matches[i].queryIdx ].pt );
		scene.push_back( keypoint2[ good_matches[i].trainIdx ].pt ); 
	  }

	  Mat H = findHomography( obj, scene, CV_RANSAC );

	  //-- Get the corners from the image_1 ( the object to be "detected" )
	  Point2f obj_corners[4] = { cvPoint(0,0), cvPoint( src1.cols, 0 ), cvPoint( src1.cols, src1.rows ), cvPoint( 0, src1.rows ) };
	  Point scene_corners[4];

	  //-- Map these corners in the scene ( image_2)
	  for( int i = 0; i < 4; i++ )
	  {
		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) + src1.cols, cvRound(Y) );
	  }  
   
	  //-- Draw lines between the corners (the mapped object in the scene - image_2 )
	  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 );

	  //-- Show detected matches
	  imshow( "Good Matches & Object detection", img_matches );


    cvWaitKey(0);
    return 0;
}