Local Binary Pattern

Introduction

• In this article, we will look at the concept of Local Binary Pattern and computation of LBP image.
• 2D surface texture is characterized by spatial pattern and intensity/contrast.
• Spatial Pattern is affected by rotation, scale changes, hence for a good texture description we require a rotation and scale invariant descriptor.
• Local binary pattern binarizes the local neighborhood of each pixel and builds a histogram on these binary neighborhood patterns.
• Let P be the number of neighborhood pixels and R the distance from the center pixel $l_c$ and $l_p$ be neighborhood pixel.
• A $LBP_{P,R}$ number characterizes the local texture by assigning the binomial factor $2^P$ for each sign $sgn(l_p-l_c)$ \[ LBP_{P,R} = \sum_{p=0}^{P-1} sgn(l_p - l_c) 2^p \]
• $l_p$ for $p={0\ldots P-1}$ are a set of equally spaced pixels on a circle of radius $R$.
• $LBP_{P,R}$ features has $2^P$ possible values.For P=8 we have a binary feature vector of length $256$.
• Patterns are classified as uniform and non uniform.
• Uniform patterns have single contiguous regions of 0 and 1 while non uniform patterns do not. For example, 01100000 is a uniform pattern while 01010000 is an example of non uniform pattern
• We can see that there are 9 possible uniform pattern values

  0	0	0	0	0	0	0	0
  1	0	0	0	0	0	0	0
  1	1	0	0	0	0	0	0
  1	1	1	0	0	0	0	0
  1	1	1	1	0	0	0	0
  1	1	1	1	1	0	0	0
  1	1	1	1	1	1	0	0
  1	1	1	1	1	1	1	0
  1	1	1	1	1	1	1	1

• Now consider the effect of rotation on the feature vector.
• Rotating the image results in circular shift of values of feature vector.
• To incorporate rotational invariance, we need to assign all possible rotations of a feature vector to a single LBP value. For example, all the below patterns

  1	0	0	0	0	0	0	0
  0	1	0	0	0	0	0	0
  0	0	1	0	0	0	0	0
  0	0	0	1	0	0	0	0
  0	0	0	0	1	0	0	0
  0	0	0	0	0	1	0	0
  0	0	0	0	0	0	1	0
  0	0	0	0	0	0	0	1

  \\ will be assigned to a single value.
• In the present article however, we are not considering rotational invariant features
• Let us consider the implementation details of LBP
• If we only consider a 3x3 neighborhood, we need to threshold the rectangular region about
• Another method would be to divide image into square blocks of size BxB. Instead of central pixel value, we consider the mean value of pixels in the central block.
• Similarly, instead of considering the single pixel value in the neighborhood, we would consider the mean value of pixels in the block.
• All the pixels in the block are encoded with the same binary value 0 or 1.
• To compute mean value over rectangular regions of image, integral images are used.
• The output of lbp images for block size 1,2 and 8 is showing in figure f1

  

  

  f1

• We can see that as block size increases, quantization effects can be seen and the information in the encoded image cannot be recognized.

   <![CDATA[       
                   #include "ImgFeatures/integralImage.h" 
                   class LBPFeatures 
                   { 
                   public:     LBPFeatures(){};     
                   Mat image;     
                   vector<uchar> features;     
                   Mat mask;     
                   IntegralImage ix; //function to compute LBP image with block size 1     
                   void compute(Mat image,Mat &dst)     
                   {         
                   uchar *ptr=image.data;         
                   image.copyTo(dst);         
                   uchar *optr=dst.data;         
                   int width=image.cols;         
                   int height=image.rows;          
                   for(int i=1;i<height-1;i++) 
                   code|="((int)ptr[(j-1)+(i-1)*width]" 
                   code="0;" 
                   center="(int)ptr[j+i*width];" 
                   j="0;j<width-1;j++)">=center)<<7 ;                 
                   code|=((int)ptr[j+(i-1)*width] >=center)<<6 ;                 
                   code|=((int)ptr[(j+1)+(i-1)*width] >=center)<<5 ;                 
                   code|=((int)ptr[(j+1)+(i)*width] >=center)<<4 ;                 
                   code|=((int)ptr[(j+1)+(i+1)*width] >=center)<<3 ;                 
                   code|=((int)ptr[j+(i+1)*width] >=center)<<2 ;                 
                   code|=((int)ptr[j-1+(i+1)*width] >=center)<<1 ;                 
                   code|=((int)ptr[j-1+(i)*width] >=center)<<0 ;                 
                   optr[j+i*width]=code;             
                   }         
                   }      
                   }      //computing integral image for block     
                   void computeBlock(Mat image,Mat & dst,int block=2)     
                   {  //computing integral image         
                   ix.compute(image);         
                   image.copyTo(dst);         
                   dst.setTo(cv::Scalar::all(0));         
                   int width=image.cols;         
                   int height=image.rows;         
                   for(int i=block;i<height-block;i=i+block) 
                   code|="(meanv" code="0;" 
                   j="block;j<width-block;j=j+block)" 
                   val="(int)ix.calcMean(r1);" r1="Rect(x,y,block,block);" 
                   x="i;" y="j;" k="0;k<8;k++)" 
                   meanv="ix.calcMean(r);" 
                   r="Rect(j,i,block,block);">= val)<<(7-k);                  
                   }                 
                   Mat roi=dst(r);                 //setting value of all pixel in output                 
                   //image to the encoded value for visualization                 
                   roi.setTo(cv::Scalar::all(code));             
                   }         
                   }       
                   }  
                   }; 

• The code for the same can be found in the git repo for OpenVisionLibrary https://github.com/pi19404/OpenVision/ in the following files ImgFeatures/lbpfeatures.hpp and lbpFeatures.cpp.