opencv学习笔记七十：图像拼接

简要：

图像拼接在实际的应用场景很广，举一个例子，用你的手机对某一场景拍照，但是没有办法一次将所有你要拍的景物全部拍下来，所以你对该场景从左往右依次拍了好几张图，来把你要拍的所有景物记录下来，图像拼接就是要将这些图像拼接成一个完整的大图。

核心：

• 特征点检测
• 特征点匹配
• 图像配准（透视变换）
• 图像拷贝
• 图像融合

#include<opencv2\opencv.hpp>
#include<opencv2\xfeatures2d.hpp>
using namespace cv;
using namespace xfeatures2d;
using namespace std;

void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);
vector<Point2f>src2Corners(4), trans2Corners(4);

int main(int arc, char** argv) 
{ 
  Mat src1 = imread("15.jpeg");
  Mat src2 = imread("16.jpeg");
  namedWindow("input1", CV_WINDOW_AUTOSIZE);
  imshow("input1", src1);
  imshow("input2", src2);

  //SURF特征点检测与提取
  int minHessian = 400;
  Ptr<SURF>surf = SURF::create(minHessian);
  vector<KeyPoint>keypoints1, keypoints2;
  Mat descriptors1, descriptors2;
  surf->detectAndCompute(src1, Mat(), keypoints1, descriptors1);
  surf->detectAndCompute(src2, Mat(), keypoints2, descriptors2);

  //特征点匹配
  FlannBasedMatcher matcher;
  vector<DMatch>matches;
  matcher.match(descriptors1, descriptors2, matches);

  //寻找优良匹配，也可以用sort(matches.begin(), matches.end())对匹配点按照匹配的距离进行升序排列
  double minDist = 1000;
  for (int i = 0; i < descriptors1.rows; i++) {
    double dist = matches[i].distance;
    if (dist < minDist) {
      minDist = dist;
    }
  }
  printf("min distance:%lf\n", minDist);
  vector<DMatch>goodMatchers;
  for (int i = 0; i < descriptors1.rows; i++) {
    double dist = matches[i].distance;
    if (dist < max(3*minDist,0.02)) {
      goodMatchers.push_back(matches[i]);
    }
  }

  //画出优良匹配图
  Mat matches_img;
  drawMatches(src1, keypoints1, src2, keypoints2, goodMatchers, matches_img, Scalar::all(-1), Scalar::all(-1),vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
  imshow("output", matches_img);

  //图像配准
  vector<Point2f> imgPoints1, imgPoints2;
  for (int j = 0; j < goodMatchers.size(); j++) {
    imgPoints1.push_back(keypoints1[goodMatchers[j].queryIdx].pt);
    imgPoints2.push_back(keypoints2[goodMatchers[j].trainIdx].pt);
  }
  Mat M = findHomography(imgPoints2, imgPoints1,RANSAC);

  //src2的四个角点
  src2Corners[0].x = 0;//左上角
  src2Corners[0].y = 0;

  src2Corners[1].x = 0;//左下角
  src2Corners[1].y = src2.rows;

  src2Corners[2].x = src2.cols;//右上角
  src2Corners[2].y = 0;

  src2Corners[3].x = src2.cols;//右下角
  src2Corners[3].y = src2.rows;

  //src2经过透视变换后的四个角点
  perspectiveTransform(src2Corners, trans2Corners,M);
  
  //透视变换
  Mat src2Transform;
  warpPerspective(src2, src2Transform ,M, Size(min(trans2Corners[2].x, trans2Corners[3].x), src1.rows));
  imshow("imgTransform2", src2Transform);

  //图像拷贝
  int dst_width = src2Transform.cols;  //取最右点的长度为拼接图的长度
  int dst_height = src2Transform.rows;
  Mat dst(dst_height, dst_width, src2.type());
  dst.setTo(0);
  src2Transform.copyTo(dst(Rect(0, 0, src2Transform.cols, src2Transform.rows)));
  src1.copyTo(dst(Rect(0, 0, src1.cols, src1.rows)));//将src1中的矩形部分拷贝到dst中
  imshow("dst", dst);

  //图像融合
  OptimizeSeam(src1, src2Transform, dst);
  imshow("fusion_dst", dst);
  imwrite("fusion.jpg", dst);
  waitKey(0);
  return 0;
}

void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst){
  int start = min(trans2Corners[0].x, trans2Corners[1].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中是黑点的像素，则完全拷贝src1中的数据
      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); 
    }
  }
}

案例一： 

   

案例二：

   

案例三：

   

  

案例四：

   

    

案例五：