find object

#include  " stdafx.h "
#include  " cv.h "
#include  " highgui.h "

using  namespace cv;

int _tmain( int argc, _TCHAR* argv[])
{
     // const cv::Mat object = cv::imread("lenaface.JPG", 0);  // Load as grayscale
     // const cv::Mat image = cv::imread("lena.jpg", 0);
     const cv::Mat  object = cv::imread( " box.png ",  0);  // Load as grayscale
     const cv::Mat image = cv::imread( " box_in_scene.png ",  0);
     // 1.detect keypoints of object and image using SIFT
    cv::SiftFeatureDetector *detector;
    detector =  new SiftFeatureDetector( 0.04/ 5/ 2.0, 0.5);
     // SurfFeatureDetector detector;
    std::vector<cv::KeyPoint> objectKeypoints;
    std::vector<cv::KeyPoint> imageKeypoints;
    detector->detect( object, objectKeypoints);
     // show
     // cv::Mat output_object;
     // cv::drawKeypoints(object, objectKeypoints, output_object);
     /// /cv::imwrite("output_object.jpg", output_object);
     // cv::namedWindow("object", CV_WINDOW_AUTOSIZE);
     // cv::imshow("object", output_object);
     //
    detector->detect(image,imageKeypoints);
     // show
     // cv::Mat output_image;
     // cv::drawKeypoints(image, imageKeypoints, output_image);
     /// /cv::imwrite("output_image.jpg", output_image);
     // cv::namedWindow("image", CV_WINDOW_AUTOSIZE);
     // cv::imshow("image", output_image);

     // 2.get Descriptors
    Mat objectDescriptor,imageDescriptor;
    cv::SiftDescriptorExtractor descriptorExtractor;
     // cv::SurfDescriptorExtractor descriptorExtractor;
    descriptorExtractor.compute( object,  objectKeypoints, objectDescriptor);
    descriptorExtractor.compute(image , imageKeypoints, imageDescriptor );

     // 3.
     //  Match descriptors of 2 images (find pairs of corresponding points)
    BruteForceMatcher<L2< float>> matcher; //  Use FlannBasedMatcher matcher. It is better
    vector<DMatch> matches;
    matcher.match(objectDescriptor, imageDescriptor, matches);


     //  Extract pairs of points
    vector< int> pairOfsrcKP(matches.size()), pairOfdstKP(matches.size());
     for( size_t i =  0; i < matches.size(); i++ ){
        pairOfsrcKP[i] = matches[i].queryIdx;
        pairOfdstKP[i] = matches[i].trainIdx;
    }

    vector<Point2f> sPoints; KeyPoint::convert(objectKeypoints, sPoints,pairOfsrcKP);
    vector<Point2f> dPoints; KeyPoint::convert(imageKeypoints, dPoints,pairOfdstKP);

     //  Matched pairs of 2D points. Those pairs will be used to calculate homography
    Mat src2Dfeatures;
    Mat dst2Dfeatures;
    Mat(sPoints).copyTo(src2Dfeatures);
    Mat(dPoints).copyTo(dst2Dfeatures);

     //  Calculate homography
    vector<uchar> outlierMask;
    
        double h[ 9];
     // CvMat H = cvMat(3, 3, CV_64F, h);
    Mat H;
    H = findHomography( src2Dfeatures, dst2Dfeatures, outlierMask, RANSAC,  3);
    Mat outimg;
    drawMatches( object, objectKeypoints,image, imageKeypoints, matches, outimg, Scalar::all(- 1), Scalar::all(- 1),
        reinterpret_cast< const vector< char>&> (outlierMask));
     // imshow("Matches: Src image (left) to dst (right)", outimg);

     //

    CvPoint src_corners[ 4] = {{ 0, 0}, { object.cols, 0}, { object.cols,  object.rows}, { 0,  object.rows}};
    CvPoint dst_corners[ 4];

     int k =  0;
     for( int i =  0; i < H.rows; i++)
     for( int j =  0; j < H.cols; j++)
        h[k++]= H.at< double>(i,j);

     for(  int i =  0; i <  4; i++ )
    {
         double x = src_corners[i].x, y = src_corners[i].y;
         double Z =  1./(h[ 6]*x + h[ 7]*y + h[ 8]);
         double X = (h[ 0]*x + h[ 1]*y + h[ 2])*Z;
         double Y = (h[ 3]*x + h[ 4]*y + h[ 5])*Z;
        dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));
    }
    Mat lineBox(outimg);
     for(  int i =  0; i <  4; i++ )
    {
        CvPoint r1 = dst_corners[i% 4];
        CvPoint r2 = dst_corners[(i+ 1)% 4];
        line( lineBox, cvPoint(r1.x+ object.cols, r1.y ), cvPoint(r2.x+ object.cols , r2.y), Scalar( 0, 125, 255),  3, CV_AA);
    }
    imshow( " Matches: Src image (left) to dst (right) ", lineBox);
    waitKey();
}