Surf(Speed Up Robust Feature)
Surf算法的原理
1.構建Hessian矩陣構造高斯金字塔尺度空間
事實上surf構造的金字塔圖像與sift有非常大不同，就是由於這些不同才加快了其檢測的速度。
Sift採用的是DOG圖像。而surf採用的是Hessian矩陣行列式近似值圖像。Hessian矩陣是Surf算法的核心，為了方便運算，如果函數f(z，y)，Hessian矩陣H是由函數，偏導數組成。首先來看看圖像中某個像素點的Hessian矩陣。例如以下：
即每個像素點都能夠求出一個Hessian矩陣。
H矩陣判別式為：
![gif[1]](/image/aHR0cHM6Ly9pbWFnZXMwLmNuYmxvZ3MuY29tL2Jsb2cvNTIyMDcwLzIwMTUwMy8yNDE3MjQ0Mzc3MDg3MDUuZ2lm.png "gif[1]")
判別式的值是H矩陣的特征值。能夠利用判定結果的符號將全部點分類。依據判別式取值正負，來判別該點是或不是極值點。
在SURF算法中，用圖像像素l(x。y)即為函數值f(x，y)，選用二階標准高斯函數作為濾波器，通過特定核間的卷積計算二階偏導數，這樣便能計算出H矩陣的三個矩陣元素L_xx,L_xy,L_yy 從而計算出H矩陣：
![gif[2]](/image/aHR0cHM6Ly9pbWFnZXMwLmNuYmxvZ3MuY29tL2Jsb2cvNTIyMDcwLzIwMTUwMy8yNDE3MjQ0NDY3NzExNDguZ2lm.png "gif[2]")
可是因為我們的特征點須要具備尺度無關性，所以在進行Hessian矩陣構造前，須要對其進行高斯濾波。
這樣，經過濾波后在進行Hessian的計算，其公式例如以下：
![gif[3]](/image/aHR0cHM6Ly9pbWFnZXMwLmNuYmxvZ3MuY29tL2Jsb2cvNTIyMDcwLzIwMTUwMy8yNDE3MjQ0NTM5NTkyMzQuZ2lm.png "gif[3]"){kind=small}
L(x,t)是一幅圖像在不同解析度下的表示。能夠利用高斯核G(t)與圖像函數 I(x) 在點x的卷積來實現。當中高斯核G(t)：
![gif[4]](/image/aHR0cHM6Ly9pbWFnZXMwLmNuYmxvZ3MuY29tL2Jsb2cvNTIyMDcwLzIwMTUwMy8yNDE3MjQ0NjEzMDkzOTEuZ2lm.png "gif[4]")
g(x)為高斯函數。t為高斯方差。通過這樣的方法能夠為圖像中每一個像素計算出其H行列式的決定值，並用這個值來判別特征點。為方便應用。Herbert Bay提出用近似值現取代L(x,t)。為平衡准確值與近似值間的誤差引入權值叫，權值隨尺度變化。則H矩陣判別式可表示為：
![gif[5]](/image/aHR0cHM6Ly9pbWFnZXMwLmNuYmxvZ3MuY29tL2Jsb2cvNTIyMDcwLzIwMTUwMy8yNDE3MjQ0NjY5MjM5NjQuZ2lm.png "gif[5]"){kind=small}
當中0.9是作者給出的一個經驗值，事實上它是有一套理論計算的。詳細去看surf的英文論文。
因為求Hessian時要先高斯平滑，然后求二階導數。這在離散的像素點是用模板卷積形成的。這2中操作合在一起用一個模板取代就能夠了，比方說y方向上的模板例如以下：
該圖的左邊即用高斯平滑然后在y方向上求二階導數的模板。為了加快運算用了近似處理，其處理結果如右圖所看到的，這樣就簡化了非常多。
而且右圖能夠採用積分圖來運算。大大的加快了速度。關於積分圖的介紹，能夠去查閱相關的資料。
同理。x和y方向的二階混合偏導模板例如以下所看到的：
上面講的這么多僅僅是得到了一張近似hessian行列式圖，這類似sift中的DOG圖，可是在金字塔圖像中分為非常多層。每一層叫做一個octave，每個octave中又有幾張尺度不同的圖片。在sift算法中，同一個octave層中的圖片尺寸(即大小)同樣。可是尺度(即模糊程度)不同，而不同的octave層中的圖片尺寸大小也不同樣。由於它是由上一層圖片降採樣得到的。在進行高斯模糊時，sift的高斯模板大小是始終不變的，僅僅是在不同的octave之間改變圖片的大小。而在surf中。圖片的大小是一直不變的，不同的octave層得到的待檢測圖片是改變高斯模糊尺寸大小得到的，當然了。同一個octave中個的圖片用到的高斯模板尺度也不同。
算法同意尺度空間多層圖像同一時候被處理，不需對圖像進行二次抽樣，從而提高算法性能。
左圖是傳統方式建立一個如圖所看到的的金字塔結構。圖像的寸是變化的。而且運 算會重復使用高斯函數對子層進行平滑處理。右圖說明Surf算法使原始圖像保持不變而僅僅改變濾波器大小。Surf採用這樣的方法節省了降採樣過程，其處理速度自然也就提上去了。
其金字塔圖像例如以下所看到的：
2. 利用非極大值抑制初步確定特征點
此步驟和sift類似，將經過hessian矩陣處理過的每一個像素點與其3維領域的26個點進行大小比較，假設它是這26個點中的最大值或者最小值，則保留下來，當做初步的特征點。檢測過程中使用與該尺度層圖像解析度相相應大小的濾波器進行檢測。以3×3的濾波器為例。該尺度層圖像中9個像素點之中的一個圖2檢測特征點與自身尺度層中其余8個點和在其之上及之下的兩個尺度層9個點進行比較，共26個點，圖2中標記‘x’的像素點的特征值若大於周圍像素則可確定該點為該區域的特征點。
3. 精確定位極值點
這里也和sift算法中的類似，採用3維線性插值法得到亞像素級的特征點，同一時候也去掉那些值小於一定閾值的點，添加極值使檢測到的特征點數量降低，終於僅僅有幾個特征最強點會被檢測出來。
4. 選取特征點的主方向。
這一步與sift也大有不同。Sift選取特征點主方向是採用在特征點領域內統計其梯度直方圖，取直方圖bin值最大的以及超過最大bin值80%的那些方向做為特征點的主方向。
而在surf中。不統計其梯度直方圖，而是統計特征點領域內的harr小波特征。即在特征點的領域(比方說，半徑為6s的圓內，s為該點所在的尺度)內。統計60度扇形內全部點的水平haar小波特征和垂直haar小波特征總和，haar小波的尺寸變長為4s。這樣一個扇形得到了一個值。然后60度扇形以一定間隔進行旋轉，最后將最大值那個扇形的方向作為該特征點的主方向。
該過程的示意圖例如以下：
5. 構造surf特征點描寫敘述算子
在sift中，是在特征點周圍取16*16的鄰域。並把該領域化為4*4個的小區域，每一個小區域統計8個方向梯度。最后得到4*4*8=128維的向量。該向量作為該點的sift描寫敘述子。
在surf中，也是在特征點周圍取一個正方形框，框的邊長為20s(s是所檢測到該特征點所在的尺度)。該框帶方向。方向當然就是第4步檢測出來的主方向了。然后把該框分為16個子區域。每一個子區域統計25個像素的水平方向和垂直方向的haar小波特征，這里的水平和垂直方向都是相對主方向而言的。該haar小波特征為水平方向值之和，水平方向絕對值之和，垂直方向之和，垂直方向絕對值之和。該過程的示意圖例如以下所看到的：
這樣每一個小區域就有4個值，所以每一個特征點就是16*4=64維的向量。相比sift而言，少了一半。這在特征匹配過程中會大大加快匹配速度。
6.結束語
Surf採用Henssian矩陣獲取圖像局部最值還是十分穩定的，可是在求主方向階段太過於依賴局部區域像素的梯度方向。有可能使得找到的主方向不准確，后面的特征向量提取以及匹配都嚴重依賴於主方向。即使不大偏差角度也能夠造成后面特征匹配的放大誤差，從而匹配不成功；另外圖像金字塔的層取 得不足夠緊密也會使得尺度有誤差，后面的特征向量提取相同依賴對應的尺度。發明者在這個問題上的折中解決方法是取適量的層然后進行插值。
Sift是一種僅僅 利用到灰度性質的算法，忽略了色彩信息。后面又出現了幾種據說比Surf更穩定的描寫敘述器當中一些利用到了色彩信息，讓我們拭目以待吧。
代碼：
來源：OpenCV/sample/c中的find_obj.cpp代碼
需細致注意：
1.定位部分：通過透視變換，畫出了目標在圖像中的位置。可是這么做會浪費非常多時間。能夠改進：
2.flann尋找近期的臨近Keypoints：
首先，利用圖像，構建多維查找樹，然后，利用Knn算法找到近期的Keypoints (KNN算法：http://blog.csdn.net/sangni007/article/details/7482890）
//Constructs a nearest neighbor search index for a given dataset
//利用m_image構造 a set of randomized kd-trees 一系列隨機多維檢索樹;
cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4)); // using 4 randomized kdtrees
//利用Knn近鄰算法檢索m_object。結果存入 m_indices, m_dists；
flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64) ); // maximum number of leafs checked
flann算法有非常多功能，
文檔：http://opencv.itseez.com/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html?
highlight=flann#fast-approximate-nearest-neighbor-search
/*
* A Demo to OpenCV Implementation of SURF
* Further Information Refer to "SURF: Speed-Up Robust Feature"
* Author: Liu Liu
* liuliu.1987+opencv@gmail.com
*/
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/calib3d/calib3d.hpp"
#include "opencv2/imgproc/imgproc_c.h"#include <iostream>
#include <vector>
#include <stdio.h>using namespace std;
void help()
{
printf(
"This program demonstrated the use of the SURF Detector and Descriptor using\n"
"either FLANN (fast approx nearst neighbor classification) or brute force matching\n"
"on planar objects.\n"
"Usage:\n"
"./find_obj <object_filename> <scene_filename>, default is box.png and box_in_scene.png\n\n");
return;
}// define whether to use approximate nearest-neighbor search
#define USE_FLANN
IplImage* image = 0;double compareSURFDescriptors( const float* d1, const float* d2, double best, int length )
{
double total_cost = 0;
assert( length % 4 == 0 );
for( int i = 0; i < length; i += 4 )
{
double t0 = d1[i ] - d2[i ];
double t1 = d1[i+1] - d2[i+1];
double t2 = d1[i+2] - d2[i+2];
double t3 = d1[i+3] - d2[i+3];
total_cost += t0*t0 + t1*t1 + t2*t2 + t3*t3;
if( total_cost > best )
break;
}
return total_cost;
}
int naiveNearestNeighbor( const float* vec, int laplacian,
const CvSeq* model_keypoints,
const CvSeq* model_descriptors )
{
int length = (int)(model_descriptors->elem_size/sizeof(float));
int i, neighbor = -1;
double d, dist1 = 1e6, dist2 = 1e6;
CvSeqReader reader, kreader;
cvStartReadSeq( model_keypoints, &kreader, 0 );
cvStartReadSeq( model_descriptors, &reader, 0 ); for( i = 0; i < model_descriptors->total; i++ )
{
const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;
const float* mvec = (const float*)reader.ptr;
CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
if( laplacian != kp->laplacian )
continue;
d = compareSURFDescriptors( vec, mvec, dist2, length );
if( d < dist1 )
{
dist2 = dist1;
dist1 = d;
neighbor = i;
}
else if ( d < dist2 )
dist2 = d;
}
if ( dist1 < 0.6*dist2 )
return neighbor;
return -1;
}//用於找到兩幅圖像之間匹配的點對，並把匹配的點對存儲在 ptpairs 向量中，當中物體(object)圖像的特征點
//及其對應的描寫敘述器（局部特征）分別存儲在 objectKeypoints 和 objectDescriptors，場景(image)圖像的特
//征點及其對應的描寫敘述器（局部特征）分別存儲在 imageKeypoints和 imageDescriptors
void findPairs( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int i;
CvSeqReader reader, kreader;
cvStartReadSeq( objectKeypoints, &kreader );
cvStartReadSeq( objectDescriptors, &reader );
ptpairs.clear(); for( i = 0; i < objectDescriptors->total; i++ )
{
const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;
const float* descriptor = (const float*)reader.ptr;
CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
int nearest_neighbor = naiveNearestNeighbor( descriptor, kp->laplacian, imageKeypoints, imageDescriptors );
if( nearest_neighbor >= 0 )
{
ptpairs.push_back(i);
ptpairs.push_back(nearest_neighbor);
}
}
}//Fast Library for Approximate Nearest Neighbors（FLANN）
void flannFindPairs( const CvSeq*, const CvSeq* objectDescriptors,
const CvSeq*, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int length = (int)(objectDescriptors->elem_size/sizeof(float)); cv::Mat m_object(objectDescriptors->total, length, CV_32F);
cv::Mat m_image(imageDescriptors->total, length, CV_32F);
// copy descriptors
CvSeqReader obj_reader;
float* obj_ptr = m_object.ptr<float>(0);
cvStartReadSeq( objectDescriptors, &obj_reader );
//objectDescriptors to m_object
for(int i = 0; i < objectDescriptors->total; i++ )
{
const float* descriptor = (const float*)obj_reader.ptr;
CV_NEXT_SEQ_ELEM( obj_reader.seq->elem_size, obj_reader );
memcpy(obj_ptr, descriptor, length*sizeof(float));
obj_ptr += length;
}
//imageDescriptors to m_image
CvSeqReader img_reader;
float* img_ptr = m_image.ptr<float>(0);
cvStartReadSeq( imageDescriptors, &img_reader );
for(int i = 0; i < imageDescriptors->total; i++ )
{
const float* descriptor = (const float*)img_reader.ptr;
CV_NEXT_SEQ_ELEM( img_reader.seq->elem_size, img_reader );
memcpy(img_ptr, descriptor, length*sizeof(float));
img_ptr += length;
} // find nearest neighbors using FLANN
cv::Mat m_indices(objectDescriptors->total, 2, CV_32S);
cv::Mat m_dists(objectDescriptors->total, 2, CV_32F);
//Constructs a nearest neighbor search index for a given dataset
//利用m_image構造 a set of randomized kd-trees 一系列隨機多維檢索樹;
cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4)); // using 4 randomized kdtrees
//利用Knn近鄰算法檢索m_object；結果存入 m_indices, m_dists；
flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64) ); // maximum number of leafs checked int* indices_ptr = m_indices.ptr<int>(0);
float* dists_ptr = m_dists.ptr<float>(0);
for (int i=0;i<m_indices.rows;++i)
{
if (dists_ptr[2*i]<0.6*dists_ptr[2*i+1])
{
ptpairs.push_back(i);
ptpairs.push_back(indices_ptr[2*i]);
}
}
}//用於尋找物體(object)在場景(image)中的位置,位置信息保存在參數dst_corners中。參數src_corners由物
//體(object的width幾height等決定，其它部分參數如上findPairs
/* a rough implementation for object location */
int locatePlanarObject( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors,
const CvPoint src_corners[4], CvPoint dst_corners[4] )
{
double h[9];
CvMat _h = cvMat(3, 3, CV_64F, h);
vector<int> ptpairs;
vector<CvPoint2D32f> pt1, pt2;
CvMat _pt1, _pt2;
int i, n;#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif n = (int)(ptpairs.size()/2);
if( n < 4 )
return 0; pt1.resize(n);
pt2.resize(n);
for( i = 0; i < n; i++ )
{
pt1[i] = ((CvSURFPoint*)cvGetSeqElem(objectKeypoints,ptpairs[i*2]))->pt;
pt2[i] = ((CvSURFPoint*)cvGetSeqElem(imageKeypoints,ptpairs[i*2+1]))->pt;
} _pt1 = cvMat(1, n, CV_32FC2, &pt1[0] );
_pt2 = cvMat(1, n, CV_32FC2, &pt2[0] );
if( !cvFindHomography( &_pt1, &_pt2, &_h, CV_RANSAC, 5 ))//計算兩個平面之間的透視變換
return 0; for( i = 0; i < 4; i++ )
{
double x = src_corners[i].x, y = src_corners[i].y;
double Z = 1./(h[6]*x + h[7]*y + h[8]);
double X = (h[0]*x + h[1]*y + h[2])*Z;
double Y = (h[3]*x + h[4]*y + h[5])*Z;
dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));
} return 1;
}
int main(int argc, char** argv)
{
//物體(object)和場景(scene)的圖像向來源
const char* object_filename = argc == 3 ? argv[1] : "D:/src.jpg";
const char* scene_filename = argc == 3 ?
argv[2] : "D:/Demo.jpg"; help(); IplImage* object = cvLoadImage( object_filename, CV_LOAD_IMAGE_GRAYSCALE );
IplImage* image = cvLoadImage( scene_filename, CV_LOAD_IMAGE_GRAYSCALE );
if( !object || !image )
{
fprintf( stderr, "Can not load %s and/or %s\n",
object_filename, scene_filename );
exit(-1);
}
//內存存儲器
CvMemStorage* storage = cvCreateMemStorage(0); cvNamedWindow("Object", 1);
cvNamedWindow("Object Correspond", 1); static CvScalar colors[] =
{
{{0,0,255}},
{{0,128,255}},
{{0,255,255}},
{{0,255,0}},
{{255,128,0}},
{{255,255,0}},
{{255,0,0}},
{{255,0,255}},
{{255,255,255}}
};
IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);
cvCvtColor( object, object_color, CV_GRAY2BGR ); CvSeq* objectKeypoints = 0, *objectDescriptors = 0;
CvSeq* imageKeypoints = 0, *imageDescriptors = 0;
int i;
/*
CvSURFParams params = cvSURFParams(500, 1);//SURF參數設置：閾值500。生成128維描寫敘述符
cvSURFParams 函數原型例如以下：
CvSURFParams cvSURFParams(double threshold, int extended)
{
CvSURFParams params;
params.hessianThreshold = threshold; // 特征點選取的 hessian 閾值
params.extended = extended; // 是否擴展，1 - 生成128維描寫敘述符。0 - 64維描寫敘述符
params.nOctaves = 4;
params.nOctaveLayers = 2;
return params;
}
*/
CvSURFParams params = cvSURFParams(500, 1); double tt = (double)cvGetTickCount();//計時
/*
提取圖像中的特征點，函數原型：
CVAPI(void) cvExtractSURF( const CvArr* img, const CvArr* mask,
CvSeq** keypoints, CvSeq** descriptors,
CvMemStorage* storage, CvSURFParams params, int useProvidedKeyPts CV_DEFAULT(0) );
第3、4個參數返回結果：特征點和特征點描寫敘述符，數據類型是指針的指針，
*/
cvExtractSURF( object, 0, &objectKeypoints, &objectDescriptors, storage, params );
printf("Object Descriptors: %d\n", objectDescriptors->total); cvExtractSURF( image, 0, &imageKeypoints, &imageDescriptors, storage, params );
printf("Image Descriptors: %d\n", imageDescriptors->total);
tt = (double)cvGetTickCount() - tt; printf( "Extraction time = %gms\n", tt/(cvGetTickFrequency()*1000.));
CvPoint src_corners[4] = {{0,0}, {object->width,0}, {object->width, object->height}, {0, object->height}};
//定義感興趣的區域
CvPoint dst_corners[4];
IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
//設置感興趣區域
//形成一大一小兩幅圖顯示在同一窗體
cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
cvCopy( object, correspond );
cvSetImageROI( correspond, cvRect( 0, object->height, correspond->width, correspond->height ) );
cvCopy( image, correspond );
cvResetImageROI( correspond );#ifdef USE_FLANN
printf("Using approximate nearest neighbor search\n");
#endif
//尋找物體(object)在場景(image)中的位置。並將信息保存（矩形框）
if( locatePlanarObject( objectKeypoints, objectDescriptors, imageKeypoints,
imageDescriptors, src_corners, dst_corners ))
{
for( i = 0; i < 4; i++ )
{
CvPoint r1 = dst_corners[i%4];
CvPoint r2 = dst_corners[(i+1)%4];
cvLine( correspond, cvPoint(r1.x, r1.y+object->height ),
cvPoint(r2.x, r2.y+object->height ), colors[8] );
}
}
//定義並保存物體(object)在場景(image)圖形之間的匹配點對。並將其存儲在向量 ptpairs 中，之后能夠對
//ptpairs 進行操作
vector<int> ptpairs;
#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif
//顯示匹配結果（直線連接）
for( i = 0; i < (int)ptpairs.size(); i += 2 )
{
CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, ptpairs[i] );
CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, ptpairs[i+1] );
cvLine( correspond, cvPointFrom32f(r1->pt),
cvPoint(cvRound(r2->pt.x), cvRound(r2->pt.y+object->height)), colors[8] );
} cvShowImage( "Object Correspond", correspond );
//顯示物體(object)的全部特征點
for( i = 0; i < objectKeypoints->total; i++ )
{
CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, i );
CvPoint center;
int radius;
center.x = cvRound(r->pt.x);
center.y = cvRound(r->pt.y);
radius = cvRound(r->size*1.2/9.*2);
cvCircle( object_color, center, radius, colors[0], 1, 8, 0 );
}
cvShowImage( "Object", object_color ); cvWaitKey(0); //釋放窗體所占用的內存
cvDestroyWindow("Object");
cvDestroyWindow("Object Correspond"); return 0;
}
opencv小試SURF算法：
#include "opencv2/opencv.hpp" int main(){ cv::Mat image, image1 = cv::imread ("test.jpg");
//灰度變換
cv::cvtColor (image1,image,CV_BGR2GRAY); std::vector<cv::KeyPoint> keypoints; cv::SurfFeatureDetector surf(2500); surf.detect (image,keypoints); cv::drawKeypoints (image,keypoints,image,cv::Scalar::all (255),cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
cv::namedWindow ("surf");
cv::imshow ("surf",image);
cv::waitKey (0);
return 0;
}
測試結果：
標記圈的半徑長短和特征點所在尺度有關，那條半徑是特征點的方向。
SIFT算法的教程、源代碼及應用軟件
1、ubc:DAVID LOWE---SIFT算法的創始人，兩篇巨經典
http://www.cs.ubc.ca/~lowe/
2、cmu:YanKe---PCASIFT,總結的SIFT方面的文章
http://www.andrew.cmu.edu/user/yke/
3、ubc:M.BROWN---SIFT算法用於圖像拼接的經典應用autopano-sift。包含一個SIFTLIB庫
http://www.cs.ubc.ca/~mbrown/autostitch/autostitch.html
http://www.cs.ubc.ca/~mbrown/panorama/panorama.html
4、toronto:Jepson---Matlab SIFT tutorial, 超級超級超級經典~
http://www.cs.toronto.edu/~jepson/csc2503/
5、ucla:Vedaldi---加州大學一個博士生編的Matlab SIFT tutorial
http://www.cs.ucla.edu/~vedaldi/
6.http://en.wikipedia.org/wiki/Scale-inva ... _transform
7. 大牛整理的計算機視覺分類
http://www.cs.ubc.ca/~lowe/vision.html
8. http://note.sonots.com/SciSoftware/SIFT.html
9.提到了計算變換矩陣的RANSAC法
http://web.engr.oregonstate.edu/~hess/index.html
10. 仿射不變特征點檢測。提到了性能評價的方法
http://www.robots.ox.ac.uk/~vgg/research/affine/
11. 一個日本人，挺牛的
http://note.sonots.com/
12. PCA-SIFT
http://www.cs.cmu.edu/~yke/pcasift/
13 opencv sift
http://web.engr.oregonstate.edu/~hess/index.html
14 matlab sift
http://www.vlfeat.org/~vedaldi/code/sift.html
http://www.vlfeat.org/overview/sift.html
15 Improve Scale Invariant Feature Transform (SIFT) 斯坦福
http://robots.stanford.edu/cs223b04/project9.html
16 Known implementations of SIFT mit
http://people.csail.mit.edu/albert/ladypack/wiki/index.php/Known_implementations_of_SIFT
三、尺度不變的SURF特征
surf特征是類似於SIFT特征的一種尺度不變的特征點，它的長處在於比SIFT效率要高，在實際運算中能夠達到實時性的要求。關於SURF的原理這里就只是多的介紹，網絡上這類的文章非常多。
類似於FAST特征點的求法，SURF也能夠使用通用接口求得，而SURF特征的類為SurfFeatureDetector，類似的SIFT特征點的檢測類為SiftFeatureDetector。
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/nonfree/features2d.hpp>
usingnamespacecv;
intmain()
{
Mat image=imread("../buliding.png");
vector<KeyPoint> keypoints;
SurfFeatureDetector surf(2500.);
surf.detect(image,keypoints);
drawKeypoints(image,keypoints,image,Scalar(255,0,0),
DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
namedWindow("result");
imshow("result",image);
waitKey();
return0;
}
這里有一個值得說明的問題是：OpenCV2.4版本號后好像把SurfFeatureDetector這個類的定義移到了頭文件nonfree/features2d.hpp
中，所以頭文件里要增加該文件，而且要把opencv_nonfree24xd.lib增加屬性表的鏈接器熟悉的輸入中。當中x換成你當前opencv的版本。
終於的顯示效果例如以下：
四、SURF特征的描寫敘述
在圖像配准中。特征點的描寫敘述往往不是位置這么簡單，而是使用了一個N維向量來描寫敘述一個特征點。這些描寫敘述子之間能夠通過定義距離公式來比較相近程度。
SurfDescriptorExtractor 是一個提取SURF特征點以及其描寫敘述的類。
以下是一個寬景圖像的拼接配准的樣例：
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/nonfree/features2d.hpp>
#include<opencv2/legacy/legacy.hpp>
using namespacecv;
intmain()
{
Mat image1=imread("../b1.png");
Mat image2=imread("../b2.png");
// 檢測surf特征點
vector<KeyPoint> keypoints1,keypoints2;
SurfFeatureDetector detector(400);
detector.detect(image1, keypoints1);
detector.detect(image2, keypoints2);
// 描寫敘述surf特征點
SurfDescriptorExtractor surfDesc;
Mat descriptros1,descriptros2;
surfDesc.compute(image1,keypoints1,descriptros1);
surfDesc.compute(image2,keypoints2,descriptros2);
// 計算匹配點數
BruteForceMatcher<L2<float>>matcher;
vector<DMatch> matches;
matcher.match(descriptros1,descriptros2,matches);
std::nth_element(matches.begin(),matches.begin()+24,matches.end());
matches.erase(matches.begin()+25,matches.end());
// 畫出匹配圖
Mat imageMatches;
drawMatches(image1,keypoints1,image2,keypoints2,matches,
imageMatches,Scalar(255,0,0));
namedWindow("image2");
imshow("image2",image2);
waitKey();
return0;
}
程序中我們選擇了25個配准點，得到最后的匹配例如以下：
