向梯度直方图(Histogram of Oriented Gradient, HOG)特征

The HOG features are widely use for object detection. HOG decomposes an image into small squared cells, computes an histogram of oriented gradients in each cell, normalizes the
result using a block-wise pattern, and return a descriptor for each cell.

Stacking the cells into a squared image region can be used as an image window descriptor for object detection, for example by means of an SVM.

This tutorial shows how to use the VLFeat function 

vl_hog

 to
compute HOG features of various kind and manipulate them.

Basic HOG computation

We start by considering an example input image:



An example image.

HOG is computed by calling the 

vl_hog

 function:

cellSize = 8 ;
hog = vl_hog(im, cellSize, 'verbose') ;

The same function can also be used to generate a pictorial rendition of the features, although this unavoidably destroys some of the information contained in the feature itself. To this end, use the 

render

 command:

imhog = vl_hog('render', hog, 'verbose') ;
clf ; imagesc(imhog) ; colormap gray ;

This should produce the following image:



Standard HOG features with a cell size of eight pixels.

HOG is an array of cells, with the third dimension spanning feature components:

> size(hog)

ans =

16    16    31

In this case the feature has 31 dimensions. HOG exists in many variants. VLFeat supports two: the UoCTTI variant (used by default) and the original Dalal-Triggs variant (with 2×2 square HOG blocks for normalization). The main difference is that
the UoCTTI variant computes bot directed and undirected gradients as well as a four dimensional texture-energy feature, but projects the result down to 31 dimensions. Dalal-Triggs works instead with undirected gradients only and does not do any compression,
for a total of 36 dimension. The Dalal-Triggs variant can be computed as

% Dalal-Triggs variant
cellSize = 8 ;
hog = vl_hog(im, cellSize, 'verbose', 'variant', 'dalaltriggs') ;
imhog = vl_hog('render', hog, 'verbose', 'variant', 'dalaltriggs') ;

The result is visually very similar:



Dalal-Triggs variant. Differences with the standard version are difficult to appreciated in the rendition.

Flipping HOG from left to right

Often it is necessary to flip HOG features from left to right (for example in order to model an axis symmetric object). This can be obtained analytically from the feature itself by permuting the histogram dimensions appropriately. The permutation
is obtained as follows:

% Get permutation to flip a HOG cell from left to right
perm = vl_hog('permutation') ;

Then these two examples produce identical results (provided that the image contains an exact number of cells:

imHog = vl_hog('render', hog) ;
imHogFromFlippedImage = vl_hog('render', hogFromFlippedImage) ;
imFlippedHog = vl_hog('render', flippedHog) ;

This is shown in the figure:



Flipping HOG features from left to right either by flipping the input image or the features directly.

Other HOG parameters

vl_hog

 supports
other parameters as well. For example, one can specify the number of orientations in the histograms by the 

numOrientations

option:

% Specify the number of orientations
hog = vl_hog(im, cellSize, 'verbose', 'numOrientations', o) ;
imhog = vl_hog('render', hog, 'verbose', 'numOrientations', o) ;

Changing the number of orientations changes the features quite significantly:



HOG features for 

numOrientations

 equal to 3, 4, 5, 9, and 21 repsectively.

Another useful option is 

BilinearOrientations

 switching on the bilinear orientation assignment of the gradient (this is not used
in certain implementation like UoCTTI).

% Specify the number of orientations
hog = vl_hog(im,cellSize,'numOrientations', 4) ;
imhog = vl_hog('render', hog, 'numOrientations', 4) ;

resulting in



From left to right: input image, hard orientation assigments for 

numOrientations

 equals to four, and soft orientation assigments.

from: http://www.vlfeat.org/overview/hog.html