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