[传统图像处理]-------HOG方向梯度直方图

最新推荐文章于 2021-12-14 22:39:22 发布

ZJE_ANDY

最新推荐文章于 2021-12-14 22:39:22 发布

阅读量977

点赞数

分类专栏：图像处理

本文链接：https://blog.csdn.net/u014453898/article/details/106750705

版权

图像处理专栏收录该内容

8 篇文章 4 订阅

订阅专栏

Histogram of Oriented Gridients，缩写为HOG，是目前计算机视觉、模式识别领域很常用的一种描述图像局部纹理的特征。就是说先计算图片某一区域中不同方向上梯度的值，然后进行累积，得到直方图，这个直方图呢，就可以代表这块区域了，也就是作为特征，可以输入到分类器里面了。

计算每一个像素的梯度：

计算方式：如下图为A像素及其上下左右的四个像素值。

通过计算水平梯度gx和垂直梯度gy来获取梯度值g。

水平梯度gx：

$g_{x}=30-20=10$

垂直梯度：

$g_{y}=64-32=32$

梯度值g：

梯度方向：

梯度方向将会取绝对值，因此梯度方向的范围是0-180度。取绝对值的原因是这样效果更好。

经过上面过程，每一个像素点的梯度值和梯度方向都可以被求出来。

计算梯度方向直方图：

由于一个点有梯度值和梯度方向两个数值。一个cell有8*8个像素，所以一个cell有8*8*2=128个数值。每一个cell都会生成一个方向梯度直方图，通过统计形成梯度直方图，128个值将会变成9个值。怎样变呢，过程如下：

首先，把180°分成九分，即每份是20°。如下图所示，如蓝色部分的点，从左边的梯度方向图可知，此点的梯度方向为80度，所以在下面的角度为80的bin中，填入这点的梯度数值，即2。那如果某点的梯度方向不是刚刚好是20、40....160度怎么办呢？如红色部分的点所示，可以看出，红色点的梯度方向为10°，其梯度数值为4，由于10位于0到20中间，所以把梯度数值各分一半给0的bin和20的bin。循环这个过程，那么一个cell就可以得到一个梯度方向直方图。

统计完一个cell的64个点后，得到一个长度为9的一维vector(向量)：

归一化

归一化的目的是降低光照的影响。

归一化是以block为单位，如下图所示，一个block=4个cell，一个cell是8*8像素，那么一个block即是16*16个像素。

（绿色是cell，蓝色是block）

我们已经知道一个cell是有一个直方图的，可以看成一个长度为9的一维向量。那么一个block就有4个这样的9*1的向量，把4个一维向量合成一个，则一个block会有一个36*1的一维向量。然后进行归一化。

归一化过程用的是L2归一化：

比如对于一个（128，64，32）的三维向量来说，模长是：

那么归一化后的向量变成了（0.87，0.43，0.22）。

计算HOG特征向量及可视化：

现在就到了最后一步了。如上图(跑步选手)，水平会有7个block(block每次移动一个格子)，垂直会有15个。所以一张图一共会有15*7=105个block，每个block有一个36*1的一维向量，所以一张图就有一个长度为 105*36 = 3780 的一维向量。

既然一张图的HOG特征是一个一维向量，那怎么可视化出来呢。

HOG的可视化结果为下图：

（应用：每张图片的HOG特征是可以输入到分类器中实现分类的）

可以看到，每一个cell都有9条线(线的数目跟梯度方向直方图中的bin个数相同)，9条线格子表示180°分成9份后不同的方向(例如20°，40°........)。我们用一个python 的sklearn库实现的HOG看看效果：

from skimage.feature import hog
from skimage import io

im = io.imread('D://timg.jpg',as_grey=True)
normalised_blocks, hog_image = hog(im, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), visualise=True)
io.imshow(im)
io.show()
io.imshow(hog_image)
io.show()

输入：

输出的HOG可视化：

上面是cell为8*8像素的，为了明显展示，我们把cell调到32*32看看输出的效果：

可以看到，以格子为单位，很多以一点为中心往外辐射的线条，这些就是一个cell中，9个bin对应的线条（包括梯度和梯度方向）。

非调用接口的python代码：

import cv2
import numpy as np
import math
import matplotlib.pyplot as plt
img = cv2.imread("D://car.jpg", cv2.IMREAD_GRAYSCALE)
def compute_image_gradient(img):
    #print(img.shape) #(333, 500)
    x_values = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=5)
    y_values = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=5)
    magnitude = abs(cv2.addWeighted(x_values, 0.5, y_values, 0.5, 0))
    angle = cv2.phase(x_values, y_values, angleInDegrees=True)
    #print(angle.shape) #(333, 500)
    return magnitude, angle
def choose_bins(gradient_angle, unit, bin_size):
    idx = int(gradient_angle / unit) #9个bin的某一个
    mod = gradient_angle % unit
    return idx, (idx + 1) % bin_size, mod
def compute_cell_gradient(cell_magnitude, cell_angle, bin_size, unit):
    centers = [0] * bin_size
    #print(cell_magnitude.shape) (8,8)
    for i in range(cell_magnitude.shape[0]):
        for j in range(cell_magnitude.shape[1]):
            strength = cell_magnitude[i][j]
            gradient_angle = cell_angle[i][j]
            min_angle, max_angle, mod = choose_bins(gradient_angle, unit, bin_size)
            #print(gradient_angle, unit, min_angle, max_angle)
            centers[min_angle] += (strength * (1 - (mod / unit)))
            centers[max_angle] += (strength * (mod / unit))
    return centers
def normalized(cell_gradient_vector):
    hog_vector = []
    for i in range(cell_gradient_vector.shape[0] - 1):
        for j in range(cell_gradient_vector.shape[1] - 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
def visual(cell_gradient, height, width, cell_size, unit):
    #print(cell_gradient.shape) #(41, 62, 9)
    feature_image = np.zeros([height, width])
    cell_width = cell_size / 2
    #print(cell_width) #4
    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]
            #print(cell_grad.shape) #(9,)
            cell_grad /= max_mag
            angle = 0
            angle_gap = unit
            for magnitude in cell_grad:
                angle_radian = math.radians(angle)
                x1 = int(x * cell_size + magnitude * cell_width * math.cos(angle_radian))
                y1 = int(y * cell_size + magnitude * cell_width * math.sin(angle_radian))
                x2 = int(x * cell_size - magnitude * cell_width * math.cos(angle_radian))
                y2 = int(y * cell_size - magnitude * cell_width * math.sin(angle_radian))

                cv2.line(feature_image, (y1, x1), (y2, x2), int(255 * math.sqrt(magnitude)))
                angle += angle_gap
    return feature_image
def main(img):
    cell_size = 8
    bin_size = 9
    unit = 360 // bin_size
    height, width = img.shape
    magnitude, angle = compute_image_gradient(img)
    #print(magnitude.shape)#(333, 500)
    cell_gradient_vector = np.zeros((height // cell_size, width // cell_size, bin_size))
    #print(cell_gradient_vector.shape) #(41, 62, 9)
    for i in range(cell_gradient_vector.shape[0]):
        for j in range(cell_gradient_vector.shape[1]):
            cell_magnitude = magnitude[i * cell_size:(i + 1) * cell_size,
                             j * cell_size:(j + 1) * cell_size]
            #print(cell_magnitude.shape) #(8, 8)
            cell_angle = angle[i * cell_size:(i + 1) * cell_size,
                         j * cell_size:(j + 1) * cell_size]
            cell_gradient_vector[i][j] = compute_cell_gradient(cell_magnitude, cell_angle, bin_size, unit) #返回一个cell的直方图
    hog_vector = normalized(cell_gradient_vector)
    #print(cell_gradient_vector.shape) #(20, 31, 9)
    hog_image = visual(cell_gradient_vector, height, width, cell_size, unit)
    plt.imshow(hog_image, cmap=plt.cm.gray)
    plt.show()
if __name__ == '__main__':
    img = cv2.imread('D://timg.jpg', cv2.IMREAD_GRAYSCALE)
    cv2.imshow("origin", img)
    cv2.waitKey()
    main(img)

效果：

输入

输出

HOG的应用：

HOG+SVM实现行人检测：

大概流程：

其中SVM是用已有的opencv中的svm检测器

import cv2 as cv

# 主程序入口
if __name__ == '__main__':
    # 读取图像
    src = cv.imread("D:/p.jpg")
    cv.imshow("input", src)
    # HOG + SVM
    hog = cv.HOGDescriptor()
    hog.setSVMDetector(cv.HOGDescriptor_getDefaultPeopleDetector())
    # Detect people in the image
    (rects, weights) = hog.detectMultiScale(src,
                                            winStride=(4, 4),
                                            padding=(8, 8),
                                            scale=1.25,
                                            useMeanshiftGrouping=False)
    # 矩形框
    for (x, y, w, h) in rects:
        cv.rectangle(src, (x, y), (x + w, y + h), (0, 255, 0), 2)
    # 显示
    cv.imshow("hog-detector", src)
    cv.waitKey(0)
    cv.destroyAllWindows()

效果：