devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

opencv ORB特征提取与匹配-实现图像拼接

作者：凡人多烦事01 | 2024-04-03 15:07:07

赞

踩

opencv orb特征提取

本文基于opencv对两张存在交集的图片进行了拼接，这两张图片拍摄角度不同，并且画面存在一定的交集，该功能可以用代码实现两张图片的拼接。通过设计两张特定的拼接掩膜（mask），来过度拼接处的像素突变，拼接效果很好。

步骤如下：

加载图片

  1.     Mat room1 = imread("E:\\opencv_tutorial_data-master\\images\\room1 (2).jpg");
  2.     Mat room2 = imread("E:\\opencv_tutorial_data-master\\images\\room2 (2).jpg");
  3.     //由于手机拍摄的照片像素过大不方便显示，所以对图片进行resize
  4.     resize(room1, room1, Size((int)(room1.cols / 2), (int)(room1.rows / 2)), 0.5, 0.5);
  5.     resize(room2, room2, Size((int)(room2.cols / 2), (int)(room2.rows / 2)), 0.5, 0.5);
  6.     if (room1.empty() == true || room2.empty() == true) {
  7. 	    cout << "error" << endl;
  8. 	    return -1;
  9.     }
  10.     imshow("room1", room1);
  11.     imshow("room2", room2);


room1

 room2

orb特征提取

  1.     //创建ORB特征点提取对象，设置提取点数
  2. 	auto orb = ORB::create(500);
  3. 	//存放提取的特征点
  4. 	vector<KeyPoint> kpts_orb_room1;
  5. 	vector<KeyPoint> kpts_orb_room2;
  6. 	//存放特征点描述子
  7. 	Mat dec_orb_room1, dec_orb_room2;
  8. 	//特征点提取和描述子计算
  9. 	orb->detectAndCompute(room1, Mat(), kpts_orb_room1, dec_orb_room1);
  10. 	orb->detectAndCompute(room2, Mat(), kpts_orb_room2, dec_orb_room2);

特征点暴力匹配

  1. 	//创建暴力匹配子对象
  2. 	auto bf_matcher = BFMatcher::create(NORM_HAMMING, false);
  3. 	//存放描述子匹配关系
  4. 	vector<DMatch> matches_bf;
  5. 	//特征点描述子匹配
  6. 	bf_matcher->match(dec_orb_room1, dec_orb_room2, matches_bf);
  7.  
  8.  
  9. 	//特征点筛选
  10. 	float good_rate = 0.025f;//设置筛选率为0.025
  11. 	int num_good_matchs = matches_bf.size()*good_rate;
  12. 	std::sort(matches_bf.begin(), matches_bf.end());
  13. 	matches_bf.erase(matches_bf.begin() + num_good_matchs, matches_bf.end());
  14. 	//绘制筛选后匹配结果
  15. 	Mat result_bf;
  16. 	drawMatches(room1, kpts_orb_room1, room2, kpts_orb_room2, matches_bf, result_bf);

匹配结果 

生成掩膜

  1.     //获取全景图的大小
  2. 	int mix_high = max(room1.rows,room2.rows);
  3. 	int mix_widht = room1.cols + room2.cols;
  4. 	Mat mix_room_01 = Mat::zeros(Size(mix_widht, mix_high),CV_8UC3);
  5. 	Rect roi;
  6. 	roi.x = 0;
  7. 	roi.y = 0;
  8. 	roi.width = room1.cols;
  9. 	roi.height = room1.rows;
  10.  
  11. 	//获取room2与room1的对齐图像
  12. 	room1.copyTo(mix_room_01(roi));
  13. 	imshow("mix_room_01", mix_room_01);
  14. 	Mat mix_room_02;
  15. 	warpPerspective(room2, mix_room_02, h,Size(mix_widht, mix_high));
  16. 	imshow("mix_room2", mix_room_02);
  17.  
  18. 	//计算重合区域mask
  19. 	Mat mask = Mat::zeros(Size(mix_widht, mix_high),CV_8UC1);
  20. 	generate_mask(mix_room_02,mask);
  21. 	imshow("mask",mask);
  22.  
  23. 	//创建遮罩层并根据mask完成权重初始化
  24. 	Mat mask1= Mat::ones(Size(mix_widht, mix_high), CV_32FC1);
  25. 	Mat mask2= Mat::ones(Size(mix_widht, mix_high), CV_32FC1);
  26.  
  27.  
  28. 	//room1 mask1
  29. 	linesapce(mask1,1,0,room1.cols,mask);
  30. 	imshow("mask1", mask1);
  31. 	//room2 mask2
  32. 	linesapce(mask2, 0, 1, room2.cols, mask);
  33. 	imshow("mask2", mask2);
  1.  
  2. void generate_mask(Mat&img, Mat&mask) {
  3. 	int w = img.cols;
  4. 	int h = img.rows;
  5. 	for (int row = 0; row < h;row++) {
  6. 		for (int col = 0; col < w; col++) {
  7. 			Vec3b p = img.at<Vec3b>(row,col);
  8. 			int b = p[0];
  9. 			int g = p[1];
  10. 			int r = p[2];
  11. 			if (b == g && g == r && r == 0) {
  12. 				mask.at<uchar>(row, col) = 255;
  13. 			}
  14.  
  15. 		}
  16. 		
  17. 	}
  18. }
  19. void linesapce(Mat&image, float begin, float finish, int w1, Mat&mask) {
  20. 	int offstx = 0;
  21. 	float interval = 0;
  22. 	float delta = 0;
  23. 	for (int i = 0; i < image.rows; i++) {
  24. 		offstx = 0;
  25. 		interval = 0;
  26. 		delta = 0;
  27. 		for (int j = 0; j < image.cols; j++) {
  28. 			int pv = mask.at<uchar>(i, j);
  29. 			if (pv == 0 && offstx == 0) {
  30. 				offstx = j;
  31. 				delta = w1 - offstx;
  32. 				interval = (finish-begin) / (delta - 1);
  33. 				image.at<float>(i, j) = begin + (j - offstx)*interval;
  34. 			}
  35. 			else if(pv==0&&offstx>0&&(j-offstx)<delta){
  36. 				image.at<float>(i, j) = begin + (j - offstx)*interval;
  37. 			}
  38. 			 
  39. 		}
  40. 	}
  41. }

融合

  1.  
  2. 	//左侧融合
  3. 	Mat m1;
  4. 	vector<Mat> mv;
  5. 	mv.push_back(mask1);
  6. 	mv.push_back(mask1);
  7. 	mv.push_back(mask1);
  8. 	merge(mv,m1);
  9. 	mix_room_01.convertTo(mix_room_01,CV_32F);
  10. 	multiply(mix_room_01,m1, mix_room_01);
  11.  
  12. 	//右侧融合
  13. 	Mat m2;
  14. 	mv.clear();
  15. 	mv.push_back(mask2);
  16. 	mv.push_back(mask2);
  17. 	mv.push_back(mask2);
  18. 	merge(mv, m2);
  19. 	mix_room_02.convertTo(mix_room_02, CV_32F);
  20. 	multiply(mix_room_02, m2, mix_room_02);
  21.  
  22. 	//合并
  23. 	Mat mix_room;
  24. 	add(mix_room_01, mix_room_02, mix_room);
  25. 	mix_room.convertTo(mix_room,CV_8U);
  26. 	imshow("mix_room", mix_room);
  27.  
  28. 	imshow("result_bf", result_bf);
  29. 	waitKey(0);
  30. 	return 0;

 最终效果！！！

 完整代码

  1. #include <iostream>
  2. #include<opencv2\opencv.hpp>
  3. #include<opencv2\xfeatures2d.hpp>
  4. #include<vector>
  5.  
  6. using namespace std;
  7. using namespace cv;
  8. using namespace xfeatures2d;
  9.  
  10. void linesapce(Mat&image,float begin,float finish,int w1,Mat&mask);
  11. void generate_mask(Mat&img,Mat&mask);
  12.  
  13. int main()
  14. {
  15. 	Mat room1 = imread("E:\\opencv_tutorial_data-master\\images\\room1 (2).jpg");
  16. 	Mat room2 = imread("E:\\opencv_tutorial_data-master\\images\\room2 (2).jpg");
  17. 	resize(room1, room1, Size((int)(room1.cols / 2), (int)(room1.rows / 2)), 0.5, 0.5);
  18. 	resize(room2, room2, Size((int)(room2.cols / 2), (int)(room2.rows / 2)), 0.5, 0.5);
  19. 	if (room1.empty() == true || room2.empty() == true) {
  20. 		cout << "error" << endl;
  21. 		return -1;
  22. 	}
  23. 	imshow("room1", room1);
  24. 	imshow("room2", room2);
  25. 	//创建ORB特征点提取对象，设置提取点数
  26. 	auto orb = ORB::create(500);
  27. 	//存放提取的特征点
  28. 	vector<KeyPoint> kpts_orb_room1;
  29. 	vector<KeyPoint> kpts_orb_room2;
  30. 	//存放特征点描述子
  31. 	Mat dec_orb_room1, dec_orb_room2;
  32. 	//特征点提取和描述子计算
  33. 	orb->detectAndCompute(room1, Mat(), kpts_orb_room1, dec_orb_room1);
  34. 	orb->detectAndCompute(room2, Mat(), kpts_orb_room2, dec_orb_room2);
  35.  
  36.  
  37. 	/*---------FLANN 匹配-------------*/
  38. 	/*
  39. 	if ((dec_orb_book.type() != CV_32F) && (dec_orb_book_in_scene.type() != CV_32F)) {
  40. 		dec_orb_book.convertTo(dec_orb_book, CV_32F);
  41. 		dec_orb_book_in_scene.convertTo(dec_orb_book_in_scene, CV_32F);
  42. 	}
  43. 	auto flann_matcher = FlannBasedMatcher::create();
  44. 	vector<DMatch> matches_flann;
  45. 	flann_matcher->match(dec_orb_book, dec_orb_book_in_scene, matches_flann);
  46. 	Mat result_flann;
  47. 	drawMatches(book, kpts_orb_book, book_in_scene, kpts_orb_book_in_scene, matches_flann, result_flann);
  48. 	imshow("result_flann", result_flann);
  49. 	*/
  50. 	/*--------------------------------*/
  51.  
  52.  
  53. 	/*---------暴力 匹配-------------*/
  54.  
  55. 	//创建暴力匹配子对象
  56. 	auto bf_matcher = BFMatcher::create(NORM_HAMMING, false);
  57. 	//存放描述子匹配关系
  58. 	vector<DMatch> matches_bf;
  59. 	//特征点描述子匹配
  60. 	bf_matcher->match(dec_orb_room1, dec_orb_room2, matches_bf);
  61.  
  62.  
  63. 	//特征点筛选
  64. 	float good_rate = 0.025f;
  65. 	int num_good_matchs = matches_bf.size()*good_rate;
  66. 	std::sort(matches_bf.begin(), matches_bf.end());
  67. 	matches_bf.erase(matches_bf.begin() + num_good_matchs, matches_bf.end());
  68. 	//绘制筛选后匹配结果
  69. 	Mat result_bf;
  70. 	drawMatches(room1, kpts_orb_room1, room2, kpts_orb_room2, matches_bf, result_bf);
  71. 	//获取两张图的特征点
  72. 	vector<Point2f>room1_points;
  73. 	vector<Point2f>room2_points;
  74. 	for (size_t t = 0; t < matches_bf.size(); t++) {
  75. 		room1_points.push_back(kpts_orb_room1[matches_bf[t].queryIdx].pt);
  76. 		room2_points.push_back(kpts_orb_room2[matches_bf[t].trainIdx].pt);
  77. 	}
  78. 	//根据对应的特征点获取从demo->scene的变换矩阵
  79. 	Mat h = findHomography(room2_points, room1_points,  RANSAC);
  80.  
  81. 	//获取全景图的大小
  82. 	int mix_high = max(room1.rows,room2.rows);
  83. 	int mix_widht = room1.cols + room2.cols;
  84. 	Mat mix_room_01 = Mat::zeros(Size(mix_widht, mix_high),CV_8UC3);
  85. 	Rect roi;
  86. 	roi.x = 0;
  87. 	roi.y = 0;
  88. 	roi.width = room1.cols;
  89. 	roi.height = room1.rows;
  90.  
  91. 	//获取room2与room1的对齐图像
  92. 	room1.copyTo(mix_room_01(roi));
  93. 	imshow("mix_room_01", mix_room_01);
  94. 	Mat mix_room_02;
  95. 	warpPerspective(room2, mix_room_02, h,Size(mix_widht, mix_high));
  96. 	imshow("mix_room2", mix_room_02);
  97.  
  98. 	//计算重合区域mask
  99. 	Mat mask = Mat::zeros(Size(mix_widht, mix_high),CV_8UC1);
  100. 	generate_mask(mix_room_02,mask);
  101. 	imshow("mask",mask);
  102.  
  103. 	//创建遮罩层并根据mask完成权重初始化
  104. 	Mat mask1= Mat::ones(Size(mix_widht, mix_high), CV_32FC1);
  105. 	Mat mask2= Mat::ones(Size(mix_widht, mix_high), CV_32FC1);
  106.  
  107.  
  108. 	//room1 mask1
  109. 	linesapce(mask1,1,0,room1.cols,mask);
  110. 	imshow("mask1", mask1);
  111. 	//room2 mask2
  112. 	linesapce(mask2, 0, 1, room2.cols, mask);
  113. 	imshow("mask2", mask2);
  114.  
  115. 	//左侧融合
  116. 	Mat m1;
  117. 	vector<Mat> mv;
  118. 	mv.push_back(mask1);
  119. 	mv.push_back(mask1);
  120. 	mv.push_back(mask1);
  121. 	merge(mv,m1);
  122. 	mix_room_01.convertTo(mix_room_01,CV_32F);
  123. 	multiply(mix_room_01,m1, mix_room_01);
  124.  
  125. 	//右侧融合
  126. 	Mat m2;
  127. 	mv.clear();
  128. 	mv.push_back(mask2);
  129. 	mv.push_back(mask2);
  130. 	mv.push_back(mask2);
  131. 	merge(mv, m2);
  132. 	mix_room_02.convertTo(mix_room_02, CV_32F);
  133. 	multiply(mix_room_02, m2, mix_room_02);
  134.  
  135. 	//合并
  136. 	Mat mix_room;
  137. 	add(mix_room_01, mix_room_02, mix_room);
  138. 	mix_room.convertTo(mix_room,CV_8U);
  139. 	imshow("mix_room", mix_room);
  140.  
  141. 	imshow("result_bf", result_bf);
  142. 	waitKey(0);
  143. 	return 0;
  144. }
  145.  
  146. void generate_mask(Mat&img, Mat&mask) {
  147. 	int w = img.cols;
  148. 	int h = img.rows;
  149. 	for (int row = 0; row < h;row++) {
  150. 		for (int col = 0; col < w; col++) {
  151. 			Vec3b p = img.at<Vec3b>(row,col);
  152. 			int b = p[0];
  153. 			int g = p[1];
  154. 			int r = p[2];
  155. 			if (b == g && g == r && r == 0) {
  156. 				mask.at<uchar>(row, col) = 255;
  157. 			}
  158.  
  159. 		}
  160. 		
  161. 	}
  162. }
  163. void linesapce(Mat&image, float begin, float finish, int w1, Mat&mask) {
  164. 	int offstx = 0;
  165. 	float interval = 0;
  166. 	float delta = 0;
  167. 	for (int i = 0; i < image.rows; i++) {
  168. 		offstx = 0;
  169. 		interval = 0;
  170. 		delta = 0;
  171. 		for (int j = 0; j < image.cols; j++) {
  172. 			int pv = mask.at<uchar>(i, j);
  173. 			if (pv == 0 && offstx == 0) {
  174. 				offstx = j;
  175. 				delta = w1 - offstx;
  176. 				interval = (finish-begin) / (delta - 1);
  177. 				image.at<float>(i, j) = begin + (j - offstx)*interval;
  178. 			}
  179. 			else if(pv==0&&offstx>0&&(j-offstx)<delta){
  180. 				image.at<float>(i, j) = begin + (j - offstx)*interval;
  181. 			}
  182. 			 
  183. 		}
  184. 	}
  185. }

参考资料：

腾讯课堂贾志刚老师课程

《opencv4入门到精通》

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/355997
推荐阅读
相关标签

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

  

闽ICP备14008679号