使用Python实现图像LBP特征提取的操作方法

目录

• 一、LBP特征介绍
• 二、LBP特征描述
• 三、一些改进版本的LBP
• 1.圆形LBP算子
• 2.旋转不变的LBP算子
• 3.LBP等价模式
• 四、提取LBP算子的步骤
• 五、提取效果
• 六、代码实现

一、LBP特征介绍

LBP特征叫做局部二值模式，常用于纹理特征提取，并在纹理分类中具有较强的区分能力。它主要是利用结构法思想分析固定窗口特征，再利用统计法做整体的特征提取，是一种理论简单但功能强大的纹理分析算法。

LBP的基本思想：它利用图像中的每一个点和邻域中点的灰度值的差异构成图像的细节纹理，用其中心像素的灰度值作为阈值，与它的邻域中的像素灰度值相比较得到一个_8bit的二进制码_来表达局部纹理特征。

二、LBP特征描述

原始的LBP算子定义为在3×3的窗口内，以窗口中心像素为阈值，将相邻的8个像素的灰度值与其进行比较，若周围像素值大于中心像素值，则该像素点的位 置被标记为1，否则为0。这样，3×3邻域内的8个点经比较可产生8位二进制（通常转换为十进制数即LBP码，共256种），即得到该窗口中心像素点的LBP 值，并用这个值来反映该区域的纹理信息。

对于一幅大小是W*H的图像，因为边缘像素无法计算8位的LBP值，所以将LBP值转换为灰度图像时，它的大小是(W-2)*(H-2).

三、一些改进版本的LBP

1.圆形LBP算子

圆形LBP算子即采用以中心点为圆心的圆形邻域代替上文中的正方形邻域。邻域尺寸可以由半径R和采样点P确定。

2.旋转不变的LBP算子

上文中可以看出，LBP算子是灰度不变的，但却_不是旋转不变的，图像的旋转就会得到不同的LBP值。因此将LBP算子进行了扩展，提出了具有旋转不变性的LBP算子，即不断旋转圆形邻域得到一系列初始定义的LBP值，取其最小值作为该邻域的LBP值_。

举一个简单的例子，对于11110000来说，其旋转后能够得到11100001、10000111等值。这一个算子的旋转不变的LBP值就是其旋转后能得到的最小值00001111。

3.LBP等价模式

为了解决LBP模式过多的问题，提出了“等价模式”这一个概念。当某个LBP所对应的循环二进制数从0到1或从1到0最多有两次跳变时，该LBP所对应的二进制就称为一个等价模式类。如00000000（0次跳变），00000111（只含一次从0到1的跳变），10001111（先由1跳到0，再由0跳到1，共两次跳变）都是等价模式类。

这里对“模式”进行具体阐述：“模式”可以理解为LBP特征值的范围、种类等等。比如常用的3*3大小的正方形LBP算子的LBP模式就是256。引入这个“等价模式”主要是想要减少模式的数量，方便运算。

在统计时可以将这些等价模式对应的LBP的值按照大小进行映射；将其他不等价的模式归为一类。

比如，一种常用的操作就是将256中LBP算子中58种等价模式按照大小映射到0-57中，将其余的不属于等价模式的值规定为58。比如0被映射为0,255（也是一个等价模式，0次跳变）就被映射为57。具体操作可以再下面的代码中进一步查看。当然，读者也可以根据需要自己定义其他的映射法则。

经过这种等价操作，模式数量从2P种减少为 P(P-1)+2种。

四、提取LBP算子的步骤

• 首先将检测窗口划分为16×16的小区域（cell）

• 对于每个cell中的一个像素，将相邻的8个像素的灰度值与其进行比较，若周围像素值大于中心像素值，则该像素点的位置被标记为1，否则为0。这样，3×3邻域内的8个点经比较可产生8位二进制数，即得到该窗口中心像素点的LBP值；

• 然后计算每个cell的直方图，即每个数字（假定是十进制数LBP值）出现的频率；然后对该直方图进行归一化处理。

• 最后_将得到的每个cell的统计直方图连接成为一个特征向量_，也就是整幅图的LBP纹理特征向量；

• 最后便可利用SVM或者其他机器学习算法进行分类了。

五、提取效果

下图展示的效果依次为原图、圆形LBP算子提取结果、旋转不变LBP结果和等价模式的提取结果。

六、代码实现编程客栈

对于初学者来说，手写代码实现提取特征效果能够锻炼代码能力和加强对特征的理解，读者可以参照下面的代码进行学习。

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


class LBP():
    def __init__(self, img,cell_size):
        self.img = img #灰度图
        self.height, self.width = img.shape[:2]
        self.cell_size = cell_size
    
    # 传进来一个int型8位整数 找到旋转后最小的值
    def find_min(self,code):
        min = cod编程客栈e
  编程      for i in range(8):
            code = (code << 1) | (code >> 7)
            if code < min:
                min = code
        return min
            

    def lbp_circle(self):
        # 圆形LBP算子 这里写成了P=8,R=1 实际上这个与矩形3*3的LBP算子是一样的
        lbp = np.zeros((self.height, self.width), np.uint8) #统计的lbp是比原来少2行2列的，这里为了方便拆分成cell直接把四周的lbp的值置为0
        for i in range(1, self.height - 1):
            for j in range(1, self.width - 1):
                center = self.img[i, j]
                code = 0
                code |= (self.img[i - 1, j - 1] >= center) << 7
                code |= (self.img[i - 1, j] >= center) << 6
                code |= (self.img[i - 1, j + 1] >= center) << 5
                code |= (self.img[i, j + 1] >= center) << 4
                code |= (self.img[i + 1, j + 1] >= center) << 3
                code |= (self.img[i + 1, j] >= center) << 2
                code |= (self.img[i + 1, j - 1] >= center) << 1
                code |= (self.img[i, j - 1] >= center) << 0
                lbp[i, j] = code
        return lbp
    
    # 旋转不变模式
    def lbp_uniform(self):
        lbp = self.lbp_circle()
        # 圆形LBP算子 这里写成了P=8,R=1 实际上这个与矩形3*3的LBP算子是一样的
        lbp_uniform= np.zeros((self.height, self.width), np.uint8) #统计的lbp是比原来少2行2列的，这里为了方便拆分成cell直接把四周的lbp的值置为0
        # 旋转不变模式 找到旋转中的最小值
        for i in range(1, self.height - 1):
            for j in range(1, self.width - 1):
                lbp_uniform[i,j] = self.find_min(lbp[i, j])
        return lbp_uniform
    
    # 等价模式 这里将等价的模式按照大小映射到0-57中，然后将不等价模式标记为58
    def lbp_equivalent(self):
        # 定义等价模式的字典
        uniform_map = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 6: 5, 7: 6, 8: 7, 12: 8,14: 9, 15: 10, 16: 11, 24: 12, 28: 13, 30: 14, 31: 15, 32: 16, 48: 17,
                         56: 18, 60: 19, 62: 20, 63: 21, 64: 22, 96: 23, 112: 24,120: 25, 124: 26, 126: 27, 127: 28, 128: 29, 129: 30, 131: 31, 135: 32,143: 33,
                         159: 34, 191: 35, 192: 36, 193: 37, 195: 38, 199: 39, 207: 40,223: 41, 224: 42, 225: 43, 227: 44, 231: 45, 239: 46, 240: 47, 241: 48,
                         243: 49, 247: 50, 248: 51, 249: 52, 251: 53, 252: 54, 253: 55, 254: 56,255: 57}
        lbp_equivalent = np.zeros((self.height, self.width), np.uint8) #统计的lbp是比原来少2行2列的，这里为了方便拆分成cell直接把四周的lbp的值置为0
        lbp = self.lbp_circle()
        for i in range(1, self.height - 1):
            for j in range(1, self.width - 1):
                if lbp[i, j] in uniform_map:
   编程客栈                 # 按照字典序赋值
                    lbp_equivalent[i, j] = uniform_map[lbp[i, j]]
                else:
                    lbp_equivalent[i, j] = 58
        return lbp_equivalent
    
    # 统计每个cell的直方图 并对其进行归一化 这里使用的是L2范数归一化
    def lbp_histogram(self,lbp):
        bin_size = lbp.max() + 1 # 获取直方图的维数
        # 统计每个cell的直方图
        cell_histogram = np.zeros((self.height // self.cell_size, self.width // self.cell_size, bin_size), np.float32) 
        for i in range(self.height // self.cell_size):
            for j in range(self.width // self.cell_size):
                cell = lbp[i * self.cell_size:(i + 1) * self.cell_size, j * self.cell_size:(j + 1) * self.cell_size]
                cell_histogram[i, j] = np.bincount(cell.flatten(), minlength=bin_size)
              # 对每个cell的直方图进行归一化 这里使python用的是L2范数归一化
        for i in range(self.height // self.cell_size):
            for j in range(self.width // self.cell_size):
                cell_histogram[i, j] = cell_histogram[i, j] / np.linalg.norm(cell_histogram[i, j])
        return cell_histogram
   
    # 拼接每个cell，得到最后的LBP特征向量
    def lbp_feature(self,lbp):
        cell_histogram = self.lbp_histogram(lbp)
        # 拼接每个cell，得到最后的LBP特征向量 是一个一维向量
        lbp_feature = np.zeros((cell_histogram.shape[0] * cell_histogram.shape[1] * cell_histogram.shape[2]), np.float32)
        for i in range(cell_histogram.shape[0]):
            for j in range(cell_histogram.shape[1]):
                for k in range(cell_histogram.shape[2]):
                    lbp_feature[i * cell_histogram.shape[1] * cell_histogram.shape[2] + j * cell_histogram.shape[2] + k] = cell_histogram[i, j, k]
        return lbp_feature
        
if __name__ == '__main__':
    img = cv2.imread('1.png')
    # 灰度图读取
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    lbp = LBP(img,16) #这里设置cell大小为16*16
    lbp_circle = lbp.lbp_circle()
    lbp_uniform = lbp.lbp_uniform()
    lbp_equivalent = lbp.lbp_equivalent()
    print("圆形LBP特征向量:",lbp.lbp_feature(lbp_circle))  # 圆形LBP特征向量
    print("旋转不变LBP特征向量:",lbp.lbp_feature(lbp_uniform))  # 旋转不变LBP特征向量
    print("等价LBP特征向量:",lbp.lbp_feature(lbp_equivalent))  # 等价LBP特征向量

     # 显示原图和 lbp
    img = cv2.imread('1.png')
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # 将 BGR 转换为 RGB 以正确显示
    plt.subplot(2, 2, 1)
    plt.imshow(img)
    plt.title('Original Image')
    plt.subplot(2, 2, 2)
    plt.imshow(lbp_circle, cmap='gray',vmin=0, vmax=255)
    plt.title('LBP Circle')
    plt.subplot(2, 2, 3)
    plt.imshow(lbp_uniform, cmap='gray',vmin=0, vmax=255)
    plt.title('LBP Uniform')
    plt.subplot(2, 2, 4)
    plt.imshow(lbp_equivalent, cmap='gray',vmin=0, vmax=255)
    plt.title('LBP Equivalent')

    # 保存图像
    plt.savefig('1_lbp_result.png')

    plt.show()

到此这篇关于使用python实现图像LBP特征提取的操作方法的文章就介绍到这了,更多相关Python 图像LBP提取内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！