精华内容
下载资源
问答
  • LBP特征python版本代码

    2020-04-13 18:44:11
    LBP是一种用来描述图像局部纹理特征的算子;它具有旋转不变性和灰度不变性等显著的优点。它是首先由T. Ojala, M.Pietikäinen,和 D. Harwood 在1994年提出,用于纹理特征提取。而且,提取的特征是图像的局部的纹理...
  • Uniform LBP(均匀LBP) 为解决二进制模式过多的问题,提高统计性,Ojala提出了采用一种“等价模式”(Uniform Pattern)来对LBP算子的模式种类进行降维。Ojala等认为,在实际图像中,绝大多数LBP模式最多只包含两次...

    Uniform LBP(均匀LBP)

    为解决二进制模式过多的问题,提高统计性,Ojala提出了采用一种“等价模式”(Uniform Pattern)来对LBP算子的模式种类进行降维。Ojala等认为,在实际图像中,绝大多数LBP模式最多只包含两次从1到0或从0到1的跳变。因此,Ojala将“等价模式”定义为:当某个LBP所对应的循环二进制数从0到1或从1到0最多有两次跳变时,该LBP所对应的二进制就称为一个等价模式类。如00000000(0次跳变),00000111(只含一次从0到1的跳变),10001111(先由1跳到0,再由0跳到1,共两次跳变)都是等价模式类。除等价模式类以外的模式都归为另一类,称为混合模式类,例如10010111(共四次跳变)。通过这样的改进,二进制模式的种类大大减少,而不会丢失任何信息。模式数量由原来的2P种减少为 P ( P-1)+2种,其中P表示邻域集内的采样点数。对于3×3邻域内8个采样点来说,二进制模式由原始的256种减少为58种,即:它把值分为59类,58个uniform pattern为一类,依次从大到小排序;其它的所有值为第59类。这样直方图从原来的256维变成59维。这使得特征向量的维数更少,并且可以减少高频噪声带来的影响。
    Python代码:

    import numpy as np
    import cv2
    import os
    np.set_printoptions(threshold = 1e6)
    def arry_58():
        l = np.zeros(58, dtype=int)
        m = []
        a = -1
        for i in range(256):
            bit = '{:08b}'.format(i)  # 二进制化
            arry = []  # 二进制生成数组
            count = 0  # 计数变化次数
            # 把字符串变为数组方便统计变化次数
            for x in range(len(bit)):
                arry.append(int(bit[x]))
            # print(arry)
            first = arry[0]  # 数组第一个为first,与之后的比较
            for j in range(1, len(arry)):
                if arry[j] != first:  # 如果变化,计数单位加1
                    count += 1
                    first = arry[j]  # 并且把变化的值重新赋值
            # print(count)
            if count <= 2:  # 如果变化次数小于2,则依次排序
                a += 1
                # print(i)
                l[a] = i
        l = l.tolist()
        return l
    def uniform_LBP(img):
        h, w = img.shape  # 图像的长和宽
        dst = np.zeros((h - 2, w - 2), dtype=img.dtype)  # 新建一张图
        # dst = np.zeros(img.shape, dtype=img.dtype)  # 新建一张图
        arry58 = arry_58()
        for i in range(1, h - 1):
            for j in range(1, w - 1):
                center = img[i][j]
                code = []
                count = 0
    
                code7 = img[i - 1][j - 1]
                if code7 >= center:
                    code7 = 1
                else:
                    code7 = 0
                code.append(code7)
    
                code6 = img[i - 1][j]
                if code6 >= center:
                    code6 = 1
                else:
                    code6 = 0
                code.append(code6)
    
                code5 = img[i - 1][j + 1]
                if code5 >= center:
                    code5 = 1
                else:
                    code5 = 0
                code.append(code5)
    
                code4 = img[i][j + 1]
                if code4 >= center:
                    code4 = 1
                else:
                    code4 = 0
                code.append(code4)
    
                code3 = img[i + 1][j + 1]
                if code3 >= center:
                    code3 = 1
                else:
                    code3 = 0
                code.append(code3)
    
                code2 = img[i + 1][j]
                if code2 >= center:
                    code2 = 1
                else:
                    code2 = 0
                code.append(code2)
    
                code1 = img[i + 1][j - 1]
                if code1 >= center:
                    code1 = 1
                else:
                    code1 = 0
                code.append(code1)
    
                code0 = img[i][j - 1]
                if code0 >= center:
                    code0 = 1
                else:
                    code0 = 0
                code.append(code0)
                LBP = code7*128 + code6*64 + code5*32 + code4*16 + code3*8 + code2*4 + code1*2 + code0*1
                #print("LBP值为:",LBP)
                #print("8位编码为:",code)
                first = code[0]  # 数组第一个为first,与之后的比较
                for x in range(1, len(code)):
                    if code[x] != first:  # 如果变化,计数单位加1
                        count += 1
                        first = code[x]  # 并且把变化的值重新赋值
                #print("跳变次数",count)
                if count > 2:  # 如果变化次数大于3,则归为59位
                   dst[i - 1][j - 1] = 58
                else:  # 否则,按原来的数计算
                    loca = arry58.index(LBP)  # 获取位置
                    dst[i - 1][j - 1] = loca
        return dst
    
    if __name__ == '__main__':
        gray = cv2.imread('./b.jpg', cv2.IMREAD_GRAYSCALE)
        print(gray.shape)
        a = uniform_LBP(gray)
        cv2.imshow('uniform_lbp', a)
        cv2.imwrite("./2.jpg", a)
        cv2.waitKey(0)
    

    展开全文
  • Python实现LBP算法

    千次阅读 2020-07-28 12:20:44
    LBP算法原始LBP算法圆形LBP旋转不变LBP等价LBP旋转不变等价LBP 局部二值模式(Local Binary Pattern,LBP)的基本思想是将中心像素点的灰度值作为阈值,将其邻域内的像素点灰度值与阈值进行比较,从而得到二进制...

    局部二值模式(Local Binary Pattern,LBP)的基本思想是将中心像素点的灰度值作为阈值,将其邻域内的像素点灰度值与阈值进行比较,从而得到二进制编码用以表述局部纹理特征。

    • 优势

    LBP表示方法不易受图像整体灰度线性变化的影响,当图像的灰度值发生线性均匀变化时,其LBP特征编码是不变的。LBP特征计算简单,表征能力强,在纹理特征描述上具有较好的效果。

    • 发展历史
    1. 原始的LPB
    2. 圆形LPB

    为了解决不能自由更改尺寸的缺陷。

    1. 旋转不变的LPB

    上面的LBP特征具有灰度不变性,但还不具备旋转不变性,此改进为了解决旋转不变性。

    原始LBP算法

    基本的LBP算子:3×3的矩形块,有1个中心像素和8个邻域像素分别对应9个灰度值。特征值:以中心像素的灰度值为阈值,将其邻域的8个灰度值与阈值比较,大于中心灰度值的像素用1表示,反之用0表示。然后根据顺时针方向读出8个二进制值。经阈值化后的二值矩阵可看成一个二值纹理模式,用来刻画邻域内像素点的灰度相对中心点的变化情况。

    • 手写代码
    import matplotlib.pyplot as plt
    import cv2 as cv
    from skimage import data
    img = data.coffee()
    def lbp_basic(img):
        basic_array = np.zeros(img.shape,np.uint8)
        for i in range(basic_array.shape[0]-1):
            for j in range(basic_array.shape[1]-1):
                basic_array[i,j] = bin_to_decimal(cal_basic_lbp(img,i,j))
        return basic_array
    def cal_basic_lbp(img,i,j):#比中心像素大的点赋值为1,比中心像素小的赋值为0,返回得到的二进制序列
        sum = []
        if img[i - 1, j ] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i - 1, j+1 ] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i , j + 1] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i + 1, j+1 ] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i + 1, j ] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i + 1, j - 1] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i , j - 1] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i - 1, j - 1] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        return sum
    def bin_to_decimal(bin):#二进制转十进制
        res = 0
        bit_num = 0 #左移位数
        for i in bin[::-1]:
            res += i << bit_num   # 左移n位相当于乘以2的n次方
            bit_num += 1
        return res
    def show_basic_hist(a): #画原始lbp的直方图      
        hist = cv.calcHist([a],[0],None,[256],[0,256])
        hist = cv.normalize(hist,hist)
        plt.figure(figsize = (8,4))
        plt.plot(hist, color='r')
        plt.xlim([0,256])
        plt.show()
    img1 = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
    basic_array = lbp_basic(img1)
    show_basic_hist(basic_array)
    plt.figure(figsize=(11,11))
    plt.subplot(1,2,1)
    plt.imshow(img1)
    plt.subplot(1,2,2)
    plt.imshow(basic_array,cmap='Greys_r')
    plt.show()  
    


    • 调库
    import skimage.feature
    import skimage.segmentation
    img_ku = skimage.feature.local_binary_pattern(img1,8,1.0,method='default')
    img_ku = img_ku.astype(np.uint8)
    hist = cv.calcHist([img_ku],[0],None,[256],[0,256])
    hist = cv.normalize(hist,hist)
    plt.plot(hist, color='r')
    plt.xlim([0,256])
    plt.show()
    plt.imshow(img_ku,cmap='Greys_r')
    plt.show()
    


    • 方法说明 skimage.feature.local_binary_pattern

    skimage.feature.local_binary_pattern(image, P, R, method=‘default’)
    1、image:灰度图像的像素矩阵
    2、P:选取中心像素周围的像素点的个数
    3、R:选取的区域的半径
    4、method : {‘default’, ‘ror’, ‘uniform’, ‘var’}

    default:原始的局部二值模式
    参考地址

    圆形LBP

    圆形邻域的像素采样方式会比8-邻域的方式要更灵活,可以通过改变圆形的半径R来调整邻域大小。但半径R越大,采样点的数目P也越多。对于没有落到像素格子中央的点的灰度值,一般采用插值法得到。
    除此之外,通过对采样角度设置更高的量化等级,可以得到更精细的角度分辨率。

    LBP算子为:

    旋转不变LBP

    我们总是选择最右中间点作为起始点g0,所以当LBP算子旋转的时候,g0会发生变化,这样即使是同一个模板、同一个位置、同样的P、R,计算得到的LBP特征值都是不同的。为了消除这种旋转差异,重新定义了LBP计算方式:

    其中ROR(x,i)指的是对p位数字x进行i次循环右移。也就是说,从各个旋转的LBP二进制串中,找到最小的值,作为这个模板的LBP特征。举个例子,假设P=8,R=1(8个点,半径1),那么对于4个连续的1,4个连续的0(00001111)来说,可以旋转的有:

    显然最小的是15,所以这个模板的值就是15。

    缺点:看起来圆形LBP很完美,但实际使用发现LBPROT并不具有很好地辨别力,因为随着采样点数的增加,二进制模式会急剧增多,会使得数据量过大,直方图过于稀疏,不能很好地反映图像特征。

    • python代码实现
    from skimage import data
    import cv2 as cv
    import matplotlib.pyplot as plt
    # revolve_map为旋转不变模式的36种特征值从小到大进行序列化编号得到的字典
    revolve_map = {0: 0, 1: 1, 3: 2, 5: 3, 7: 4, 9: 5, 11: 6, 13: 7, 15: 8, 17: 9, 19: 10, 21: 11, 23: 12, 25: 13, 27: 14, 29: 15, 31: 16, 37: 17, 
    39: 18, 43: 19, 45: 20, 47: 21, 51: 22, 53: 23,55: 24,59: 25, 61: 26, 63: 27, 85: 28, 87: 29, 91: 30, 95: 31, 111: 32, 119: 33, 127: 34, 
    255: 35}
        
    def lbp_revolve(img): #图像旋转不变LBP特征
        revolve_array = np.zeros(img.shape,np.uint8)
        width = img.shape[0]
        height = img.shape[1]
        for i in range(1,width-1):
            for j in range(1,height-1):
                sum = cal_basic_lbp(img,i,j)
                revolve_key = get_min_for_revolve(sum)  #得到各个旋转的LBP二进制串中的最小值
                revolve_array[i, j] = revolve_map[revolve_key]  #将值范围映射到0~35
        return revolve_array
    
    def cal_basic_lbp(img,i,j):#比中心像素大的点赋值为1,比中心像素小的赋值为0,返回得到的二进制序列
        sum = []
        if img[i - 1, j ] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i - 1, j+1 ] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i , j + 1] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i + 1, j+1 ] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i + 1, j ] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i + 1, j - 1] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i , j - 1] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        if img[i - 1, j - 1] > img[i, j]:
            sum.append(1)
        else:
            sum.append(0)
        return sum    
    def get_min_for_revolve(arr): # 获取二进制序列进行不断环形旋转得到新的二进制序列的最小十进制值
        values = [] #存放每次移位后的值,最后选择值最小那个
        circle = arr*2  # 用于循环移位,分别计算其对应的十进制
        for i in range(0,8):
            j = 0
            sum = 0
            bit_sum = 0
            while j < 8:
                sum += circle[i+j] << bit_sum
                bit_sum += 1
                j += 1
            values.append(sum)
        return min(values)
     # 绘制图像旋转不变LBP特征的归一化统计直方图
    def show_revolve_hist(img_array):
        show_hist(img_array, [36], [0, 36])
    def show_hist(img_array,im_bins,im_range):
        hist = cv.calcHist([img_array], [0], None, im_bins, im_range)
        hist = cv.normalize(hist, hist).flatten()
        plt.plot(hist, color='r')
        plt.xlim(im_range)
        plt.show()
    img = data.coffee()
    img1 = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
    re_arr = lbp_revolve(img1)
    show_revolve_hist(re_arr)
    plt.imshow(re_arr, cmap='Greys_r')
    plt.show()
    


    等价LBP

    针对圆形LBP缺点,有人进一步提出等价LBP特征。利用等价模式来对LBP模板种类进行降维。我们首先定义“跳变”为二进制串中"01"、"10"这样的变化,定义度量准则为二进制串中的跳变次数。人们发现图像中大部分包含的都是至多两种跳变,且这些囊括了“亮点”、‘暗点’、‘平坦区域’、‘变化的边缘’等等,基本包含了绝大部分主要信息。

    定义:当某个LBP所对应的循环二进制数从0到1或从1到0最多有两次跳变时,该LBP所对应的二进制就称为一个等价模式类。如00000000(0次跳变),00000111(只含一次从0到1的跳变),10001111(先由1跳到0,再由0跳到1,共两次跳变)都是等价模式类。除等价模式类以外的模式都归为另一类,称为混合模式类。

    通过这样的改进,二进制模式的种类大大减少,而不会丢失任何信息。模式数量由原来的2^P种减少为 P ( P-1)+2种,其中P表示邻域集内的采样点数。对于3×3邻域内8个采样点来说,二进制模式由原始的256种减少为58种,这使得特征向量的维数更少,并且可以减少高频噪声带来的影响。

    跳变0次有两个、跳变1次有

    • 步骤
    1. 输入图像若为彩色图像,则将其灰度化,转化为仅含单通道像素的灰度图像;
    2. 按照从左到右、从上到下的顺序依次遍历图像中的所有像素。对于每个像素而言,选取其为中心的3 * 3 邻域;
    3. 于每个邻域,以该邻域中心的像素值作为阈值,其四周的8个像素值与之进行比较,若值大于阈值像素的值,则该位置处被置为1,否则置为0;
    4. 经过对比后,在3 * 3邻域内,其四周8个点可产生8位二进制数,将这8位二进制数依次排列组成二进制序列,依次计算每个8位二进制数的“01”,“10”跳变次数,若跳变次数小于等于2,则将该二进制序列对应的十进制值就是邻域中心的LBP值;若跳变次数大于2,则直接将邻域中心点的LBP值置为 P+1, 也就是9。但在下边代码中,我们不这么做,我们将跳变次数小于等于2的十进制值映射到0~57,跳变次数大于2的,LBP值置为58.
    5. 对图像内的所有像素遍历后,可得到整幅图像中的LBP值,即最终产生的ULBP特征。
    • python 实现
    # uniform_map为等价模式的58种特征值从小到大进行序列化编号得到的字典
    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}
    def lbp_uniform(img):
        revolve_array = np.zeros(img.shape,np.uint8)
        width = img.shape[0]
        height = img.shape[1]
        for i in range(1,width-1):
            for j in range(1,height-1):
                sum_ = cal_basic_lbp(img,i,j) #获得二进制
                num_ = calc_sum(sum_)  #获得跳变次数
                if num_ <= 2:
                    revolve_array[i,j] = uniform_map[bin_to_decimal(sum_)] #若跳变次数小于等于2,则将该二进制序列对应的十进制值就是邻域中心的LBP值,因为只有58种可能的值,但值得最大值可以是255,所以这里进行映射。
                else:
                    revolve_array[i,j] = 58
        return revolve_array
    def calc_sum(r):  # 获取值r的二进制中跳变次数
        sum_ = 0
        for i in range(0,len(r)-1):
            if(r[i] != r[i+1]):
                sum_ += 1
        return sum_
    def show_uniform_hist(img_array):
        show_hist(img_array, [60], [0, 60])
    def show_hist(img_array,im_bins,im_range):
        hist = cv.calcHist([img_array], [0], None, im_bins, im_range)
        hist = cv.normalize(hist, hist).flatten()
        plt.plot(hist, color='r')
        plt.xlim(im_range)
        plt.show()
    
    uniform_array = lbp_uniform(img1)
    show_revolve_hist(uniform_array)
    plt.imshow(uniform_array,cmap='Greys_r')
    plt.show()
    

    旋转不变等价LBP

    与等价LBP类似,区别在于若跳变次数小于等于2,则将该二进制序列1的位数就是邻域中心的LBP值;若跳变次数大于2,则直接将邻域中心点的LBP值置为 P+1, 也就是9。

    def lbp_uniform(img):
        revolve_array = np.zeros(img.shape,np.uint8)
        width = img.shape[0]
        height = img.shape[1]
        for i in range(1,width-1):
            for j in range(1,height-1):
                sum_ = cal_basic_lbp(img,i,j) #获得二进制
                num_ = calc_sum(sum_)  #获得跳变次数
                if num_ <= 2:
                    revolve_array[i,j] = count(bin_to_decimal(sum_)) #若跳变次数小于等于2,则将该二进制序列1的位数作为LBP值
                else:
                    revolve_array[i,j] = 9  # P + 1 = 8 + 1 = 9
        return revolve_array
    def calc_sum(r):  # 获取值r的二进制中跳变次数
        sum_ = 0
        for i in range(0,len(r)-1):
            if(r[i] != r[i+1]):
                sum_ += 1
        return sum_
    def show_uniform_hist(img_array):
        show_hist(img_array, [10], [0,10])
    def show_hist(img_array,im_bins,im_range):
        hist = cv.calcHist([img_array], [0], None, im_bins, im_range)
        hist = cv.normalize(hist, hist).flatten()
        plt.plot(hist, color='r')
        plt.xlim(im_range)
        plt.show()
    def count(num):
        cnt = 0
        while num:
            if num & 1 == 1:
                cnt += 1
            num = num >> 1
        return cnt
    def bin_to_decimal(bin):#二进制转十进制
        res = 0
        bit_num = 0 #左移位数
        for i in bin[::-1]:
            res += i << bit_num   # 左移n位相当于乘以2的n次方
            bit_num += 1
        return res
    uniform_array = lbp_uniform(img1)
    show_revolve_hist(uniform_array)
    plt.imshow(uniform_array,cmap='Greys_r')
    plt.show()
    


    展开全文
  • lbp.py是用于纹理分类的局部二进制模式 (LBP) 算法的 Python 实现。 先决条件 以下所示的版本已经过验证。 其他版本也可能有效,但尚未得到验证。 Git 2.3.* 或 2.4.* Python 2.7.9 带有以下包: NumPy 1.9.2 ...
  • from skimage import feature as skft import cv2 import numpy as np Img = cv2.imread(r"E:bpPackage\colorful_lena.jpg") grayImg = cv2.cvtColor(Img,cv2.COLOR_RGB2GRAY) methods = ["default",... lbp = skf.
    from skimage import feature as skft
    import cv2
    import numpy as np
    Img = cv2.imread(r"E:bpPackage\colorful_lena.jpg")
    grayImg = cv2.cvtColor(Img,cv2.COLOR_RGB2GRAY)
    methods = ["default","uniform","nri_uniform",'ror','var']
    for method in methods:
    	lbp = skft.local_binary_pattern(grayImg,P=8,R=1,method=method)
    	lbp = lbp.astype(np.uint8)#将其转化为8位无字符整形
    	cv2.imshow(method,lbp)
    	# cv2.imwrite(method+".jpg",lbp)
    cv2.waitKey(0)

     

    展开全文
  • python-LBP特征

    万次阅读 2016-12-08 11:30:54
    因为python更轻量,更方便所以硕士毕业论文使用python处理下,做的过程中记录下使用python处理特征提取遇到的一些问题,以上为背景。开发环境windows8.1 pycharm anaconda2 (自带很多包) opencv2.4.11读取图像...

    之前都是使用OpenCV/C++来做的图像处理。因为python更轻量,更方便所以硕士毕业论文使用python处理下,做的过程中记录下使用python处理特征提取遇到的一些问题,以上为背景。

    开发环境

    windows8.1
    pycharm
    anaconda2 (自带很多包)
    opencv2.4.11

    读取图像

    可以使用opencv,也可以使用skimage,记住他们的区别:
    1. 读图:opencv读图进来是BGR,而skimage是RGB。
    2. 显示:opencv的接口使用BGR,而matplotlib.pyplot 则是RGB模式。

    具体步骤:
    先安装opencv python package
    方法参考anaconda 安装opencv

    具体做法是:将G:\Opencv249\opencv\build\Python\2.7\x64 目录下的cv2.pyd文件拷贝到G:\Anaconda\Lib\site-packages下,重新打开PyCharm即可

    使用opencv读取图像,计算LBP特征,使用matplotlib.pyplot 显示所有的图像,

    
    #!usr/bin/env python
    #-*- coding: utf-8 -*-
    from skimage.transform import rotate
    from skimage.feature import local_binary_pattern
    from skimage import data, io
    from skimage.color import label2rgb
    import skimage
    import numpy as np
    import matplotlib.pyplot as plt
    from PIL import Image
    import cv2
    
    # settings for LBP
    radius = 3
    n_points = 8 * radius
    
    
    # 读取图像
    image = cv2.imread('1.png')
    
    #显示到plt中,需要从BGR转化到RGB,若是cv2.imshow(win_name, image),则不需要转化
    image1 = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    plt.subplot(131)
    plt.imshow(image1)
    
    # 转换为灰度图显示
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    plt.subplot(132)
    plt.imshow(image, cmap='gray')
    
    # 处理
    lbp = local_binary_pattern(image, n_points, radius)
    
    plt.subplot(133)
    plt.imshow(lbp, cmap='gray')
    plt.show()
    
    

    LBP 特征

    http://blog.csdn.net/pi9nc/article/details/18623971
    http://blog.csdn.net/zouxy09/article/details/7929531
    http://blog.csdn.net/dujian996099665/article/details/8886576

    展开全文
  • 主要介绍了Python + OpenCV 实现LBP特征提取的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 原图 效果图 ...radius = 1 # LBP算法中范围半径的取值 n_points = 8 * radius # 领域像素点数 # 读取图像 image = cv.imread('200.jpg') cv.namedWindow("image", cv.WINDOW_NORMAL) cv.imshow('imag.
  • 主要介绍了python实现LBP方法提取图像纹理特征实现分类的步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • LBP人脸识别的python实现

    千次阅读 热门讨论 2016-12-10 14:11:48
    这几天看了看LBP及其人脸识别的流程,并在网络上搜相应的python代码,有,但代码质量不好,于是自己就重新写了下,对于att_faces数据集的识别率能达到95.0%~99.0%(40种类型,每种随机选5张训练,5张识别),全部...
  • 使用的python LBP代码

    2021-02-18 13:03:38
    这是skimage的函数,比上次找到的代码更好用一些 from skimage.transform import rotate from skimage.feature import local_... 8, 1, “uniform”) print(“image =”) print(image) print(“lbp =”) print(lbp)
  • LBP统计直方图Python代码实现

    千次阅读 2019-12-23 20:23:01
    LBP统计直方图分为整体统计和分块统计 1、整体统计 即将生成的LBP特征进行整幅图像的统计,这样做的缺点时丢失了位置信息,但是维度较小。 实现代码: 假设生成的LBP特征如下面所示,大小为6×18 14 15 31 30 ...
  • Python实现的LBP特征提取

    千次阅读 2019-03-11 17:20:05
    # -*- coding: utf-8 -*- import cv2 import numpy as np import math import os import matplotlib.pyplot as plt # 取得给定的LBP字符串的最小二进制值,实现旋转不变形 ... str_lbp_tmp = str_lbp_i...
  • LBP特征学习(附python实现)

    千次阅读 2019-04-20 22:21:00
    LBP特征学习(附python实现) LBP的全称是Local Binary Pattern即局部二值模式,是局部信息提取中的一种方法,它具有旋转不变性和灰度不变性等显著的优点。在人脸识别领域有很多案例,此外,局部特征...
  • 人脸识别算法-LBP算法及python实现

    万次阅读 多人点赞 2015-06-08 20:12:40
    上一次我们说了人脸识别算法-特征脸方法(Eigenface)及python实现,在这一次,我们来看一看LBP算法。相比于特征脸方法,LBP的识别率已经有了很大的提升。 在这里,我们用的数据库和上次一样,都是UCI的YALE的人脸...
  • LBP特征及其变体和python实现

    千次阅读 2018-03-19 23:07:50
    LBP(Local Binary Pattern),局部二值模式,主要用于提取纹理特征,根据文献[1]我们可以了解到LBP及其变体。一般的使用方法是,先将图像转换为灰度图,接着计算LBP特征图,最后计算其直方图作为特征向量。 0.如何...
  • 1.2 纹理描述方法二、基于pythonLBP算法说明及实现2.1 LBP特征提取的一般步骤2.2 原始LBP2.3 圆形LBP算子2.5 旋转不变性2.4 等价模式和混合模式三、基于python-skimage的LBP实现四、基于python-opencv的LBP实现...
  • LBP特征提取算法 LBP(Local Binary Patterns,局部二值模式)是提取局部特征作为判别依据的,一种有效的纹理描述算子,度量和提取图像局部的纹理信息,它具有旋转不变性和灰度不变性等显著的优点,对光照具有不变性。...
  • python实现LBP方法提取图像纹理特征实现分类

    万次阅读 多人点赞 2017-04-06 21:58:45
    题目描述这篇博文是数字图像处理的大作业. 题目描述:给定40张不同风格的纹理图片,大小为512*512,要求将每张图片分为大小相同的9块,利用其中的5块...本文采用LBP的方法提取图像的纹理信息,然后转化成直方图作为图像的特

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,048
精华内容 819
关键字:

lbppython

python 订阅