Added reST tutorials for Contours (6 in imgproc) and for Corner Detection (4 in features2D) + links in conf.py

doc/tutorials/features2d/trackingmotion/corner_subpixeles/corner_subpixeles.rst

@@ -0,0 +1,139 @@
+.. _corner_subpixeles:
+
+Detecting corners location in subpixeles
+****************************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :corner_sub_pix:`cornerSubPix <>` to find more exact corner positions (more exact than integer pixels).
+
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /// Global variables
+   Mat src, src_gray;
+
+   int maxCorners = 10;
+   int maxTrackbar = 25;
+
+   RNG rng(12345);
+   char* source_window = "Image";
+
+   /// Function header
+   void goodFeaturesToTrack_Demo( int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Create Window
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+
+     /// Create Trackbar to set the number of corners
+     createTrackbar( "Max  corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );  
+
+     imshow( source_window, src );
+
+     goodFeaturesToTrack_Demo( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /**
+    * @function goodFeaturesToTrack_Demo.cpp
+    * @brief Apply Shi-Tomasi corner detector
+    */
+   void goodFeaturesToTrack_Demo( int, void* )
+   {
+     if( maxCorners < 1 ) { maxCorners = 1; }
+  
+     /// Parameters for Shi-Tomasi algorithm
+     vector<Point2f> corners;
+     double qualityLevel = 0.01;
+     double minDistance = 10;
+     int blockSize = 3;
+     bool useHarrisDetector = false;
+     double k = 0.04;
+
+     /// Copy the source image
+     Mat copy;
+     copy = src.clone();
+
+     /// Apply corner detection
+     goodFeaturesToTrack( src_gray, 
+	  	          corners,
+		          maxCorners,
+		          qualityLevel,
+		          minDistance,
+		          Mat(),
+		          blockSize,
+		          useHarrisDetector,
+		          k );
+  
+
+     /// Draw corners detected
+     cout<<"** Number of corners detected: "<<corners.size()<<endl;
+     int r = 4;
+     for( int 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 ); }
+
+     /// Show what you got
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, copy );  
+
+     /// Set the neeed parameters to find the refined corners
+     Size winSize = Size( 5, 5 );
+     Size zeroZone = Size( -1, -1 );
+     TermCriteria criteria = TermCriteria( CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 40, 0.001 );
+
+     /// Calculate the refined corner locations
+     cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );
+
+     /// Write them down
+     for( int i = 0; i < corners.size(); i++ )
+        { cout<<" -- Refined Corner ["<<i<<"]  ("<<corners[i].x<<","<<corners[i].y<<")"<<endl; }	
+   }
+
+
+Explanation
+============
+
+Result
+======
+
+.. image:: images/Corner_Subpixeles_Original_Image.jpg
+              :height: 200pt
+              :align: center 
+  
+Here is the result:
+
+.. image:: images/Corner_Subpixeles_Result.jpg
+              :height: 100pt
+              :align: center   
+

doc/tutorials/features2d/trackingmotion/generic_corner_detector/generic_corner_detector.rst

@@ -0,0 +1,155 @@
+.. _generic_corner_detector:
+
+Creating yor own corner detector
+********************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :corner_eigenvals_and_vecs:`cornerEigenValsAndVecs <>` to find the eigenvalues and eigenvectors to determine if a pixel is a corner.
+   * Use the OpenCV function :corner_min_eigenval:`cornerMinEigenVal <>` to find the minimum eigenvalues for corner detection. 
+   * To implement our own version of the Harris detector as well as the Shi-Tomasi detector, by using the two functions above.
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /// Global variables
+   Mat src, src_gray; 
+   Mat myHarris_dst; Mat myHarris_copy; Mat Mc;
+   Mat myShiTomasi_dst; Mat 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;
+
+   RNG rng(12345);
+
+   char* myHarris_window = "My Harris corner detector";
+   char* myShiTomasi_window = "My Shi Tomasi corner detector";
+
+   /// Function headers
+   void myShiTomasi_function( int, void* );
+   void myHarris_function( int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Set some parameters
+     int blockSize = 3; int 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 );
+
+     cornerEigenValsAndVecs( src_gray, myHarris_dst, blockSize, apertureSize, BORDER_DEFAULT );
+
+     /* 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<float>( j, i, 0 );
+               float lambda_2 = myHarris_dst.at<float>( j, i, 1 );
+               Mc.at<float>(j,i) = lambda_1*lambda_2 - 0.04*pow( ( lambda_1 + lambda_2 ), 2 );
+             }
+        }
+
+     minMaxLoc( Mc, &myHarris_minVal, &myHarris_maxVal, 0, 0, Mat() );
+  
+     /* Create Window and Trackbar */
+     namedWindow( myHarris_window, CV_WINDOW_AUTOSIZE );
+     createTrackbar( " Quality Level:", myHarris_window, &myHarris_qualityLevel, max_qualityLevel, myHarris_function );  
+     myHarris_function( 0, 0 );
+
+     /// 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, 0, 0, Mat() );
+
+     /* Create Window and Trackbar */
+     namedWindow( myShiTomasi_window, CV_WINDOW_AUTOSIZE );   
+     createTrackbar( " Quality Level:", myShiTomasi_window, &myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function );  
+     myShiTomasi_function( 0, 0 );
+  
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function myShiTomasi_function  */
+   void myShiTomasi_function( int, void* )
+   {
+     myShiTomasi_copy = src.clone();
+
+     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 );
+   }
+
+   /** @function myHarris_function */
+   void myHarris_function( int, void* )
+   {
+     myHarris_copy = src.clone();
+
+     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 );
+   }
+
+
+
+Explanation
+============
+
+Result
+======
+
+.. image:: images/My_Harris_corner_detector_Result.jpg
+              :height: 200pt
+              :align: center   
+
+
+.. image:: images/My_Shi_Tomasi_corner_detector_Result.jpg
+              :height: 200pt
+              :align: center   
+

doc/tutorials/features2d/trackingmotion/good_features_to_track/good_features_to_track.rst

@@ -0,0 +1,122 @@
+.. _good_features_to_track:
+
+Shi-Tomasi corner detector
+**************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the function :good_features_to_track:`goodFeaturesToTrack <>` to detect corners using the Shi-Tomasi method.
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /// Global variables
+   Mat src, src_gray;
+
+   int maxCorners = 23;
+   int maxTrackbar = 100;
+
+   RNG rng(12345);
+   char* source_window = "Image";
+
+   /// Function header
+   void goodFeaturesToTrack_Demo( int, void* );
+
+   /**
+    * @function main
+    */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Create Window
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+
+     /// Create Trackbar to set the number of corners
+     createTrackbar( "Max  corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );  
+
+     imshow( source_window, src );
+
+     goodFeaturesToTrack_Demo( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /**
+    * @function goodFeaturesToTrack_Demo.cpp
+    * @brief Apply Shi-Tomasi corner detector
+    */
+   void goodFeaturesToTrack_Demo( int, void* ) 
+   {
+     if( maxCorners < 1 ) { maxCorners = 1; }
+  
+     /// Parameters for Shi-Tomasi algorithm
+     vector<Point2f> corners;
+     double qualityLevel = 0.01;
+     double minDistance = 10;
+     int blockSize = 3;
+     bool useHarrisDetector = false;
+     double k = 0.04;
+
+     /// Copy the source image
+     Mat copy;
+     copy = src.clone();
+
+     /// Apply corner detection
+     goodFeaturesToTrack( src_gray, 
+	   	          corners,
+		          maxCorners,
+		          qualityLevel,
+		          minDistance,
+		          Mat(),
+		          blockSize,
+		          useHarrisDetector,
+		          k );
+  
+
+     /// Draw corners detected
+     cout<<"** Number of corners detected: "<<corners.size()<<endl;
+     int r = 4;
+     for( int 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 ); }
+
+     /// Show what you got
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, copy );  
+   }
+
+Explanation
+============
+
+Result
+======
+
+.. image:: images/Shi_Tomasi_Detector_Result.jpg
+              :height: 200pt
+              :align: center   
+
+

doc/tutorials/features2d/trackingmotion/harris_detector/harris_detector.rst

@@ -0,0 +1,116 @@
+.. _harris_detector:
+
+Harris corner detector
+**********************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the function :corner_harris:`cornerHarris <>` to detect corners using the Harris-Stephens method.
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv; 
+   using namespace std;
+
+   /// Global variables
+   Mat src, src_gray;
+   int thresh = 200;
+   int max_thresh = 255;
+
+   char* source_window = "Source image";
+   char* corners_window = "Corners detected";
+
+   /// Function header
+   void cornerHarris_demo( int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Create a window and a trackbar
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     createTrackbar( "Threshold: ", source_window, &thresh, max_thresh, cornerHarris_demo );
+     imshow( source_window, src );
+  
+     cornerHarris_demo( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function cornerHarris_demo */
+   void cornerHarris_demo( int, void* )
+   {
+
+     Mat dst, dst_norm, dst_norm_scaled;
+     dst = Mat::zeros( src.size(), CV_32FC1 );
+
+     /// Detector parameters
+     int blockSize = 2;
+     int apertureSize = 3;
+     double k = 0.04;
+ 
+     /// Detecting corners
+     cornerHarris( src_gray, dst, blockSize, apertureSize, k, BORDER_DEFAULT );
+
+     /// 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, CV_WINDOW_AUTOSIZE );
+     imshow( corners_window, dst_norm_scaled );
+   }
+
+
+Explanation
+============
+
+Result
+======
+
+The original image:
+
+.. image:: images/Harris_Detector_Original_Image.jpg
+              :height: 200pt
+              :align: center   
+
+The detected corners are surrounded by a small black circle
+
+.. image:: images/Harris_Detector_Result.jpg
+              :height: 200pt
+              :align: center   
+
+