title: OpenCV cv::findHomography runtime error
body: <p>I am using to compile and run code from <a href="http://opencv.itseez.com/doc/tutorials/features2d/feature_homography/feature_homography.html#feature-homography">Features2D + Homography to find a known object</a> tutorial, and I am getting this</p>
  
  <pre><code>OpenCV Error: Assertion failed (npoints &gt;= 0 &amp;&amp; points2.checkVector(2) == npoint
  s &amp;&amp; points1.type() == points2.type()) in unknown function, file c:\Users\vp\wor
  k\ocv\opencv\modules\calib3d\src\fundam.cpp, line 1062
  </code></pre>
  
  <p>run-time error. after debugging I find that the program is crashing at findHomography function.</p>
  
  <pre><code>Unhandled exception at 0x760ab727 in OpenCVTemplateMatch.exe: Microsoft C++ exception: cv::Exception at memory location 0x0029eb3c..
  </code></pre>
  
  <p>in the <a href="http://opencv.itseez.com/modules/core/doc/intro.html">Introduction</a> of OpenCV, the "cv Namespace" chapter says that </p>
  
  <blockquote>
    <p>Some of the current or future OpenCV external names may conflict with STL or other libraries. In this case, use explicit namespace specifiers to resolve the name conflicts:</p>
  </blockquote>
  
  <p>I changed my code and use everywhere explicit namespace specifiers, but problem did not solved. If you can, please help me in this problem, or say which function do same thing as findHomography, and do not crash program.</p>
  
  <p>And this is 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"
  
  void readme();
  
  /** @function main */
  int main( int argc, char** argv )
  {
      if( argc != 3 )
      { readme(); return -1; }
  
      cv::Mat img_object = cv::imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE );
      cv::Mat img_scene = cv::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;
  
      cv::SurfFeatureDetector detector( minHessian );
  
      std::vector&lt;cv::KeyPoint&gt; keypoints_object, keypoints_scene;
  
      detector.detect( img_object, keypoints_object );
      detector.detect( img_scene, keypoints_scene );
  
      //-- Step 2: Calculate descriptors (feature vectors)
      cv::SurfDescriptorExtractor extractor;
  
      cv::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
      cv::FlannBasedMatcher matcher;
      std::vector&lt; cv::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; cv::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]); }
      }
  
      cv::Mat img_matches;
      cv::drawMatches( img_object, keypoints_object, img_scene, keypoints_scene,
          good_matches, img_matches, cv::Scalar::all(-1), cv::Scalar::all(-1),
          std::vector&lt;char&gt;(), cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
  
      //-- Localize the object
      std::vector&lt;cv::Point2f&gt; obj;
      std::vector&lt;cv::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 );
      }
  
      cv::Mat H = cv::findHomography( obj, scene, CV_RANSAC );
  
      //-- Get the corners from the image_1 ( the object to be "detected" )
      std::vector&lt;cv::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;cv::Point2f&gt; scene_corners(4);
  
      cv::perspectiveTransform( obj_corners, scene_corners, H);
  
      //-- Draw lines between the corners (the mapped object in the scene - image_2 )
      cv::line( img_matches, scene_corners[0] + cv::Point2f( img_object.cols, 0), scene_corners[1] + cv::Point2f( img_object.cols, 0), cv::Scalar(0, 255, 0), 4 );
      cv::line( img_matches, scene_corners[1] + cv::Point2f( img_object.cols, 0), scene_corners[2] + cv::Point2f( img_object.cols, 0), cv::Scalar( 0, 255, 0), 4 );
      cv::line( img_matches, scene_corners[2] + cv::Point2f( img_object.cols, 0), scene_corners[3] + cv::Point2f( img_object.cols, 0), cv::Scalar( 0, 255, 0), 4 );
      cv::line( img_matches, scene_corners[3] + cv::Point2f( img_object.cols, 0), scene_corners[0] + cv::Point2f( img_object.cols, 0), cv::Scalar( 0, 255, 0), 4 );
  
      //-- Show detected matches
      cv::imshow( "Good Matches &amp; Object detection", img_matches );
  
      cv::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>