LBP（Local Binary Pattern），即局部二进制模式，对一个像素点以半径r画一个圈，在圈上取K个点（一般为8），这K个点的值（像素值大于中心点为1，否则为0）组成K位二进制数。此即局部二进制模式，实际中使用的是LBP特征谱的直方统计图。在旧版的Opencv里，使用CvHaarClassifierCascade函数，只支持Harr特征。新版使用CascadeClassifier类，还可以支持LBP特征。Opencv的人脸识别使用的是Extended LBP（即circle_LBP），其LBP特征值的模式为256（0-255）种。

优点：

1，旋转不变性（局部二进制循环左移或右移其表示不变）

2，一定程度上消除了光照变化的问题

3，纹理特征维度低，计算速度快

缺点：

1，当光照变化不均匀时,各像素间的大小关系被破坏,对应的LBP算子也就发生了变化

2，通过引入旋转不变的定义,使LBP算子更具鲁棒性。但这也使得LBP算子丢失了方向信息（如使局部二进制左移或右移，结果是一样的，但是图像不一样）

以下介绍若干中LBP：

1，原始LBP。基于方框选取中心点周围8个像素，构成8位二进制

# 以下不再重复这个部分

import cv2

import numpy as np

image_path=your_img_path
# 原始LBP算法：选取中心点周围的8个像素点，大于中心点为1，小于为0，将这些1或0顺时针串成8位二进制，即最终表示

def origin_LBP(img):

    dst = np.zeros(img.shape,dtype=img.dtype)

    h,w=img.shape

    start_index=1

    for i in range(start_index,h-1):

        for j in range(start_index,w-1):

            center = img[i][j]

            code = 0

#             顺时针，左上角开始的8个像素点与中心点比较，大于等于的为1，小于的为0，最后组成8位2进制

            code |= (img[i-1][j-1] >= center) << (np.uint8)(7)

            code |= (img[i-1][j  ] >= center) << (np.uint8)(6)

            code |= (img[i-1][j+1] >= center) << (np.uint8)(5)

            code |= (img[i  ][j+1] >= center) << (np.uint8)(4)

            code |= (img[i+1][j+1] >= center) << (np.uint8)(3)

            code |= (img[i+1][j  ] >= center) << (np.uint8)(2)

            code |= (img[i+1][j-1] >= center) << (np.uint8)(1)

            code |= (img[i  ][j-1] >= center) << (np.uint8)(0)

            dst[i-start_index][j-start_index]= code

    return dst

# 读入灰度图

gray = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# LBP处理

org_lbp = origin_LBP(gray)
cv2.imshow('img', gray)

cv2.imshow('org_lbp', org_lbp)

# 若针对视频取图片，delay=k时表示下一帧在kms后选取

cv2.waitKey(0)

2，Extended LBP

# 使用圆形选取框替代矩形框选：给定半径为r（半径越小，纹理越细），在此圆上选择K个点（选取点越多，亮度越高），同样，逆/顺时针组成K为二进制

# 称为extend LBP

def circular_LBP(img, radius=3, neighbors=8):

    h,w=img.shape

    dst = np.zeros((h-2*radius, w-2*radius),dtype=img.dtype)

    for i in range(radius,h-radius):

        for j in range(radius,w-radius):

            # 获得中心像素点的灰度值

            center = img[i,j]

            for k in range(neighbors):

                # 计算采样点对于中心点坐标的偏移量rx，ry

                rx = radius * np.cos(2.0 * np.pi * k / neighbors)

                ry = -(radius * np.sin(2.0 * np.pi * k / neighbors))

                # 为双线性插值做准备

                # 对采样点偏移量分别进行上下取整

                x1 = int(np.floor(rx))

                x2 = int(np.ceil(rx))

                y1 = int(np.floor(ry))

                y2 = int(np.ceil(ry))

                # 将坐标偏移量映射到0-1之间

                tx = rx - x1

                ty = ry - y1

                # 根据0-1之间的x，y的权重计算公式计算权重，权重与坐标具体位置无关，与坐标间的差值有关

                w1 = (1-tx) * (1-ty)

                w2 =    tx  * (1-ty)

                w3 = (1-tx) *    ty

                w4 =    tx  *    ty

                 # 根据双线性插值公式计算第k个采样点的灰度值

                neighbor=img[i+y1,j+x1] * w1 + img[i+y2,j+x1] *w2 + img[i+y1,j+x2] *  w3 +img[i+y2,j+x2] *w4

                # LBP特征图像的每个邻居的LBP值累加，累加通过与操作完成，对应的LBP值通过移位取得

                dst[i-radius,j-radius] |= (neighbor>center)  <<  (np.uint8)(neighbors-k-1)

    return dst

gray = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

circul_1_8 = circular_LBP(gray,1,8)

circul_3_8 = circular_LBP(gray,3,8)

circul_3_6 = circular_LBP(gray,3,6)

# 最好是先计算完，统一显示

cv2.imshow('img', gray)

cv2.imshow('r1k8', circul_1_8)

cv2.imshow('r3k8', circul_3_8)

cv2.imshow('r3k6', circul_3_6)

cv2.waitKey(0)

cv2.destroyAllWindows()

其中，双线性插值公式为：

3，加入旋转不变性

# 在圆形选取框基础上，加入旋转不变操作

def rotation_invariant_LBP(img, radius=3, neighbors=8):

    h,w=img.shape

    dst = np.zeros((h-2*radius, w-2*radius),dtype=img.dtype)

    for i in range(radius,h-radius):

        for j in range(radius,w-radius):

            # 获得中心像素点的灰度值

            center = img[i,j]

            for k in range(neighbors):

                # 计算采样点对于中心点坐标的偏移量rx，ry

                rx = radius * np.cos(2.0 * np.pi * k / neighbors)

                ry = -(radius * np.sin(2.0 * np.pi * k / neighbors))

                # 为双线性插值做准备

                # 对采样点偏移量分别进行上下取整

                x1 = int(np.floor(rx))

                x2 = int(np.ceil(rx))

                y1 = int(np.floor(ry))

                y2 = int(np.ceil(ry))

                # 将坐标偏移量映射到0-1之间

                tx = rx - x1

                ty = ry - y1

                # 根据0-1之间的x，y的权重计算公式计算权重，权重与坐标具体位置无关，与坐标间的差值有关

                w1 = (1-tx) * (1-ty)

                w2 =    tx  * (1-ty)

                w3 = (1-tx) *    ty

                w4 =    tx  *    ty

                # 根据双线性插值公式计算第k个采样点的灰度值

                neighbor = img[i+y1,j+x1] * w1 + img[i+y2,j+x1] *w2 + img[i+y1,j+x2] *  w3 +img[i+y2,j+x2] *w4

                # LBP特征图像的每个邻居的LBP值累加，累加通过与操作完成，对应的LBP值通过移位取得

                dst[i-radius,j-radius] |= (neighbor>center)  <<  (np.uint8)(neighbors-k-1)

    # 进行旋转不变处理

    for i in range(dst.shape[0]):

        for j in range(dst.shape[1]):

            currentValue = dst[i,j]

            minValue = currentValue

            for k in range(1, neighbors):

                # 对二进制编码进行循环左移，意思即选取移动过程中二进制码最小的那个作为最终值

                temp = (np.uint8)(currentValue>>(neighbors-k)) |  (np.uint8)(currentValue<<k)

                if temp < minValue:

                    minValue = temp

            dst[i,j] = minValue

    return dst       

gray = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

rotation_invariant = rotation_invariant_LBP(gray,3,8)

cv2.imshow('img', gray)

cv2.imshow('ri', rotation_invariant)

cv2.waitKey(0)

cv2.destroyAllWindows()

4，等价模式

def get_shifts(data):

    '''

    计算跳变次数，即二进制码相邻2位不同，总共出现的次数

    '''

    count = 0

    binaryCode = "{0:0>8b}".format(data)

    for i in range(1,len(binaryCode)):

        if binaryCode[i] != binaryCode[(i-1)]:

            count+=1

    return count

def create_table(img):

    # LBP特征值对应图像灰度编码表，直接默认采样点为8位

    temp = 1

    table =np.zeros((256),dtype=img.dtype)

    for i in range(256):

#         跳变小于3定义为等价模式类，共58，混合类算做1种

        if get_shifts(i)<3:

            table[i] = temp

            temp+=1

    return table

# 等价模式类：二进制码跳变次数小于3，8位二进制码共58种等价模式，其他256-58种为混合类。混合类的LBP特征将置为0，所以最终图像偏暗

def uniform_pattern_LBP(img,table,radius=3, neighbors=8):

    h,w=img.shape

    dst = np.zeros((h-2*radius, w-2*radius),dtype=img.dtype)

    for i in range(radius,h-radius):

        for j in range(radius,w-radius):

            # 获得中心像素点的灰度值

            center = img[i,j]

            for k in range(neighbors):

                # 计算采样点对于中心点坐标的偏移量rx，ry

                rx = radius * np.cos(2.0 * np.pi * k / neighbors)

                ry = -(radius * np.sin(2.0 * np.pi * k / neighbors))

                # 为双线性插值做准备

                # 对采样点偏移量分别进行上下取整

                x1 = int(np.floor(rx))

                x2 = int(np.ceil(rx))

                y1 = int(np.floor(ry))

                y2 = int(np.ceil(ry))

                # 将坐标偏移量映射到0-1之间

                tx = rx - x1

                ty = ry - y1

                # 根据0-1之间的x，y的权重计算公式计算权重，权重与坐标具体位置无关，与坐标间的差值有关

                w1 = (1-tx) * (1-ty)

                w2 =    tx  * (1-ty)

                w3 = (1-tx) *    ty

                w4 =    tx  *    ty

                # 根据双线性插值公式计算第k个采样点的灰度值

                neighbor = img[i+y1,j+x1] * w1 + img[i+y2,j+x1] *w2 + img[i+y1,j+x2] *  w3 +img[i+y2,j+x2] *w4

                # LBP特征图像的每个邻居的LBP值累加，累加通过与操作完成，对应的LBP值通过移位取得

                dst[i-radius,j-radius] |= (neighbor>center)  <<  (np.uint8)(neighbors-k-1)

                # 进行LBP特征的UniformPattern编码

                # 8位二进制码形成后，查表，对属于混合类的特征置0

                if k==neighbors-1:

                    dst[i-radius,j-radius] = table[dst[i-radius,j-radius]]

    return dst

gray = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

table=create_table(gray)

uniform_pattern = uniform_pattern_LBP(gray,table,3,8)

cv2.imshow('img', gray)

cv2.imshow('up', uniform_pattern)

cv2.waitKey(0)

cv2.destroyAllWindows()

5，MB_LBP：先对像素做区域平均处理，再使用原始LBP

# 先对像素分割，用一个小区域的平均值代替这个区域，再用LBP特征处理

def multi_scale_block_LBP(img,scale):

    h,w= img.shape

    # cellSize表示一个cell大小

    cellSize = int(scale / 3)

    offset = int(cellSize / 2)

    cellImage = np.zeros((h-2*offset, w-2*offset),dtype=img.dtype)

    for i in range(offset,h-offset):

        for j in range(offset,w-offset):

            temp = 0

            for m in range(-offset,offset+1):

                for n in range(-offset,offset+1):

                    temp += img[i+n,j+m]

#             即取一个cell里所有像素的平均值

            temp /= (cellSize*cellSize)

            cellImage[i-offset,j-offset] = np.uint8(temp)

#     再对平均后的像素做LBP特征处理

    dst = origin_LBP(cellImage)

    return dst

gray = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

mb_3 = multi_scale_block_LBP(gray,3)

mb_9 = multi_scale_block_LBP(gray,9)

mb_15 = multi_scale_block_LBP(gray,15)

cv2.imshow('img', gray)

cv2.imshow('mb_3', mb_3)

cv2.imshow('mb_9', mb_9)

cv2.imshow('mb_15', mb_15)

cv2.waitKey(0)

cv2.destroyAllWindows()

5，LBPH，Local Binary Patterns Histograms

此处基于等价模式，再使用像素各分割块的直方统计图，拼接为最后的特征向量

# 先使用等价模式预处理图像，降维。再分割图像，对每个分割块进行直方统计（降维后的类别为59），返回密度向量，再拼接各个分割块对应的密度向量

# 最终返回grid_x*grid_y*numPatterns维的特征向量，作为图像的LBPH特征向量

def getLBPH(img_lbp,numPatterns,grid_x,grid_y,density):

    '''

    计算LBP特征图像的直方图LBPH

    '''

    h,w=img_lbp.shape

    width = int(w / grid_x)

    height = int(h / grid_y)

    # 定义LBPH的行和列，grid_x*grid_y表示将图像分割的块数，numPatterns表示LBP值的模式种类

    result = np.zeros((grid_x * grid_y,numPatterns),dtype=float)

    resultRowIndex = 0

    # 对图像进行分割，分割成grid_x*grid_y块，grid_x，grid_y默认为8

    for i in range(grid_x):

        for j in range(grid_y):

            # 图像分块

            src_cell = img_lbp[i*height:(i+1)*height,j*width:(j+1)*width]

            # 计算直方图

            hist_cell = getLocalRegionLBPH(src_cell,0,(numPatterns-1),density)

            #将直方图放到result中

            result[resultRowIndex]=hist_cell

            resultRowIndex+=1

    return np.reshape(result,(-1))

def getLocalRegionLBPH(src,minValue,maxValue,density=True):

    '''

    计算一个LBP特征图像块的直方图

    '''

    data = np.reshape(src,(-1))

    # 计算得到直方图bin的数目，直方图数组的大小

    bins = maxValue - minValue + 1;

    # 定义直方图每一维的bin的变化范围

    ranges = (float(minValue),float(maxValue + 1))

#     density为True返回的是每个bin对应的概率值，bin为单位宽度时，概率总和为1

    hist, bin_edges = np.histogram(src, bins=bins, range=ranges, density=density)

    return hist

uniform_pattern = uniform_pattern_LBP(gray,table,3,8)

#等价模式58种，混合模式算1种

lbph = getLBPH(uniform_pattern,59,8,8,True)

参考博客：https://blog.csdn.net/lk3030/article/details/84034963

Opencv之LBP特征（算法）的更多相关文章

  1. OpenCV开发笔记（五十五）：红胖子8分钟带你深入了解Haar、LBP特征以及级联分类器识别过程（图文并茂+浅显易懂+程序源码）

    若该文为原创文章,未经允许不得转载原博主博客地址:https://blog.csdn.net/qq21497936原博主博客导航:https://blog.csdn.net/qq21497936/ar ...

  2. 行人检测4（LBP特征）

    参考原文: http://blog.csdn.net/zouxy09/article/details/7929531 http://www.cnblogs.com/dwdxdy/archive/201 ...

  3. 图像物体检測识别中的LBP特征

    版权声明:本文为博主原创文章,未经博主同意不得转载. https://blog.csdn.net/xinzhangyanxiang/article/details/37317863 图像物体检測识别中 ...

  4. LBP特征

    此篇摘取 <LBP特征原理及代码实现> <LBP特征 学习笔记> 另可参考实现: <LBP特征学习及实现> <LBP特征的实现及LBP+SVM分类> & ...

  5. 图像的全局特征--LBP特征

    原文链接:http://blog.csdn.net/zouxy09/article/details/7929531#comments 这个特征或许对三维图像特征提取有很大作用.文章有修改,如有疑问,请 ...

  6. OpenCV人脸识别LBPH算法源码分析

    1 背景及理论基础 人脸识别是指将一个需要识别的人脸和人脸库中的某个人脸对应起来(类似于指纹识别),目的是完成识别功能,该术语需要和人脸检测进行区分,人脸检测是在一张图片中把人脸定位出来,完成的是搜寻 ...

  7. OpenCV 轮廓基本特征

     http://blog.csdn.net/tiemaxiaosu/article/details/51360499 OpenCV 轮廓基本特征 2016-05-10 10:26 556人阅读 评论( ...

  8. 图像特征提取之LBP特征

    LBP(Local Binary Pattern,局部二值模式)是一种用来描述图像局部纹理特征的算子:它具有旋转不变性和灰度不变性等显著的优点.它是首先由T. Ojala, M.Pietik?inen ...

  9. 图像特征提取三大法宝：HOG特征，LBP特征，Haar特征（转载）

    (一)HOG特征 1.HOG特征: 方向梯度直方图(Histogram of Oriented Gradient, HOG)特征是一种在计算机视觉和图像处理中用来进行物体检测的特征描述子.它通过计算和 ...

随机推荐

  1. loj2589 「NOIP2009」Hankson 的趣味题

    对于质因数分解理解还不到位. 此题可知$lcm$是$x$的倍数,$x$是$lcm$的约数,只要在$lcm$的分解质因数里对每一个质因子讨论种数即可. 具体来说,对于$lcm$的一个质因子$p$,讨论$ ...

  2. Discuz升级

      1.下载论坛程序文件 2.备份数据库 3.建立文件夹 old,旧程序除了 data , config, uc_client, uc_server 目录以外的程序移动进入 old目录中4. 上传 u ...

  3. C++关于构造函数 和 析构函数 能否抛出异常的讨论

    构造函数和析构函数分别管理对象的建立和释放,负责对象的诞生和死亡的过程.当一个对象诞生时,构造函数负责创建并初始化对象的内部环境,包括分配内存.创建内部对象和打开相关的外部资源,等等.而当对象死亡时, ...

  4. JAVA笔记4-static关键字

    1.static方法中不能使用this关键字 2.例题:static成员变量用于计数     

  5. python实现一个层次聚类方法

    层次聚类(Hierarchical Clustering) 一.概念 层次聚类不需要指定聚类的数目,首先它是将数据中的每个实例看作一个类,然后将最相似的两个类合并,该过程迭代计算只到剩下一个类为止,类 ...

  6. JS框架_(AJAX)检测ip和地区

    百度云盘 传送门  密码:l94p 实现效果: <!DOCTYPE html> <html> <head> <meta charset="utf-8 ...

  7. python学习之路（7）

    调用函数 Python内置了很多有用的函数,我们可以直接调用. 要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数abs,只有一个参数.可以直接从Python的官方网站查看文档: http: ...

  8. 2018-2019-2 网络对抗技术 20165232 Exp 9 Web安全基础

    2018-2019-2 网络对抗技术 20165232 Exp 9 Web安全基础 实验任务 本实践的目标理解常用网络攻击技术的基本原理,做不少于7个题目,共3.5分.包括(SQL,XSS,CSRF) ...

  9. SecureCRT For Mac安装、破解、使用详细总结

    转:https://blog.csdn.net/so_geili/article/details/83315852#_4 https://www.sednax.com/download.php

  10. 使用SNMP监控服务器运行情况

    系统监测的基本概念及分类: a．系统监测的概述: 如何对现有IT架构的整体以及细节运行情况进行科学.系统和高效地监测是目前各企业运维和管理部门一项非常重要的工作内容.随着当前企业IT环境中服务器.应用 ...