opencv2.3.1学习笔记（1）

今天开始学习opencv，将前一段时间maltab仿真的结果在c++下实现，这样一来可以学习c++，或者学习opencv这种开源工具的代码习惯。

我主要做的是图像的配准，我计划最终实现基于视频的全景图像拼接，慢慢来，现在只做图像配准。

今天一个代码很有意义，现在记录下来。

#include <opencv2/opencv.hpp> 
#include <stdio.h>

using namespace std; 
using namespace cv; 



int main(int argc, char* argv[]) 
{ 
    Mat img1=imread("bird1.jpg");
    Mat img2=imread("bird2.jpg");
    cvtColor(img1,img1,CV_RGB2GRAY);
    cvtColor(img2,img2,CV_RGB2GRAY);

    //-- Step 1: Detect the keypoints using SURF Detector
    int minHessian=400;
    SurfFeatureDetector detector( minHessian );
    std::vector<KeyPoint> keypoints_1, keypoints_2;
    detector.detect( img1, keypoints_1 );
    detector.detect( img2, keypoints_2 );

    //-- Step 2: Calculate descriptors (feature vectors)
    SurfDescriptorExtractor extractor;
    Mat descriptors_1, descriptors_2;
    extractor.compute( img1, keypoints_1, descriptors_1 );
    extractor.compute( img2, keypoints_2, descriptors_2 );

    //-- Step 3: Matching descriptor vectors using FLANN matcher
    FlannBasedMatcher matcher;
//    BruteForceMatcher<L2<float>> matcher;
    std::vector< DMatch > matches;
    matcher.match( descriptors_1, descriptors_2, matches );

    double max_dist = 0; 
    double min_dist = 100;
    //-- Quick calculation of max and min distances between keypoints
    for( int i = 0; i < descriptors_1.rows; i++ )
    { 
        double dist = matches[i].distance;
        if( dist < min_dist ) min_dist = dist;
        if( dist > 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 2*min_dist )
    //-- PS.- radiusMatch can also be used here.
    std::vector< DMatch > good_matches;

    for( int i = 0; i < descriptors_1.rows; i++ )
    {
        if( matches[i].distance < 2*min_dist )
        { 
            good_matches.push_back( matches[i]);
        }
    }

    //-- Draw only "good" matches
    Mat img_matches;
    drawMatches( img1, keypoints_1, img2, keypoints_2,
                good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
                vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );


    //-- Localize the object
    std::vector<Point2f> obj;
    std::vector<Point2f> scene;

    for( int i = 0; i < good_matches.size(); i++ )
    {
        //-- Get the keypoints from the good matches
        obj.push_back( keypoints_1[ good_matches[i].queryIdx ].pt );
        scene.push_back( keypoints_2[ 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<Point2f> obj_corners(4);
    obj_corners[0] = cvPoint(0,0); 
    obj_corners[1] = cvPoint( img1.cols, 0 );
    obj_corners[2] = cvPoint( img1.cols, img1.rows ); 
    obj_corners[3] = cvPoint( 0, img1.rows );
    std::vector<Point2f> scene_corners(4);
    perspectiveTransform( obj_corners, scene_corners, H);

    //-- register the imahe using perspective transform
    //-- get the size of the registerd image
    Mat imageturn=Mat::zeros(max(scene_corners[1].x,scene_corners[2].x),
        max(scene_corners[2].y,scene_corners[3].y),img1.type());
    warpPerspective(img1,imageturn,H,cv::Size(imageturn.rows,imageturn.cols));

    //-- register the image using affine transform
    vector<Point2f> img1corners(3);
    img1corners[0]=obj[0];
    img1corners[1]=obj[1];
    img1corners[2]=obj[2];
    vector<Point2f> img2corners(3);
    img2corners[0]=scene[0];
    img2corners[1]=scene[1];
    img2corners[2]=scene[2];
    Mat affineMat=getAffineTransform(img1corners,img2corners);
    Mat imageAffine=Mat::zeros(max(scene_corners[1].x,scene_corners[2].x),
        max(scene_corners[2].y,scene_corners[3].y),img1.type());
    warpAffine(img1,imageAffine,affineMat,cv::Size(imageAffine.rows,imageAffine.cols));

    //-- Draw lines between the corners (the mapped object in the scene - image_2 )
    line( img_matches, scene_corners[0] + Point2f( img1.cols, 0), scene_corners[1] + Point2f( img1.cols, 0), Scalar( 0, 255, 0), 4 );
    line( img_matches, scene_corners[1] + Point2f( img1.cols, 0), scene_corners[2] + Point2f( img1.cols, 0), Scalar( 0, 255, 0), 4 );
    line( img_matches, scene_corners[2] + Point2f( img1.cols, 0), scene_corners[3] + Point2f( img1.cols, 0), Scalar( 0, 255, 0), 4 );
    line( img_matches, scene_corners[3] + Point2f( img1.cols, 0), scene_corners[0] + Point2f( img1.cols, 0), Scalar( 0, 255, 0), 4 );

    //-- Show detected matches
    imshow( "Good Matches & Object detection", img_matches );
    imshow("perspective image",imageturn);
    imshow("affine image",imageAffine);
    //-- Show detected matches
    //imshow( "Good Matches", img_matches );

    //for( int i = 0; i < good_matches.size(); i++ )
    //{ 
    //    printf( "-- Good Match [%d] Keypoint 1: %d  -- Keypoint 2: %d  \n", i, good_matches[i].queryIdx, good_matches[i].trainIdx ); 
    //}
    waitKey();
    return 0;
}