LBP詳細解釋-有opencv代碼解釋

沒有看LBP之前覺得它很神祕，看完了之後也就那麼回事，不過提出LBP的人確實很偉大！！ 

LBP（Local Binary Pattern，局部二值模式）是一種用來描述圖像局部紋理特徵的算子；它具有旋轉不變性和灰度不變性等顯著的優點。它是首先由T. Ojala, M.Pietikäinen, 和D. Harwood 在1994年提出，用於紋理特徵提取。而且，提取的特徵是圖像的局部的紋理特徵；

 

1、LBP特徵的描述

       原始的LBP算子定義爲在3*3的窗口內，以窗口中心像素爲閾值，將相鄰的8個像素的灰度值與其進行比較，若周圍像素值大於中心像素值，則該像素點的位置被標記爲1，否則爲0。這樣，3*3鄰域內的8個點經比較可產生8位二進制數（通常轉換爲十進制數即LBP碼，共256種），即得到該窗口中心像素點的LBP值，並用這個值來反映該區域的紋理信息。如下圖所示：

LBP的改進版本：

       原始的LBP提出後，研究人員不斷對其提出了各種改進和優化。

（1）圓形LBP算子：

        基本的 LBP 算子的最大缺陷在於它只覆蓋了一個固定半徑範圍內的小區域，這顯然不能滿足不同尺寸和頻率紋理的需要。爲了適應不同尺度的紋理特徵，並達到灰度和旋轉不變性的要求，Ojala 等對 LBP 算子進行了改進，將 3×3 鄰域擴展到任意鄰域，並用圓形鄰域代替了正方形鄰域，改進後的 LBP 算子允許在半徑爲 R 的圓形鄰域內有任意多個像素點。從而得到了諸如半徑爲R的圓形區域內含有P個採樣點的LBP算子；

（2）LBP旋轉不變模式

       從 LBP 的定義可以看出，LBP 算子是灰度不變的，但卻不是旋轉不變的。圖像的旋轉就會得到不同的 LBP值。

         Maenpaa等人又將 LBP 算子進行了擴展，提出了具有旋轉不變性的 LBP 算子，即不斷旋轉圓形鄰域得到一系列初始定義的 LBP 值，取其最小值作爲該鄰域的 LBP 值。

       圖 2.5 給出了求取旋轉不變的 LBP 的過程示意圖，圖中算子下方的數字表示該算子對應的 LBP 值，圖中所示的 8 種 LBP模式，經過旋轉不變的處理，最終得到的具有旋轉不變性的 LBP 值爲 15。也就是說，圖中的 8 種 LBP 模式對應的旋轉不變的 LBP 模式都是00001111。

（3）LBP等價模式

       一個LBP算子可以產生不同的二進制模式，對於半徑爲R的圓形區域內含有P個採樣點的LBP算子將會產生P² 種模式。很顯然，隨着鄰域集內採樣點數的增加，二進制模式的種類是急劇增加的。例如：5×5鄰域內20個採樣點，有2²⁰＝1,048,576種二進制模式。如此多的二值模式無論對於紋理的提取還是對於紋理的識別、分類及信息的存取都是不利的。同時，過多的模式種類對於紋理的表達是不利的。例如，將LBP算子用於紋理分類或人臉識別時，常採用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（共四次跳變）（這是我的個人理解，不知道對不對）。

       通過這樣的改進，二進制模式的種類大大減少，而不會丟失任何信息。模式數量由原來的2^P種減少爲 P ( P-1)+2種，其中P表示鄰域集內的採樣點數。對於3×3鄰域內8個採樣點來說，二進制模式由原始的256種減少爲58種，這使得特徵向量的維數更少，並且可以減少高頻噪聲帶來的影響。

 

2、LBP特徵用於檢測的原理

       顯而易見的是，上述提取的LBP算子在每個像素點都可以得到一個LBP“編碼”，那麼，對一幅圖像（記錄的是每個像素點的灰度值）提取其原始的LBP算子之後，得到的原始LBP特徵依然是“一幅圖片”（記錄的是每個像素點的LBP值）。

從上圖可以看出LBP對光照具有很強的魯棒性

        LBP的應用中，如紋理分類、人臉分析等，一般都不將LBP圖譜作爲特徵向量用於分類識別，而是採用LBP特徵譜的統計直方圖作爲特徵向量用於分類識別。

       因爲，從上面的分析我們可以看出，這個“特徵”跟位置信息是緊密相關的。直接對兩幅圖片提取這種“特徵”，並進行判別分析的話，會因爲“位置沒有對準”而產生很大的誤差。後來，研究人員發現，可以將一幅圖片劃分爲若干的子區域，對每個子區域內的每個像素點都提取LBP特徵，然後，在每個子區域內建立LBP特徵的統計直方圖。如此一來，每個子區域，就可以用一個統計直方圖來進行描述；整個圖片就由若干個統計直方圖組成；

        例如：一幅100*100像素大小的圖片，劃分爲10*10=100個子區域（可以通過多種方式來劃分區域），每個子區域的大小爲10*10像素；在每個子區域內的每個像素點，提取其LBP特徵，然後，建立統計直方圖；這樣，這幅圖片就有10*10個子區域，也就有了10*10個統計直方圖，利用這10*10個統計直方圖，就可以描述這幅圖片了。之後，我們利用各種相似性度量函數，就可以判斷兩幅圖像之間的相似性了；

 

3、對LBP特徵向量進行提取的步驟

（1）首先將檢測窗口劃分爲16×16的小區域（cell）；

（2）對於每個cell中的一個像素，將相鄰的8個像素的灰度值與其進行比較，若周圍像素值大於中心像素值，則該像素點的位置被標記爲1，否則爲0。這樣，3*3鄰域內的8個點經比較可產生8位二進制數，即得到該窗口中心像素點的LBP值；

（3）然後計算每個cell的直方圖，即每個數字（假定是十進制數LBP值）出現的頻率；然後對該直方圖進行歸一化處理。

（4）最後將得到的每個cell的統計直方圖進行連接成爲一個特徵向量，也就是整幅圖的LBP紋理特徵向量；

然後便可利用SVM或者其他機器學習算法進行分類了。

Reference：

黃非非，基於 LBP 的人臉識別研究，重慶大學碩士學位論文，2009.5

4 opencv中如何提取LBP特徵

（1） opencv1.0中LBP的實現-原始LBP特徵

從下面的實現過程可以看出，忽略了邊緣的影響，而且dst必須是提前分配好的，與src尺寸一致的圖像

//基於舊版本的opencv的LBP算法opencv1.0
void LBP (IplImage *src,IplImage *dst)
{
    int tmp[8]={0};
    CvScalar s;

    IplImage * temp = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U,1);
    uchar *data=(uchar*)src->imageData;
    int step=src->widthStep;
 // 圖像位寬

    cout<<"step"<<step<<endl;

    for (int i=1;i<src->height-1;i++)
      for(int j=1;j<src->width-1;j++)
      {
          int sum=0;
          if(data[(i-1)*step+j-1]>data[i*step+j])
 // 左上角
            tmp[0]=1;

          if(data[i*step+(j-1)]>data[i*step+j])
  // 上方
            tmp[1]=1;

          if(data[(i+1)*step+(j-1)]>data[i*step+j])
 // 右上角
            tmp[2]=1;

          if (data[(i+1)*step+j]>data[i*step+j])
 // 右側
            tmp[3]=1;

          if (data[(i+1)*step+(j+1)]>data[i*step+j])
 // 右下角
            tmp[4]=1;

          if(data[i*step+(j+1)]>data[i*step+j])
 // 下方
            tmp[5]=1;

          if(data[(i-1)*step+(j+1)]>data[i*step+j])
 // 左下角
            tmp[6]=1;

          if(data[(i-1)*step+j]>data[i*step+j])
 // 左側
            tmp[7]=1;

          //計算LBP編碼
            s.val[0]=(tmp[0]*1+tmp[1]*2+tmp[2]*4+tmp[3]*8+tmp[4]*16+tmp[5]*32+tmp[6]*64+tmp[7]*128);
            cvSet2D(dst,i,j,s);寫入LBP圖像

      }
}

（2）後期版本的LBP

a 圓形LBP算子

// src爲輸入圖像，dst爲輸出圖像，radius爲半徑，neighbor爲計算當前點LBP所需的鄰域像素點數，也就是樣本點個數

template <typename _Tp> static // 模板函數，根據不同的原始數據類型得到不同的結果

inline void elbp_(InputArray _src, OutputArray _dst, int radius, int neighbors) 

{

    //get matrices

    Mat src = _src.getMat();

    // allocate memory for result因此不用在外部給_dst分配內存空間，輸出數據類型都是int

    _dst.create(src.rows-2*radius, src.cols-2*radius, CV_32SC1);

    Mat dst = _dst.getMat();

    // zero

    dst.setTo(0);

    for(int n=0; n<neighbors; n++) 

    {

        // sample points 獲取當前採樣點

        float x = static_cast<float>(-radius) * sin(2.0*CV_PI*n/static_cast<float>(neighbors));

        float y = static_cast<float>(radius) * cos(2.0*CV_PI*n/static_cast<float>(neighbors));

        // relative indices 下取整和上取整

        int fx = static_cast<int>(floor(x)); // 向下取整

        int fy = static_cast<int>(floor(y));

        int cx = static_cast<int>(ceil(x));  // 向上取整

        int cy = static_cast<int>(ceil(y));

        // fractional part 小數部分

        float tx = x - fx;

        float ty = y - fy;

        // set interpolation weights 設置四個點的插值權重

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

        float w2 =      tx  * (1 - ty);

        float w3 = (1 - tx) *      ty;

        float w4 =      tx  *      ty;

        // iterate through your data 循環處理圖像數據

        for(int i=radius; i < src.rows-radius;i++) 

        {

            for(int j=radius;j < src.cols-radius;j++) 

            {

                // calculate interpolated value 計算插值，t表示四個點的權重和

                float t = w1*src.at<_Tp>(i+fy,j+fx) + 

w2*src.at<_Tp>(i+fy,j+cx) + 

w3*src.at<_Tp>(i+cy,j+fx) + 

w4*src.at<_Tp>(i+cy,j+cx);

                // floating point precision, so check some machine-dependent epsilon

                // std::numeric_limits<float>::epsilon()=1.192092896e-07F

                // 當t>=src(i,j)的時候取1，並進行相應的移位

                dst.at<int>(i-radius,j-radius) += ((t > src.at<_Tp>(i,j)) || 

                            (std::abs(t-src.at<_Tp>(i,j)) < std::numeric_limits<float>::epsilon())) << n;

            }

        }

    }

}

// 外部接口，根據不同的數據類型調用模板函數

static void elbp(InputArray src, OutputArray dst, int radius, int neighbors)

{

    int type = src.type();

    switch (type) {

    case CV_8SC1:   elbp_<char>(src,dst, radius, neighbors); break;

    case CV_8UC1:   elbp_<unsigned char>(src, dst, radius, neighbors); break;

    case CV_16SC1:  elbp_<short>(src,dst, radius, neighbors); break;

    case CV_16UC1:  elbp_<unsigned short>(src,dst, radius, neighbors); break;

    case CV_32SC1:  elbp_<int>(src,dst, radius, neighbors); break;

    case CV_32FC1:  elbp_<float>(src,dst, radius, neighbors); break;

    case CV_64FC1:  elbp_<double>(src,dst, radius, neighbors); break;

    default:

        string error_msg = format("Using Circle Local Binary Patterns for feature extraction only works                                     on single-channel images (given %d). Please pass the image data as a grayscale image!", type);

        CV_Error(CV_StsNotImplemented, error_msg);

        break;

    }

}

Mat cv::elbp(InputArray src, int radius, int neighbors) {

    Mat dst;

    elbp(src, dst, radius, neighbors);

    return dst;

}

b 原始LBP算子

// 原始LBP算子只是計算8鄰域內的局部二值模式

template <typename _Tp> static

void olbp_(InputArray _src, OutputArray _dst) {

    // get matrices

    Mat src = _src.getMat();

    // allocate memory for result

    _dst.create(src.rows-2, src.cols-2, CV_8UC1);

    Mat dst = _dst.getMat();

    // zero the result matrix

    dst.setTo(0);

    // calculate patterns

    for(int i=1;i<src.rows-1;i++) 

    {

        for(int j=1;j<src.cols-1;j++)

        {

            _Tp center = src.at<_Tp>(i,j);

            unsigned char code = 0;

            code |= (src.at<_Tp>(i-1,j-1) >= center) << 7;

            code |= (src.at<_Tp>(i-1,j) >= center) << 6;

            code |= (src.at<_Tp>(i-1,j+1) >= center) << 5;

            code |= (src.at<_Tp>(i,j+1) >= center) << 4;

            code |= (src.at<_Tp>(i+1,j+1) >= center) << 3;

            code |= (src.at<_Tp>(i+1,j) >= center) << 2;

            code |= (src.at<_Tp>(i+1,j-1) >= center) << 1;

            code |= (src.at<_Tp>(i,j-1) >= center) << 0;

            dst.at<unsigned char>(i-1,j-1) = code;

        }

    }

}

// 外部接口，根據不同的數據類型調用模板函數

void cv::olbp(InputArray src, OutputArray dst) {

    switch (src.getMat().type()) {

    case CV_8SC1:   olbp_<char>(src,dst); break;

    case CV_8UC1:   olbp_<unsigned char>(src,dst); break;

    case CV_16SC1:  olbp_<short>(src,dst); break;

    case CV_16UC1:  olbp_<unsigned short>(src,dst); break;

    case CV_32SC1:  olbp_<int>(src,dst); break;

    case CV_32FC1:  olbp_<float>(src,dst); break;

    case CV_64FC1:  olbp_<double>(src,dst); break;

    default: 

        string error_msg = format("Using Original Local Binary Patterns for feature extraction only works                                     on single-channel images (given %d). Please pass the image data as a grayscale image!", type);

        CV_Error(CV_StsNotImplemented, error_msg);

        break;

    }

}

Mat cv::olbp(InputArray src) {

    Mat dst;

    olbp(src, dst);

    return dst;

}

注意：

1 Opencv1.0中原始LBP在處理相等的時候按照0進行處理，而在Opencv以後的版本中是按照1進行處理的

2 opencv1.0中輸出LBP Map與源圖像同等尺寸，而opencv以後的版本中原始LBP算子輸出的結果比原始圖像長寬上

各小2個像素

3 對於elbp中當radius=1,neighbor=8的時候和olbp得到的結果不是一樣的，實驗結果如下：

第三張圖像爲radius=2,neighbor=16的elbp圖像

第四張圖像爲radius=2,neighbor=8的elbp圖像

從上面的結果可以看出，選擇不同的radius和neighbor有很大的差別

(3) 計算整幅圖像的LBPH

// 計算LBPM的空間直方圖分佈，得到一個一維向量

// src爲LBPM是通過olbp或者elbp計算得到的

// numPatterns爲計算LBP的模式數目，一般爲2的冪

// grid_x和grid_y分別爲每行或每列的block個數

// normed爲是否進行歸一化處理

static Mat spatial_histogram(InputArray _src, int numPatterns,

                             int grid_x, int grid_y, bool normed)

{

    Mat src = _src.getMat();

    // allocate memory for the spatial histogram爲LBPH分配內存空間

    Mat result = Mat::zeros(grid_x * grid_y, numPatterns, CV_32FC1);

    // return matrix with zeros if no data was given，如果沒有輸入數據，返回的是0

    if(src.empty())

        return result.reshape(1,1);

    // calculate LBP patch size block的尺寸

    int width = src.cols/grid_x;

    int height = src.rows/grid_y;

    // initial result_row 初始化結果行

    int resultRowIdx = 0;

    // iterate through grid

    for(int i = 0; i < grid_y; i++) 

    {

        for(int j = 0; j < grid_x; j++)

         {

            // 獲取指定區域

            Mat src_cell = Mat(src, Range(i*height,(i+1)*height), Range(j*width,(j+1)*width));

            // 計算指定區域的直方圖

            Mat cell_hist = histc(src_cell, 0, (numPatterns-1), true);

            // copy to the result matrix 將計算得到的結果拷貝到每一行

            Mat result_row = result.row(resultRowIdx);

            cell_hist.reshape(1,1).convertTo(result_row, CV_32FC1);

            // increase row count in result matrix

            resultRowIdx++;

        }

    }

    // return result as reshaped feature vector

    return result.reshape(1,1);

}

（4） 從image到LBPH

int radius = 1;

int neighbor = 8;

Mat lbp_image = elbp(cv::cvarrToMat(m_refFaceImg), radius, neighbor); //robust performance

Mat query = spatial_histogram(

lbp_image, /* lbp_image */

m_numPatterns, /* number of possible patterns可爲static_cast<int>(std::pow(2.0, static_cast<double>(_neighbors)))*/

m_grid_x, /* grid size x */

m_grid_y, /* grid size y */

true /* normed histograms */

);