图像拼接在实际的应用场景很广，比如无人机航拍，遥感图像等等，图像拼接是进一步做图像理解基础步骤，拼接效果的好坏直接影响接下来的工作，所以一个好的图像拼接算法非常重要。

再举一个身边的例子吧，你用你的手机对某一场景拍照，但是你没有办法一次将所有你要拍的景物全部拍下来，所以你对该场景从左往右依次拍了好几张图，来把你要拍的所有景物记录下来。那么我们能不能把这些图像拼接成一个大图呢？我们利用opencv就可以做到图像拼接的效果！

比如我们有对这两张图进行拼接。

从上面两张图可以看出，这两张图有比较多的重叠部分，这也是拼接的基本要求。

那么要实现图像拼接需要那几步呢？简单来说有以下几步：

  1. 对每幅图进行特征点提取
  2. 对对特征点进行匹配
  3. 进行图像配准
  4. 把图像拷贝到另一幅图像的特定位置
  5. 对重叠边界进行特殊处理

好吧，那就开始正式实现图像配准。

第一步就是特征点提取。现在CV领域有很多特征点的定义，比如sift、surf、harris角点、ORB都是很有名的特征因子，都可以用来做图像拼接的工作，他们各有优势。本文将使用ORB和SURF进行图像拼接，用其他方法进行拼接也是类似的。

基于SURF的图像拼接

用SIFT算法来实现图像拼接是很常用的方法，但是因为SIFT计算量很大，所以在速度要求很高的场合下不再适用。所以，它的改进方法SURF因为在速度方面有了明显的提高（速度是SIFT的3倍），所以在图像拼接领域还是大有作为。虽说SURF精确度和稳定性不及SIFT，但是其综合能力还是优越一些。下面将详细介绍拼接的主要步骤。

1.特征点提取和匹配

特征点提取和匹配的方法我在上一篇文章《OpenCV探索之路（二十三）：特征检测和特征匹配方法汇总》中做了详细的介绍，在这里直接使用上文所总结的SURF特征提取和特征匹配的方法。

  1. //提取特征点
  2. SurfFeatureDetector Detector(2000);
  3. vector<KeyPoint> keyPoint1, keyPoint2;
  4. Detector.detect(image1, keyPoint1);
  5. Detector.detect(image2, keyPoint2);
  7. //特征点描述，为下边的特征点匹配做准备
  8. SurfDescriptorExtractor Descriptor;
  9. Mat imageDesc1, imageDesc2;
  10. Descriptor.compute(image1, keyPoint1, imageDesc1);
  11. Descriptor.compute(image2, keyPoint2, imageDesc2);
  13. FlannBasedMatcher matcher;
  14. vector<vector<DMatch> > matchePoints;
  15. vector<DMatch> GoodMatchePoints;
  17. vector<Mat> train_desc(1, imageDesc1);
  18. matcher.add(train_desc);
  19. matcher.train();
  21. matcher.knnMatch(imageDesc2, matchePoints, 2);
  22. cout << "total match points: " << matchePoints.size() << endl;
  24. // Lowe's algorithm,获取优秀匹配点
  25. for (int i = 0; i < matchePoints.size(); i++)
  26. {
  27.     if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
  28.     {
  29.         GoodMatchePoints.push_back(matchePoints[i][0]);
  30.     }
  31. }
  33. Mat first_match;
  34. drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
  35. imshow("first_match ", first_match);

2.图像配准

这样子我们就可以得到了两幅待拼接图的匹配点集，接下来我们进行图像的配准，即将两张图像转换为同一坐标下，这里我们需要使用findHomography函数来求得变换矩阵。但是需要注意的是，findHomography函数所要用到的点集是Point2f类型的，所有我们需要对我们刚得到的点集GoodMatchePoints再做一次处理，使其转换为Point2f类型的点集。

  1. vector<Point2f> imagePoints1, imagePoints2;
  3. for (int i = 0; i<GoodMatchePoints.size(); i++)
  4. {
  5.     imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
  6.     imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
  7. }

这样子，我们就可以拿着imagePoints1, imagePoints2去求变换矩阵了，并且实现图像配准。值得注意的是findHomography函数的参数中我们选泽了CV_RANSAC，这表明我们选择RANSAC算法继续筛选可靠地匹配点，这使得匹配点解更为精确。

  1. //获取图像1到图像2的投影映射矩阵 尺寸为3*3
  2. Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
  3. ////也可以使用getPerspectiveTransform方法获得透视变换矩阵，不过要求只能有4个点，效果稍差
  4. //Mat   homo=getPerspectiveTransform(imagePoints1,imagePoints2);
  5. cout << "变换矩阵为：\n" << homo << endl << endl; //输出映射矩阵     
  7. //图像配准
  8. Mat imageTransform1, imageTransform2;
  9. warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
  10. //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
  11. imshow("直接经过透视矩阵变换", imageTransform1);
  12. imwrite("trans1.jpg", imageTransform1);

3. 图像拷贝

拷贝的思路很简单，就是将左图直接拷贝到配准图上就可以了。

  1. //创建拼接后的图,需提前计算图的大小
  2. int dst_width = imageTransform1.cols;  //取最右点的长度为拼接图的长度
  3. int dst_height = image02.rows;
  5. Mat dst(dst_height, dst_width, CV_8UC3);
  6. dst.setTo(0);
  8. imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
  9. image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));
  11. imshow("b_dst", dst);

4.图像融合（去裂缝处理）

从上图可以看出，两图的拼接并不自然，原因就在于拼接图的交界处，两图因为光照色泽的原因使得两图交界处的过渡很糟糕，所以需要特定的处理解决这种不自然。这里的处理思路是加权融合，在重叠部分由前一幅图像慢慢过渡到第二幅图像，即将图像的重叠区域的像素值按一定的权值相加合成新的图像。


  2. //优化两图的连接处，使得拼接自然
  3. void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
  4. {
  5.     int start = MIN(corners.left_top.x, corners.left_bottom.x);//开始位置，即重叠区域的左边界  
  7.     double processWidth = img1.cols - start;//重叠区域的宽度
  8.     int rows = dst.rows;
  9.     int cols = img1.cols; //注意，是列数*通道数
  10.     double alpha = 1;//img1中像素的权重
  11.     for (int i = 0; i < rows; i++)
  12.     {
  13.         uchar* p = img1.ptr<uchar>(i);  //获取第i行的首地址
  14.         uchar* t = trans.ptr<uchar>(i);
  15.         uchar* d = dst.ptr<uchar>(i);
  16.         for (int j = start; j < cols; j++)
  17.         {
  18.             //如果遇到图像trans中无像素的黑点，则完全拷贝img1中的数据
  19.             if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
  20.             {
  21.                 alpha = 1;
  22.             }
  23.             else
  24.             {
  25.                 //img1中像素的权重，与当前处理点距重叠区域左边界的距离成正比，实验证明，这种方法确实好
  26.                 alpha = (processWidth - (j - start)) / processWidth;
  27.             }
  29.             d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
  30.             d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
  31.             d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);
  33.         }
  34.     }
  36. }

多尝试几张，验证拼接效果

测试一

测试二

测试三

最后给出完整的SURF算法实现的拼接代码。

  1. #include "highgui/highgui.hpp"
  2. #include "opencv2/nonfree/nonfree.hpp"
  3. #include "opencv2/legacy/legacy.hpp"
  4. #include <iostream>  
  6. using namespace cv;
  7. using namespace std;
  9. void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);
  11. typedef struct
  12. {
  13.     Point2f left_top;
  14.     Point2f left_bottom;
  15.     Point2f right_top;
  16.     Point2f right_bottom;
  17. }four_corners_t;
  19. four_corners_t corners;
  21. void CalcCorners(const Mat& H, const Mat& src)
  22. {
  23.     double v2[] = { 0, 0, 1 };//左上角
  24.     double v1[3];//变换后的坐标值
  25.     Mat V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  26.     Mat V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  28.     V1 = H * V2;
  29.     //左上角(0,0,1)
  30.     cout << "V2: " << V2 << endl;
  31.     cout << "V1: " << V1 << endl;
  32.     corners.left_top.x = v1[0] / v1[2];
  33.     corners.left_top.y = v1[1] / v1[2];
  35.     //左下角(0,src.rows,1)
  36.     v2[0] = 0;
  37.     v2[1] = src.rows;
  38.     v2[2] = 1;
  39.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  40.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  41.     V1 = H * V2;
  42.     corners.left_bottom.x = v1[0] / v1[2];
  43.     corners.left_bottom.y = v1[1] / v1[2];
  45.     //右上角(src.cols,0,1)
  46.     v2[0] = src.cols;
  47.     v2[1] = 0;
  48.     v2[2] = 1;
  49.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  50.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  51.     V1 = H * V2;
  52.     corners.right_top.x = v1[0] / v1[2];
  53.     corners.right_top.y = v1[1] / v1[2];
  55.     //右下角(src.cols,src.rows,1)
  56.     v2[0] = src.cols;
  57.     v2[1] = src.rows;
  58.     v2[2] = 1;
  59.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  60.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  61.     V1 = H * V2;
  62.     corners.right_bottom.x = v1[0] / v1[2];
  63.     corners.right_bottom.y = v1[1] / v1[2];
  65. }
  67. int main(int argc, char *argv[])
  68. {
  69.     Mat image01 = imread("g5.jpg", 1);    //右图
  70.     Mat image02 = imread("g4.jpg", 1);    //左图
  71.     imshow("p2", image01);
  72.     imshow("p1", image02);
  74.     //灰度图转换
  75.     Mat image1, image2;
  76.     cvtColor(image01, image1, CV_RGB2GRAY);
  77.     cvtColor(image02, image2, CV_RGB2GRAY);
  79.     //提取特征点
  80.     SurfFeatureDetector Detector(2000);
  81.     vector<KeyPoint> keyPoint1, keyPoint2;
  82.     Detector.detect(image1, keyPoint1);
  83.     Detector.detect(image2, keyPoint2);
  85.     //特征点描述，为下边的特征点匹配做准备
  86.     SurfDescriptorExtractor Descriptor;
  87.     Mat imageDesc1, imageDesc2;
  88.     Descriptor.compute(image1, keyPoint1, imageDesc1);
  89.     Descriptor.compute(image2, keyPoint2, imageDesc2);
  91.     FlannBasedMatcher matcher;
  92.     vector<vector<DMatch> > matchePoints;
  93.     vector<DMatch> GoodMatchePoints;
  95.     vector<Mat> train_desc(1, imageDesc1);
  96.     matcher.add(train_desc);
  97.     matcher.train();
  99.     matcher.knnMatch(imageDesc2, matchePoints, 2);
  100.     cout << "total match points: " << matchePoints.size() << endl;
  102.     // Lowe's algorithm,获取优秀匹配点
  103.     for (int i = 0; i < matchePoints.size(); i++)
  104.     {
  105.         if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
  106.         {
  107.             GoodMatchePoints.push_back(matchePoints[i][0]);
  108.         }
  109.     }
  111.     Mat first_match;
  112.     drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
  113.     imshow("first_match ", first_match);
  115.     vector<Point2f> imagePoints1, imagePoints2;
  117.     for (int i = 0; i<GoodMatchePoints.size(); i++)
  118.     {
  119.         imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
  120.         imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
  121.     }
  123.     //获取图像1到图像2的投影映射矩阵 尺寸为3*3
  124.     Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
  125.     ////也可以使用getPerspectiveTransform方法获得透视变换矩阵，不过要求只能有4个点，效果稍差
  126.     //Mat   homo=getPerspectiveTransform(imagePoints1,imagePoints2);
  127.     cout << "变换矩阵为：\n" << homo << endl << endl; //输出映射矩阵      
  129.    //计算配准图的四个顶点坐标
  130.     CalcCorners(homo, image01);
  131.     cout << "left_top:" << corners.left_top << endl;
  132.     cout << "left_bottom:" << corners.left_bottom << endl;
  133.     cout << "right_top:" << corners.right_top << endl;
  134.     cout << "right_bottom:" << corners.right_bottom << endl;
  136.     //图像配准
  137.     Mat imageTransform1, imageTransform2;
  138.     warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
  139.     //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
  140.     imshow("直接经过透视矩阵变换", imageTransform1);
  141.     imwrite("trans1.jpg", imageTransform1);
  143.     //创建拼接后的图,需提前计算图的大小
  144.     int dst_width = imageTransform1.cols;  //取最右点的长度为拼接图的长度
  145.     int dst_height = image02.rows;
  147.     Mat dst(dst_height, dst_width, CV_8UC3);
  148.     dst.setTo(0);
  150.     imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
  151.     image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));
  153.     imshow("b_dst", dst);
  155.     OptimizeSeam(image02, imageTransform1, dst);
  157.     imshow("dst", dst);
  158.     imwrite("dst.jpg", dst);
  160.     waitKey();
  162.     return 0;
  163. }
  165. //优化两图的连接处，使得拼接自然
  166. void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
  167. {
  168.     int start = MIN(corners.left_top.x, corners.left_bottom.x);//开始位置，即重叠区域的左边界  
  170.     double processWidth = img1.cols - start;//重叠区域的宽度
  171.     int rows = dst.rows;
  172.     int cols = img1.cols; //注意，是列数*通道数
  173.     double alpha = 1;//img1中像素的权重
  174.     for (int i = 0; i < rows; i++)
  175.     {
  176.         uchar* p = img1.ptr<uchar>(i);  //获取第i行的首地址
  177.         uchar* t = trans.ptr<uchar>(i);
  178.         uchar* d = dst.ptr<uchar>(i);
  179.         for (int j = start; j < cols; j++)
  180.         {
  181.             //如果遇到图像trans中无像素的黑点，则完全拷贝img1中的数据
  182.             if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
  183.             {
  184.                 alpha = 1;
  185.             }
  186.             else
  187.             {
  188.                 //img1中像素的权重，与当前处理点距重叠区域左边界的距离成正比，实验证明，这种方法确实好
  189.                 alpha = (processWidth - (j - start)) / processWidth;
  190.             }
  192.             d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
  193.             d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
  194.             d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);
  196.         }
  197.     }
  199. }

基于ORB的图像拼接

利用ORB进行图像拼接的思路跟上面的思路基本一样，只是特征提取和特征点匹配的方式略有差异罢了。这里就不再详细介绍思路了，直接贴代码看效果。

  1. #include "highgui/highgui.hpp"
  2. #include "opencv2/nonfree/nonfree.hpp"
  3. #include "opencv2/legacy/legacy.hpp"
  4. #include <iostream>  
  6. using namespace cv;
  7. using namespace std;
  9. void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);
  11. typedef struct
  12. {
  13.     Point2f left_top;
  14.     Point2f left_bottom;
  15.     Point2f right_top;
  16.     Point2f right_bottom;
  17. }four_corners_t;
  19. four_corners_t corners;
  21. void CalcCorners(const Mat& H, const Mat& src)
  22. {
  23.     double v2[] = { 0, 0, 1 };//左上角
  24.     double v1[3];//变换后的坐标值
  25.     Mat V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  26.     Mat V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  28.     V1 = H * V2;
  29.     //左上角(0,0,1)
  30.     cout << "V2: " << V2 << endl;
  31.     cout << "V1: " << V1 << endl;
  32.     corners.left_top.x = v1[0] / v1[2];
  33.     corners.left_top.y = v1[1] / v1[2];
  35.     //左下角(0,src.rows,1)
  36.     v2[0] = 0;
  37.     v2[1] = src.rows;
  38.     v2[2] = 1;
  39.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  40.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  41.     V1 = H * V2;
  42.     corners.left_bottom.x = v1[0] / v1[2];
  43.     corners.left_bottom.y = v1[1] / v1[2];
  45.     //右上角(src.cols,0,1)
  46.     v2[0] = src.cols;
  47.     v2[1] = 0;
  48.     v2[2] = 1;
  49.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  50.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  51.     V1 = H * V2;
  52.     corners.right_top.x = v1[0] / v1[2];
  53.     corners.right_top.y = v1[1] / v1[2];
  55.     //右下角(src.cols,src.rows,1)
  56.     v2[0] = src.cols;
  57.     v2[1] = src.rows;
  58.     v2[2] = 1;
  59.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  60.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  61.     V1 = H * V2;
  62.     corners.right_bottom.x = v1[0] / v1[2];
  63.     corners.right_bottom.y = v1[1] / v1[2];
  65. }
  67. int main(int argc, char *argv[])
  68. {
  69.     Mat image01 = imread("t1.jpg", 1);    //右图
  70.     Mat image02 = imread("t2.jpg", 1);    //左图
  71.     imshow("p2", image01);
  72.     imshow("p1", image02);
  74.     //灰度图转换
  75.     Mat image1, image2;
  76.     cvtColor(image01, image1, CV_RGB2GRAY);
  77.     cvtColor(image02, image2, CV_RGB2GRAY);
  79.     //提取特征点
  80.     OrbFeatureDetector  surfDetector(3000);
  81.     vector<KeyPoint> keyPoint1, keyPoint2;
  82.     surfDetector.detect(image1, keyPoint1);
  83.     surfDetector.detect(image2, keyPoint2);
  85.     //特征点描述，为下边的特征点匹配做准备
  86.     OrbDescriptorExtractor  SurfDescriptor;
  87.     Mat imageDesc1, imageDesc2;
  88.     SurfDescriptor.compute(image1, keyPoint1, imageDesc1);
  89.     SurfDescriptor.compute(image2, keyPoint2, imageDesc2);
  91.     flann::Index flannIndex(imageDesc1, flann::LshIndexParams(12, 20, 2), cvflann::FLANN_DIST_HAMMING);
  93.     vector<DMatch> GoodMatchePoints;
  95.     Mat macthIndex(imageDesc2.rows, 2, CV_32SC1), matchDistance(imageDesc2.rows, 2, CV_32FC1);
  96.     flannIndex.knnSearch(imageDesc2, macthIndex, matchDistance, 2, flann::SearchParams());
  98.     // Lowe's algorithm,获取优秀匹配点
  99.     for (int i = 0; i < matchDistance.rows; i++)
  100.     {
  101.         if (matchDistance.at<float>(i, 0) < 0.4 * matchDistance.at<float>(i, 1))
  102.         {
  103.             DMatch dmatches(i, macthIndex.at<int>(i, 0), matchDistance.at<float>(i, 0));
  104.             GoodMatchePoints.push_back(dmatches);
  105.         }
  106.     }
  108.     Mat first_match;
  109.     drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
  110.     imshow("first_match ", first_match);
  112.     vector<Point2f> imagePoints1, imagePoints2;
  114.     for (int i = 0; i<GoodMatchePoints.size(); i++)
  115.     {
  116.         imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
  117.         imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
  118.     }
  120.     //获取图像1到图像2的投影映射矩阵 尺寸为3*3
  121.     Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
  122.     ////也可以使用getPerspectiveTransform方法获得透视变换矩阵，不过要求只能有4个点，效果稍差
  123.     //Mat   homo=getPerspectiveTransform(imagePoints1,imagePoints2);
  124.     cout << "变换矩阵为：\n" << homo << endl << endl; //输出映射矩阵      
  126.                                                 //计算配准图的四个顶点坐标
  127.     CalcCorners(homo, image01);
  128.     cout << "left_top:" << corners.left_top << endl;
  129.     cout << "left_bottom:" << corners.left_bottom << endl;
  130.     cout << "right_top:" << corners.right_top << endl;
  131.     cout << "right_bottom:" << corners.right_bottom << endl;
  133.     //图像配准
  134.     Mat imageTransform1, imageTransform2;
  135.     warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
  136.     //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
  137.     imshow("直接经过透视矩阵变换", imageTransform1);
  138.     imwrite("trans1.jpg", imageTransform1);
  140.     //创建拼接后的图,需提前计算图的大小
  141.     int dst_width = imageTransform1.cols;  //取最右点的长度为拼接图的长度
  142.     int dst_height = image02.rows;
  144.     Mat dst(dst_height, dst_width, CV_8UC3);
  145.     dst.setTo(0);
  147.     imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
  148.     image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));
  150.     imshow("b_dst", dst);
  152.     OptimizeSeam(image02, imageTransform1, dst);
  154.     imshow("dst", dst);
  155.     imwrite("dst.jpg", dst);
  157.     waitKey();
  159.     return 0;
  160. }
  162. //优化两图的连接处，使得拼接自然
  163. void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
  164. {
  165.     int start = MIN(corners.left_top.x, corners.left_bottom.x);//开始位置，即重叠区域的左边界  
  167.     double processWidth = img1.cols - start;//重叠区域的宽度
  168.     int rows = dst.rows;
  169.     int cols = img1.cols; //注意，是列数*通道数
  170.     double alpha = 1;//img1中像素的权重
  171.     for (int i = 0; i < rows; i++)
  172.     {
  173.         uchar* p = img1.ptr<uchar>(i);  //获取第i行的首地址
  174.         uchar* t = trans.ptr<uchar>(i);
  175.         uchar* d = dst.ptr<uchar>(i);
  176.         for (int j = start; j < cols; j++)
  177.         {
  178.             //如果遇到图像trans中无像素的黑点，则完全拷贝img1中的数据
  179.             if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
  180.             {
  181.                 alpha = 1;
  182.             }
  183.             else
  184.             {
  185.                 //img1中像素的权重，与当前处理点距重叠区域左边界的距离成正比，实验证明，这种方法确实好
  186.                 alpha = (processWidth - (j - start)) / processWidth;
  187.             }
  189.             d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
  190.             d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
  191.             d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);
  193.         }
  194.     }
  196. }

看一看拼接效果，我觉得还是不错的。

看一下这一组图片，这组图片产生了鬼影，为什么？因为两幅图中的人物走动了啊！所以要做图像拼接，尽量保证使用的是静态图片，不要加入一些动态因素干扰拼接。

opencv自带的拼接算法stitch

opencv其实自己就有实现图像拼接的算法，当然效果也是相当好的，但是因为其实现很复杂，而且代码量很庞大，其实在一些小应用下的拼接有点杀鸡用牛刀的感觉。最近在阅读sticth源码时，发现其中有几个很有意思的地方。

1.opencv stitch选择的特征检测方式

一直很好奇opencv stitch算法到底选用了哪个算法作为其特征检测方式，是ORB，SIFT还是SURF？读源码终于看到答案。

  1. #ifdef HAVE_OPENCV_NONFREE
  2.         stitcher.setFeaturesFinder(new detail::SurfFeaturesFinder());
  3. #else
  4.         stitcher.setFeaturesFinder(new detail::OrbFeaturesFinder());
  5. #endif

在源码createDefault函数中（默认设置），第一选择是SURF,第二选择才是ORB（没有NONFREE模块才选），所以既然大牛们这么选择，必然是经过综合考虑的，所以应该SURF算法在图像拼接有着更优秀的效果。

2.opencv stitch获取匹配点的方式

以下代码是opencv stitch源码中的特征点提取部分，作者使用了两次特征点提取的思路：先对图一进行特征点提取和筛选匹配（1->2），再对图二进行特征点的提取和匹配（2->1），这跟我们平时的一次提取的思路不同，这种二次提取的思路可以保证更多的匹配点被选中，匹配点越多，findHomography求出的变换越准确。这个思路值得借鉴。


  2. matches_info.matches.clear();
  4. Ptr<flann::IndexParams> indexParams = new flann::KDTreeIndexParams();
  5. Ptr<flann::SearchParams> searchParams = new flann::SearchParams();
  7. if (features2.descriptors.depth() == CV_8U)
  8. {
  9.     indexParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
  10.     searchParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
  11. }
  13. FlannBasedMatcher matcher(indexParams, searchParams);
  14. vector< vector<DMatch> > pair_matches;
  15. MatchesSet matches;
  17. // Find 1->2 matches
  18. matcher.knnMatch(features1.descriptors, features2.descriptors, pair_matches, 2);
  19. for (size_t i = 0; i < pair_matches.size(); ++i)
  20. {
  21.     if (pair_matches[i].size() < 2)
  22.         continue;
  23.     const DMatch& m0 = pair_matches[i][0];
  24.     const DMatch& m1 = pair_matches[i][1];
  25.     if (m0.distance < (1.f - match_conf_) * m1.distance)
  26.     {
  27.         matches_info.matches.push_back(m0);
  28.         matches.insert(make_pair(m0.queryIdx, m0.trainIdx));
  29.     }
  30. }
  31. LOG("\n1->2 matches: " << matches_info.matches.size() << endl);
  33. // Find 2->1 matches
  34. pair_matches.clear();
  35. matcher.knnMatch(features2.descriptors, features1.descriptors, pair_matches, 2);
  36. for (size_t i = 0; i < pair_matches.size(); ++i)
  37. {
  38.     if (pair_matches[i].size() < 2)
  39.         continue;
  40.     const DMatch& m0 = pair_matches[i][0];
  41.     const DMatch& m1 = pair_matches[i][1];
  42.     if (m0.distance < (1.f - match_conf_) * m1.distance)
  43.         if (matches.find(make_pair(m0.trainIdx, m0.queryIdx)) == matches.end())
  44.             matches_info.matches.push_back(DMatch(m0.trainIdx, m0.queryIdx, m0.distance));
  45. }
  46. LOG("1->2 & 2->1 matches: " << matches_info.matches.size() << endl);

这里我仿照opencv源码二次提取特征点的思路对我原有拼接代码进行改写，实验证明获取的匹配点确实较一次提取要多。

  1. //提取特征点
  2. SiftFeatureDetector Detector(1000);  // 海塞矩阵阈值，在这里调整精度，值越大点越少，越精准
  3. vector<KeyPoint> keyPoint1, keyPoint2;
  4. Detector.detect(image1, keyPoint1);
  5. Detector.detect(image2, keyPoint2);
  7. //特征点描述，为下边的特征点匹配做准备
  8. SiftDescriptorExtractor Descriptor;
  9. Mat imageDesc1, imageDesc2;
  10. Descriptor.compute(image1, keyPoint1, imageDesc1);
  11. Descriptor.compute(image2, keyPoint2, imageDesc2);
  13. FlannBasedMatcher matcher;
  14. vector<vector<DMatch> > matchePoints;
  15. vector<DMatch> GoodMatchePoints;
  17. MatchesSet matches;
  19. vector<Mat> train_desc(1, imageDesc1);
  20. matcher.add(train_desc);
  21. matcher.train();
  23. matcher.knnMatch(imageDesc2, matchePoints, 2);
  25. // Lowe's algorithm,获取优秀匹配点
  26. for (int i = 0; i < matchePoints.size(); i++)
  27. {
  28.     if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
  29.     {
  30.         GoodMatchePoints.push_back(matchePoints[i][0]);
  31.         matches.insert(make_pair(matchePoints[i][0].queryIdx, matchePoints[i][0].trainIdx));
  32.     }
  33. }
  34. cout<<"\n1->2 matches: " << GoodMatchePoints.size() << endl;
  36. #if 1
  38. FlannBasedMatcher matcher2;
  39. matchePoints.clear();
  40. vector<Mat> train_desc2(1, imageDesc2);
  41. matcher2.add(train_desc2);
  42. matcher2.train();
  44. matcher2.knnMatch(imageDesc1, matchePoints, 2);
  45. // Lowe's algorithm,获取优秀匹配点
  46. for (int i = 0; i < matchePoints.size(); i++)
  47. {
  48.     if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
  49.     {
  50.         if (matches.find(make_pair(matchePoints[i][0].trainIdx, matchePoints[i][0].queryIdx)) == matches.end())
  51.         {
  52.             GoodMatchePoints.push_back(DMatch(matchePoints[i][0].trainIdx, matchePoints[i][0].queryIdx, matchePoints[i][0].distance));
  53.         }
  55.     }
  56. }
  57. cout<<"1->2 & 2->1 matches: " << GoodMatchePoints.size() << endl;
  58. #endif

最后再看一下opencv stitch的拼接效果吧~速度虽然比较慢，但是效果还是很好的。

  1. #include <iostream>
  2. #include <opencv2/core/core.hpp>
  3. #include <opencv2/highgui/highgui.hpp>
  4. #include <opencv2/imgproc/imgproc.hpp>
  5. #include <opencv2/stitching/stitcher.hpp>
  6. using namespace std;
  7. using namespace cv;
  8. bool try_use_gpu = false;
  9. vector<Mat> imgs;
  10. string result_name = "dst1.jpg";
  11. int main(int argc, char * argv[])
  12. {
  13.     Mat img1 = imread("34.jpg");
  14.     Mat img2 = imread("35.jpg");
  16.     imshow("p1", img1);
  17.     imshow("p2", img2);
  19.     if (img1.empty() || img2.empty())
  20.     {
  21.         cout << "Can't read image" << endl;
  22.         return -1;
  23.     }
  24.     imgs.push_back(img1);
  25.     imgs.push_back(img2);
  27.     Stitcher stitcher = Stitcher::createDefault(try_use_gpu);
  28.     // 使用stitch函数进行拼接
  29.     Mat pano;
  30.     Stitcher::Status status = stitcher.stitch(imgs, pano);
  31.     if (status != Stitcher::OK)
  32.     {
  33.         cout << "Can't stitch images, error code = " << int(status) << endl;
  34.         return -1;
  35.     }
  36.     imwrite(result_name, pano);
  37.     Mat pano2 = pano.clone();
  38.     // 显示源图像，和结果图像
  39.     imshow("全景图像", pano);
  40.     if (waitKey() == 27)
  41.         return 0;
  42. }

OpenCV探索之路（二十四）图像拼接和图像融合技术的更多相关文章

  1. OpenCV探索之路（十四）：绘制点、直线、几何图形

    绘制点和圆 void cvCircle( CvArr* img, CvPoint center, int radius, CvScalar color, int thickness=1, int li ...

  2. Bootstrap<基础二十四> 缩略图

    Bootstrap 缩略图.大多数站点都需要在网格中布局图像.视频.文本等.Bootstrap 通过缩略图为此提供了一种简便的方式.使用 Bootstrap 创建缩略图的步骤如下: 在图像周围添加带有 ...

  3. 二十四、Struts2中的UI标签

    二十四.Struts2中的UI标签 Struts2中UI标签的优势: 数据回显 页面布局和排版(Freemark),struts2提供了一些常用的排版(主题:xhtml默认 simple ajax) ...

  4. WCF技术剖析之二十四: ServiceDebugBehavior服务行为是如何实现异常的传播的?

    原文:WCF技术剖析之二十四: ServiceDebugBehavior服务行为是如何实现异常的传播的? 服务端只有抛出FaultException异常才能被正常地序列化成Fault消息,并实现向客户 ...

  5. VMware vSphere 服务器虚拟化之二十四 桌面虚拟化之手动池管理物理机

    VMware vSphere 服务器虚拟化之二十四 桌面虚拟化之手动池管理物理机 VMwareView手动池可以管理物理计算机 说明: 环境基于实验二十三 1.准备一台Windows 7的物理计算机名 ...

  6. Bootstrap入门（二十四）data属性

    Bootstrap入门(二十四)data属性 你可以仅仅通过 data 属性 API 就能使用所有的 Bootstrap 插件,无需写一行 JavaScript 代码.这是 Bootstrap 中的一 ...

  7. 3360: [Usaco2004 Jan]算二十四

    3360: [Usaco2004 Jan]算二十四 Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 6  Solved: 6[Submit][Statu ...

  8. JAVA之旅（二十四）——I/O流，字符流，FileWriter，IOException，文件续写，FileReader，小练习

    JAVA之旅(二十四)--I/O流,字符流,FileWriter,IOException,文件续写,FileReader,小练习 JAVA之旅林林总总也是写了二十多篇了,我们今天终于是接触到了I/O了 ...

  9. 二十四. Python基础(24)--封装

    二十四. Python基础(24)--封装 ● 知识结构   ● 类属性和__slots__属性 class Student(object):     grade = 3 # 也可以写在__slots ...

随机推荐

  1. 使用Web页面配置ESP8266的参数

    前言 使用Web页面配置ESP8266的参数相对于使用串口AT指令配置更加直观和简单.与配置路由器方式类似. 基本思路 基本思路是ESP8266工作AP模式下,作为TCP Server监听TCP Cl ...

  2. Android5.1 - 通讯录建立群组

    [问题] 在没有账户的时候,不应该有添加联系人群组的选项. 我们要把这个选项干掉. [相关log]06-23 17:25:00.804: E/GroupEditorFragment(6030): No ...

  3. Python基础之模块、数据类型及数据类型转换

    一.模块 1.标准库 不需要安装,直接调入使用的模块. import sys模块: import sys print(sys.path) #打印环境变量绝对路径 print(sys.argv) #打印 ...

  4. JMeter 之Synchronizing Timer运行原理

    JMeter测试并发场景,是通过设置Synchronizing Timer(同步定时器),熟悉LoadRunner性能测试的话,就知道里面有个概念:集合点. Synchronizing Timer则可 ...

  5. 游戏里的动态阴影-ShadowMap实现原理

    ShadowMap是比较流行的实时阴影实现方案,原理比较简单,但真正实现起来还是会遇到很多问题的,我这里主要记录下实现方式 先看效果 凹凸地形上也有阴影 实现原理 ShadowMap技术是从灯光空间用 ...

  6. Result Maps collection does not contain value for...

    出现上述错误 主要是因为你的select标签内部的resultMap属性指向的不正确 在sql文件中只要有一个resultMap或resultType属性指向错误,则在这个文件中其余正确的语句也不能执 ...

  7. innodb关键特性之double write

    # 脏页刷盘的风险 两次写的原理机制 1.解决问题 2.使用场景 3.doublewrite的工作流程 4.崩溃恢复 # doublewrite的副作用 1.监控doublewrite负载 2.关闭d ...

  8. sublime自定义配置

    { "expand_tabs_on_save": true, "font_size": 13, "ignored_packages": [ ...

  9. margin用的时候常见问题

    margin1.     在同一个方向布局        同时设置左右margin的时候间距是两者之和        同时设置上下margin的时候间距是较大的那个,大者为尊2.    拖拽父级    ...

  10. Eclipse 改变字体大小，设置背景色

    Eclipse背景颜色修改: 操作界面默认颜色为白色.对于我们长期使用电脑编程的人来说,白色很刺激我们的眼睛,所以我经常会改变workspace的背景色,使眼睛舒服一些.设置方法如下: 1.打开win ...