图像拼接技术就是将数张有重叠部分的图像（可能是不同时间、不同视角或者不同传感器获得的）拼成一幅无缝的全景图或高分辨率图像的技术。
下面用opencv实现一下多张图像进行拼接
如下图所示，三张不同角度的图像最终拼接成一张全视角的图像

from imutils import paths
import numpy as np
import argparse
import imutils
import cv2

# 构造参数解析器并解析参数
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--images",default='images', type=str, required=True,
                help="path to input directory of images to stitch")
ap.add_argument("-o", "--output", default='output.png',type=str, required=True,
                help="path to the output image")
ap.add_argument("-c", "--crop", type=int, default=0,
                help="whether to crop out largest rectangular region")
args = vars(ap.parse_args())  # vars函数是实现返回对象object的属性和属性值的字典对象

print(args)  # {'images': 'images/scottsdale', 'output': 'output.png', 'crop': 1}
# 匹配输入图像的路径并初始化我们的图像列表
# rectangular_region = 2
print("[INFO] loading images...")
# 获取到每张待拼接图像并排序，如['第一张图片路径'， 第二张图片路径'，第三张图片路径']
imagePaths = sorted(list(paths.list_images(args["images"])))
# print(imagePaths)
# imagePaths = ['IMG_1786-2.jpg',
# 			  'IMG_1787-2.jpg',
# 			  'IMG_1788-2.jpg']
images = []

# 遍历图像路径，加载每个路径，然后将它们添加到我们的路径中图像到stich列表
for imagePath in imagePaths:
    image = cv2.imread(imagePath)
    images.append(image)

# 初始化OpenCV的图像sticher对象，然后执行图像拼接
print("[INFO] stitching images...")
stitcher = cv2.createStitcher() if imutils.is_cv3() else cv2.Stitcher_create()
(status, stitched) = stitcher.stitch(images)


# print(status, stitched)
# 如果状态为“0”，则OpenCV成功执行图像拼接
if status == 0:
    # 检查我们是否应该从拼接图像中裁剪出最大的矩形区域
    if args["crop"] > 0:
        # 在拼接图像周围创建一个10像素的黑色边框
        print("[INFO] cropping...")
        stitched = cv2.copyMakeBorder(stitched, 10, 10, 10, 10,
                                      cv2.BORDER_CONSTANT, (0, 0, 0))
        # cv2.imshow('123',stitched)

        # 将拼接图像转换为灰度
        gray = cv2.cvtColor(stitched, cv2.COLOR_BGR2GRAY)
        # cv2.imshow('456', gray)
        # 对灰度图像进行阈值二值化，
        # 这样所有大于零的像素都设置为255（前景），而其他所有像素都保持为0（背景）
        thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY)[1]
        # cv2.imshow('789', thresh)
        # 在阈值图像中找到所有外部轮廓，然后找到 “最大 ”轮廓，它将是拼接图像的轮廓
        # cv2.RETR_EXTERNAL：只找外轮廓。cv2.CHAIN_APPROX_SIMPLE：输出少量轮廓点
        # 输出参数1：图像
        # 输出参数2：轮廓列表
        # 输出参数3：层级
        cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        # print(cnts) #cnts包括三个数组：
        # print(len(cnts))

        cnts = imutils.grab_contours(cnts)

        ################################
        # imutils.grab_contours 的源码 ：

            # # if the length the contours tuple returned by cv2.findContours
            # # is '2' then we are using either OpenCV v2.4, v4-beta, or
            # # v4-official
            # if len(cnts) == 2:
            #     cnts = cnts[0]
            # # if the length of the contours tuple is '3' then we are using
            # # either OpenCV v3, v4-pre, or v4-alpha
            # elif len(cnts) == 3:
            #     cnts = cnts[1]
            # # otherwise OpenCV has changed their cv2.findContours return
            # # signature yet again and I have no idea WTH is going on
            # else:
            #     raise Exception(("Contours tuple must have length 2 or 3, "
            #                      "otherwise OpenCV changed their cv2.findContours return "
            #                      "signature yet again. Refer to OpenCV's documentation "
            #                      "in that case"))
            # # return the actual contours array
            # return cnts
        ##################################

        # 抓取具有最大区域的轮廓（即拼接图像本身的轮廓），cv2.contourArea是求轮廓面积
        c = max(cnts, key=cv2.contourArea)
        # print(c)
        # print(c.shape)
        # 为掩码分配内存，该掩码将包含拼接图像区域的矩形边界框
        mask = np.zeros(thresh.shape, dtype="uint8")
        # 计算出最大轮廓的边界框,使用边界矩形信息.使用 cv2.boundingRect(img) 函数，用一个最小的矩形，
        # 把找到的形状包起来，img是一个二值图，也就是它的参数；返回四个值，分别是 x，y，w，h；
        # 其中 x，y 是矩阵左上点的坐标，w，h 是矩阵的宽和高
        (x, y, w, h) = cv2.boundingRect(c)
        # 使用cv2.rectangle给图像加框，我们在mask上绘制一个纯白色矩形。
        # 参数1：图像
        # 参数2：左上角坐标
        # 参数3：右下角坐标
        # 参数4：框的颜色
        # 参数5：框的粗细
        cv2.rectangle(mask, (x, y), (x + w, y + h), 255, -1)

        # 创建掩码的两个副本
        # 第一个mask，将逐渐缩小，直到它可以放入全景内部。
        minRect = mask.copy()
        # 第二个mask，将用于确定是否需要继续减小minRect的大小。
        sub = mask.copy()
        cv2.imshow('111',sub)

        # 保持循环，直到sub中没有更多的前景像素
        # 对二值化图像执行countNonZero。可得到非零像素点数(即外边框的像素点)
        print(cv2.countNonZero(sub))
        while cv2.countNonZero(sub) > 0:
            # 执行侵蚀形态学操作以减小minRect的大小。
            minRect = cv2.erode(minRect, None)
            cv2.imshow('333',minRect)
            # 从minRect中减去thresh ，一旦minRect中没有更多的前景像素，我们就可以从循环中断开
            sub = cv2.subtract(minRect, thresh)

        # 在最小矩形掩码中找到轮廓，然后提取边界框（x，y） - 坐标
        cnts = cv2.findContours(minRect.copy(), cv2.RETR_EXTERNAL,
                                cv2.CHAIN_APPROX_SIMPLE)
        cv2.imshow('444',cnts[0])
        cnts = imutils.grab_contours(cnts)
        c = max(cnts, key=cv2.contourArea)
        (x, y, w, h) = cv2.boundingRect(c)

        # 使用边界框坐标来提取我们的最终拼接图像
        stitched = stitched[y:y + h, x:x + w]

        # 将输出拼接图像写入磁盘
        cv2.imwrite("result.jpg", stitched)

        # 将输出拼接图像显示到我们的屏幕
        cv2.imshow("Stitched", stitched)
        cv2.waitKey(0)

# 否则，拼接失败，可能是由于检测不到足够的关键点

else:
   print("[INFO] image stitching failed ({})".format(status))

#执行
python main.py --images images/ --output output.png --crop 1

结果如下所示

有一说一opencv真的牛掰

OpenCV常用图像拼接方法(一) ：直接拼接

vconcat()—垂直方向拼接，要求待拼接图像有相同的宽度； hconcat()—水平方向拼接，要求待拼接图像有相同的高度。

使用vconcat()和hconcat()拼接则要求待拼接图像有相同的宽度或高度

 	Mat img = imread("girl.jpg");
    vector<Mat>vImgs;
    Mat result;
    vImgs.push_back(img);
    vImgs.push_back(img);
    vconcat(vImgs, result); //垂直方向拼接
    //hconcat(vImgs, result); //水平方向拼接
    imshow("result",result);
    cout << "Hello World!" << endl;
    waitKey(0);

其他拼接函数

        vector<Mat> images;

        images.push_back(imread("stitch1.jpg"));
        images.push_back(imread("stitch2.jpg"));

        // 设置拼接模式与参数
        Mat result1, result2, result3;
        Stitcher::Mode mode = Stitcher::PANORAMA;
        Ptr<Stitcher> stitcher = Stitcher::create(mode);

        // 拼接方式-多通道融合
        auto blender = detail::Blender::createDefault(detail::Blender::MULTI_BAND);
        stitcher->setBlender(blender);

        // 拼接
        Stitcher::Status status = stitcher->stitch(images, result1);

        // 平面曲翘拼接
        auto plane_warper = makePtr<cv::PlaneWarper>();
        stitcher->setWarper(plane_warper);
        status = stitcher->stitch(images, result2);

        // 鱼眼拼接
        auto fisheye_warper = makePtr<cv::FisheyeWarper>();
        stitcher->setWarper(fisheye_warper);
        status = stitcher->stitch(images, result3);

        // 检查返回
        if (status != Stitcher::OK)
        {
            cout << "Can't stitch images, error code = " << int(status) << endl;
            return EXIT_FAILURE;
        }

        imshow("result1.png", result1);
        imshow("result2.png", result2);
        imshow("result3.png", result3);

         waitKey(0);

图示：

OpenCV常用图像拼接方法(二) ：基于模板匹配拼接

• 适用范围：图像有重合区域，且待拼接图像之间无明显尺度变化和畸变。
• 优点：简单、快速(相比于SIFT特征匹配拼接)。
• 常用实例：两个相邻相机水平拍摄图像拼接。

截取如下两部分ROI作为待拼接图像。

待拼接图①：

待拼接图②：

思路：在图①中截取部分公共区域ROI作为模板，利用模板在图②中匹配，得到最佳匹配位置后计算X和Y方向需要平移的像素距离，将图②对应的拼接到大图中。如下，模板为青色区域：

部分代码和效果如下：

 Mat imgL = imread("A.jpg");
  Mat imgR = imread("B.jpg");
  double start = getTickCount();
  Mat grayL, grayR;
  cvtColor(imgL, grayL, COLOR_BGR2GRAY);
  cvtColor(imgR, grayR, COLOR_BGR2GRAY);

  Rect rectCut = Rect(372, 122, 128, 360);
  Rect rectMatched = Rect(0, 0, imgR.cols / 2, imgR.rows);
  Mat imgTemp = grayL(Rect(rectCut));
  Mat imgMatched = grayR(Rect(rectMatched));

  int width = imgMatched.cols - imgTemp.cols + 1;
  int height = imgMatched.rows - imgTemp.rows + 1;
  Mat matchResult(height, width, CV_32FC1);
  matchTemplate(imgMatched, imgTemp, matchResult, TM_CCORR_NORMED);
  normalize(matchResult, matchResult, 0, 1, NORM_MINMAX, -1);  //归一化到0--1范围

  double minValue, maxValue;
  Point minLoc, maxLoc;
  minMaxLoc(matchResult, &minValue, &maxValue, &minLoc, &maxLoc);

  Mat dstImg(imgL.rows, imgR.cols + rectCut.x - maxLoc.x, CV_8UC3, Scalar::all(0));
  Mat roiLeft = dstImg(Rect(0, 0, imgL.cols, imgL.rows));
  imgL.copyTo(roiLeft);

  Mat debugImg = imgR.clone();
  rectangle(debugImg, Rect(maxLoc.x, maxLoc.y, imgTemp.cols, imgTemp.rows), Scalar(0, 255, 0), 2, 8);
  imwrite("match.jpg", debugImg);

  Mat roiMatched = imgR(Rect(maxLoc.x, maxLoc.y - rectCut.y, imgR.cols - maxLoc.x, imgR.rows - 1 - (maxLoc.y - rectCut.y)));
  Mat roiRight = dstImg(Rect(rectCut.x, 0, roiMatched.cols, roiMatched.rows));

  roiMatched.copyTo(roiRight);

  double end = getTickCount();
  double useTime = (end - start) / getTickFrequency();
  cout << "use-time : " << useTime << "s" << endl;

  imwrite("dst.jpg", dstImg);
  cout << "Done!" << endl;

匹配结果：

拼接结果：

OpenCV常用图像拼接方法(三) ：SIFT特征匹配拼接方法
特点和适用范围：图像有足够重合相同特征区域，且待拼接图像之间无明显尺度变换和畸变。
优点：适应部分倾斜变化情况。缺点：需要有足够的相同特征区域进行匹配，速度较慢，拼接较大图片容易崩溃。
如下是待拼接的两张图片：

特征匹配图：

拼接结果图：

拼接缝处理后(拼接处过渡更自然)：

/********************直接图像拼接函数*************************/
bool ImageOverlap0(Mat &img1, Mat &img2)
{
  Mat g1(img1, Rect(0, 0, img1.cols, img1.rows));  // init roi
  Mat g2(img2, Rect(0, 0, img2.cols, img2.rows));
 
  cvtColor(g1, g1, COLOR_BGR2GRAY);
  cvtColor(g2, g2, COLOR_BGR2GRAY);
 
  vector<cv::KeyPoint> keypoints_roi, keypoints_img;  /* keypoints found using SIFT */
  Mat descriptor_roi, descriptor_img;                           /* Descriptors for SIFT */
  FlannBasedMatcher matcher;                                   /* FLANN based matcher to match keypoints */
 
  vector<cv::DMatch> matches, good_matches;
  cv::Ptr<cv::SIFT> sift = cv::SIFT::create();
  int i, dist = 80;
 
  sift->detectAndCompute(g1, cv::Mat(), keypoints_roi, descriptor_roi);      /* get keypoints of ROI image */
  sift->detectAndCompute(g2, cv::Mat(), keypoints_img, descriptor_img);         /* get keypoints of the image */
  matcher.match(descriptor_roi, descriptor_img, matches);  //实现描述符之间的匹配
 
  double max_dist = 0; double min_dist = 5000;
  //-- Quick calculation of max and min distances between keypoints
  for (int i = 0; i < descriptor_roi.rows; i++)
  {
    double dist = matches[i].distance;
    if (dist < min_dist) min_dist = dist;
    if (dist > max_dist) max_dist = dist;
  }
  // 特征点筛选
  for (i = 0; i < descriptor_roi.rows; i++)
  {
    if (matches[i].distance < 3 * min_dist)
    {
      good_matches.push_back(matches[i]);
    }
  }
 
  printf("%ld no. of matched keypoints in right image\n", good_matches.size());
  /* Draw matched keypoints */
 
  Mat img_matches;
  //绘制匹配
  drawMatches(img1, keypoints_roi, img2, keypoints_img,
    good_matches, img_matches, Scalar::all(-1),
    Scalar::all(-1), vector<char>(),
    DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
  imshow("matches", img_matches);
 
  vector<Point2f> keypoints1, keypoints2;
  for (i = 0; i < good_matches.size(); i++)
  {
    keypoints1.push_back(keypoints_img[good_matches[i].trainIdx].pt);
    keypoints2.push_back(keypoints_roi[good_matches[i].queryIdx].pt);
  }
  //计算单应矩阵(仿射变换矩阵)
  Mat H = findHomography(keypoints1, keypoints2, RANSAC);
  Mat H2 = findHomography(keypoints2, keypoints1, RANSAC);
 
 
  Mat stitchedImage;  //定义仿射变换后的图像(也是拼接结果图像)
  Mat stitchedImage2;  //定义仿射变换后的图像(也是拼接结果图像)
  int mRows = img2.rows;
  if (img1.rows > img2.rows)
  {
    mRows = img1.rows;
  }
 
  int count = 0;
  for (int i = 0; i < keypoints2.size(); i++)
  {
    if (keypoints2[i].x >= img2.cols / 2)
      count++;
  }
  //判断匹配点位置来决定图片是左还是右
  if (count / float(keypoints2.size()) >= 0.5)  //待拼接img2图像在右边
  {
    cout << "img1 should be left" << endl;
    vector<Point2f>corners(4);
    vector<Point2f>corners2(4);
    corners[0] = Point(0, 0);
    corners[1] = Point(0, img2.rows);
    corners[2] = Point(img2.cols, img2.rows);
    corners[3] = Point(img2.cols, 0);
    stitchedImage = Mat::zeros(img2.cols + img1.cols, mRows, CV_8UC3);
    warpPerspective(img2, stitchedImage, H, Size(img2.cols + img1.cols, mRows));
 
    perspectiveTransform(corners, corners2, H);
    /*
    circle(stitchedImage, corners2[0], 5, Scalar(0, 255, 0), 2, 8);
    circle(stitchedImage, corners2[1], 5, Scalar(0, 255, 255), 2, 8);
    circle(stitchedImage, corners2[2], 5, Scalar(0, 255, 0), 2, 8);
    circle(stitchedImage, corners2[3], 5, Scalar(0, 255, 0), 2, 8); */
    cout << corners2[0].x << ", " << corners2[0].y << endl;
    cout << corners2[1].x << ", " << corners2[1].y << endl;
    imshow("temp", stitchedImage);
    //imwrite("temp.jpg", stitchedImage);
 
    Mat half(stitchedImage, Rect(0, 0, img1.cols, img1.rows));
    img1.copyTo(half);
    imshow("result", stitchedImage);
  }
  else  //待拼接图像img2在左边
  {
    cout << "img2 should be left" << endl;
    stitchedImage = Mat::zeros(img2.cols + img1.cols, mRows, CV_8UC3);
    warpPerspective(img1, stitchedImage, H2, Size(img1.cols + img2.cols, mRows));
    imshow("temp", stitchedImage);
 
    //计算仿射变换后的四个端点
    vector<Point2f>corners(4);
    vector<Point2f>corners2(4);
    corners[0] = Point(0, 0);
    corners[1] = Point(0, img1.rows);
    corners[2] = Point(img1.cols, img1.rows);
    corners[3] = Point(img1.cols, 0);
 
    perspectiveTransform(corners, corners2, H2);  //仿射变换对应端点
    /*
    circle(stitchedImage, corners2[0], 5, Scalar(0, 255, 0), 2, 8);
    circle(stitchedImage, corners2[1], 5, Scalar(0, 255, 255), 2, 8);
    circle(stitchedImage, corners2[2], 5, Scalar(0, 255, 0), 2, 8);
    circle(stitchedImage, corners2[3], 5, Scalar(0, 255, 0), 2, 8); */
    cout << corners2[0].x << ", " << corners2[0].y << endl;
    cout << corners2[1].x << ", " << corners2[1].y << endl;
 
    Mat half(stitchedImage, Rect(0, 0, img2.cols, img2.rows));
    img2.copyTo(half);
    imshow("result", stitchedImage);
 
  }
  imwrite("result.bmp", stitchedImage);
  return true;
}

OpenCV常用图像拼接方法(四) ：SURF特征匹配拼接方法
参考链接：
https://www.cnblogs.com/skyfsm/p/7411961.html
https://www.cnblogs.com/skyfsm/p/7401523.html