Add Java and Python code for the following features2d tutorials: Harris corner detector, Shi-Tomasi corner detector, Creating your own corner detector, Detecting corners location in subpixels, Feature Detection, Feature Description, Feature Matching with FLANN, Features2D + Homography to find a known object. Use Lowe's ratio test to filter the matches.

samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp

@@ -13,15 +13,15 @@ using namespace std;
 
 /// Global variables
 Mat src, src_gray;
-Mat myHarris_dst; Mat myHarris_copy; Mat Mc;
-Mat myShiTomasi_dst; Mat myShiTomasi_copy;
+Mat myHarris_dst, myHarris_copy, Mc;
+Mat myShiTomasi_dst, myShiTomasi_copy;
 
 int myShiTomasi_qualityLevel = 50;
 int myHarris_qualityLevel = 50;
 int max_qualityLevel = 100;
 
-double myHarris_minVal; double myHarris_maxVal;
-double myShiTomasi_minVal; double myShiTomasi_maxVal;
+double myHarris_minVal, myHarris_maxVal;
+double myShiTomasi_minVal, myShiTomasi_maxVal;
 
 RNG rng(12345);
 
@@ -37,56 +37,54 @@ void myHarris_function( int, void* );
  */
 int main( int argc, char** argv )
 {
-  /// Load source image and convert it to gray
-  CommandLineParser parser( argc, argv, "{@input | ../data/stuff.jpg | input image}" );
-  src = imread( parser.get<String>( "@input" ), IMREAD_COLOR );
-  if ( src.empty() )
-  {
-    cout << "Could not open or find the image!\n" << endl;
-    cout << "Usage: " << argv[0] << " <Input image>" << endl;
-    return -1;
-  }
-  cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | ../data/building.jpg | input image}" );
+    src = imread( parser.get<String>( "@input" ) );
+    if ( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
 
-  /// Set some parameters
-  int blockSize = 3; int apertureSize = 3;
+    /// Set some parameters
+    int blockSize = 3, apertureSize = 3;
 
-  /// My Harris matrix -- Using cornerEigenValsAndVecs
-  myHarris_dst = Mat::zeros( src_gray.size(), CV_32FC(6) );
-  Mc = Mat::zeros( src_gray.size(), CV_32FC1 );
+    /// My Harris matrix -- Using cornerEigenValsAndVecs
+    cornerEigenValsAndVecs( src_gray, myHarris_dst, blockSize, apertureSize );
 
-  cornerEigenValsAndVecs( src_gray, myHarris_dst, blockSize, apertureSize, BORDER_DEFAULT );
+    /* calculate Mc */
+    Mc = Mat( src_gray.size(), CV_32FC1 );
+    for( int i = 0; i < src_gray.rows; i++ )
+    {
+        for( int j = 0; j < src_gray.cols; j++ )
+        {
+            float lambda_1 = myHarris_dst.at<Vec6f>(i, j)[0];
+            float lambda_2 = myHarris_dst.at<Vec6f>(i, j)[1];
+            Mc.at<float>(i, j) = lambda_1*lambda_2 - 0.04f*pow( ( lambda_1 + lambda_2 ), 2 );
+        }
+    }
 
-  /* calculate Mc */
-  for( int j = 0; j < src_gray.rows; j++ )
-     { for( int i = 0; i < src_gray.cols; i++ )
-          {
-            float lambda_1 = myHarris_dst.at<Vec6f>(j, i)[0];
-            float lambda_2 = myHarris_dst.at<Vec6f>(j, i)[1];
-            Mc.at<float>(j,i) = lambda_1*lambda_2 - 0.04f*pow( ( lambda_1 + lambda_2 ), 2 );
-          }
-     }
+    minMaxLoc( Mc, &myHarris_minVal, &myHarris_maxVal );
 
-  minMaxLoc( Mc, &myHarris_minVal, &myHarris_maxVal, 0, 0, Mat() );
+    /* Create Window and Trackbar */
+    namedWindow( myHarris_window );
+    createTrackbar( "Quality Level:", myHarris_window, &myHarris_qualityLevel, max_qualityLevel, myHarris_function );
+    myHarris_function( 0, 0 );
 
-  /* Create Window and Trackbar */
-  namedWindow( myHarris_window, WINDOW_AUTOSIZE );
-  createTrackbar( " Quality Level:", myHarris_window, &myHarris_qualityLevel, max_qualityLevel, myHarris_function );
-  myHarris_function( 0, 0 );
+    /// My Shi-Tomasi -- Using cornerMinEigenVal
+    cornerMinEigenVal( src_gray, myShiTomasi_dst, blockSize, apertureSize );
 
-  /// My Shi-Tomasi -- Using cornerMinEigenVal
-  myShiTomasi_dst = Mat::zeros( src_gray.size(), CV_32FC1 );
-  cornerMinEigenVal( src_gray, myShiTomasi_dst, blockSize, apertureSize, BORDER_DEFAULT );
+    minMaxLoc( myShiTomasi_dst, &myShiTomasi_minVal, &myShiTomasi_maxVal );
 
-  minMaxLoc( myShiTomasi_dst, &myShiTomasi_minVal, &myShiTomasi_maxVal, 0, 0, Mat() );
+    /* Create Window and Trackbar */
+    namedWindow( myShiTomasi_window );
+    createTrackbar( "Quality Level:", myShiTomasi_window, &myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function );
+    myShiTomasi_function( 0, 0 );
 
-  /* Create Window and Trackbar */
-  namedWindow( myShiTomasi_window, WINDOW_AUTOSIZE );
-  createTrackbar( " Quality Level:", myShiTomasi_window, &myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function );
-  myShiTomasi_function( 0, 0 );
-
-  waitKey(0);
-  return(0);
+    waitKey();
+    return 0;
 }
 
 /**
@@ -94,18 +92,20 @@ int main( int argc, char** argv )
  */
 void myShiTomasi_function( int, void* )
 {
-  myShiTomasi_copy = src.clone();
+    myShiTomasi_copy = src.clone();
+    myShiTomasi_qualityLevel = MAX(myShiTomasi_qualityLevel, 1);
 
-  if( myShiTomasi_qualityLevel < 1 ) { myShiTomasi_qualityLevel = 1; }
-
-  for( int j = 0; j < src_gray.rows; j++ )
-     { for( int i = 0; i < src_gray.cols; i++ )
-          {
-            if( myShiTomasi_dst.at<float>(j,i) > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel )
-              { circle( myShiTomasi_copy, Point(i,j), 4, Scalar( rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255) ), -1, 8, 0 ); }
-          }
-     }
-  imshow( myShiTomasi_window, myShiTomasi_copy );
+    for( int i = 0; i < src_gray.rows; i++ )
+    {
+        for( int j = 0; j < src_gray.cols; j++ )
+        {
+            if( myShiTomasi_dst.at<float>(i,j) > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel )
+            {
+                circle( myShiTomasi_copy, Point(j,i), 4, Scalar( rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256) ), FILLED );
+            }
+        }
+    }
+    imshow( myShiTomasi_window, myShiTomasi_copy );
 }
 
 /**
@@ -113,16 +113,18 @@ void myShiTomasi_function( int, void* )
  */
 void myHarris_function( int, void* )
 {
-  myHarris_copy = src.clone();
+    myHarris_copy = src.clone();
+    myHarris_qualityLevel = MAX(myHarris_qualityLevel, 1);
 
-  if( myHarris_qualityLevel < 1 ) { myHarris_qualityLevel = 1; }
-
-  for( int j = 0; j < src_gray.rows; j++ )
-     { for( int i = 0; i < src_gray.cols; i++ )
-          {
-            if( Mc.at<float>(j,i) > myHarris_minVal + ( myHarris_maxVal - myHarris_minVal )*myHarris_qualityLevel/max_qualityLevel )
-              { circle( myHarris_copy, Point(i,j), 4, Scalar( rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255) ), -1, 8, 0 ); }
-          }
-     }
-  imshow( myHarris_window, myHarris_copy );
+    for( int i = 0; i < src_gray.rows; i++ )
+    {
+        for( int j = 0; j < src_gray.cols; j++ )
+        {
+            if( Mc.at<float>(i,j) > myHarris_minVal + ( myHarris_maxVal - myHarris_minVal )*myHarris_qualityLevel/max_qualityLevel )
+            {
+                circle( myHarris_copy, Point(j,i), 4, Scalar( rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256) ), FILLED );
+            }
+        }
+    }
+    imshow( myHarris_window, myHarris_copy );
 }

samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp

@@ -27,26 +27,26 @@ void cornerHarris_demo( int, void* );
  */
 int main( int argc, char** argv )
 {
-  /// Load source image and convert it to gray
-  CommandLineParser parser( argc, argv, "{@input | ../data/building.jpg | input image}" );
-  src = imread( parser.get<String>( "@input" ), IMREAD_COLOR );
-  if ( src.empty() )
-  {
-    cout << "Could not open or find the image!\n" << endl;
-    cout << "Usage: " << argv[0] << " <Input image>" << endl;
-    return -1;
-  }
-  cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | ../data/building.jpg | input image}" );
+    src = imread( parser.get<String>( "@input" ) );
+    if ( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
 
-  /// Create a window and a trackbar
-  namedWindow( source_window, WINDOW_AUTOSIZE );
-  createTrackbar( "Threshold: ", source_window, &thresh, max_thresh, cornerHarris_demo );
-  imshow( source_window, src );
+    /// Create a window and a trackbar
+    namedWindow( source_window );
+    createTrackbar( "Threshold: ", source_window, &thresh, max_thresh, cornerHarris_demo );
+    imshow( source_window, src );
 
-  cornerHarris_demo( 0, 0 );
+    cornerHarris_demo( 0, 0 );
 
-  waitKey(0);
-  return(0);
+    waitKey();
+    return 0;
 }
 
 /**
@@ -55,33 +55,33 @@ int main( int argc, char** argv )
  */
 void cornerHarris_demo( int, void* )
 {
+    /// Detector parameters
+    int blockSize = 2;
+    int apertureSize = 3;
+    double k = 0.04;
 
-  Mat dst, dst_norm, dst_norm_scaled;
-  dst = Mat::zeros( src.size(), CV_32FC1 );
+    /// Detecting corners
+    Mat dst = Mat::zeros( src.size(), CV_32FC1 );
+    cornerHarris( src_gray, dst, blockSize, apertureSize, k );
 
-  /// Detector parameters
-  int blockSize = 2;
-  int apertureSize = 3;
-  double k = 0.04;
+    /// Normalizing
+    Mat dst_norm, dst_norm_scaled;
+    normalize( dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
+    convertScaleAbs( dst_norm, dst_norm_scaled );
 
-  /// Detecting corners
-  cornerHarris( src_gray, dst, blockSize, apertureSize, k, BORDER_DEFAULT );
+    /// Drawing a circle around corners
+    for( int i = 0; i < dst_norm.rows ; i++ )
+    {
+        for( int j = 0; j < dst_norm.cols; j++ )
+        {
+            if( (int) dst_norm.at<float>(i,j) > thresh )
+            {
+                circle( dst_norm_scaled, Point(j,i), 5,  Scalar(0), 2, 8, 0 );
+            }
+        }
+    }
 
-  /// Normalizing
-  normalize( dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
-  convertScaleAbs( dst_norm, dst_norm_scaled );
-
-  /// Drawing a circle around corners
-  for( int j = 0; j < dst_norm.rows ; j++ )
-     { for( int i = 0; i < dst_norm.cols; i++ )
-          {
-            if( (int) dst_norm.at<float>(j,i) > thresh )
-              {
-               circle( dst_norm_scaled, Point( i, j ), 5,  Scalar(0), 2, 8, 0 );
-              }
-          }
-     }
-  /// Showing the result
-  namedWindow( corners_window, WINDOW_AUTOSIZE );
-  imshow( corners_window, dst_norm_scaled );
+    /// Showing the result
+    namedWindow( corners_window );
+    imshow( corners_window, dst_norm_scaled );
 }

samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp

@@ -28,29 +28,29 @@ void goodFeaturesToTrack_Demo( int, void* );
  */
 int main( int argc, char** argv )
 {
-  /// Load source image and convert it to gray
-  CommandLineParser parser( argc, argv, "{@input | ../data/pic3.png | input image}" );
-  src = imread(parser.get<String>( "@input" ), IMREAD_COLOR);
-  if ( src.empty() )
-  {
-    cout << "Could not open or find the image!\n" << endl;
-    cout << "Usage: " << argv[0] << " <Input image>" << endl;
-    return -1;
-  }
-  cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | ../data/pic3.png | input image}" );
+    src = imread( parser.get<String>( "@input" ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
 
-  /// Create Window
-  namedWindow( source_window, WINDOW_AUTOSIZE );
+    /// Create Window
+    namedWindow( source_window );
 
-  /// Create Trackbar to set the number of corners
-  createTrackbar( "Max  corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );
+    /// Create Trackbar to set the number of corners
+    createTrackbar( "Max corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );
 
-  imshow( source_window, src );
+    imshow( source_window, src );
 
-  goodFeaturesToTrack_Demo( 0, 0 );
+    goodFeaturesToTrack_Demo( 0, 0 );
 
-  waitKey(0);
-  return(0);
+    waitKey();
+    return 0;
 }
 
 /**
@@ -59,52 +59,54 @@ int main( int argc, char** argv )
  */
 void goodFeaturesToTrack_Demo( int, void* )
 {
-  if( maxCorners < 1 ) { maxCorners = 1; }
+    /// Parameters for Shi-Tomasi algorithm
+    maxCorners = MAX(maxCorners, 1);
+    vector<Point2f> corners;
+    double qualityLevel = 0.01;
+    double minDistance = 10;
+    int blockSize = 3, gradientSize = 3;
+    bool useHarrisDetector = false;
+    double k = 0.04;
 
-  /// Parameters for Shi-Tomasi algorithm
-  vector<Point2f> corners;
-  double qualityLevel = 0.01;
-  double minDistance = 10;
-  int blockSize = 3, gradiantSize = 3;
-  bool useHarrisDetector = false;
-  double k = 0.04;
+    /// Copy the source image
+    Mat copy = src.clone();
 
-  /// Copy the source image
-  Mat copy;
-  copy = src.clone();
-
-  /// Apply corner detection
-  goodFeaturesToTrack( src_gray,
-               corners,
-               maxCorners,
-               qualityLevel,
-               minDistance,
-               Mat(),
-               blockSize,
-               gradiantSize,
-               useHarrisDetector,
-               k );
+    /// Apply corner detection
+    goodFeaturesToTrack( src_gray,
+                         corners,
+                         maxCorners,
+                         qualityLevel,
+                         minDistance,
+                         Mat(),
+                         blockSize,
+                         gradientSize,
+                         useHarrisDetector,
+                         k );
 
 
-  /// Draw corners detected
-  cout<<"** Number of corners detected: "<<corners.size()<<endl;
-  int r = 4;
-  for( size_t i = 0; i < corners.size(); i++ )
-     { circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)), -1, 8, 0 ); }
+    /// Draw corners detected
+    cout << "** Number of corners detected: " << corners.size() << endl;
+    int radius = 4;
+    for( size_t i = 0; i < corners.size(); i++ )
+    {
+        circle( copy, corners[i], radius, Scalar(rng.uniform(0,255), rng.uniform(0, 256), rng.uniform(0, 256)), FILLED );
+    }
 
-  /// Show what you got
-  namedWindow( source_window, WINDOW_AUTOSIZE );
-  imshow( source_window, copy );
+    /// Show what you got
+    namedWindow( source_window );
+    imshow( source_window, copy );
 
-  /// Set the needed parameters to find the refined corners
-  Size winSize = Size( 5, 5 );
-  Size zeroZone = Size( -1, -1 );
-  TermCriteria criteria = TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 40, 0.001 );
+    /// Set the needed parameters to find the refined corners
+    Size winSize = Size( 5, 5 );
+    Size zeroZone = Size( -1, -1 );
+    TermCriteria criteria = TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 40, 0.001 );
 
-  /// Calculate the refined corner locations
-  cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );
+    /// Calculate the refined corner locations
+    cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );
 
-  /// Write them down
-  for( size_t i = 0; i < corners.size(); i++ )
-     { cout<<" -- Refined Corner ["<<i<<"]  ("<<corners[i].x<<","<<corners[i].y<<")"<<endl; }
+    /// Write them down
+    for( size_t i = 0; i < corners.size(); i++ )
+    {
+        cout << " -- Refined Corner [" << i << "]  (" << corners[i].x << "," << corners[i].y << ")" << endl;
+    }
 }

samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp

@@ -29,29 +29,29 @@ void goodFeaturesToTrack_Demo( int, void* );
  */
 int main( int argc, char** argv )
 {
-  /// Load source image and convert it to gray
-  CommandLineParser parser( argc, argv, "{@input | ../data/pic3.png | input image}" );
-  src = imread( parser.get<String>( "@input" ), IMREAD_COLOR );
-  if( src.empty() )
-  {
-    cout << "Could not open or find the image!\n" << endl;
-    cout << "Usage: " << argv[0] << " <Input image>" << endl;
-    return -1;
-  }
-  cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | ../data/pic3.png | input image}" );
+    src = imread( parser.get<String>( "@input" ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
 
-  /// Create Window
-  namedWindow( source_window, WINDOW_AUTOSIZE );
+    /// Create Window
+    namedWindow( source_window );
 
-  /// Create Trackbar to set the number of corners
-  createTrackbar( "Max  corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );
+    /// Create Trackbar to set the number of corners
+    createTrackbar( "Max corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );
 
-  imshow( source_window, src );
+    imshow( source_window, src );
 
-  goodFeaturesToTrack_Demo( 0, 0 );
+    goodFeaturesToTrack_Demo( 0, 0 );
 
-  waitKey(0);
-  return(0);
+    waitKey();
+    return 0;
 }
 
 /**
@@ -60,40 +60,40 @@ int main( int argc, char** argv )
  */
 void goodFeaturesToTrack_Demo( int, void* )
 {
-  if( maxCorners < 1 ) { maxCorners = 1; }
+    /// Parameters for Shi-Tomasi algorithm
+    maxCorners = MAX(maxCorners, 1);
+    vector<Point2f> corners;
+    double qualityLevel = 0.01;
+    double minDistance = 10;
+    int blockSize = 3, gradientSize = 3;
+    bool useHarrisDetector = false;
+    double k = 0.04;
 
-  /// Parameters for Shi-Tomasi algorithm
-  vector<Point2f> corners;
-  double qualityLevel = 0.01;
-  double minDistance = 10;
-  int blockSize = 3, gradiantSize = 3;
-  bool useHarrisDetector = false;
-  double k = 0.04;
+    /// Copy the source image
+    Mat copy = src.clone();
 
-  /// Copy the source image
-  Mat copy;
-  copy = src.clone();
-
-  /// Apply corner detection
-  goodFeaturesToTrack( src_gray,
-               corners,
-               maxCorners,
-               qualityLevel,
-               minDistance,
-               Mat(),
-               blockSize,
-               gradiantSize,
-               useHarrisDetector,
-               k );
+    /// Apply corner detection
+    goodFeaturesToTrack( src_gray,
+                         corners,
+                         maxCorners,
+                         qualityLevel,
+                         minDistance,
+                         Mat(),
+                         blockSize,
+                         gradientSize,
+                         useHarrisDetector,
+                         k );
 
 
-  /// Draw corners detected
-  cout<<"** Number of corners detected: "<<corners.size()<<endl;
-  int r = 4;
-  for( size_t i = 0; i < corners.size(); i++ )
-     { circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)), -1, 8, 0 ); }
+    /// Draw corners detected
+    cout << "** Number of corners detected: " << corners.size() << endl;
+    int radius = 4;
+    for( size_t i = 0; i < corners.size(); i++ )
+    {
+        circle( copy, corners[i], radius, Scalar(rng.uniform(0,255), rng.uniform(0, 256), rng.uniform(0, 256)), FILLED );
+    }
 
-  /// Show what you got
-  namedWindow( source_window, WINDOW_AUTOSIZE );
-  imshow( source_window, copy );
+    /// Show what you got
+    namedWindow( source_window );
+    imshow( source_window, copy );
 }

samples/cpp/tutorial_code/features2D/feature_description/SURF_matching_Demo.cpp

@@ -0,0 +1,60 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/highgui.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using std::cout;
+using std::endl;
+
+const char* keys =
+    "{ help h |                          | Print help message. }"
+    "{ input1 | ../data/box.png          | Path to input image 1. }"
+    "{ input2 | ../data/box_in_scene.png | Path to input image 2. }";
+
+int main( int argc, char* argv[] )
+{
+    CommandLineParser parser( argc, argv, keys );
+    Mat img1 = imread( parser.get<String>("input1"), IMREAD_GRAYSCALE );
+    Mat img2 = imread( parser.get<String>("input2"), IMREAD_GRAYSCALE );
+    if ( img1.empty() || img2.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        parser.printMessage();
+        return -1;
+    }
+
+    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+    int minHessian = 400;
+    Ptr<SURF> detector = SURF::create( minHessian );
+    std::vector<KeyPoint> keypoints1, keypoints2;
+    Mat descriptors1, descriptors2;
+    detector->detectAndCompute( img1, noArray(), keypoints1, descriptors1 );
+    detector->detectAndCompute( img2, noArray(), keypoints2, descriptors2 );
+
+    //-- Step 2: Matching descriptor vectors with a brute force matcher
+    // Since SURF is a floating-point descriptor NORM_L2 is used
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::BRUTEFORCE);
+    std::vector< DMatch > matches;
+    matcher->match( descriptors1, descriptors2, matches );
+
+    //-- Draw matches
+    Mat img_matches;
+    drawMatches( img1, keypoints1, img2, keypoints2, matches, img_matches );
+
+    //-- Show detected matches
+    imshow("Matches", img_matches );
+
+    waitKey();
+    return 0;
+}
+#else
+int main()
+{
+    std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
+    return 0;
+}
+#endif

samples/cpp/tutorial_code/features2D/feature_detection/SURF_detection_Demo.cpp

@@ -0,0 +1,46 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/highgui.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using std::cout;
+using std::endl;
+
+int main( int argc, char* argv[] )
+{
+    CommandLineParser parser( argc, argv, "{@input | ../data/box.png | input image}" );
+    Mat src = imread( parser.get<String>( "@input" ), IMREAD_GRAYSCALE );
+    if ( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+
+    //-- Step 1: Detect the keypoints using SURF Detector
+    int minHessian = 400;
+    Ptr<SURF> detector = SURF::create( minHessian );
+    std::vector<KeyPoint> keypoints;
+    detector->detect( src, keypoints );
+
+    //-- Draw keypoints
+    Mat img_keypoints;
+    drawKeypoints( src, keypoints, img_keypoints );
+
+    //-- Show detected (drawn) keypoints
+    imshow("SURF Keypoints", img_keypoints );
+
+    waitKey();
+    return 0;
+}
+#else
+int main()
+{
+    std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
+    return 0;
+}
+#endif

samples/cpp/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.cpp

@@ -0,0 +1,72 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/highgui.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using std::cout;
+using std::endl;
+
+const char* keys =
+    "{ help h |                          | Print help message. }"
+    "{ input1 | ../data/box.png          | Path to input image 1. }"
+    "{ input2 | ../data/box_in_scene.png | Path to input image 2. }";
+
+int main( int argc, char* argv[] )
+{
+    CommandLineParser parser( argc, argv, keys );
+    Mat img1 = imread( parser.get<String>("input1"), IMREAD_GRAYSCALE );
+    Mat img2 = imread( parser.get<String>("input2"), IMREAD_GRAYSCALE );
+    if ( img1.empty() || img2.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        parser.printMessage();
+        return -1;
+    }
+
+    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+    int minHessian = 400;
+    Ptr<SURF> detector = SURF::create( minHessian );
+    std::vector<KeyPoint> keypoints1, keypoints2;
+    Mat descriptors1, descriptors2;
+    detector->detectAndCompute( img1, noArray(), keypoints1, descriptors1 );
+    detector->detectAndCompute( img2, noArray(), keypoints2, descriptors2 );
+
+    //-- Step 2: Matching descriptor vectors with a FLANN based matcher
+    // Since SURF is a floating-point descriptor NORM_L2 is used
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
+    std::vector< std::vector<DMatch> > knn_matches;
+    matcher->knnMatch( descriptors1, descriptors2, knn_matches, 2 );
+
+    //-- Filter matches using the Lowe's ratio test
+    const float ratio_thresh = 0.7f;
+    std::vector<DMatch> good_matches;
+    for (size_t i = 0; i < knn_matches.size(); i++)
+    {
+        if (knn_matches[i].size() > 1 && knn_matches[i][0].distance / knn_matches[i][1].distance <= ratio_thresh)
+        {
+            good_matches.push_back(knn_matches[i][0]);
+        }
+    }
+
+    //-- Draw matches
+    Mat img_matches;
+    drawMatches( img1, keypoints1, img2, keypoints2, good_matches, img_matches, Scalar::all(-1),
+                 Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
+
+    //-- Show detected matches
+    imshow("Good Matches", img_matches );
+
+    waitKey();
+    return 0;
+}
+#else
+int main()
+{
+    std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
+    return 0;
+}
+#endif

samples/cpp/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.cpp

@@ -0,0 +1,107 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/calib3d.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using std::cout;
+using std::endl;
+
+const char* keys =
+        "{ help h |                          | Print help message. }"
+        "{ input1 | ../data/box.png          | Path to input image 1. }"
+        "{ input2 | ../data/box_in_scene.png | Path to input image 2. }";
+
+int main( int argc, char* argv[] )
+{
+    CommandLineParser parser( argc, argv, keys );
+    Mat img_object = imread( parser.get<String>("input1"), IMREAD_GRAYSCALE );
+    Mat img_scene = imread( parser.get<String>("input2"), IMREAD_GRAYSCALE );
+    if ( img_object.empty() || img_scene.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        parser.printMessage();
+        return -1;
+    }
+
+    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+    int minHessian = 400;
+    Ptr<SURF> detector = SURF::create( minHessian );
+    std::vector<KeyPoint> keypoints_object, keypoints_scene;
+    Mat descriptors_object, descriptors_scene;
+    detector->detectAndCompute( img_object, noArray(), keypoints_object, descriptors_object );
+    detector->detectAndCompute( img_scene, noArray(), keypoints_scene, descriptors_scene );
+
+    //-- Step 2: Matching descriptor vectors with a FLANN based matcher
+    // Since SURF is a floating-point descriptor NORM_L2 is used
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
+    std::vector< std::vector<DMatch> > knn_matches;
+    matcher->knnMatch( descriptors_object, descriptors_scene, knn_matches, 2 );
+
+    //-- Filter matches using the Lowe's ratio test
+    const float ratio_thresh = 0.75f;
+    std::vector<DMatch> good_matches;
+    for (size_t i = 0; i < knn_matches.size(); i++)
+    {
+        if (knn_matches[i].size() > 1 && knn_matches[i][0].distance / knn_matches[i][1].distance <= ratio_thresh)
+        {
+            good_matches.push_back(knn_matches[i][0]);
+        }
+    }
+
+    //-- Draw matches
+    Mat img_matches;
+    drawMatches( img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, Scalar::all(-1),
+                 Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
+
+    //-- Localize the object
+    std::vector<Point2f> obj;
+    std::vector<Point2f> scene;
+
+    for( size_t i = 0; i < good_matches.size(); i++ )
+    {
+        //-- Get the keypoints from the good matches
+        obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );
+        scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt );
+    }
+
+    Mat H = findHomography( obj, scene, RANSAC );
+
+    //-- Get the corners from the image_1 ( the object to be "detected" )
+    std::vector<Point2f> obj_corners(4);
+    obj_corners[0] = Point2f(0, 0);
+    obj_corners[1] = Point2f( (float)img_object.cols, 0 );
+    obj_corners[2] = Point2f( (float)img_object.cols, (float)img_object.rows );
+    obj_corners[3] = Point2f( 0, (float)img_object.rows );
+    std::vector<Point2f> scene_corners(4);
+
+    perspectiveTransform( obj_corners, scene_corners, H);
+
+    //-- Draw lines between the corners (the mapped object in the scene - image_2 )
+    line( img_matches, scene_corners[0] + Point2f((float)img_object.cols, 0),
+          scene_corners[1] + Point2f((float)img_object.cols, 0), Scalar(0, 255, 0), 4 );
+    line( img_matches, scene_corners[1] + Point2f((float)img_object.cols, 0),
+          scene_corners[2] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
+    line( img_matches, scene_corners[2] + Point2f((float)img_object.cols, 0),
+          scene_corners[3] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
+    line( img_matches, scene_corners[3] + Point2f((float)img_object.cols, 0),
+          scene_corners[0] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
+
+    //-- Show detected matches
+    imshow("Good Matches & Object detection", img_matches );
+
+    waitKey();
+    return 0;
+}
+#else
+int main()
+{
+    std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
+    return 0;
+}
+#endif