title: gcc linking error: undefined reference to symbol '_ZN2cv5flann12SearchParamsC1Eifb',
body: <p>I am using <code>OpenCv</code> along with Eclipse to implement matching with homography. I am getting the following error while building it:</p>
  
  <blockquote>
    <p>/usr/bin/ld: ./src/flann.o: undefined reference to symbol
    '_ZN2cv5flann12SearchParamsC1Eifb'</p>
  </blockquote>
  
  <p><a href="http://i.stack.imgur.com/w2L2r.png" rel="nofollow">An image of compilation error.</a></p>
  
  <p>Here's my code:</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/nonfree.hpp"
  
  using namespace cv;
  
  void readme();
  
  /** @function main */
  int main()
  {
  
  
    Mat img_object = imread( "/home/gaps/Desktop/DSC00268.JPG");
    Mat img_scene = imread( "/home/gaps/Desktop/chart_1-2_1816185b.jpg" );
  
    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( minHessian );
  
    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;
  
    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
    std::vector&lt;Point2f&gt; obj;
    std::vector&lt;Point2f&gt; scene;
  
    for( int 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 )
    line( img_matches, scene_corners[0] + Point2f( img_object.cols, 0), scene_corners[1] + Point2f( img_object.cols, 0), Scalar(0, 255, 0), 4 );
    line( img_matches, scene_corners[1] + Point2f( img_object.cols, 0), scene_corners[2] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 );
    line( img_matches, scene_corners[2] + Point2f( img_object.cols, 0), scene_corners[3] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 );
    line( img_matches, scene_corners[3] + Point2f( img_object.cols, 0), scene_corners[0] + Point2f( img_object.cols, 0), 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_descriptor &lt;img1&gt; &lt;img2&gt;" &lt;&lt; std::endl; 
  }
  </code></pre>