OpenCV特徵點檢測------Surf（特徵點篇）

阿新 • • 發佈：2018-12-30

Surf(Speed Up Robust Feature)

Surf演算法的原理

1.構建Hessian矩陣構造高斯金字塔尺度空間

其實surf構造的金字塔影象與sift有很大不同，就是因為這些不同才加快了其檢測的速度。Sift採用的是DOG影象，而surf採用的是Hessian矩陣行列式近似值影象。Hessian矩陣是Surf演算法的核心，為了方便運算，假設函式f(z，y)，Hessian矩陣H是由函式，偏導陣列成。首先來看看影象中某個畫素點的Hessian矩陣，如下：

即每一個畫素點都可以求出一個Hessian矩陣。

H矩陣判別式為：

判別式的值是H矩陣的特徵值，可以利用判定結果的符號將所有點分類，根據判別式取值正負，來判別該點是或不是極值點。

在SURF演算法中，用影象畫素l(x，y)即為函式值f(x，y)，選用二階標準高斯函式作為濾波器，通過特定核間的卷積計算二階偏導數，這樣便能計算出H矩陣的三個矩陣元素L_xx,L_xy,L_yy 從而計算出H矩陣：

但是由於我們的特徵點需要具備尺度無關性，所以在進行Hessian矩陣構造前，需要對其進行高斯濾波。

這樣，經過濾波後在進行Hessian的計算，其公式如下：

L(x,t)是一幅影象在不同解析度下的表示，可以利用高斯核G(t)與影象函式 I(x) 在點x的卷積來實現，其中高斯核G(t)：

g(x)為高斯函式，t為高斯方差。通過這種方法可以為影象中每個畫素計算出其H行列式的決定值，並用這個值來判別特徵點。為方便應用，Herbert Bay提出用近似值現代替L(x,t)。為平衡準確值與近似值間的誤差引入權值叫，權值隨尺度變化，則H矩陣判別式可表示為：

其中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：

    //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演算法有很多功能，

/*
 * A Demo to OpenCV Implementation of SURF
 * Further Information Refer to "SURF: Speed-Up Robust Feature"
 * Author: Liu Liu
 * [email protected]
 */
#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個配準點，得到最後的匹配如下：

參考：

http://blog.csdn.net/yangtrees/article/details/7482960/

OpenCV特徵點檢測------Surf（特徵點篇）

三、尺度不變的SURF特徵

四、SURF特徵的描述

OpenCV特徵點檢測------Surf（特徵點篇）

opencv筆記（1）——特徵點檢測之ORB特徵提取

學習OpenCV——Surf（特徵點篇）&flann快速最近鄰搜尋演算法

學習OpenCV——Surf（特徵點篇）&flann

第一篇：基於深度學習的人臉特徵點檢測 - 背景（轉載）

【OpenCV3經典程式設計100例】（24）2D特徵：Harris角點檢測cornerHarris（）

opencv中haar特徵檢測人臉（適合小白）

影象處理-常用特徵點檢測方法以及特徵描述子

OpenCV角點檢測goodFeaturesToTrack（）原始碼分析

opencv-角點檢測之Harris角點檢測

計算機視覺（七）：特徵檢測/提取（feature detection/extraction）

異常點檢測演算法（一）概率統計

角點檢測運算元（Harris, KLT, SIFT,SUSAN）

異常點檢測演算法（二）矩陣分解

【OpenCV】角點檢測：Harris角點及Shi-Tomasi角點檢測

基於生長的棋盤格角點檢測方法--（2）程式碼詳解（上）

“查看更多”--和--“點擊收起”（模擬開關事件）

每天學習點--------第二天（2017-09-09）

QQ菜單案例，點擊展開再次點擊關閉（類似手風琴效果）

kettle----功能點用法總結（不定期更新）

OpenCV特徵點檢測------Surf（特徵點篇）

三、尺度不變的SURF特徵

四、SURF特徵的描述

相關推薦