title: OpenCV undefined reference to cv::SURF::SURF() eclipse
body: <p>I am trying to stitch images in android like panorama view.I am trying to use surf descriptor for stitching images.I am using 2.4.0 version of openCv because upper version doesn't contain nonfree folder for surf descriptor.I have also included </p>
  
  <pre><code> #include "opencv2/nonfree/features2d.hpp"
   #include "opencv2/nonfree/nonfree.hpp"
  </code></pre>
  
  <p>in header and also given the path  <strong>..\jni\include</strong> and <strong>..\native\libs\armeabi-v7a</strong> in GNU path which contains all <strong>.a</strong>  files.Below is my code which i have taken from the OpenCV example</p>
  
  <pre><code> #include &lt;stdio.h&gt;
   #include &lt;iostream&gt;
   #include "opencv2/core/core.hpp"
   #include "opencv2/features2d/features2d.hpp"
   #include "opencv2/highgui/highgui.hpp"
   #include "opencv2/calib3d/calib3d.hpp"
   #include "opencv2/nonfree/features2d.hpp"
   #include "opencv2/nonfree/nonfree.hpp" 
  
  
   using namespace std;
   using namespace cv;
  
  void readme();
  
   int main( int argc, char** argv )
  {
   if( argc != 3 )
   { 
    readme(); return -1; 
   }
  
   Mat img_object = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE );
   Mat img_scene = imread( argv[2], CV_LOAD_IMAGE_GRAYSCALE );
  
   if( !img_object.data || !img_scene.data )
   { std::cout&lt;&lt; " --(!) Error reading images " &lt;&lt; std::endl; return -1; }
  
   //-- Step 1: Detect the keypoints using SURF Detector
   int minHessian = 400;
  
   SurfFeatureDetector detector(400); //error:undefined reference to cv::SURF::SURF(double, int, int, bool, bool)
  
   std::vector&lt;KeyPoint&gt; keypoints_object, keypoints_scene;
  
   detector.detect( img_object, keypoints_object );
   detector.detect( img_scene, keypoints_scene );
  
  //-- Step 2: Calculate descriptors (feature vectors)
  SurfDescriptorExtractor extractor; //error:undefined reference to cv::SURF::SURF()
  
  Mat descriptors_object, descriptors_scene;
  
  extractor.compute( img_object, keypoints_object, descriptors_object );
  extractor.compute( img_scene, keypoints_scene, descriptors_scene );
  
  //-- Step 3: Matching descriptor vectors using FLANN matcher
  FlannBasedMatcher matcher;
  std::vector&lt; DMatch &gt; matches;
  matcher.match( descriptors_object, descriptors_scene, matches );
  
  double max_dist = 0; double min_dist = 100;
  
  //-- Quick calculation of max and min distances between keypoints
  
  for( int i = 0; i &lt; descriptors_object.rows; i++ )
  { double dist = matches[i].distance;
   if( dist &lt; min_dist ) min_dist = dist;
    if( dist &gt; 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 3*min_dist )
   std::vector&lt; DMatch &gt; good_matches;
  
   for( int i = 0; i &lt; descriptors_object.rows; i++ )
   { if( matches[i].distance &lt; 3*min_dist )
    { good_matches.push_back( matches[i]); }
    }
  
   Mat img_matches;
   drawMatches( img_object, keypoints_object, img_scene, keypoints_scene,
             good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
             vector&lt;char&gt;(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
  
  
    //-- Localize the object from img_1 in img_2
    std::vector&lt;Point2f&gt; obj;
    std::vector&lt;Point2f&gt; scene;
  
    for( size_t i = 0; i &lt; 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, CV_RANSAC );
  
   //-- Get the corners from the image_1 ( the object to be "detected" )
    std::vector&lt;Point2f&gt; obj_corners(4);
    obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( img_object.cols, 0 );
    obj_corners[2] = cvPoint( img_object.cols, img_object.rows ); obj_corners[3] = cvPoint( 0, img_object.rows );
    std::vector&lt;Point2f&gt; scene_corners(4);
  
    perspectiveTransform( obj_corners, scene_corners, H);
  
  
   //-- Draw lines between the corners (the mapped object in the scene - image_2 )
   Point2f offset( (float)img_object.cols, 0);
   line( img_matches, scene_corners[0] + offset, scene_corners[1] + offset, Scalar(0, 255, 0), 4 );
   line( img_matches, scene_corners[1] + offset, scene_corners[2] + offset, Scalar( 0, 255, 0), 4 );
   line( img_matches, scene_corners[2] + offset, scene_corners[3] + offset, Scalar( 0, 255, 0), 4 );
   line( img_matches, scene_corners[3] + offset, scene_corners[0] + offset, Scalar( 0, 255, 0), 4 );
  
   //-- Show detected matches
   imshow( "Good Matches &amp; Object detection", img_matches );
  
   waitKey(0);
  
   return 0;}
  
   /**
   * @function readme
   */
  void readme()
  { std::cout &lt;&lt; " Usage: ./SURF_Homography &lt;img1&gt; &lt;img2&gt;" &lt;&lt; std::endl; } 
  </code></pre>
  
  <p>I got the error where SurfFeatureDetector and SurfDescriptorExtractor declared.I have written error in comment.Anybody have any idea regarding this then please suggest.I am really stuck to this problem.:(  Thanks in advance. </p>