本範例的程式碼主要都是 學習OpenCV——通過KeyPoints進行目標定位這篇部落格提供的，然後在它的基礎上稍加修改，檢測keypoints點的檢測器是SURF，獲取描述子也是用到SURF來描述，而用到的匹配器是FlannBased，匹配的方式是Knn方式，最後通過findHomography尋找單對映矩陣，perspectiveTransform獲得最終的目標，在這個過程中還通過單對映矩陣來進一步去除偽匹配，這裡只是貼出程式碼和程式碼解析，至於原理還沒弄得特別明白，希望接下來可以繼續學習，學懂了演算法原理再來補充。

1、程式碼實現

#include "stdafx.h"
#include "opencv2/opencv.hpp"
#include <vector>  
#include <iostream>  

using namespace cv;  
using namespace std;  
Mat src,frameImg;  
int width;  
int height;  
vector<Point> srcCorner(4);  
vector<Point> dstCorner(4);  

static bool createDetectorDescriptorMatcher( const string& detectorType, const string& descriptorType, const string& matcherType,  
	Ptr<FeatureDetector>& featureDetector,  
	Ptr<DescriptorExtractor>& descriptorExtractor,  
	Ptr<DescriptorMatcher>& descriptorMatcher )  
{  
	cout << "< Creating feature detector, descriptor extractor and descriptor matcher ..." << endl;  
	if (detectorType=="SIFT"||detectorType=="SURF")  
		initModule_nonfree();  
	featureDetector = FeatureDetector::create( detectorType );  
	descriptorExtractor = DescriptorExtractor::create( descriptorType );  
	descriptorMatcher = DescriptorMatcher::create( matcherType );  
	cout << ">" << endl;  
	bool isCreated = !( featureDetector.empty() || descriptorExtractor.empty() || descriptorMatcher.empty() );  
	if( !isCreated )  
		cout << "Can not create feature detector or descriptor extractor or descriptor matcher of given types." << endl << ">" << endl;  
	return isCreated;  
}  


bool refineMatchesWithHomography(const std::vector<cv::KeyPoint>& queryKeypoints,    
	const std::vector<cv::KeyPoint>& trainKeypoints,     
	float reprojectionThreshold,    
	std::vector<cv::DMatch>& matches,    
	cv::Mat& homography  )  
{  
	const int minNumberMatchesAllowed = 4;    
	if (matches.size() < minNumberMatchesAllowed)    
		return false;    
	// Prepare data for cv::findHomography    
	std::vector<cv::Point2f> queryPoints(matches.size());    
	std::vector<cv::Point2f> trainPoints(matches.size());    
	for (size_t i = 0; i < matches.size(); i++)    
	{    
		queryPoints[i] = queryKeypoints[matches[i].queryIdx].pt;    
		trainPoints[i] = trainKeypoints[matches[i].trainIdx].pt;    
	}    
	// Find homography matrix and get inliers mask    
	std::vector<unsigned char> inliersMask(matches.size());    
	homography = cv::findHomography(queryPoints,     
		trainPoints,     
		CV_FM_RANSAC,     
		reprojectionThreshold,     
		inliersMask);    
	std::vector<cv::DMatch> inliers;    
	for (size_t i=0; i<inliersMask.size(); i++)    
	{    
		if (inliersMask[i])    
			inliers.push_back(matches[i]);    
	}    
	matches.swap(inliers);  
	Mat homoShow;  
	drawMatches(src,queryKeypoints,frameImg,trainKeypoints,matches,homoShow,Scalar::all(-1),CV_RGB(255,255,255),Mat(),2);       
	imshow("homoShow",homoShow);   
	return matches.size() > minNumberMatchesAllowed;   

}  


bool matchingDescriptor(const vector<KeyPoint>& queryKeyPoints,const vector<KeyPoint>& trainKeyPoints,  
	const Mat& queryDescriptors,const Mat& trainDescriptors,   
	Ptr<DescriptorMatcher>& descriptorMatcher,  
	bool enableRatioTest = true)  
{  
	vector<vector<DMatch>> m_knnMatches;  
	vector<DMatch>m_Matches;  

	if (enableRatioTest)  
	{  
		cout<<"KNN Matching"<<endl;  
		const float minRatio = 1.f / 1.5f;  
		descriptorMatcher->knnMatch(queryDescriptors,trainDescriptors,m_knnMatches,2);  
		for (size_t i=0; i<m_knnMatches.size(); i++)  
		{  
			const cv::DMatch& bestMatch = m_knnMatches[i][0];  
			const cv::DMatch& betterMatch = m_knnMatches[i][1];  
			float distanceRatio = bestMatch.distance / betterMatch.distance;  
			if (distanceRatio < minRatio)  
			{  
				m_Matches.push_back(bestMatch);  
			}  
		}  

	}  
	else  
	{  
		cout<<"Cross-Check"<<endl;  
		Ptr<cv::DescriptorMatcher> BFMatcher(new cv::BFMatcher(cv::NORM_HAMMING, true));  
		BFMatcher->match(queryDescriptors,trainDescriptors, m_Matches );  
	}  
	Mat homo;  
	float homographyReprojectionThreshold = 1.0;  
	bool homographyFound = refineMatchesWithHomography(  
		queryKeyPoints,trainKeyPoints,homographyReprojectionThreshold,m_Matches,homo);  

	if (!homographyFound)  
		return false;  
	else  
	{  
		if (m_Matches.size()>10)
		{
			std::vector<Point2f> obj_corners(4);
			obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( src.cols, 0 );
			obj_corners[2] = cvPoint( src.cols, src.rows ); obj_corners[3] = cvPoint( 0, src.rows );
			std::vector<Point2f> scene_corners(4);
			perspectiveTransform( obj_corners, scene_corners, homo);
			line(frameImg,scene_corners[0],scene_corners[1],CV_RGB(255,0,0),2);  
			line(frameImg,scene_corners[1],scene_corners[2],CV_RGB(255,0,0),2);  
			line(frameImg,scene_corners[2],scene_corners[3],CV_RGB(255,0,0),2);  
			line(frameImg,scene_corners[3],scene_corners[0],CV_RGB(255,0,0),2);  
			return true;  
		}
		return true;
	}  


}  
int main()  
{  
	string filename = "box.png";  
	src = imread(filename,0);  
	width = src.cols;  
	height = src.rows;  
	string detectorType = "SIFT";  
	string descriptorType = "SIFT";  
	string matcherType = "FlannBased";  

	Ptr<FeatureDetector> featureDetector;  
	Ptr<DescriptorExtractor> descriptorExtractor;  
	Ptr<DescriptorMatcher> descriptorMatcher;  
	if( !createDetectorDescriptorMatcher( detectorType, descriptorType, matcherType, featureDetector, descriptorExtractor, descriptorMatcher ) )  
	{  
		cout<<"Creat Detector Descriptor Matcher False!"<<endl;  
		return -1;  
	}  
	//Intial: read the pattern img keyPoint  
	vector<KeyPoint> queryKeypoints;  
	Mat queryDescriptor;  
	featureDetector->detect(src,queryKeypoints);  
	descriptorExtractor->compute(src,queryKeypoints,queryDescriptor);  

	VideoCapture cap(0); // open the default camera  
	cap.set( CV_CAP_PROP_FRAME_WIDTH,320);
	cap.set( CV_CAP_PROP_FRAME_HEIGHT,240 );
	if(!cap.isOpened())  // check if we succeeded  
	{  
		cout<<"Can't Open Camera!"<<endl;  
		return -1;  
	}  
	srcCorner[0] = Point(0,0);  
	srcCorner[1] = Point(width,0);  
	srcCorner[2] = Point(width,height);  
	srcCorner[3] = Point(0,height);  

	vector<KeyPoint> trainKeypoints;  
	Mat trainDescriptor;  

	Mat frame,grayFrame;
	char key=0;  

	//	frame = imread("box_in_scene.png");  
	while (key!=27)  
	{  
		cap>>frame;  
		if (!frame.empty())
		{
			frame.copyTo(frameImg);
			printf("%d,%d\n",frame.depth(),frame.channels());
			grayFrame.zeros(frame.rows,frame.cols,CV_8UC1);
			cvtColor(frame,grayFrame,CV_BGR2GRAY);  
			trainKeypoints.clear();  
			trainDescriptor.setTo(0);  
			featureDetector->detect(grayFrame,trainKeypoints);  

			if(trainKeypoints.size()!=0)  
			{  
				descriptorExtractor->compute(grayFrame,trainKeypoints,trainDescriptor);  

				bool isFound = matchingDescriptor(queryKeypoints,trainKeypoints,queryDescriptor,trainDescriptor,descriptorMatcher);  
				imshow("foundImg",frameImg);  

			}  
		}
		key = waitKey(1); 	
	}  
	cap.release();
	return 0;
}  
 

2、執行結果

3、用到的類和函式

DescriptorMatcher::knnMatch

功能：對查詢集的每個描述子尋找k個最好的匹配子

結構：

 void DescriptorMatcher::knnMatch(const Mat& queryDescriptors, const Mat& trainDescriptors, vector<vector<DMatch>>& matches, int k, const Mat& mask=Mat(), bool compactResult=false ) const

BFMatcher::BFMatcher

功能：蠻力匹配

結構：

 BFMatcher::BFMatcher(int normType=NORM_L2, bool crossCheck=false )

crossCheck ：如果為false，則預設為BFMatcher行為，對每個查詢描述子中尋找k個最接近的鄰居，如果為true，則是knnMatch() 方法，而k=1，返回一對匹配子，這個方法只返回最接近的距離的一對匹配子，當有足夠多的匹配子的時候，這種方法通常能夠產生最好的結果和最小的誤差。

findHomography

功能：在兩個平面之間尋找單對映變換矩陣

結構：

Mat findHomography(InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray() )

CV_LMEDS - 基於Least-Median 的方法

ransacReprojThreshold：處理一組點對為內部點的最大容忍重投影誤差（只在RANSAC方法中使用），其形式為：    如果     

那麼點i則被考慮為內部點，如果srcPoints和dstPoints是以畫素為單位，通常把引數設定為1-10範圍內 

mask ：可選的輸出掩碼( CV_RANSAC or CV_LMEDS ). 輸入的掩碼值被忽略. （儲存inliers的點）                            

這個函式的作用是在原平面和目標平面之間返回一個單對映矩陣

因此反投影誤差是最小的。

如果引數被設定為0，那麼這個函式使用所有的點和一個簡單的最小二乘演算法來計算最初的單應性估計，但是，如果不是所有的點對都完全符合透視變換，那麼這個初始的估計會很差，在這種情況下，你可以使用兩個robust演算法中的一個。 RANSAC 和LMeDS , 使用座標點對生成了很多不同的隨機組合子集（每四對一組），使用這些子集和一個簡單的最小二乘法來估計變換矩陣，然後計算出單應性的質量，最好的子集被用來產生初始單應性的估計和掩碼。
RANSAC方法幾乎可以處理任何異常，但是需要一個閾值， LMeDS 方法不需要任何閾值，但是隻有在inliers大於50%時才能計算正確，最後，如果沒有outliers和噪音非常小，則可以使用預設的方法。

PerspectiveTransform

功能：向量陣列的透視變換

結構：

void perspectiveTransform(InputArray src, OutputArray dst, InputArray m)

dst ：輸出和src同樣的size和type
m ：3x3 或者4x4浮點轉換矩陣
轉換方法為：