2. 程式人生 > >【特徵匹配】BRIEF特徵描述子原理及原始碼解析

【特徵匹配】BRIEF特徵描述子原理及原始碼解析

阿新 • • 發佈：2019-01-23

轉載請註明出處： http://blog.csdn.net/luoshixian099/article/details/48338273

  傳統的特徵點描述子如SIFT,SURF描述子，每個特徵點採用128維(SIFT)或者64維(SURF)向量去描述，每個維度上佔用4位元組，SIFT需要128×4=512位元組記憶體，SURF則需要256位元組。如果對於記憶體資源有限的情況下，這種描述子方法顯然不適應。同時，在形成描述子的過程中，也比較耗時。後來有人提出採用PCA降維的方法，但沒有解決計算描述子耗時的問題。

   鑑於上述的缺點Michael Calonder等人在論文提出BRIEF描述特徵點的方法(BRIEF:Binary Robust Independent Elementary Features)。BRIEF描述子採用二進位制碼串(每一位非1即0)作為描述子向量，論文中考慮長度有128,256,512幾種，同時形成描述子演算法的過程簡單，由於採用二進位制碼串，匹配上採用漢明距離，（一個串變成另一個串所需要的最小替換次數）。但由於BRIEF描述子不具有方向性，大角度旋轉會對匹配上有很大的影響。

   BRIRF只提出了描述特徵點的方法，所以特徵點的檢測部分必須結合其他的方法，如SIFT,SURF等，但論文中建議與Fast結合，因為會更能體現出Brirf速度快等優點。

--------------------------------------------------------------------------------------------------

BRIEF描述子原理簡要為三個步驟，長度為N的二進位制碼串作為描述子(佔用記憶體N/8)：

   1.以特徵點P為中心，取一個S×S大小的Patch鄰域；

   2.在這個鄰域內隨機取N對點，然後對這2×N點分別做高斯平滑。定義τ測試，比較N對畫素點的灰度值的大小；

                                     

   3.最後把步驟2得到的N個二進位制碼串組成一個N維向量即可；

                                     

-----------------------------------------------------------------------------------------------------

原理解析：

__1.關於做τ測試前，需要對隨機點做高斯平滑，由於採用單個的畫素灰度值做比較，會對噪聲很敏感；採用高斯平滑影象，會降低噪聲的影響，使得         描述子更加穩定。論文中建議採用9×9的kernal。

__2.論文中對隨機取N對點採用了5中不同的方法做測試，論文中建議採用G II的方法：

                       

             G I :（X,Y）~（-S/2,S/2）分佈，X,Y即均勻分佈；

             G II: ，X,Y均服從高斯分佈；

             G III: ，先隨機取X點，再以X點為中心，取Y點；

             G IV: 在空間量化極座標系下，隨機取2N個點；

             G V: X固定在中心，在Patch內，Y在極座標系中儘可能取所有可能的值；

__3.最後漢明距離的計算，直接比較兩二進位制碼串的距離，距離定義為：其中一個串變成另一個串所需要的最少操作。因而比歐氏距離運算速度快.

      如果取N=128,即每個特徵點需要128/8=16個位元組記憶體大小作為其描述子。

                                        

OPENCV原始碼解析：

#include <stdio.h>
#include <iostream>
#include "cv.h"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/core/core.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/nonfree/nonfree.hpp"
using namespace std;
using namespace cv;
int main( int argc, char** argv )
{

	Mat img_1 = imread( "F:\\Picture\\book.jpg", CV_LOAD_IMAGE_GRAYSCALE );
	Mat img_2 = imread( "F:\\Picture\\book_2.jpg", CV_LOAD_IMAGE_GRAYSCALE );

	if( !img_1.data || !img_2.data )
	{ 
		return -1; }
	//-- Step 1: Detect the keypoints using SURF Detector
	int minHessian = 400;
	SurfFeatureDetector detector( minHessian);    //採用Surf特徵點檢測
	std::vector<KeyPoint> keypoints_1, keypoints_2;
	detector.detect( img_1, keypoints_1 );
	detector.detect( img_2, keypoints_2 );
	//-- Step 2: Calculate descriptors (feature vectors)
	BriefDescriptorExtractor  extractor(64);  //引數表示位元組數,採用長度為64×8=512的向量表示，見下方分析
	Mat descriptors_1, descriptors_2;
	extractor.compute( img_1, keypoints_1, descriptors_1 );
	extractor.compute( img_2, keypoints_2, descriptors_2 );
	//-- Step 3: Matching descriptor vectors with a brute force matcher
	BFMatcher  matcher(NORM_HAMMING);   //漢明距離匹配特徵點
	std::vector< DMatch > matches;
	matcher.match( descriptors_1, descriptors_2, matches );
	//-- Draw matches
	Mat img_matches;
	drawMatches( img_1, keypoints_1, img_2, keypoints_2, matches, img_matches );
	////-- Show detected matches
	imshow("Matches", img_matches );
	waitKey(0);
	return 0;
}

Brief描述子的類定義：

注意bytes引數表示的是描述子佔用的位元組數不是描述子長度，如預設採用32位元組對應描述子長度為32×8=256；

/*
 * BRIEF Descriptor
 */
class CV_EXPORTS BriefDescriptorExtractor : public DescriptorExtractor
{
public:
    static const int PATCH_SIZE = 48;  //鄰域範圍
    static const int KERNEL_SIZE = 9;//平滑積分核大小

    // bytes is a length of descriptor in bytes. It can be equal 16, 32 or 64 bytes.
    BriefDescriptorExtractor( int bytes = 32 );  //佔用位元組數32,對應描述子長度為32×8=256;

    virtual void read( const FileNode& );
    virtual void write( FileStorage& ) const;

    virtual int descriptorSize() const;
    virtual int descriptorType() const;

    /// @todo read and write for brief

    AlgorithmInfo* info() const;

protected:
    virtual void computeImpl(const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptors) const; //計算特徵描述子函式

    typedef void(*PixelTestFn)(const Mat&, const vector<KeyPoint>&, Mat&); //不同長度的描述子呼叫不同的函式

    int bytes_;//佔用位元組數
    PixelTestFn test_fn_;
};

計算特徵描述子函式：

void BriefDescriptorExtractor::computeImpl(const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptors) const
{
    // Construct integral image for fast smoothing (box filter)
    Mat sum;

    Mat grayImage = image;
    if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );

    ///TODO allow the user to pass in a precomputed integral image
    //if(image.type() == CV_32S)
    //  sum = image;
    //else

    integral( grayImage, sum, CV_32S);  //計算積分影象

    //Remove keypoints very close to the border
    KeyPointsFilter::runByImageBorder(keypoints, image.size(), PATCH_SIZE/2 + KERNEL_SIZE/2);//剔除落在邊界外的角點

    descriptors = Mat::zeros((int)keypoints.size(), bytes_, CV_8U);
    test_fn_(sum, keypoints, descriptors);  //計算特徵點描述子
}

關於對隨機點平滑，不採用論文中高斯平滑，而是採用隨機點鄰域內積分和代替，同樣可以降低噪聲的影響：

inline int smoothedSum(const Mat& sum, const KeyPoint& pt, int y, int x)
{
    static const int HALF_KERNEL = BriefDescriptorExtractor::KERNEL_SIZE / 2;

    int img_y = (int)(pt.pt.y + 0.5) + y;
    int img_x = (int)(pt.pt.x + 0.5) + x;
    return   sum.at<int>(img_y + HALF_KERNEL + 1, img_x + HALF_KERNEL + 1)
           - sum.at<int>(img_y + HALF_KERNEL + 1, img_x - HALF_KERNEL)
           - sum.at<int>(img_y - HALF_KERNEL, img_x + HALF_KERNEL + 1)
           + sum.at<int>(img_y - HALF_KERNEL, img_x - HALF_KERNEL);
}
描述子向量的形成（以長度為16位元組×8=128為例）：

陣列des每一個元素佔用一個位元組，原始碼位置：...\modules\features2d\src\generated_16.i

// Code generated with '$ scripts/generate_code.py src/test_pairs.txt 16'
#define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)
    desc[0] = (uchar)(((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));
    desc[1] = (uchar)(((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0));
    desc[2] = (uchar)(((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0));
    desc[3] = (uchar)(((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0));
    desc[4] = (uchar)(((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0));
    desc[5] = (uchar)(((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0));
    desc[6] = (uchar)(((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0));
    desc[7] = (uchar)(((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0));
    desc[8] = (uchar)(((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0));
    desc[9] = (uchar)(((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0));
    desc[10] = (uchar)(((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0));
    desc[11] = (uchar)(((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0));
    desc[12] = (uchar)(((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0));
    desc[13] = (uchar)(((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0));
    desc[14] = (uchar)(((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0));
    desc[15] = (uchar)(((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0));
#undef SMOOTHED

參考文章：

         Michael Calonder et.BRIEF:Binary Robust Independent Elementary Features

         http://www.cnblogs.com/ronny/p/4081362.html?utm_source=tuicool

相關推薦

【特徵匹配】BRIEF特徵描述子原理及原始碼解析

轉載請註明出處： http://blog.csdn.net/luoshixian099/article/details/48338273   傳統的特徵點描述子如SIFT,SURF描述子，每個特徵點採用128維(SIFT)或者64維(SURF)向量去描述，每個維度上

【特徵匹配】Harris及Shi-Tomasi原理及原始碼解析

演算法原理：呼叫cornerMinEigenVal()函式求出每個畫素點自適應矩陣M的較小特徵值,儲存在矩陣eig中，然後找到矩陣eig中最大的畫素值記為maxVal,然後閾值處理，小於qualityLevel*maxVal的特徵值排除掉，最後函式確保所有發現的角點之間具有足夠的距離。void cv::goo

【模式匹配】之 —— KMP演算法詳解及證明

本文所述KMP演算法原始碼可在這裡下載： Name Date Reason for change Revision 超然 2013.03.19 First version 1.0 超然 2013.04.15 Added

【資料結構】堆疊、佇列的原理及java實現

一、堆是一個執行時資料區，通過new等指令建立，不需要程式程式碼顯式釋放 <1>優點： 可動態分配記憶體大小，生存週期不必事先告訴編譯器，Java垃圾回收自動回收不需要的資料； <2>缺點： 執行時需動態分配記憶體，資料存取速度較

【機器學習】支援向量機SVM原理及推導

參考：http://blog.csdn.net/ajianyingxiaoqinghan/article/details/72897399 部分圖片來自於上面部落格。 0 由來 在二分類問題中，我們可以計算資料代入模型後得到的結果，如果這個結果有明顯的區別，

【機器學習】LDA線性判別分析原理及例項

1、LDA的基本原理 LDA線性判別分析也是一種經典的降維方法，LDA是一種監督學習的降維技術，也就是說它的資料集的每個樣本是有類別輸出的。這點和PCA不同。PCA是不考慮樣本類別輸出的無監督降維技術。LDA的思想可以用一句話概括，就是“*投影后類內方

【特徵匹配】RANSAC演算法原理與原始碼解析

轉載請註明出處：http://blog.csdn.net/luoshixian099/article/details/50217655 勿在浮沙築高臺   隨機抽樣一致性（RANSAC）演算法，可以在一組包含“外點”的資料集中，採用不斷迭代的方法，尋找最優引數模型，不符合最

【特徵匹配】SIFT原理與C原始碼剖析

     SIFT的原理已經有很多大牛的部落格上做了解析，本文重點將以Rob Hess等人用C實現的程式碼做解析，結合程式碼SIFT原理會更容易理解。一些難理解點的用了☆標註。       歡迎大家批評指正！ 轉載請註明出處：http://blog.csdn.net/l

【特徵匹配】ORB原理與原始碼解析

相關 : CSDN-勿在浮沙築高臺   為了滿足實時性的要求，前面文章中介紹過快速提取特徵點演算法Fast,以及特徵描述子Brief。本篇文章介紹的ORB演算法結合了Fast和Brief的速度優勢，並做了改進，且ORB是免費。 Ethan Rublee等人2011年

【學習筆記】合成特徵與離群值

Dataset庫我還有問題沒有解決清楚，因此先用feed_dict方法。 首先問題1是需要我們合成特徵: 建立一個名為 rooms_per_person 的特徵。 df = pd.read_csv('california_housing_train.csv') df['

【目標檢測】LBP特徵學習記錄

LBP（Local Binary Patterns，區域性二值模式）是用來描述影象區域性紋理特徵的描述子。它最早在1994年被提出，2002年由作者整理和改進後重新發表。 T為影象的區域性紋理，將其表示為： 其中，gc是中心點的灰度值，gp(p=0,...,P-1)是

【sklearn例項】4--特徵工程之離散值編碼

離散特徵 離散特徵變數型別可以分為有序類和無序類。 無序類，價值相等且可區分，沒有等級、順序、排序、好壞等邏輯關係，各變數相互獨立：性別（男/女）、顏色（赤橙黃綠青藍紫）、登機口（A/B/C）； 有序類：各變數有級別大小等邏輯關係：尺碼（L/XL/XXL）、學歷（高/中/低） 為何要

【特徵檢測】ORB特徵提取演算法

簡介         ORB的全稱是ORiented Brief，是文章ORB: an efficient alternative to SIFT or SURF中提出的一種新的角點檢測與特徵描述演算

【特徵檢測】BRISK特徵提取演算法

// construct the image pyramids（構造影象金字塔） void BriskScaleSpace::constructPyramid(const cv::Mat& image) { // set correct size: pyramid_.clear();

【自然語言處理】【scikit-learn】文字特徵提取

詞袋錶示 文字分析是機器學習演算法的主要應用領域。 然而，原始資料，一串符號序列不能直接送到演算法本身，因為大多數演算法期望具有固定大小的數字特徵向量而不是具有可變長度的原始文字文件。 為了解決這個問題，scikit-learn提供了從文字內容中提取數字特徵的最常用方法的

【特徵檢測】HOG特徵演算法

簡介        HOG（Histogram of Oriented Gridients的簡寫）特徵檢測演算法，最早是由法國研究員Dalal等在CVPR-2005上提出來的，一種解決人體目標檢測的影象

【目標檢測】HOG特徵學習記錄

HOG特徵即方向梯度直方圖（Histgram of Oriented，HOG），最初是用來檢測行人的特徵描述子，現在也廣泛用於計算機視覺和影象處理中進行物體檢測。 通過計算和統計影象區域性區域的梯度方向直方圖來構成特徵。 影象的梯度主要存在於物體的邊緣，而區域性目標和

【特徵工程】3 特徵工程技術與方法

引言 在之前學習機器學習技術中，很少關注特徵工程(Feature Engineering)，然而，單純學習機器學習的演算法流程，可能仍然不會使用這些演算法，尤其是應用到實際問題的時候，常常不知道怎麼提取特徵來建模。  特徵是機器學習系統的原材料，對最終模型的影響是毋庸置疑的。 特徵工程的重要意義 資

【特徵檢測】FAST特徵點檢測演算法

簡介        在區域性特徵點檢測快速發展的時候，人們對於特徵的認識也越來越深入，近幾年來許多學者提出了許許多多的特徵檢測演算法及其改進演算法，在眾多的特徵提取演算法中，不乏湧現出佼佼者。     

【目標檢測】SIFT特徵學習記錄

一、生成尺度空間 尺度空間定義為 其中I(x,y)是輸入影象，*是卷積運算，可變尺度的高斯函式 二維高斯函式畫出來是下面這樣的， 卷積過程是在影象上進行滑窗，核函式和影象點乘相加。 1.1 建立高斯金字塔LOG 首先對影象做降取樣，根據不同的降