Opencv的使用小教程4——HOG特征及其python代码实现

好好学习噢！

hog特征是什么

HOG特征即方向梯度直方图 （Histogram of Oriented Gradient, HOG），源于2005年一篇CVPR论文，使用HOG+SVM做行人检测，由于效果良好而被广泛应用。HOG是一种在计算机视觉和图像处理中用来进行物体检测的特征描述子。它通过计算和统计图像局部区域的梯度方向直方图来构成特征。

该算法能够工作的原因为：

在一副图像中，局部目标的边缘存在梯度特性，而且这个特征梯度可以很好的描述这个目标。

hog的实现步骤

简略版实现方法：
1、将图像分成小的连通区域，又名分为多个细胞单元。
2、然后采集细胞单元中各像素点的梯度的或边缘的方向直方图。
3、最后把这些直方图组合起来就可以构成特征描述器。

详细版实现方法：
1、灰度化。
2、采用Gamma校正法对输入图像进行颜色空间的标准化，目的是调节图像的对比度，降低图像局部的阴影和光照变化所造成的影响，同时可以抑制噪音的干扰；
3、计算图像每个像素的梯度，主要是为了捕获轮廓信息，同时进一步弱化光照的干扰。
4、将图像划分成多个细胞单元
5、统计每个细胞单元的梯度直方图，获得每个细胞单元的特征描述子。
6、将每几个细胞单元组成一个块（例如3*3个细胞/块），一个块内所有细胞的特征描述子串联起来便得到该块的HOG特征描述子。
7、将图像内的所有块的HOG特征描述子串联起来就可以得到该图像的HOG特征描述子了。

梯度直方图的概念：

1、利用任意一种梯度算子，例如：sobel，laplacian等，对一个块进行卷积，计算得到每个像素点处的梯度方向和幅值。具体公式如下：

其中，Ix和Iy代表水平和垂直方向上的梯度值，M(x,y)代表梯度的幅度值，θ(x,y)代表梯度的方向。

2、将360度（2*PI）根据需要分割成若干个方向，例如：分割成6个方向，每个bin包含60度，整个直方图包含6维，即6个方向的特征描述子。然后根据每个像素点的梯度方向，利用双线性内插法将其幅值累加到直方图中。

python代码实现：

1、使用scikit-image库：

from skimage import feature as ft
img = cv2.imread('timg.jpg', cv2.IMREAD_GRAYSCALE)
features = ft.hog(img,orientations=6,pixels_per_cell=[20,20],cells_per_block=[2,2],visualize=True)
plt.imshow(features[1],cmap=plt.cm.gray)
plt.show()

其中：
1、image:输入图像
2、orientation: 指定块的个数。把所有的方向都转换为0°~180°内，然后按照orientation划分块，如果你选定的orientation= 6, 则bin一共有6个, 每30°有一个。
3、pixels_per_cell : 每个细胞单元的像素数, 是一个tuple类型数据,例如(20,20)
4、cell_per_block : 每个块内有多少个细胞单元, tuple类型, 例如(2,2), 意思是将block均匀划分为2x2的块。
实现效果为：

2、源码代码实现：

代码源自https://blog.csdn.net/ppp8300885/article/details/71078555

import cv2
import numpy as np
import math
import matplotlib.pyplot as plt

class Hog_descriptor():
    #---------------------------#
    #   初始化
    #   cell_size每个细胞单元的像素数
    #   bin_size表示把360分为多少边
    #---------------------------#
    def __init__(self, img, cell_size=16, bin_size=8):
        self.img = img
        self.img = np.sqrt(img / np.max(img))
        self.img = img * 255
        self.cell_size = cell_size
        self.bin_size = bin_size
        self.angle_unit = 360 / self.bin_size
    #---------------------------#
    #   获取hog向量和图片
    #---------------------------#
    def extract(self):
        # 获得原图的shape
        height, width = self.img.shape
        # 计算原图的梯度大小
        gradient_magnitude, gradient_angle = self.global_gradient()
        gradient_magnitude = abs(gradient_magnitude)

        # cell_gradient_vector用来保存每个细胞的梯度向量
        cell_gradient_vector = np.zeros((int(height / self.cell_size), int(width / self.cell_size), self.bin_size))
        height_cell,width_cell,_ = np.shape(cell_gradient_vector)
        #---------------------------#
        #   计算每个细胞的梯度直方图
        #---------------------------#
        for i in range(height_cell):
            for j in range(width_cell):
                # 获取这个细胞内的梯度大小
                cell_magnitude = gradient_magnitude[i * self.cell_size:(i + 1) * self.cell_size,
                                 j * self.cell_size:(j + 1) * self.cell_size]
                # 获得这个细胞内的角度大小
                cell_angle = gradient_angle[i * self.cell_size:(i + 1) * self.cell_size,
                             j * self.cell_size:(j + 1) * self.cell_size]
                # 转化为梯度直方图格式
                cell_gradient_vector[i][j] = self.cell_gradient(cell_magnitude, cell_angle)

        # hog图像
        hog_image = self.render_gradient(np.zeros([height, width]), cell_gradient_vector)
        hog_vector = []
        # block为2x2
        for i in range(height_cell - 1):
            for j in range(width_cell - 1):
                block_vector = []
                block_vector.extend(cell_gradient_vector[i][j])
                block_vector.extend(cell_gradient_vector[i][j + 1])
                block_vector.extend(cell_gradient_vector[i + 1][j])
                block_vector.extend(cell_gradient_vector[i + 1][j + 1])
                mag = lambda vector: math.sqrt(sum(i ** 2 for i in vector))
                magnitude = mag(block_vector)
                if magnitude != 0:
                    normalize = lambda block_vector, magnitude: [element / magnitude for element in block_vector]
                    block_vector = normalize(block_vector, magnitude)
                hog_vector.append(block_vector)
        return hog_vector, hog_image
    #---------------------------#
    #   计算原图的梯度大小
    #   角度大小
    #---------------------------#
    def global_gradient(self):
        gradient_values_x = cv2.Sobel(self.img, cv2.CV_64F, 1, 0, ksize=5)
        gradient_values_y = cv2.Sobel(self.img, cv2.CV_64F, 0, 1, ksize=5)
        gradient_magnitude = cv2.addWeighted(gradient_values_x, 0.5, gradient_values_y, 0.5, 0)
        gradient_angle = cv2.phase(gradient_values_x, gradient_values_y, angleInDegrees=True)
        return gradient_magnitude, gradient_angle
    #---------------------------#
    #   分解角度信息到
    #   不同角度的直方图上
    #---------------------------#
    def cell_gradient(self, cell_magnitude, cell_angle):
        orientation_centers = [0] * self.bin_size
        for i in range(cell_magnitude.shape[0]):
            for j in range(cell_magnitude.shape[1]):
                gradient_strength = cell_magnitude[i][j]
                gradient_angle = cell_angle[i][j]
                min_angle, max_angle, mod = self.get_closest_bins(gradient_angle)
                orientation_centers[min_angle] += (gradient_strength * (1 - (mod / self.angle_unit)))
                orientation_centers[max_angle] += (gradient_strength * (mod / self.angle_unit))
        return orientation_centers
    #---------------------------#
    #   计算每个像素点所属的角度
    #---------------------------#
    def get_closest_bins(self, gradient_angle):
        idx = int(gradient_angle / self.angle_unit)
        mod = gradient_angle % self.angle_unit
        return idx, (idx + 1) % self.bin_size, mod
    #---------------------------#
    #   将梯度直方图进行绘图
    #---------------------------#
    def render_gradient(self, image, cell_gradient):
        cell_width = self.cell_size / 2
        max_mag = np.array(cell_gradient).max()
        for x in range(cell_gradient.shape[0]):
            for y in range(cell_gradient.shape[1]):
                cell_grad = cell_gradient[x][y]
                cell_grad /= max_mag
                angle = 0
                angle_gap = self.angle_unit
                for magnitude in cell_grad:
                    angle_radian = math.radians(angle)
                    x1 = int(x * self.cell_size + magnitude * cell_width * math.cos(angle_radian))
                    y1 = int(y * self.cell_size + magnitude * cell_width * math.sin(angle_radian))
                    x2 = int(x * self.cell_size - magnitude * cell_width * math.cos(angle_radian))
                    y2 = int(y * self.cell_size - magnitude * cell_width * math.sin(angle_radian))
                    cv2.line(image, (y1, x1), (y2, x2), int(255 * math.sqrt(magnitude)))
                    angle += angle_gap
        return image

img = cv2.imread('timg.jpg', cv2.IMREAD_GRAYSCALE)
hog = Hog_descriptor(img, cell_size=20, bin_size=12)
vector, image = hog.extract()
plt.imshow(image, cmap=plt.cm.gray)
plt.show()

实现效果为：