图像处理之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;
	}