透视变换，图像拼接

#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/nonfree/features2d.hpp>
#include <opencv2/features2d/features2d.hpp>

using namespace cv;
using namespace std;

void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);

typedef struct
{
    Point2f left_top;
    Point2f left_bottom;
    Point2f right_top;
    Point2f right_bottom;
}four_corners_t;

four_corners_t corners;

void CalcCorners(const Mat& H, const Mat& src)
{
    double v2[] = { 0, 0, 1 };//左上角
    double v1[3];//变换后的坐标值
    Mat V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    Mat V1 = Mat(3, 1, CV_64FC1, v1);  //列向量

    V1 = H * V2;
    //左上角(0,0,1)
    cout << "V2: " << V2 << endl;
    cout << "V1: " << V1 << endl;
    corners.left_top.x = v1[0] / v1[2];
    corners.left_top.y = v1[1] / v1[2];

    //左下角(0,src.rows,1)
    v2[0] = 0;
    v2[1] = src.rows;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.left_bottom.x = v1[0] / v1[2];
    corners.left_bottom.y = v1[1] / v1[2];

    //右上角(src.cols,0,1)
    v2[0] = src.cols;
    v2[1] = 0;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.right_top.x = v1[0] / v1[2];
    corners.right_top.y = v1[1] / v1[2];

    //右下角(src.cols,src.rows,1)
    v2[0] = src.cols;
    v2[1] = src.rows;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.right_bottom.x = v1[0] / v1[2];
    corners.right_bottom.y = v1[1] / v1[2];

}

int main(int argc, char *argv[])
{
    Mat image01 = imread("left1.jpg", 1);    //右图
    Mat image02 = imread("left2.jpg", 1);    //左图


    //灰度图转换  
    Mat image1, image2;
    cvtColor(image01, image1, CV_RGB2GRAY);
    cvtColor(image02, image2, CV_RGB2GRAY);


    //提取特征点    
    OrbFeatureDetector Detector;

    vector<KeyPoint> keyPoint1, keyPoint2;
    Detector.detect(image1, keyPoint1);
    Detector.detect(image2, keyPoint2);
    cout << "kp1 = " <<keyPoint1.size() << "    kp2 = " << keyPoint2.size() << endl;


    //特征点描述，为下边的特征点匹配做准备    
    OrbDescriptorExtractor Descriptor;
    Mat imageDesc1, imageDesc2;
    Descriptor.compute(image1, keyPoint1, imageDesc1);
    Descriptor.compute(image2, keyPoint2, imageDesc2);

    cout << "kp1 = " <<imageDesc1.rows << "    kp2 = " << imageDesc2.rows << endl;

    //FlannBasedMatcher matcher;


    //vector<vector<DMatch> > matchePoints;
    vector<DMatch> GoodMatchePoints;

    vector< DMatch > matchePoints;
    BFMatcher matcher(NORM_L2);
        matcher.match(imageDesc1,imageDesc2,matchePoints,Mat());
     cout << "detector!" << endl;

    // Lowe's algorithm,获取优秀匹配点
     double max_dist = 0; double min_dist = 100;

       //-- Quick calculation of max and min distances between keypoints
       for( int i = 0; i < imageDesc1.rows; i++ )
       { double dist = matchePoints[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 < imageDesc1.rows; i++ )
       { if( matchePoints[i].distance < 2*min_dist )
         { GoodMatchePoints.push_back( matchePoints[i]); }
       }
    if(GoodMatchePoints.size() <= 0)
    {
        cout << "point = 0" << endl;
        return 0;
    }

    Mat first_match;
    drawMatches(image01, keyPoint1, image02, keyPoint2, GoodMatchePoints, first_match);
    imshow("first_match ", first_match);
        waitKey(0);

    vector<Point2f> imagePoints1, imagePoints2;

    for (int i = 0; i<GoodMatchePoints.size(); i++)
    {
        imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].trainIdx].pt);
        imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].queryIdx].pt);
    }



    //获取图像1到图像2的投影映射矩阵 尺寸为3*3  
    Mat homo = findHomography(imagePoints2, imagePoints1, CV_RANSAC);
    也可以使用getPerspectiveTransform方法获得透视变换矩阵，不过要求只能有4个点，效果稍差  
    //Mat   homo=getPerspectiveTransform(imagePoints1,imagePoints2);  
    cout << "变换矩阵为：\n" << homo << endl << endl; //输出映射矩阵      

   //计算配准图的四个顶点坐标
    CalcCorners(homo, image02);
    cout << "left_top:" << corners.left_top << endl;
    cout << "left_bottom:" << corners.left_bottom << endl;
    cout << "right_top:" << corners.right_top << endl;
    cout << "right_bottom:" << corners.right_bottom << endl;

    //图像配准
    Mat imageTransform1, imageTransform2;
    std::vector<Point2f> obj_corners(4);//image02
    obj_corners[0] = Point(0,0); obj_corners[1] = Point( image02.cols, 0 );
    obj_corners[2] = Point( image02.cols, image02.rows ); obj_corners[3] = Point( 0, image02.rows );
    std::vector<Point2f> scene_corners(4);
    perspectiveTransform( obj_corners, scene_corners, homo);





//    warpPerspective(image02, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image01.rows));
    warpPerspective(image02, imageTransform1, homo, Size(MAX(scene_corners[1].x, scene_corners[2].x), image01.rows));
    imshow("直接经过透视矩阵变换", imageTransform1);



    line( image01, scene_corners[0] , scene_corners[1] , Scalar(0, 255, 0), 4 );
    line( image01, scene_corners[1] , scene_corners[2] , Scalar( 0, 255, 0), 4 );
    line( image01, scene_corners[2] , scene_corners[3] , Scalar( 0, 255, 0), 4 );
    line( image01, scene_corners[3] , scene_corners[0] , Scalar( 0, 255, 0), 4 );


    imshow("p1", image01);
    imshow("p2", image02);
//    imwrite("trans1.jpg", imageTransform1);


//    //创建拼接后的图,需提前计算图的大小
    int dst_width = imageTransform1.cols;  //取最右点的长度为拼接图的长度
    int dst_height = image01.rows;

    Mat dst(dst_height, dst_width, CV_8UC3);
    dst.setTo(0);

    imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
    image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));

    imshow("b_dst", dst);


//    OptimizeSeam(image02, imageTransform1, dst);


//    imshow("dst", dst);
//    imwrite("dst.jpg", dst);


    waitKey(0);

    return 0;
}


//优化两图的连接处，使得拼接自然
void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
{
    int start = MIN(corners.left_top.x, corners.left_bottom.x);//开始位置，即重叠区域的左边界  

    double processWidth = img1.cols - start;//重叠区域的宽度  
    int rows = dst.rows;
    int cols = img1.cols; //注意，是列数*通道数
    double alpha = 1;//img1中像素的权重  
    for (int i = 0; i < rows; i++)
    {
        uchar* p = img1.ptr<uchar>(i);  //获取第i行的首地址
        uchar* t = trans.ptr<uchar>(i);
        uchar* d = dst.ptr<uchar>(i);
        for (int j = start; j < cols; j++)
        {
            //如果遇到图像trans中无像素的黑点，则完全拷贝img1中的数据
            if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
            {
                alpha = 1;
            }
            else
            {
                //img1中像素的权重，与当前处理点距重叠区域左边界的距离成正比，实验证明，这种方法确实好  
                alpha = (processWidth - (j - start)) / processWidth;
            }

            d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
            d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
            d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);

        }
    }

}