opencv surf特征点匹配拼接源码

最新推荐文章于 2024-08-20 16:12:02 发布
最新推荐文章于 2024-08-20 16:12:02 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： opencv

http://blog.csdn.net/huixingshao/article/details/42672073

/**
 * @file SURF_Homography
 * @brief SURF detector + descriptor + FLANN Matcher + FindHomography
 * @author A. Huaman
 */

#include <stdio.h>
#include <iostream>
#include <cv.h>
#include "opencv2/core/core.hpp"
#include <opencv2/opencv.hpp>  
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/calib3d/calib3d.hpp"
#include "opencv2/nonfree/features2d.hpp"
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/nonfree/nonfree.hpp>  



using namespace cv;
using namespace std;

#ifdef _DEBUG
#pragma comment (lib, "opencv_calib3d246d.lib")
#pragma comment (lib, "opencv_contrib246d.lib")
#pragma comment (lib,"opencv_imgproc246d.lib")
#pragma comment (lib, "opencv_core246d.lib")
#pragma comment (lib, "opencv_features2d246d.lib")
#pragma comment (lib, "opencv_flann246d.lib")
#pragma comment (lib, "opencv_gpu246d.lib")
#pragma comment (lib, "opencv_highgui246d.lib")
#pragma comment (lib, "opencv_legacy246d.lib")
#pragma comment (lib, "opencv_ml246d.lib")
#pragma comment (lib, "opencv_objdetect246d.lib")
#pragma comment (lib, "opencv_ts246d.lib")
#pragma comment (lib, "opencv_video246d.lib")
#pragma comment (lib, "opencv_nonfree246d.lib")
#else
#pragma comment (lib, "opencv_calib3d246.lib")
#pragma comment (lib, "opencv_contrib246.lib")
#pragma comment (lib, "opencv_imgproc246.lib")
#pragma comment (lib, "opencv_core246.lib")
#pragma comment (lib, "opencv_features2d246.lib")
#pragma comment (lib, "opencv_flann246.lib")
#pragma comment (lib, "opencv_gpu246.lib")
#pragma comment (lib, "opencv_highgui246.lib")
#pragma comment (lib, "opencv_legacy246.lib")
#pragma comment (lib, "opencv_ml246.lib")
#pragma comment (lib, "opencv_objdetect246.lib")
#pragma comment (lib, "opencv_ts246.lib")
#pragma comment (lib, "opencv_video246.lib")
#pragma comment (lib, "opencv_nonfree246.lib")
#endif

int main()
{
	initModule_nonfree();//初始化模块，使用SIFT或SURF时用到 
	Ptr<FeatureDetector> detector = FeatureDetector::create( "SURF" );//创建SIFT特征检测器，可改成SURF/ORB
	Ptr<DescriptorExtractor> descriptor_extractor = DescriptorExtractor::create( "SURF" );//创建特征向量生成器，可改成SURF/ORB
	Ptr<DescriptorMatcher> descriptor_matcher = DescriptorMatcher::create( "BruteForce" );//创建特征匹配器  
	if( detector.empty() || descriptor_extractor.empty() )  
		cout<<"fail to create detector!";  

	//读入图像  
	Mat img1 = imread("1.jpg");  
	Mat img2 = imread("2.jpg");  

	//特征点检测  
	double t = getTickCount();//当前滴答数  
	vector<KeyPoint> m_LeftKey,m_RightKey;  
	detector->detect( img1, m_LeftKey );//检测img1中的SIFT特征点，存储到m_LeftKey中  
	detector->detect( img2, m_RightKey );  
	cout<<"图像1特征点个数:"<<m_LeftKey.size()<<endl;  
	cout<<"图像2特征点个数:"<<m_RightKey.size()<<endl;  

	//根据特征点计算特征描述子矩阵，即特征向量矩阵  
	Mat descriptors1,descriptors2;  
	descriptor_extractor->compute( img1, m_LeftKey, descriptors1 );  
	descriptor_extractor->compute( img2, m_RightKey, descriptors2 );  
	t = ((double)getTickCount() - t)/getTickFrequency();  
	cout<<"SIFT算法用时："<<t<<"秒"<<endl;  

	cout<<"图像1特征描述矩阵大小："<<descriptors1.size()  
		<<"，特征向量个数："<<descriptors1.rows<<"，维数："<<descriptors1.cols<<endl;  
	cout<<"图像2特征描述矩阵大小："<<descriptors2.size()  
		<<"，特征向量个数："<<descriptors2.rows<<"，维数："<<descriptors2.cols<<endl;  

	//画出特征点  
	Mat img_m_LeftKey,img_m_RightKey;  
	drawKeypoints(img1,m_LeftKey,img_m_LeftKey,Scalar::all(-1),0);  
	drawKeypoints(img2,m_RightKey,img_m_RightKey,Scalar::all(-1),0);  
	//imshow("Src1",img_m_LeftKey);  
	//imshow("Src2",img_m_RightKey);  

	//特征匹配  
	vector<DMatch> matches;//匹配结果  
	descriptor_matcher->match( descriptors1, descriptors2, matches );//匹配两个图像的特征矩阵  
	cout<<"Match个数："<<matches.size()<<endl;  

	//计算匹配结果中距离的最大和最小值  
	//距离是指两个特征向量间的欧式距离，表明两个特征的差异，值越小表明两个特征点越接近  
	double max_dist = 0;  
	double min_dist = 100;  
	for(int i=0; i<matches.size(); i++)  
	{  
		double dist = matches[i].distance;  
		if(dist < min_dist) min_dist = dist;  
		if(dist > max_dist) max_dist = dist;  
	}  
	cout<<"最大距离："<<max_dist<<endl;  
	cout<<"最小距离："<<min_dist<<endl;  

	//筛选出较好的匹配点  
	vector<DMatch> goodMatches;  
	for(int i=0; i<matches.size(); i++)  
	{  
		if(matches[i].distance < 0.2 * max_dist)  
		{  
			goodMatches.push_back(matches[i]);  
		}  
	}  
	cout<<"goodMatch个数："<<goodMatches.size()<<endl;  

	//画出匹配结果  
	Mat img_matches;  
	//红色连接的是匹配的特征点对，绿色是未匹配的特征点  
	drawMatches(img1,m_LeftKey,img2,m_RightKey,goodMatches,img_matches,  
		Scalar::all(-1)/*CV_RGB(255,0,0)*/,CV_RGB(0,255,0),Mat(),2);  

	imshow("MatchSIFT",img_matches);  
	IplImage result=img_matches;

	waitKey(0);


	//RANSAC匹配过程
	vector<DMatch> m_Matches=goodMatches;
	// 分配空间
	int ptCount = (int)m_Matches.size();
	Mat p1(ptCount, 2, CV_32F);
	Mat p2(ptCount, 2, CV_32F);

	// 把Keypoint转换为Mat
	Point2f pt;
	for (int i=0; i<ptCount; i++)
	{
		pt = m_LeftKey[m_Matches[i].queryIdx].pt;
		p1.at<float>(i, 0) = pt.x;
		p1.at<float>(i, 1) = pt.y;

		pt = m_RightKey[m_Matches[i].trainIdx].pt;
		p2.at<float>(i, 0) = pt.x;
		p2.at<float>(i, 1) = pt.y;
	}

	// 用RANSAC方法计算F
	Mat m_Fundamental;
	vector<uchar> m_RANSACStatus;       // 这个变量用于存储RANSAC后每个点的状态
	findFundamentalMat(p1, p2, m_RANSACStatus, FM_RANSAC);

	// 计算野点个数

	int OutlinerCount = 0;
	for (int i=0; i<ptCount; i++)
	{
		if (m_RANSACStatus[i] == 0)    // 状态为0表示野点
		{
			OutlinerCount++;
		}
	}
	int InlinerCount = ptCount - OutlinerCount;   // 计算内点
	cout<<"内点数为："<<InlinerCount<<endl;


	// 这三个变量用于保存内点和匹配关系
	vector<Point2f> m_LeftInlier;
	vector<Point2f> m_RightInlier;
	vector<DMatch> m_InlierMatches;

	m_InlierMatches.resize(InlinerCount);
	m_LeftInlier.resize(InlinerCount);
	m_RightInlier.resize(InlinerCount);
	InlinerCount=0;
	float inlier_minRx=img1.cols;        //用于存储内点中右图最小横坐标，以便后续融合

	for (int i=0; i<ptCount; i++)
	{
		if (m_RANSACStatus[i] != 0)
		{
			m_LeftInlier[InlinerCount].x = p1.at<float>(i, 0);
			m_LeftInlier[InlinerCount].y = p1.at<float>(i, 1);
			m_RightInlier[InlinerCount].x = p2.at<float>(i, 0);
			m_RightInlier[InlinerCount].y = p2.at<float>(i, 1);
			m_InlierMatches[InlinerCount].queryIdx = InlinerCount;
			m_InlierMatches[InlinerCount].trainIdx = InlinerCount;

			if(m_RightInlier[InlinerCount].x<inlier_minRx) inlier_minRx=m_RightInlier[InlinerCount].x;   //存储内点中右图最小横坐标

			InlinerCount++;
		}
	}

	// 把内点转换为drawMatches可以使用的格式
	vector<KeyPoint> key1(InlinerCount);
	vector<KeyPoint> key2(InlinerCount);
	KeyPoint::convert(m_LeftInlier, key1);
	KeyPoint::convert(m_RightInlier, key2);

	// 显示计算F过后的内点匹配
	Mat OutImage;
	drawMatches(img1, key1, img2, key2, m_InlierMatches, OutImage);
	cvNamedWindow( "Match features", 1);
	cvShowImage("Match features", &IplImage(OutImage));
	waitKey(0);

	cvDestroyAllWindows();

	//矩阵H用以存储RANSAC得到的单应矩阵
	Mat H = findHomography( m_LeftInlier, m_RightInlier, RANSAC );

	//存储左图四角，及其变换到右图位置
	std::vector<Point2f> obj_corners(4);
	obj_corners[0] = Point(0,0); obj_corners[1] = Point( img1.cols, 0 );
	obj_corners[2] = Point( img1.cols, img1.rows ); obj_corners[3] = Point( 0, img1.rows );
	std::vector<Point2f> scene_corners(4);
	perspectiveTransform( obj_corners, scene_corners, H);

	//画出变换后图像位置
	Point2f offset( (float)img1.cols, 0);  
	line( OutImage, scene_corners[0]+offset, scene_corners[1]+offset, Scalar( 0, 255, 0), 4 );
	line( OutImage, scene_corners[1]+offset, scene_corners[2]+offset, Scalar( 0, 255, 0), 4 );
	line( OutImage, scene_corners[2]+offset, scene_corners[3]+offset, Scalar( 0, 255, 0), 4 );
	line( OutImage, scene_corners[3]+offset, scene_corners[0]+offset, Scalar( 0, 255, 0), 4 );
	imshow( "Good Matches & Object detection", OutImage );

	waitKey(0);
	imwrite("warp_position.jpg",OutImage);

 
 	int drift = scene_corners[1].x;                                                        //储存偏移量
 
 	//新建一个矩阵存储配准后四角的位置
 	int width = int(max(abs(scene_corners[1].x), abs(scene_corners[2].x)));
 	int height= img1.rows;                                                                  //或者：int height = int(max(abs(scene_corners[2].y), abs(scene_corners[3].y)));
 	float origin_x=0,origin_y=0;
 	if(scene_corners[0].x<0) {
 		if (scene_corners[3].x<0) origin_x+=min(scene_corners[0].x,scene_corners[3].x);
 		else origin_x+=scene_corners[0].x;}
 	width-=int(origin_x);
 	if(scene_corners[0].y<0) {
 		if (scene_corners[1].y) origin_y+=min(scene_corners[0].y,scene_corners[1].y);
 		else origin_y+=scene_corners[0].y;}
 	//可选：height-=int(origin_y);
 	Mat imageturn=Mat::zeros(width,height,img1.type());
 
 	//获取新的变换矩阵，使图像完整显示
 	for (int i=0;i<4;i++) {scene_corners[i].x -= origin_x; } 	//可选：scene_corners[i].y -= (float)origin_y; }
 	Mat H1=getPerspectiveTransform(obj_corners, scene_corners);
 
 	//进行图像变换，显示效果
	warpPerspective(img1,imageturn,H1,Size(width,height));	
 	imshow("image_Perspective", imageturn);
 	waitKey(0);
 
 
 	//图像融合
 	int width_ol=width-int(inlier_minRx-origin_x);
 	int start_x=int(inlier_minRx-origin_x);
 	cout<<"width: "<<width<<endl;
 	cout<<"img1.width: "<<img1.cols<<endl;
 	cout<<"start_x: "<<start_x<<endl;
 	cout<<"width_ol: "<<width_ol<<endl;
 
 	uchar* ptr=imageturn.data;
 	double alpha=0, beta=1;
 	for (int row=0;row<height;row++) {
 		ptr=imageturn.data+row*imageturn.step+(start_x)*imageturn.elemSize();
 		for(int col=0;col<width_ol;col++)
 		{
 			uchar* ptr_c1=ptr+imageturn.elemSize1();  uchar*  ptr_c2=ptr_c1+imageturn.elemSize1();
 			uchar* ptr2=img2.data+row*img2.step+(col+int(inlier_minRx))*img2.elemSize();
 			uchar* ptr2_c1=ptr2+img2.elemSize1();  uchar* ptr2_c2=ptr2_c1+img2.elemSize1();
 
 
 			alpha=double(col)/double(width_ol); beta=1-alpha;
 
 			if (*ptr==0&&*ptr_c1==0&&*ptr_c2==0) {
 				*ptr=(*ptr2);
 				*ptr_c1=(*ptr2_c1);
 				*ptr_c2=(*ptr2_c2);
 			}
 
 			*ptr=(*ptr)*beta+(*ptr2)*alpha;
 			*ptr_c1=(*ptr_c1)*beta+(*ptr2_c1)*alpha;
 			*ptr_c2=(*ptr_c2)*beta+(*ptr2_c2)*alpha;
 
 			ptr+=imageturn.elemSize();
 		}	}
 
 	//imshow("image_overlap", imageturn);
 	//waitKey(0);
 
 	Mat img_result=Mat::zeros(height,width+img2.cols-drift,img1.type());
 	uchar* ptr_r=imageturn.data;
 
 	for (int row=0;row<height;row++) {
 		ptr_r=img_result.data+row*img_result.step;
 
 		for(int col=0;col<imageturn.cols;col++)
 		{
 			uchar* ptr_rc1=ptr_r+imageturn.elemSize1();  uchar*  ptr_rc2=ptr_rc1+imageturn.elemSize1();
 
 			uchar* ptr=imageturn.data+row*imageturn.step+col*imageturn.elemSize();
 			uchar* ptr_c1=ptr+imageturn.elemSize1();  uchar*  ptr_c2=ptr_c1+imageturn.elemSize1();
 
 			*ptr_r=*ptr;
 			*ptr_rc1=*ptr_c1;
 			*ptr_rc2=*ptr_c2;
 
 			ptr_r+=img_result.elemSize();
 		}	
 
 		ptr_r=img_result.data+row*img_result.step+imageturn.cols*img_result.elemSize();
 		for(int col=imageturn.cols;col<img_result.cols;col++)
 		{
 			uchar* ptr_rc1=ptr_r+imageturn.elemSize1();  uchar*  ptr_rc2=ptr_rc1+imageturn.elemSize1();
 
 			uchar* ptr2=img2.data+row*img2.step+(col-imageturn.cols+drift)*img2.elemSize();
 			uchar* ptr2_c1=ptr2+img2.elemSize1();  uchar* ptr2_c2=ptr2_c1+img2.elemSize1();
 
 			*ptr_r=*ptr2;
 			*ptr_rc1=*ptr2_c1;
 			*ptr_rc2=*ptr2_c2;
 
 			ptr_r+=img_result.elemSize();
 		}	
 	}
 
 	imshow("image_result", img_result);
	//imwrite("final_result.jpg",img_result);
	return 0;
}

000000000000O
关注
专栏目录
OpenCV3.0实现SIFT特征提取+RANSAC剔除误匹配点
11-21
OpenCV3.0实现SIFT特征提取+RANSAC剔除误匹配点，首先进行提取SIFT特征点。然后再通过RANSAC剔除误匹配点
SIFT SURF ORB方法总结
qq_32425195的博客
11-09 1443
SIFT方法的原理 参考https://www.jianshu.com/p/95c4890c486b?utm_source=oschina-app 关键点： （1）SIFT会先检测图中较明显的点（如角点），对这些点提取特征 （2）sift的特征为什么具有旋转不变性： sift会先提取主方向，然后将特征点周围1616的像素根据主方向旋转；然后对每个1616分为16个44的区域，在每个区域提取8个方向的梯度直方图（提取方向的直方图，而不是每个像素的梯度值）。即sift特征是特征点周围像素的梯度相对于主梯度的方向
OpenCV几何图像变换（3）计算透视变换矩阵函数getPerspectiveTransform()的使用
最新发布
jndingxin的专栏
08-20 1137
getPerspectiveTransform() 函数用于计算一个 3×3 的透视变换矩阵，该矩阵将源图像中的四边形映射到目标图像中的另一个四边形。这种变换可以实现图像的透视校正，例如将倾斜的图像拉直或调整视角。
sift、surf、orb 特征提取及最优特征点匹配
weixin_30466421的博客
08-04 2178
目录 sift sift特征简介 sift特征提取步骤 surf surf特征简介 surf特征提取步骤 orb orb特征简介 orb特征提取算法 ...
Opencv实现：SIFT特征提取+RANSAC剔除误匹配点
勿筑高台于浮沙，脚踏实地做学习
09-11 2万+
最近整理一下利用SIFT特征提取方法和RANSAC（随机抽样一致性方法）进行剔除无匹配点的内容，将实现过程进行记录。 程序注释的非常清楚了，新手也能很快看懂。
C# opencvsharp sift和surf特征点匹配演示源码
02-01
测试环境： vs2019, netframework4.7.2,opencvhsarp4.8.0 博客地址： blog.csdn.net/FL1623863129/article/details/135972875
C# OpenCvSharp 通过特征点匹配图片.rar
11-09
在本项目"C# OpenCvSharp 通过特征点匹配图片"中，开发者使用了C#编程语言和OpenCvSharp库来实现图像处理中的一个重要任务——特征点匹配。特征点匹配是计算机视觉领域的一种基本技术，它用于识别两张图片中的相同或...
C OpenCV特征匹配源码.rar
07-10
在这个"C OpenCV特征匹配源码"压缩包中，包含了基于OpenCV实现的特征匹配类文件，特别使用了SIFT（尺度不变特征变换）算法，这是一种广泛使用的特征检测和描述方法。 SIFT算法由David Lowe在1999年提出，它具有以下...
特征点匹配源码
09-06
标题"特征点匹配源码"指的是一段利用OpenCV库进行特征点匹配的程序代码。这样的代码通常包括特征点的检测、描述符的提取以及两幅图像间特征点的匹配过程。OpenCV提供了`Feature2D`类的子类，如`SIFT`和`SURF`，来...
基于SURF的图像匹配与拼接算法程序源码（C/Opencv）
12-04
本程序源码采用尺度不变特征变换（Scale-Invariant Feature Transform，简称SURF）算法进行图像特征提取，并结合匹配算法实现图像的拼接。以下将详细解析这个程序的核心知识点。 **1. SURF算法** SURF算法是SIFT...
详解SIFT,SURF,ORB,FAST 特征提取算法比较
牛肉胡辣汤
01-20 2386
特征提取算法是在机器学习和模式识别中常用的一种技术，它的目标是从原始数据中提取出有用的特征，以用于后续的学习和推断任务。SIFT、SURF、ORB和FAST是广泛使用的特征提取算法。ORB算法是一种计算速度快于SIFT和SURF的特征提取算法，由Rublee等人于2010年提出。它具有旋转不变性和尺度不变性。FAST算法是一种用于高速特征点检测的算法，由Rosten和Drummond于2006年提出。在比较SIFT、SURF、ORB和FAST特征提取算法时，我们可以根据应用场景和需求选择适合的算法。
OpenCV的SIFT特征点提取及RANSAC去除误检测
sunzhao1000的博客
06-06 3227
关于SIFT的讲解，参考：http://blog.csdn.net/zddblog/article/details/7521424关于SANCAS的讲解，参考：http://blog.csdn.net/laobai1015/article/details/51682596SIFT（Scale Invariant Feature Transform）多尺度特征点提取算法在nonfree文件内集成。R...
[图像特征匹配]SIFT、SURF、ORB算法笔记以及代码实现
Ah丶Weii
10-08 3916
SIFT算法学习笔记 尺度不变特征转换(Scale-invariant feature transform）是一种用来侦测与描述影像中的局部性特征的视觉算法，即通过求一幅图中的特征点及其有关尺度和方向的描述子得到特征，并进行图像特征点匹配。SIFT所查找到的关键点是一些十分突出，不会因光照，仿射变换和噪音等因素而变化的点，如角点、边缘点、暗区的亮点及亮区的暗点等，噪声也保持一定程度的稳定性，除此...
利用RANSAC算法筛选SIFT特征匹配
热门推荐
Why So Serious?
06-21 6万+
关于RANSAC算法的基本思想，可从网上搜索找到，这里只是RANSAC用于SIFT特征匹配筛选时的一些说明。 RANSAC算法在SIFT特征筛选中的主要流程是： (1) 从样本集中随机抽选一个RANSAC样本，即4个匹配点对 (2) 根据这4个匹配点对计算变换矩阵M (3) 根据样本集，变换矩阵M，和误差度量函数计算满足当前变换矩阵的一致集consensus，并返回一致集中元素个数 (4
图像特征点提取及匹配的几种方法总结——基于C++和OPENCV实现SIFT、SURF、ORB、FAST
H19981118的博客
05-08 5100
学习特征提取匹配以及图像融合
详解SIFT、SURF和ORB特征点检测和描述算法
重点记录机器人和自动驾驶相关领域的技术，尤其是计算机视觉，视觉SLAM等，不仅有前言文献或必备算法的学习，也会有实际应用的点滴经验
10-08 4552
本文主要对SIFT、SURF和ORB特征点检测和描述算法进行详细的学习和比较。
[RANSAC]使用RANSAC和SIFT算法减少图片特征的误匹配
Ah丶Weii
10-29 6668
使用RANSAC和SIFT算法减少图片特征的误匹配 一、RANSAC算法简述     随机抽样一致算法（RANdom SAmple Consensus,RANSAC）,采用迭代的方式从一组包含离群的被观测数据中估算出数学模型的参数。RANSAC算法被广泛应用在计算机视觉领域和数学领域，例如直线拟合、平面拟合、计算图像或点云间的变换矩阵、计算基础矩阵等方面。     RANSAC算法假设数据中包含正...
2.2ORBSLAM3之ORB、SIFT、SURF、Harris角点、Shi-Tomas角点特征点提取方法
超爱吃小蛋糕的66的博客
06-19 2015
本节对ORB特征、SIFT特征、SURF特征、Harris角点、Shi-Tomas角点的提取与描述子计算原理进行总结，其中Harris角点、Shi-Tomas角点是关键点，没有对应的描述子，一般用于光流跟踪(Vins系列算法)。 综合所有的特征检测算法来看，所有的方法本质上都是通过计算像素灰度梯度检测关键点位置，ORB特征通过与邻域像素进行灰度值比较得到，其余SIFT，SURF，Harris角点、Shi-Tomas角点均都涉及到一个Hessian矩阵(由离散像素二阶导得到)求解问题，根据Hessian矩阵
使用OpenCV获取Harris特征点的源码分析
3. 特征匹配和提取：OpenCV还提供了特征匹配功能，可以对两个图像进行特征匹配，检测相似的特征点。 知识点三：C++源码结构分析 根据文件标题和描述，我们可以推断出压缩文件中的main_harris.cpp文件将包含以下几个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值