图像处理之HOG特征提取

图像处理之HOG特征提取算法

HOG(Histogram of Oriented Gradient)特征在对象识别与模式匹配中是一种常见的特征提取算法，是基于本地像素块进行特征直方图提取的一种算法，对象局部的变形与光照影响有很好的稳定性，最初是用HOG特征来来识别人像，通过HOG特征提取+SVM训练，可以得到很好的效果，OpenCV已经有了。HOG特征提取的大致流程如下：



第一步：

Gamma校正，主要是对输入图像进行校正，主要是为了补偿显示器带来的灰度偏差。常见的系数在2.5左右，这个方面的资料非常多。ImageJ的源代码中也有Gamma校正的实现，可以参照。

第二步：

图像转灰度，这个也属于常见操作了。

第三步：

计算图像的梯度与方向，可以使用SOBEL算子实现，最终得到图像的梯度振幅与角度。



第四步：

将图像划分为8x8的小网格，对每个小网格内的图像做梯度方向直方图，每个8x8=64个像素为一个CELL，对每个CELL根据角度分为9个直方图块（BIN），每个BIN的范围是20度。假设在CELL的某个像素点的角度是10，则把他对应的梯度值累加放到第一个编号是0的直方图中，最终得到编号是0~8的各个直方图的数据。这样做的一个不好的地方是，没有精准反应出来梯度权重对相邻直方图的影响，得到直方图也不是反锯齿的数据，所以一个刚好的方法，是根据角度的值，计算对应像素的梯度在左右相邻直方图上的权重，根据权重累加相应的值到相邻的直方图中。这样就完成了HOG中最重要的一步，权重角度直方图数据统计。CELL网格分割图如下:



得到对应的直方图如下：



角度直方图的编号与角度范围。



五：块描述子

将2x2的网格单元组合成为一个大的块(Block)对每个块之间有1/2部分是重叠区域。主要是将每个Cell的直方图合并为一个大的直方图向量，这样每个块就有36个向量描述子。对每个块的描述子做归一化处理，常见的归一化处理为L2-norm或者L1-norm，公式如下：



这样就得到每个块的描述子，对一个对象特征来说块可以是矩形的也可以是圆形的，根据要提取对象特征决定。得到特征之后，在目标图像上以一个CELL大小为步长，检测目标图像上是否有匹配的对象特征，对象特征匹配可以基于相似度，最常见的是欧几里得距离与巴斯系数。

举例：

对于64x128的像素块，可以分为8x16个Cell分为7x15个块(R-HOG) 总计的直方图向量数为：7x15x2x2x9 = 3780个向量

关键部分的代码实现：

public static List<HOGBlock> extract(byte[] gradient, int[] orientation, int width, int height) {

// cell histograms
int step = 8;
int index = 0;
int numRowBins = height / step;
int numColBins = width / step;
int binindex = 0, theta=0, gw = 0;
float ww=0, wn=0, wp=0;
HOGCell[][] cells = new HOGCell[numRowBins][numColBins];
for (int row = 0; row < height; row += step) {
for (int col = 0; col < width; col += step) {
int roffset = 0, coffset = 0;
cells[row / step][col / step] = new HOGCell();
cells[row / step][col / step].row = row;
cells[row / step][col / step].col = col;
cells[row / step][col / step].bins = new double[9];
for (int y = 0; y < step; y++) {
for (int x = 0; x < step; x++) {
roffset = y + row;
if (roffset >= height) {
roffset = 0;
}
coffset = x + col;
if (coffset >= width) {
coffset = 0;
}
index = roffset * width + coffset;
theta = orientation[index];
// 计算权重梯度，一次双线性插值
ww = theta % 20;
if(ww >= 10) {
wn = ww - 10;
wp = (20-wn) / 20.0f;
}
else {
wn = 10 - ww;
wp = (20-wn) / 20.0f;
}

// 获取方向
binindex = theta / 20;
if (binindex >= 9) {
binindex = 8;
}

// 权重梯度值累加, 反锯齿
gw = (gradient[index]&0xff);
if(ww >=10) {
cells[row / step][col / step].bins[binindex] += (wp*gw);
if(binindex < 8) {
cells[row / step][col / step].bins[binindex+1] += ((1.0-wp)*gw);
}
}
else {
cells[row / step][col / step].bins[binindex] += (wp*gw);
if(binindex > 0) {
cells[row / step][col / step].bins[binindex-1] += ((1.0-wp)*gw);
}
}
}
}
}
}

// merge as blocks for 2x2 cells, if cells less than 2x2 cells, just one
// block
index = 0;
List<HOGBlock> blocks = new ArrayList<HOGBlock>();
for (int i = 0; i < numRowBins - 1; i++) {
for (int j = 0; j < numColBins - 1; j++) {
int cellxoff = j + 1;
int cellyoff = i + 1;
if (cellxoff >= numColBins) {
cellxoff = 0;
}
if (cellyoff >= numRowBins) {
cellyoff = 0;
}
// 2x2
HOGCell cell1 = cells[i][j];
HOGCell cell2 = cells[i][cellxoff];
HOGCell cell3 = cells[cellyoff][j];
HOGCell cell4 = cells[cellyoff][cellxoff];
HOGBlock block = new HOGBlock();
block.vector = generateBlockVector(cell1, cell2, cell3, cell4);
block.width = 2;
block.height = 2;
block.xpos = cell1.col;
block.ypos = cell1.row;
block.bindex = index;
blocks.add(index, block);
index++;
}
}

// Block 归一化
for (HOGBlock cellsBlock : blocks) {
blockL1SquareNorm(cellsBlock);
}

return blocks;
}