好好学习噢！
HOG特征即方向梯度直方图 （Histogram of Oriented Gradient, HOG），源于2005年一篇CVPR论文，使用HOG+SVM做行人检测，由于效果良好而被广泛应用。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个方向的特征描述子。然后根据每个像素点的梯度方向，利用双线性内插法将其幅值累加到直方图中。
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的块。
实现效果为：
代码源自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()
实现效果为：
