• 【OpenCV图像处理】 图像拼接技术

    目录

    一：图像拼接技术 需求分析

    二：图像拼接技术 具体步骤

    三：图像拼接技术 代码实现

    四：多张图像拼接  Stitcher算法

    一：图像拼接技术 需求分析

    将下面两张图像进行拼接

     

    拼接得到一张完整的图像

    二：图像拼接技术 具体步骤

    1.选择特征点

    1.     //1、选择特征点
    2.     //左图 右图 识别特征点 是Mat对象 用c d保存
    3.     surf->detectAndCompute(left,Mat(),key2,d);
    4.     surf->detectAndCompute(right,Mat(),key1,c);
    5.  
    6.     //特征点对比，保存   特征点为中心点区域比对
    7.     vector matches;
    8.     matcher.match(d,c,matches);
    9.  
    10.     //排序从小到大 找到特征点连线
    11.     sort(matches.begin(),matches.end());

    2.保存最优的特征点对象

    1.     //2、保存最优的特征点对象
    2.     vectorgood_matches;
    3.     int ptrpoint = std::min(50,(int)(matches.size()*0.15));
    4.     for (int i = 0;i < ptrpoint;i++)
    5.     {
    6.         good_matches.push_back(matches[i]);
    7.     }
    8.  
    9.     //2-1、画线 最优的特征点对象连线
    10.     Mat outimg;
    11.     drawMatches(left,key2,right,key1,good_matches,outimg,
    12.                 Scalar::all(-1),Scalar::all(-1),
    13.                 vector<char>(),DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
    14.  
    15.     //imshow("outimg",outimg);

    3.特征点匹配

    1.     //3、特征点匹配
    2.     vectorimagepoint1,imagepoint2;
    3.     for (int i= 0 ;i < good_matches.size();i++)
    4.     {
    5.         //查找特征点可连接处                          变形
    6.         imagepoint1.push_back(key1[good_matches[i].trainIdx].pt);
    7.         //查找特征点可连接处                          查找基准线
    8.         imagepoint2.push_back(key2[good_matches[i].queryIdx].pt);
    9.     }

    4.透视转换 图像融合

    1.     //4、透视转换 图形融合
    2.     Mat homo = findHomography(imagepoint1,imagepoint2,CV_RANSAC);
    3.     //imshow("homo",homo);
    4.  
    5.     //根据透视转换矩阵进行计算 四个坐标
    6.     CalcCorners(homo,right);
    7.  
    8.     //接收透视转换结果
    9.     Mat imageTransForm;
    10.     //透视转换
    11.     warpPerspective(right,imageTransForm,homo,
    12.                     Size(MAX(corners.right_top.x,corners.right_bottom.x),left.rows));
    13.  
    14.     //右图透视变换 由于本次图片材料是自己截图拼接的 因此看不出透视变换的明显特征
    15.     //imshow("imageTransForm",imageTransForm);
    16.  
    17.     //结果进行整合
    18.     int dst_width = imageTransForm.cols;
    19.     int dst_height = left.rows;
    20.  
    21.     Mat dst(dst_height,dst_width,CV_8UC3);
    22.     dst.setTo(0);
    23.  
    24.     imageTransForm.copyTo(dst(Rect(0,0,imageTransForm.cols,imageTransForm.rows)));
    25.     left.copyTo(dst(Rect(0,0,left.cols,left.rows)));

    右图的透视转换，由于图像材料是自己截图拼接的，因此看不出透视变换的明显特征，但根据上图可知已经做出透视变换图像处理操作

    左图与右图的透视转换结果 拼接 【这里只是将窗口移动测试看下前面步骤是否正确】

    可以看出左图与右图的透视转换结果 是可以进行接下来的图像融合操作的

    5.优化图像 进行最终的结果展示

    1.     //5、优化图像
    2.     OptimizeSeam(left,imageTransForm,dst);
    3.  
    4.     //最终图像拼接结果
    5.     imshow("dst",dst);

    可以看出 顺利完成 两张图像拼接的图像处理操作 

    三：图像拼接技术 代码实现

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

    四：多张图像拼接  Stitcher算法

    如下四张图片拼接，可使用Stitcher算法【多张图片拼接】

    完整代码如下：

    1. #include 
    2. #include 
    3. #include //图像融合
    4. #include //拼接算法
    5. #include 
    6. #include 
    7.  
    8. using namespace std;
    9. using namespace cv;
    10. using namespace cv::xfeatures2d;
    11.  
    12. void example()
    13. {
    14.     Mat img1 = imread("D:/00000000000003jieduanshipincailliao/b1.png");
    15.     Mat img2 = imread("D:/00000000000003jieduanshipincailliao/b2.png");
    16.     Mat img3 = imread("D:/00000000000003jieduanshipincailliao/b3.png");
    17.     Mat img4 = imread("D:/00000000000003jieduanshipincailliao/b4.png");
    18.  
    19.     imshow("img1",img1);
    20.     imshow("img2",img2);
    21.     imshow("img3",img3);
    22.     imshow("img4",img4);
    23.  
    24.     //带顺序容器vector
    25.     vectorimages;
    26.     images.push_back(img1);
    27.     images.push_back(img2);
    28.     images.push_back(img3);
    29.     images.push_back(img4);
    30.  
    31.     //用来保存最终拼接图
    32.     Mat result;
    33.  
    34.     //false 不使用GPU加速
    35.     Stitcher sti = Stitcher::createDefault(false);
    36.     //将向量容器中所有的图片按照顺序进行拼接，结果保存在result中
    37.     Stitcher::Status sta = sti.stitch(images,result);
    38.  
    39.     if(sta != Stitcher::OK)
    40.     {
    41.         cout<<"canot Stitcher"<
    42.     }
    43.  
    44.     imshow("result",result);
    45.  
    46.     waitKey(0);
    47. }
    48.  
    49. int main()
    50. {
    51.     example();
    52.     return 0;
    53. }

  • 相关阅读:
    阿里云 / 京东 / 百度等 20 多家大厂 Java 面试上千道内卷真题
    2.4 Sample Moments and Hypothesis Tests
    编程机器人的参数表怎么看
    【Reinforcement Learning】强化学习基础内容有哪些？
    常见的设计模式
    sourceTree中的git rebase变基操作
    LeetCode高频题：设计一个股票推荐系统，自动根据注册用户的关注情况进行推荐，询问时，会推荐那个人多少只他还没有关注的股票
    聊聊SpringBootTest的webEnvironment
    使用.Net6中的System.Text.Json遇到几个常见问题及解决方案
    免费低代码平台，助企业高效管理任务
  • 原文地址：https://blog.csdn.net/m0_56051805/article/details/126145826