devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【OpenCV】SURF图像拼接和Stitcher拼接

作者：菜鸟追梦旅行 | 2024-02-14 20:09:03

赞

踩

surf图像拼接

介绍两种图像拼接的方法，一种是SURF算法的图像拼接，另一种是Stitcher硬拼接

首先先从简单的讲起

一、Stitcher直接拼接

可以实现多张图片一起拼接，只要两行代码就可以实现拼接；

1.首先准备多张图片，放入向量容器中

  1.     Mat img1 =imread("a.png");
  2.     Mat img2 =imread("b.png");
  3.     Mat img3 =imread("c.png");
  4.     Mat img4 =imread("d.png");
  5.     //图片放入容器中
  6.     vector<Mat>images;
  7.     images.push_back(img1);
  8.     images.push_back(img2);
  9.     images.push_back(img3);
  10.     images.push_back(img4);

2. 创建Stitcher对象，调用拼接算法

第一行false是表示不使用gpu加速；

  1.     //保存最终拼接图
  2.     Mat result;
  3.     
  4.     Stitcher sti=Stitcher::createDefault(false);
  5.     //将vector容器中所有的图片按顺序进行拼接，输出result
  6.     Stitcher::Status sta=sti.stitch(images,result);
  7.     if(sta!=Stitcher::OK)
  8.     {
  9.         cout<<"拼接失败"<<endl;
  10.     }
  11.     imshow("result",result);//显示

注：createDefault的方法在opencv3可用，opencv4改变了调用方式，为Stitcher::create

来看看这种拼接的效果吧

原图：

 4张图

 第一次输出效果：

 第二次输出效果：

可以看到，虽然能够拼接，但是有时候可能会丢失一部分，导致最右边没有拼接上；

虽然使用起来很简单，但是不能每次都达到想要的效果；

这边介绍第二种拼接方法：

二、SURF算法

SURF拼接一次只能拼接两张图片，其大致步骤就是匹配两幅图像中的特征点，找到最优匹配特征点；

根据配对的特征点计算坐标映射矩阵，求出右图的透视转换坐标；然后将右图透视转换后生成的图与左图进行整合，使用copyto将两图拼接

1.查找特征点

  1.     Mat left=imread("left.png");
  2.     Mat right=imread("right.png");
  3.     imshow("left",left);
  4.     imshow("right",right);
  5.     //创建SURF算法对象
  6.     Ptr<SURF> surf;
  7.     //create 函数参数 海森矩阵阀值 800特征点以内
  8.     surf =SURF::create(800);
  9.     //创建一个暴力匹配器 用于特征点匹配
  10.     BFMatcher matcher;
  11.  
  12.     //特征点容器 存放特征点KeyPoint 两张图准备两个
  13.     vector<KeyPoint>key1,key2;
  14.     //保存特征点
  15.     Mat c,d;
  16.  
  17.     //1.查找特征点
  18.     //左图 右图 识别特征点 是Mat对象 用c d保存
  19.     surf->detectAndCompute(left,Mat(),key2,d);
  20.     surf->detectAndCompute(right,Mat(),key1,c);
  21.  
  22.     //特征点对比
  23.     vector<DMatch> matches;
  24.     matcher.match(d,c,matches);//特征点匹配过后存入matchers容器
  25.  
  26.     //将匹配过后的特征点排序  从小到大，找到特征点连线
  27.     sort(matches.begin(),matches.end());

2.保存最优匹配的特征点对象，进行划线

  1.     vector<DMatch>best_matches;
  2.     int prtpoint=std::min(50,(int)(matches.size()*0.15));
  3.     for(int i=0;i<prtpoint;i++)
  4.     {
  5.         best_matches.push_back(matches[i]);
  6.     }
  7.  
  8.     //2.1进行划线，连接两个最优特征点对象
  9.     //NOT_DRAW_SINGLE_POINTS不画单个的点
  10.     Mat outimg;
  11.     drawMatches(left,key2,right,key1,best_matches,outimg,Scalar::all(-1),Scalar::all(-1),
  12.                 vector<char>(),DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);

3.特征点匹配

查找所有最优匹配特征点中，右图需要通过透视转换变形，而左图查找基准线

  1.     vector<Point2f>imagepoint1,imagepoint2;
  2.     for (int i= 0 ;i < best_matches.size();i++)
  3.     {
  4.         //查找特征点可连接处    右图需要通过透视转换变形
  5.         imagepoint1.push_back(key1[best_matches[i].trainIdx].pt);
  6.         //查找特征点可连接处    左图查找基准线
  7.         imagepoint2.push_back(key2[best_matches[i].queryIdx].pt);
  8.     }

4.透视转换，图形融合

根据配对的特征点计算坐标映射矩阵，求出透视转换坐标；将右图透视转换后生成的图与左图进行整合，使用copyto将两图拼接

  1.     Mat homo = findHomography(imagepoint1,imagepoint2,CV_RANSAC);
  2.  
  3.     //根据透视转换矩阵进行计算 右图的四个坐标
  4.     CalcCorners(homo,right);
  5.     //接收透视转换结果
  6.     Mat imageTransForm;
  7.     //透视转换
  8.     warpPerspective(right,imageTransForm,homo,Size(MAX(corners.right_top.x,corners.right_bottom.x),left.rows));
  9.     imshow("imageTransForm",imageTransForm);
  10.  
  11.     //将左图和右转换图进行整合
  12.     int dst_width = imageTransForm.cols;//右转换图的宽
  13.     int dst_height = left.rows;//左图的高
  14.  
  15.     Mat dst(dst_height,dst_width,CV_8UC3);//最终结果图
  16.     dst.setTo(0);
  17.  
  18.     imageTransForm.copyTo(dst(Rect(0,0,imageTransForm.cols,imageTransForm.rows)));
  19.     left.copyTo(dst(Rect(0,0,left.cols,left.rows)));

 5.拼接后图片可能存在拼接处的裂缝，还有扭曲，可以进行一些优化

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

完整源码：

  1. #include <iostream>
  2. #include <opencv2/opencv.hpp>
  3. #include <opencv2/highgui.hpp>//图像融合
  4. #include <opencv2/xfeatures2d.hpp>//拼接算法
  5. #include <opencv2/calib3d.hpp>
  6. #include <opencv2/imgproc.hpp>
  7. using namespace std;
  8. using namespace cv;
  9. using namespace cv::xfeatures2d;
  10. typedef struct
  11. {
  12.     Point2f left_top;
  13.     Point2f left_bottom;
  14.     Point2f right_top;
  15.     Point2f right_bottom;
  16. }four_corners_t;
  17.  
  18. four_corners_t corners;
  19.  
  20. void CalcCorners(const Mat& H, const Mat& src)
  21. {
  22.     double v2[] = { 0, 0, 1 };//左上角
  23.     double v1[3];//变换后的坐标值
  24.     Mat V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  25.     Mat V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  26.  
  27.     V1 = H * V2;
  28.     //左上角(0,0,1)
  29.     cout << "V2: " << V2 << endl;
  30.     cout << "V1: " << V1 << endl;
  31.     corners.left_top.x = v1[0] / v1[2];
  32.     corners.left_top.y = v1[1] / v1[2];
  33.  
  34.     //左下角(0,src.rows,1)
  35.     v2[0] = 0;
  36.     v2[1] = src.rows;
  37.     v2[2] = 1;
  38.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  39.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  40.     V1 = H * V2;
  41.     corners.left_bottom.x = v1[0] / v1[2];
  42.     corners.left_bottom.y = v1[1] / v1[2];
  43.  
  44.     //右上角(src.cols,0,1)
  45.     v2[0] = src.cols;
  46.     v2[1] = 0;
  47.     v2[2] = 1;
  48.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  49.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  50.     V1 = H * V2;
  51.     corners.right_top.x = v1[0] / v1[2];
  52.     corners.right_top.y = v1[1] / v1[2];
  53.  
  54.     //右下角(src.cols,src.rows,1)
  55.     v2[0] = src.cols;
  56.     v2[1] = src.rows;
  57.     v2[2] = 1;
  58.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  59.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  60.     V1 = H * V2;
  61.     corners.right_bottom.x = v1[0] / v1[2];
  62.     corners.right_bottom.y = v1[1] / v1[2];
  63. }
  64. //图像融合的去裂缝处理操作
  65. void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
  66. {
  67.     int start = MIN(corners.left_top.x, corners.left_bottom.x);//开始位置，即重叠区域的左边界
  68.  
  69.     double processWidth = img1.cols - start;//重叠区域的宽度
  70.     int rows = dst.rows;
  71.     int cols = img1.cols; //注意，是列数*通道数
  72.     double alpha = 1;//img1中像素的权重
  73.     for (int i = 0; i < rows; i++)
  74.     {
  75.         uchar* p = img1.ptr<uchar>(i);  //获取第i行的首地址
  76.         uchar* t = trans.ptr<uchar>(i);
  77.         uchar* d = dst.ptr<uchar>(i);
  78.         for (int j = start; j < cols; j++)
  79.         {
  80.             //如果遇到图像trans中无像素的黑点，则完全拷贝img1中的数据
  81.             if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
  82.             {
  83.                 alpha = 1;
  84.             }
  85.             else
  86.             {
  87.                 //img1中像素的权重，与当前处理点距重叠区域左边界的距离成正比，实验证明，这种方法确实好
  88.                 alpha = (processWidth - (j - start)) / processWidth;
  89.             }
  90.  
  91.             d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
  92.             d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
  93.             d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);
  94.  
  95.         }
  96.     }
  97. }
  98. void directly()
  99. {
  100.     Mat img1 =imread("a.png");
  101.     Mat img2 =imread("b.png");
  102.     Mat img3 =imread("c.png");
  103.     Mat img4 =imread("d.png");
  104. //    imshow("a",img1);
  105. //    imshow("b",img2);
  106. //    imshow("c",img3);
  107. //    imshow("d",img4);
  108.     //图片放入容器中
  109.     vector<Mat>images;
  110.     images.push_back(img1);
  111.     images.push_back(img2);
  112.     images.push_back(img3);
  113.     images.push_back(img4);
  114.     //保存最终拼接图
  115.     Mat result;
  116.  
  117.     Stitcher sti=Stitcher::createDefault(false);
  118.     //将vector容器中所有的图片按顺序进行拼接，输出result
  119.     Stitcher::Status sta=sti.stitch(images,result);
  120.     if(sta!=Stitcher::OK)
  121.     {
  122.         cout<<"拼接失败"<<endl;
  123.     }
  124.     imshow("result",result);
  125.  
  126. }
  127. int main()
  128. {
  129.     Mat left=imread("left.png");
  130.     Mat right=imread("right.png");
  131.     imshow("left",left);
  132.     imshow("right",right);
  133.     //创建SURF算法对象
  134.     Ptr<SURF> surf;
  135.     //create 函数参数 海森矩阵阀值 800特征点以内
  136.     surf =SURF::create(800);
  137.     //创建一个暴力匹配器 用于特征点匹配
  138.     BFMatcher matcher;
  139.  
  140.     //特征点容器 存放特征点KeyPoint 两张图准备两个
  141.     vector<KeyPoint>key1,key2;
  142.     //保存特征点
  143.     Mat c,d;
  144.  
  145.     //1.查找特征点
  146.     //左图 右图 识别特征点 是Mat对象 用c d保存
  147.     surf->detectAndCompute(left,Mat(),key2,d);
  148.     surf->detectAndCompute(right,Mat(),key1,c);
  149.  
  150.     //特征点对比
  151.     vector<DMatch> matches;
  152.     matcher.match(d,c,matches);//特征点匹配过后存入matchers容器
  153.  
  154.     //将匹配过后的特征点排序  从小到大，找到特征点连线
  155.     sort(matches.begin(),matches.end());
  156.  
  157.     //2.保存最优匹配的特征点对象
  158.     vector<DMatch>best_matches;
  159.     int prtpoint=std::min(50,(int)(matches.size()*0.15));
  160.     for(int i=0;i<prtpoint;i++)
  161.     {
  162.         best_matches.push_back(matches[i]);
  163.     }
  164.  
  165.     //2.1进行划线，连接两个最优特征点对象
  166.     //NOT_DRAW_SINGLE_POINTS不画单个的点
  167.     Mat outimg;
  168.     drawMatches(left,key2,right,key1,best_matches,outimg,Scalar::all(-1),Scalar::all(-1),
  169.                 vector<char>(),DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
  170.     //imshow("outimg",outimg);//划线图
  171.  
  172.     //3.特征点匹配
  173.     vector<Point2f>imagepoint1,imagepoint2;
  174.     for (int i= 0 ;i < best_matches.size();i++)
  175.     {
  176.         //查找特征点可连接处    右图需要通过透视转换变形
  177.         imagepoint1.push_back(key1[best_matches[i].trainIdx].pt);
  178.         //查找特征点可连接处    左图查找基准线
  179.         imagepoint2.push_back(key2[best_matches[i].queryIdx].pt);
  180.     }
  181.     //4、透视转换 图形融合
  182.     //先进行计算坐标映射矩阵
  183.     Mat homo = findHomography(imagepoint1,imagepoint2,CV_RANSAC);
  184.  
  185.     //根据透视转换矩阵进行计算 右图的四个坐标
  186.     CalcCorners(homo,right);
  187.     //接收透视转换结果
  188.     Mat imageTransForm;
  189.     //透视转换
  190.     warpPerspective(right,imageTransForm,homo,Size(MAX(corners.right_top.x,corners.right_bottom.x),left.rows));
  191.     imshow("imageTransForm",imageTransForm);
  192.  
  193.     //将左图和右转换图进行整合
  194.     int dst_width = imageTransForm.cols;//右转换图的宽
  195.     int dst_height = left.rows;//左图的高
  196.  
  197.     Mat dst(dst_height,dst_width,CV_8UC3);//最终结果图
  198.     dst.setTo(0);
  199.  
  200.     imageTransForm.copyTo(dst(Rect(0,0,imageTransForm.cols,imageTransForm.rows)));
  201.     left.copyTo(dst(Rect(0,0,left.cols,left.rows)));
  202.  
  203.     //5、优化图像，中间缝合处理
  204.     OptimizeSeam(left,imageTransForm,dst);
  205.     //输出拼接图像
  206.     imshow("dst",dst);
  207.  
  208.     //directly();//直接拼接
  209.     waitKey(0);
  210.     return 0;
  211. }

感谢观看！！！！

以上就是全部内容，如果对您有帮助，欢迎点赞评论，或者发现有哪里写错的，欢迎指正！

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号