本文目标是通过使用SIFT和RANSAC算法，完成特征点的正确匹配，并求出变换矩阵，通过变换矩阵计算出要识别物体的边界（文章中有部分源码，整个工程我也上传了，请点击 这里 ）。

SIFT算法是目前公认的效果最好的特征点检测算法，关于该算法的就不多说了，网上的资料有很多，在此提供两个链接，一个是SIFT原文的译文，一个是关于SIFT算法的详细解释：

SIFT算法译文

SIFT算法详解

整个实现过程可以复述如下：提供两张初始图片，一幅为模板图像，一幅为测试图片，目的就是根据模板图片中的物体，检测出测试图片中的物体，并表示出物体的具体位置和大小，测试图片中的物体位置和大小，已经事先用白色方框标记。

首先，对两幅图片，都使用SIFT算法提取特征点，提取结果如下：（SIFT特征提取方法就用的是上文链接“SIFT算法详解”中提供的代码）

然后对特征点进行匹配，按照SIFT算法原文作者的思路，每个特征点产生一个128维的向量，计算向量之间的欧式距离，采用最近比次近的方式完成匹配，如果最近距离比上次近距离小于0.8，则认为这是一个正确的匹配， 否则认为匹配不成功。结果这种匹配后的情况如下图：

可以发现，仍然存在着很多错误的匹配点，所以再尝试用RANSAC算法消除错误匹配，尝试使用openCV中的findFundamentalMat函数消除错误匹配：

通过使用findFundamentalMat函数，函数返回一个3*3的矩阵，一开始我认为这个矩阵就是变换矩阵，只要将左图中的点与这个变换矩阵相乘，就可以得到右图中的对应点。但是这其实是不对的。

在这里有一个误解，就是findFundamentalMat函数确实可以使用RANSAC方法消除错误匹配，从名字上可以发现，这个函数的作用是返回基础矩阵的，基础矩阵和变换矩阵是两个不同的概念。基础矩阵描述是三维场景中的像点之间的对应关系（其实到现在为止这个函数求出的基础矩阵有个毛用我也不知道）。所以说，如果使用这个函数，这个实验也就能做到这一步了，没法再往下做了。

所以，为了得到变换矩阵，后来我才发现openCV中还有函数findHomography，这个函数才是真正的计算变换矩阵的函数，它的函数返回值才是真正的变换矩阵。

其实这个问题困扰了我很久，关于消除错误匹配的方法，网上查出来的多数都是通过findFundamentalMat函数来进行，所以我就想当然的认为该函数的返回值是变换矩阵了。而网上关于findHomography的介绍比较少，所以才会让人们误解findFundamentalMat会计算出变换矩阵了。

尝试用findHomography函数返回的矩阵，在模板图像中，已经用绿色方框标示出物体轮廓，根据物体的四个边界点，与变换矩阵相乘，即可得到变换后的物体的轮廓的四个边界点，将此边界点连接即为物体轮廓，如下图所示（绿色方框为事先标注的模板物体中的轮廓，白色方框为事先标注的测试图片中的轮廓，红色方框为经过绿色方框经变换矩阵变换后计算出的轮廓）：

从结果可以看出，这才是比较正确的结果。

实验过程中的主要代码如下（这是主要的代码，SIFT算法和一些其他的功能函数我都写在了其他的文件中）：

#include<math.h>
#include<time.h>
#include <windows.h>
#include <iostream>
using namespace std;
#include <cv.h>
#include <highgui.h>
#include <cxcore.h>
using namespace cv;
#include "sift.h"
#include "my_function.h"
int main()
	//加载两幅图片
	Mat src1 = imread("F:\\ylab\\image database\\camera\\obj01_001.jpg");
    Mat src2 = imread("F:\\ylab\\image database\\imagesTest2\\test01_.jpg");
	//这四个坐标是模板图像中绿色方框的四个顶点
	Point2f m1(173.0,0.0),m2(168.0,464.0),m3(507.0,464.0),m4(499.0,0.0);
	std::vector<Point2f> obj_corners(4);
	obj_corners[0] = cvPoint(173.0,0.0); 
    obj_corners[1] = cvPoint(168.0,464.0);
    obj_corners[2] = cvPoint(507.0,464.0); 
    obj_corners[3] = cvPoint(499.0,0.0);
	//原始图片比较大，我这里将图片同一处理成了640*480的大小
	Size certainsize=Size(640,480);
    Mat src_1;
	Mat src_2;
    resize(src1,src_1,certainsize);
	resize(src2,src_2,certainsize);
    //两个图像的特征点序列
	Vector<Keypoint> feature_1,feature_2;
	//采用sift算法，计算特征点序列，这个SIFT函数是在另外的文件中写好的
    Sift(src_1, feature_1, 1.6);
	Sift(src_2, feature_2, 1.6);
	//feature_dis为带有距离的特征点结构体序列
	Vector<Key_point> feature_dis_1;
	Vector<Key_point> feature_dis_2;
	Vector<Key_point> result;
	//对特征点进行匹配，这个Match_feature是我自己写的，就是采用最近比次近小于0.8即为合适的匹配，这种匹配方式
	//openCV中并没有，所以我就自己写了
	Match_feature(feature_1,feature_2,feature_dis_1,feature_dis_2);	
	printf("The number of features is %d\n",feature_1.size());
	printf("The number of the match features is %d\n",feature_dis_1.size());
	//从这里开始使用RANSAC方法进行运算
	//下面的程序都好无奈，所有的结构都只能转化成openCV的类型才能用openCV的函数。。
	Ptr<DescriptorMatcher> descriptor_matcher = DescriptorMatcher::create( "BruteForce" );//创建特征匹配器  
	int count=feature_dis_1.size();
	//把特征点序列转化成openCV能够使用的类型
	vector<KeyPoint>keypoints1,keypoints2;
	KeyPoint keyp;
	for(int i=0;i<count;i++)
		keyp.pt.x=feature_dis_1[i].dx;
		keyp.pt.y=feature_dis_1[i].dy;
		keypoints1.push_back(keyp);
		keyp.pt.x=feature_dis_2[i].dx;
		keyp.pt.y=feature_dis_2[i].dy;
		keypoints2.push_back(keyp);
	Mat descriptors1(count,FEATURE_ELEMENT_LENGTH, CV_32F);
	Mat descriptors2(count,FEATURE_ELEMENT_LENGTH, CV_32F);
	 for (int i=0; i<count; i++)
		for(int j=0;j<FEATURE_ELEMENT_LENGTH;j++)
			descriptors1.at<float>(i,j)=feature_dis_1[i].descriptor[j];
			descriptors2.at<float>(i,j)=feature_dis_2[i].descriptor[j];
	Mat img_match;
	vector<DMatch> matches; 
    descriptor_matcher->match( descriptors1, descriptors2, matches ); 
    Mat img_matches;
	drawMatches(src_1,keypoints1,src_2,keypoints2,matches,img_matches);
	//其实我前面已经完成匹配了，到这里，用openCV自带的方式重新匹配了一遍，并且显示了一下
	imshow("SIFT",img_matches);
	//imwrite("F:\\ylab\\CSDN_image\\3.jpg",img_matches);
	Mat p1(feature_dis_1.size(),2,CV_32F);
	Mat p2(feature_dis_1.size(),2,CV_32F);
	for(int i=0;i<feature_dis_1.size();i++)
		p1.at<float>(i,0)=feature_dis_1[i].dx;
		p1.at<float>(i,1)=feature_dis_1[i].dy;
		p2.at<float>(i,0)=feature_dis_2[i].dx;
		p2.at<float>(i,1)=feature_dis_2[i].dy;
	// 用RANSAC方法计算F
    Mat m_Fundamental;
    // 上面这个变量是基本矩阵
    vector<uchar> m_RANSACStatus;
    // 上面这个变量已经定义过，用于存储RANSAC后每个点的状态
	//一开始使用findFundamentalMat函数，发现可以消除错误匹配，实现很好的效果，但是
	//就是函数返回值不是变换矩阵，而是没有什么用的基础矩阵
	m_Fundamental = findFundamentalMat(p1,p2,m_RANSACStatus,CV_FM_RANSAC);
	//这里使用findHomography函数，这个函数的返回值才是真正的变换矩阵
	Mat m_homography;
    vector<uchar> m;
    m_homography=findHomography(p1,p2,CV_RANSAC,3,m);                              
	//由变换矩阵，求得变换后的物体边界四个点
    std::vector<Point2f> scene_corners(4);
    perspectiveTransform( obj_corners, scene_corners, m_homography);
    line( src_2, scene_corners[0] , scene_corners[1] , Scalar(0, 0, 255), 2 );
    line( src_2, scene_corners[1] , scene_corners[2] , Scalar(0, 0, 255), 2 );
    line( src_2, scene_corners[2] , scene_corners[3] , Scalar(0, 0, 255), 2 );
    line( src_2, scene_corners[3] , scene_corners[0] , Scalar(0, 0, 255), 2 );
	int nr=m_Fundamental.rows; // number of rows  
    int nc=m_Fundamental.cols *m_Fundamental.channels(); // total number of elements per line 
	// 计算野点个数
    int OutlinerCount = 0;
    for (int i=0; i<Count; i++)
         if (m_RANSACStatus[i] == 0) // 状态为0表示野点
              OutlinerCount++;
    // 计算内点
     vector<Point2f> m_LeftInlier;
	 vector<Point2f> m_RightInlier;
	 vector<DMatch> m_InlierMatches;
	// 上面三个变量用于保存内点和匹配关系
	int ptCount = (int)matches.size();
	int InlinerCount = ptCount - OutlinerCount;
	m_InlierMatches.resize(InlinerCount);
	m_LeftInlier.resize(InlinerCount);
	m_RightInlier.resize(InlinerCount);
	InlinerCount = 0;
	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;
		      InlinerCount++;
 //   //printf("最终的匹配点个数为：%d\n",InlinerCount);
	 把内点转换为drawMatches可以使用的格式
	vector<KeyPoint> key1(InlinerCount);
	vector<KeyPoint> key2(InlinerCount);
	KeyPoint::convert(m_LeftInlier, key1);
	KeyPoint::convert(m_RightInlier, key2);
	// 显示计算F过后的内点匹配
	//Mat m_matLeftImage;
    //Mat m_matRightImage;
	// 以上两个变量保存的是左右两幅图像
	line(src_1,m1,m2,Scalar(0,255,0),2);
	line(src_1,m2,m3,Scalar(0,255,0),2);
	line(src_1,m3,m4,Scalar(0,255,0),2);
	line(src_1,m4,m1,Scalar(0,255,0),2);
	Mat OutImage;
	drawMatches(src_1, key1, src_2, key2, m_InlierMatches, OutImage);	
	imshow("SIFT_RANSAC",OutImage);	
	//imwrite("F:\\ylab\\CSDN_image\\5.jpg",OutImage);
    cvWaitKey( 0 );
	return 0;
                    SIFT算法是目前公认的效果最好的特征点检测算法，关于该算法的就不多说了，网上的资料有很多，在此提供两个链接，一个是SIFT原文的译文，一个是关于SIFT算法的详细解释：SIFT算法译文SIFT算法详解整个实现过程可以复述如下：提供两张初始图片，一幅为模板图像，一幅为测试图片，目的就是根据模板图片中的物体，检测出测试图片中的物体，并表示出物体的具体位置和大小，测试图片中的物体位
				
在 Python 中使用 SIFT、单应性、KNN 和 Ransac 的简单图像拼接算法。有关完整的详细信息和解释，欢迎阅读image_stitching.pdf。
该项目是实现一种基于特征的自动图像拼接算法。当我们输入两个具有重叠字段的图像时，我们期望获得一个宽阔的无缝全景图。
我们使用尺度不变特征变换（SIFT）来提取输入图像的局部特征，使用K个最近邻算法来匹配这些特征，并使用随机样本一致性（Ransac）来计算单应矩阵，该矩阵将用于图像变形。最后，我们应用加权矩阵作为图像混合的掩码。
（4）基于匹配的特征估计单应性矩阵；
（5）利用单应性矩阵作图像变换与拼接。
此资源为整个项目工程，包含了全景拼接算法、数据集、结果以及报告（英语），供大家学习与交流。
欢迎大家积极点赞和评论，博主会定期回复！
				
这频率是每半个月一课啊，每周一课要改名了八！哈哈哈
http://blog.sina.com.cn/s/blog_4298002e01013w9a.html
OpenCV在未知相机内参数情况下的立体图像矫正方法及注意事项
http://blog.sina.com.cn/s/blog_4298002e01013yb8.html
http://hi.baidu.com/zhongdudu/blog/item/8f6b242424e53833c995597f.html
关于Opencv的一些内容, 可以访问该博客的其他内容.
OpenCV 图像处理常用函数
2007-02-25 12
				
RANSAC（RANdom SAmple Consensus随机抽样一致）通过反复选择数据中的一组随机子集来达成目标。被选取的子集被假设为局内点，并用下述方法进行验证：
1.有一个模型适应于假设的局内点，即所有的未知参数都能从假设的局内点计算得出。（求解仿射变换，至少需要三个点）
2.用1中得到的模型去测试所有的其它数据，如果某个点适用于估计的模型，认为它也是局内点。
3.如果有足够多的点被归...
				
由双目立体视觉进行三位重建的第一步是寻找两幅图像中的对应点。目前人们已经发明了很多二维图像配准算法，比如SIFT, SURF等等。最新版本的OpenCV 2.2中的features2d库中包含了很多常用的算法，其中特征点定位的算法有FAST, SIFT, SURF ,MSER, HARRIS等，特征点描述算法有SURF, SIFT等，还有若干种特征点匹配算法。这三个步骤的算法可以任选其一，自由组合，非常方便。我经过实验，选择了一种速度、特征点数量和精度都比较好的组合方案：FAST角点检测算法+SURF特征描述子+FLANN(Fast Library for Approximate Nearest Neighbors) 匹配算法。
在匹配过程中需要有一些措施来过滤误匹配。一种比较常用的方法是比较第一匹配结果和第二匹配结果的得分差距是否足够大，这种方法可以过滤掉一些由于相似造成的误匹配。还有一种方法是利用已经找到的匹配点，使用RANSAC算法求得两幅视图之间的单应矩阵，然后将左视图中的坐标P用单应矩阵映射到右视图的Q点，观察与匹配结果Q’的欧氏距离是否足够小。当然由于图像是具有深度的，Q与
# 提取特征点和描述符
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
2. 特征点匹配
使用OpenCV的FLANN算法可以进行特征点匹配。代码如下：
# 初始化FLANN匹配器
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(index_params, search_params)
# 匹配特征点
matches = flann.knnMatch(des1, des2, k=2)
good_matches = []
for m, n in matches:
    if m.distance < 0.7 * n.distance:
        good_matches.append(m)
# 可视化匹配结果
img_match = cv2.drawMatches(img1, kp1, img2, kp2, good_matches, None, flags=2)
cv2.imshow('matches', img_match)
cv2.waitKey()
3. RANSAC算法
使用OpenCV的findHomography函数可以使用RANSAC算法估计图像间的单应性矩阵。代码如下：
MIN_MATCH_COUNT = 10
if len(good_matches) > MIN_MATCH_COUNT:
    src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
    dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
    M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
else:
    print("Not enough matches are found - %d/%d" % (len(good_matches), MIN_MATCH_COUNT))
    exit()
# 拼接图片
h, w = img1.shape[:2]
result = cv2.warpPerspective(img1, M, (w*2, h))
result[0:h, 0:w] = img2
cv2.imshow('result', result)
cv2.waitKey()
这样就可以用SIFT和RANSAC算法实现图像拼接了。