• 如何将图片进行竖直拼接(全景拼接)

    针对这个问题,我找遍了全网,都没有找到这个代码,都是在水平方向进行相应的拼接过程,自己也是看了一些代码,试图去修改一下,然后展示出来,但是修改的过程总是出现问题.

    重点来了,其实这个问题特别的容易解决,现在既然只能够实现水平拼接,那么将采集到的图片进行一个旋转,之后进行水平拼接,再将其旋转回去不就可以了吗.------是不是有种一语道破梦中人的感觉!(浪费了那么长时间去改代码,不如换一种思路去解决问题)

    首先是实现相应的图片旋转的过程,代码是如下所示:

    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5. using namespace cv;
    6.  
    7. int main()
    8. {
    9. 	Mat src = imread("C://Users//td//Desktop//相机图像大//7.jpg");
    10. 	Mat dst;
    11. 	Point center(src.cols / 2, src.rows / 2); //旋转中心
    12. 	double angle = -90.0;  //角度
    13. 	double scale = 1.0;  //缩放系数
    14. 	Mat rotMat = getRotationMatrix2D(center, angle, scale);
    15. 	warpAffine(src, dst, rotMat, src.size());
    16. 	imshow("src", src);
    17.  
    18. 	Mat img_matchesOutput;
    19. 	resize(dst, img_matchesOutput, Size(1280, 720));
    20. 	imshow("MatchSIFT", img_matchesOutput);
    21. 	
    22. 	waitKey();
    23. }

    结果示意图:

    上面进行一个图片旋转的过程会产生相应的黑色区域，使得进行匹配的过程会出现问题，所以上面的过程是存在一定的问题的。

    1. #include   
    2. using namespace cv;
    3.  
    4. int main()
    5. {
    6. 	Mat src = imread("C:\\Users\\td\\Desktop\\相机图像大/t1.jpg", 1);
    7. 	Mat srcCopy = Mat(src.rows, src.cols, src.depth());
    8. 	transpose(src, srcCopy);
    9. 	//flip(srcCopy, srcCopy, 1);  //rotate 270 
    10. 	flip(srcCopy, srcCopy, 0);  //rotate 90 
    11.  
    12. 	namedWindow("source Image", WINDOW_AUTOSIZE);
    13. 	imshow("source Image", src);
    14.  
    15. 	namedWindow("Display Image", WINDOW_AUTOSIZE);
    16. 	imshow("Display Image", srcCopy);
    17. 	waitKey(0);
    18. 	return 0;
    19. }

    这个过程是不存在黑色区域的，结果图如下：这里应当注意的是，这里的旋转方向是沿着逆时针进行旋转的，想要改变旋转方向需要改变相应的一个旋转参数。

    旋转之前

    旋转之后

    后面是进行图片拼接的过程:图片拼接有好多方法,直接在网上进行一个调用就可以了。

    方法一：opencv库里面自带的一个Stitcher，（要配置OpenCV环境）调用的代码如下所示：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. int main()
    12. {
    13. 	//step 1. load img
    14. 	std::vector imgs;
    15. 	Mat img1 = imread("D:/image/img1.png", IMREAD_COLOR);
    16. 	Mat img2 = imread("D:/image/img2.png", IMREAD_COLOR);
    17. 	imgs.emplace_back(img1);
    18. 	imgs.emplace_back(img2);
    19.  
    20. 	//进行拼接的函数 Stitcher
    21. 	Mat result;
    22. 	Stitcher stitcher = Stitcher::createDefault(false);
    23. 	Stitcher::Status status = stitcher.stitch(imgs, result);
    24.  
    25. 	if (status != Stitcher::OK)
    26. 	{
    27. 		std::string error_msg = "Can't stitch images, error code = " + 
    28.         std::to_string(status);
    29. 		printff(error_msg);
    30. 	}
    31. 	else
    32. 	{
    33. 		imshow("result", result);//这里的图片如果要是过大是显示不全的，可以调用一个改变图片大小的函数
    34. 	}
    35. 	waitKey(0);
    36. 	return 0;
    37. }

    方法二：SIFT + RANSAC（这里需要说明一下配置环境，因为SIFT角点检测方法在OpenCV 3.x版本就申请了专利，因此，建议使用Opencv 2.9.0版本）

    1. #include 
    2. #include 
    3. #include   
    4. #include   
    5. #include 
    6. #include 
    7. #include   
    8. #include   
    9.  
    10. using namespace cv; 
    11. using namespace std; 
    12.  
    13. int main()
    14. {
    15. 	initModule_nonfree();//初始化模块，使用SIFT或SURF时用到 
    16. 	Ptr detector = FeatureDetector::create( "SURF" );//创建SIFT特征检测器，可改成SURF/ORB
    17. 	Ptr descriptor_extractor = DescriptorExtractor::create( "SURF" );//创建特征向量生成器，可改成SURF/ORB
    18. 	Ptr descriptor_matcher = DescriptorMatcher::create( "BruteForce" );//创建特征匹配器  
    19. 	if( detector.empty() || descriptor_extractor.empty() )  
    20. 		cout<<"fail to create detector!";  
    21.  
    22. 	Mat src1 = imread("C:\\Users\\td\\Desktop\\相机图像大\\直杆拼接\\Pic_1.bmp");
    23. 	//Mat src1 = imread("C:\\Users\\td\\Desktop\\相机图像大/t1.jpg");
    24. 	Mat img1 = Mat(src1.rows, src1.cols, src1.depth());
    25. 	transpose(src1, img1);
    26. 	flip(img1, img1, 3);  //rotate 90 
    27.  
    28. 	Mat src2 = imread("C:\\Users\\td\\Desktop\\相机图像大\\直杆拼接\\Pic_2.bmp");
    29. 	//Mat src2 = imread("C:\\Users\\td\\Desktop\\相机图像大/t2.jpg");
    30. 	Mat img2 = Mat(src2.rows, src2.cols, src2.depth());
    31. 	transpose(src2, img2);
    32. 	flip(img2, img2, 3);  //rotate 90 
    33.  
    34. 	//特征点检测  
    35. 	double t = getTickCount();//当前滴答数  
    36. 	vector m_LeftKey,m_RightKey;  
    37. 	detector->detect( img1, m_LeftKey );//检测img1中的SIFT特征点，存储到m_LeftKey中  
    38. 	detector->detect( img2, m_RightKey );  
    39. 	cout<<"图像1特征点个数:"<size()<
    40. 	cout<<"图像2特征点个数:"<size()<
    41.  
    42. 	//根据特征点计算特征描述子矩阵，即特征向量矩阵  
    43. 	Mat descriptors1,descriptors2;  
    44. 	descriptor_extractor->compute( img1, m_LeftKey, descriptors1 );  
    45. 	descriptor_extractor->compute( img2, m_RightKey, descriptors2 );  
    46. 	t = ((double)getTickCount() - t)/getTickFrequency();  
    47. 	cout<<"SIFT算法用时："<"秒"<
    48.  
    49. 	cout<<"图像1特征描述矩阵大小："<size()  
    50. 		<<"，特征向量个数："<"，维数："<
    51. 	cout<<"图像2特征描述矩阵大小："<size()  
    52. 		<<"，特征向量个数："<"，维数："<
    53.  
    54. 	//画出特征点  
    55. 	Mat img_m_LeftKey,img_m_RightKey;  
    56. 	drawKeypoints(img1,m_LeftKey,img_m_LeftKey,Scalar::all(-1),0);  
    57. 	drawKeypoints(img2,m_RightKey,img_m_RightKey,Scalar::all(-1),0);  
    58. 	//imshow("Src1",img_m_LeftKey);  
    59. 	//imshow("Src2",img_m_RightKey);  
    60.  
    61. 	//特征匹配  
    62. 	vector matches;//匹配结果  
    63. 	descriptor_matcher->match( descriptors1, descriptors2, matches );//匹配两个图像的特征矩阵  
    64. 	cout<<"Match个数："<size()<
    65.  
    66. 	//计算匹配结果中距离的最大和最小值  
    67. 	//距离是指两个特征向量间的欧式距离，表明两个特征的差异，值越小表明两个特征点越接近  
    68. 	double max_dist = 0;  
    69. 	double min_dist = 100;  
    70. 	for(int i=0; isize(); i++)  
    71. 	{  
    72. 		double dist = matches[i].distance;  
    73. 		if(dist < min_dist) min_dist = dist;  
    74. 		if(dist > max_dist) max_dist = dist;  
    75. 	}  
    76. 	cout<<"最大距离："<
    77. 	cout<<"最小距离："<
    78.  
    79. 	//筛选出较好的匹配点  
    80. 	vector goodMatches;  
    81. 	for(int i=0; isize(); i++)  
    82. 	{  
    83. 		if(matches[i].distance < 0.2 * max_dist)  
    84. 		{  
    85. 			goodMatches.push_back(matches[i]);  
    86. 		}  
    87. 	}  
    88. 	cout<<"goodMatch个数："<size()<
    89.  
    90. 	//画出匹配结果  
    91. 	Mat img_matches;  
    92. 	//红色连接的是匹配的特征点对，绿色是未匹配的特征点  
    93. 	drawMatches(img1,m_LeftKey,img2,m_RightKey,goodMatches,img_matches,  
    94. 		Scalar::all(-1)/*CV_RGB(255,0,0)*/,CV_RGB(0,255,0),Mat(),2);  
    95.  
    96. 	Mat img_matchesOutput2;
    97. 	resize(img_matches, img_matchesOutput2, Size(1280, 720));
    98. 	imshow("MatchSIFT", img_matchesOutput2);
    99.  
    100. 	IplImage result=img_matches;
    101.  
    102. 	waitKey(0);
    103.  
    104. 	//RANSAC匹配过程
    105. 	vector m_Matches=goodMatches;
    106. 	// 分配空间
    107. 	int ptCount = (int)m_Matches.size();
    108. 	Mat p1(ptCount, 2, CV_32F);
    109. 	Mat p2(ptCount, 2, CV_32F);
    110.  
    111. 	// 把Keypoint转换为Mat
    112. 	Point2f pt;
    113. 	for (int i=0; i
    114. 	{
    115. 		pt = m_LeftKey[m_Matches[i].queryIdx].pt;
    116. 		p1.at<float>(i, 0) = pt.x;
    117. 		p1.at<float>(i, 1) = pt.y;
    118.  
    119. 		pt = m_RightKey[m_Matches[i].trainIdx].pt;
    120. 		p2.at<float>(i, 0) = pt.x;
    121. 		p2.at<float>(i, 1) = pt.y;
    122. 	}
    123.  
    124. 	// 用RANSAC方法计算F
    125. 	Mat m_Fundamental;
    126. 	vector m_RANSACStatus;       // 这个变量用于存储RANSAC后每个点的状态
    127. 	findFundamentalMat(p1, p2, m_RANSACStatus, FM_RANSAC);
    128. 	
    129. 	// 计算野点个数
    130.  
    131. 	int OutlinerCount = 0;
    132. 	for (int i=0; i
    133. 	{
    134. 		if (m_RANSACStatus[i] == 0)    // 状态为0表示野点
    135. 		{
    136. 			OutlinerCount++;
    137. 		}
    138. 	}
    139. 	int InlinerCount = ptCount - OutlinerCount;   // 计算内点
    140. 	cout<<"内点数为："<
    141.  
    142. 	
    143.    // 这三个变量用于保存内点和匹配关系
    144.    vector m_LeftInlier;
    145.    vector m_RightInlier;
    146.    vector m_InlierMatches;
    147.  
    148. 	m_InlierMatches.resize(InlinerCount);
    149. 	m_LeftInlier.resize(InlinerCount);
    150. 	m_RightInlier.resize(InlinerCount);
    151. 	InlinerCount=0;
    152. 	float inlier_minRx=img1.cols;        //用于存储内点中右图最小横坐标，以便后续融合
    153.  
    154. 	for (int i=0; i
    155. 	{
    156. 		if (m_RANSACStatus[i] != 0)
    157. 		{
    158. 			m_LeftInlier[InlinerCount].x = p1.at<float>(i, 0);
    159. 			m_LeftInlier[InlinerCount].y = p1.at<float>(i, 1);
    160. 			m_RightInlier[InlinerCount].x = p2.at<float>(i, 0);
    161. 			m_RightInlier[InlinerCount].y = p2.at<float>(i, 1);
    162. 			m_InlierMatches[InlinerCount].queryIdx = InlinerCount;
    163. 			m_InlierMatches[InlinerCount].trainIdx = InlinerCount;
    164.  
    165. 			if(m_RightInlier[InlinerCount].x//存储内点中右图最小横坐标
    166.  
    167. 			InlinerCount++;
    168. 		}
    169. 	}
    170.  
    171. 	// 把内点转换为drawMatches可以使用的格式
    172. 	vector key1(InlinerCount);
    173. 	vector key2(InlinerCount);
    174. 	KeyPoint::convert(m_LeftInlier, key1);
    175. 	KeyPoint::convert(m_RightInlier, key2);
    176.  
    177.     // 显示计算F过后的内点匹配
    178. 	Mat OutImage;
    179. 	drawMatches(img1, key1, img2, key2, m_InlierMatches, OutImage);
    180. 	//cvNamedWindow( "Match features", 1);
    181. 	//cvShowImage("Match features", &IplImage(OutImage));
    182. 	waitKey(0);
    183.  
    184. 	cvDestroyAllWindows();
    185.  
    186. 	//矩阵H用以存储RANSAC得到的单应矩阵
    187. 	Mat H = findHomography( m_LeftInlier, m_RightInlier, RANSAC );
    188.  
    189. 	//存储左图四角，及其变换到右图位置
    190. 	std::vector obj_corners(4);
    191. 	obj_corners[0] = Point(0,0); obj_corners[1] = Point( img1.cols, 0 );
    192. 	obj_corners[2] = Point( img1.cols, img1.rows ); obj_corners[3] = Point( 0, img1.rows );
    193. 	std::vector scene_corners(4);
    194. 	perspectiveTransform( obj_corners, scene_corners, H);
    195.  
    196. 	//画出变换后图像位置
    197. 	Point2f offset( (float)img1.cols, 0);  
    198. 	line( OutImage, scene_corners[0]+offset, scene_corners[1]+offset, Scalar( 0, 255, 0), 4 );
    199. 	line( OutImage, scene_corners[1]+offset, scene_corners[2]+offset, Scalar( 0, 255, 0), 4 );
    200. 	line( OutImage, scene_corners[2]+offset, scene_corners[3]+offset, Scalar( 0, 255, 0), 4 );
    201. 	line( OutImage, scene_corners[3]+offset, scene_corners[0]+offset, Scalar( 0, 255, 0), 4 );
    202. 	imshow( "Good Matches & Object detection", OutImage );
    203. 	Mat img_matchesOutput3;
    204. 	resize(OutImage, img_matchesOutput3, Size(1280, 720));
    205. 	imshow("Good Matches & Object detection", img_matchesOutput3);
    206. 	/*	while(1)
    207. 	{
    208. 		if(waitKey(100)==19) cvSaveImage("E:\\warp_position.jpg",  &IplImage(OutImage));  
    209. 		if(waitKey(100)==27) break;
    210. 	}                                                              //按esc继续，ctl+s保存图像
    211. 	*/
    212. 	int drift = scene_corners[1].x;                                                        //储存偏移量
    213.  
    214. 	//新建一个矩阵存储配准后四角的位置
    215. 	int width = int(max(abs(scene_corners[1].x), abs(scene_corners[2].x)));
    216. 	int height= img1.rows;                                                                  //或者：int height = int(max(abs(scene_corners[2].y), abs(scene_corners[3].y)));
    217. 	float origin_x=0,origin_y=0;
    218. 		if(scene_corners[0].x<0) {
    219. 			if (scene_corners[3].x<0) origin_x+=min(scene_corners[0].x,scene_corners[3].x);
    220. 		else origin_x+=scene_corners[0].x;}
    221. 		width-=int(origin_x);
    222. 	if(scene_corners[0].y<0) {
    223. 		if (scene_corners[1].y) origin_y+=min(scene_corners[0].y,scene_corners[1].y);
    224. 		else origin_y+=scene_corners[0].y;}
    225. 	//可选：height-=int(origin_y);
    226. 	Mat imageturn=Mat::zeros(width,height,img1.type());
    227.  
    228. 	//获取新的变换矩阵，使图像完整显示
    229. 	for (int i=0;i<4;i++) {scene_corners[i].x -= origin_x; } 	//可选：scene_corners[i].y -= (float)origin_y; }
    230. 	Mat H1=getPerspectiveTransform(obj_corners, scene_corners);
    231.  
    232. 	//进行图像变换，显示效果
    233. 	warpPerspective(img1,imageturn,H1,Size(width,height));	
    234.  
    235.  
    236. 	Mat img_matchesOutput4;
    237. 	resize(imageturn, img_matchesOutput4, Size(1280, 720));
    238. 	imshow("image_Perspective", img_matchesOutput4);
    239.  
    240. 	waitKey(0);
    241.  
    242.  
    243. 	//图像融合
    244. 	int width_ol=width-int(inlier_minRx-origin_x);
    245. 	int start_x=int(inlier_minRx-origin_x);
    246.     cout<<"width: "<
    247. 	cout<<"img1.width: "<
    248. 	cout<<"start_x: "<
    249. 	cout<<"width_ol: "<
    250.  
    251. 	uchar* ptr=imageturn.data;
    252. 	double alpha=0, beta=1;
    253. 	for (int row=0;row
    254. 		ptr=imageturn.data+row*imageturn.step+(start_x)*imageturn.elemSize();
    255. 		for(int col=0;col
    256. 		{
    257. 			uchar* ptr_c1=ptr+imageturn.elemSize1();  uchar*  ptr_c2=ptr_c1+imageturn.elemSize1();
    258. 			uchar* ptr2=img2.data+row*img2.step+(col+int(inlier_minRx))*img2.elemSize();
    259. 			uchar* ptr2_c1=ptr2+img2.elemSize1();  uchar* ptr2_c2=ptr2_c1+img2.elemSize1();
    260.  
    261. 			
    262. 			alpha=double(col)/double(width_ol); beta=1-alpha;
    263.  
    264. 			if (*ptr==0&&*ptr_c1==0&&*ptr_c2==0) {
    265. 				*ptr=(*ptr2);
    266. 				*ptr_c1=(*ptr2_c1);
    267. 				*ptr_c2=(*ptr2_c2);
    268. 			}
    269.  
    270. 			*ptr=(*ptr)*beta+(*ptr2)*alpha;
    271. 			*ptr_c1=(*ptr_c1)*beta+(*ptr2_c1)*alpha;
    272. 			*ptr_c2=(*ptr_c2)*beta+(*ptr2_c2)*alpha;
    273.  
    274. 			ptr+=imageturn.elemSize();
    275. 		}	}
    276. 	
    277. 	//imshow("image_overlap", imageturn);
    278. 	//waitKey(0);
    279.  
    280. 	Mat img_result=Mat::zeros(height,width+img2.cols-drift,img1.type());
    281. 	uchar* ptr_r=imageturn.data;
    282. 	
    283. 	for (int row=0;row
    284. 		ptr_r=img_result.data+row*img_result.step;
    285.  
    286. 		for(int col=0;col
    287. 		{
    288. 			uchar* ptr_rc1=ptr_r+imageturn.elemSize1();  uchar*  ptr_rc2=ptr_rc1+imageturn.elemSize1();
    289.  
    290. 			uchar* ptr=imageturn.data+row*imageturn.step+col*imageturn.elemSize();
    291. 			uchar* ptr_c1=ptr+imageturn.elemSize1();  uchar*  ptr_c2=ptr_c1+imageturn.elemSize1();
    292.  
    293. 			*ptr_r=*ptr;
    294. 			*ptr_rc1=*ptr_c1;
    295. 			*ptr_rc2=*ptr_c2;
    296.  
    297. 			ptr_r+=img_result.elemSize();
    298. 		}	
    299.  
    300. 		ptr_r=img_result.data+row*img_result.step+imageturn.cols*img_result.elemSize();
    301. 		for(int col=imageturn.cols;col
    302. 		{
    303. 			uchar* ptr_rc1=ptr_r+imageturn.elemSize1();  uchar*  ptr_rc2=ptr_rc1+imageturn.elemSize1();
    304.  
    305. 			uchar* ptr2=img2.data+row*img2.step+(col-imageturn.cols+drift)*img2.elemSize();
    306. 			uchar* ptr2_c1=ptr2+img2.elemSize1();  uchar* ptr2_c2=ptr2_c1+img2.elemSize1();
    307.  
    308. 			*ptr_r=*ptr2;
    309. 			*ptr_rc1=*ptr2_c1;
    310. 			*ptr_rc2=*ptr2_c2;
    311.  
    312. 			ptr_r+=img_result.elemSize();
    313. 		}	
    314. 	}
    315. 	Mat img_matchesOutput5;
    316. 	resize(img_result, img_matchesOutput5, Size(1280, 720));
    317. 	imshow("image_result", img_matchesOutput5);
    318.  
    319. 	/*
    320. 		while(1)
    321. 	{
    322. 		if(waitKey(100)==19) cvSaveImage("E:\\final_result.jpg",  &IplImage(img_result));  
    323. 		if(waitKey(100)==27) break;                     //按esc退出，ctl+s保存图像
    324. 	}
    325. 	*/
    326. 	return 0;
    327. }
    328.

    当然是还有其他的方法，SIFT毕竟检测速度并不是很快，其余的方法自行研究。

  • 相关阅读:
    Notexpress 从另一个文档粘贴过来引文出错的问题
    2022年SQL大厂高频实战面试题（详细解析）
    Python 读写 Excel 文件
    C++课堂整理--第一章内容
    十年老程序员分享13个最常用的Python深度学习库和介绍，赶紧收藏码住！
    【C语言简单实现数据结构】排序之交换排序和归并排序
    vue处理边界情况
    【数仓基础（一）】基础概念：数据仓库【用于决策的数据集合】的概念、建立数据仓库的原因与好处
    2169 -- 最大公约数题解
    linux 修改用户的密码
  • 原文地址：https://blog.csdn.net/m0_47489229/article/details/126890476