标签：extend 处理 ges 声明 转变 降维 接口 计算 read
老规矩，先上背景，算是表示对LBP算法提出者的一种尊敬（其实，是为了装...kkk,大家都懂ha）。
一、LBP背景：
LBP（Local Binary Pattern，局部二值模式）是一种用来描述图像局部纹理特征的算子；它具有旋转不变性和灰度不变性等显著的优点。它是首先由T. Ojala, M.Pietikäinen, 和D. Harwood 在1994年提出，用于纹理特征提取。而且，提取的特征是图像的局部的纹理特征。至今，仍在图像识别和人脸识别部分，有很好的效果。
二、LBP特征的原理：
从94年T. Ojala, M.Pietikäinen, 和D. Harwood提出至今，LBP经历过多次的改进，以下根据时间顺序介绍：
FirstBleed：
原始的LBP算子定义为在3*3的窗口内，以窗口内的中心点的像素值为标准，对比窗口内其余8个元素的像数值大小，大于中心点的位置用1表示，小于为0。如此，3*3领域内的8个点恰可产生8为二进制数字（通常转化为十进制表示成LBP值）即为中心点的LBP特征值。
上图：
SecondBleed:
原始的LBP提出后，研究人员不断对其改进和优化，以下是改进点。
（一）：圆形LBP算子:
原始LBP算子固定为某个区域，在图像尺寸和频率纹理发生改变时，会出现很大的偏差，不能正确反映像素点周围的纹理信息。为适应不同尺寸的纹理特征，Ojal将圆形邻域替代正方形邻域。改进后的LBP允许半径为R的圆形邻域有任意多个特征点。从而得到诸如半径为R的圆形区域内含有P个采样点的LBP算子：
上图：
计算方法：
xt = xd + Rcos(2πp/P)
yt = yd - Rsin(2πp/P)
其中（xt,yt）为某个采样点，(xd,yd)为邻域中心点，p为第p个采样点，P为采样点的个数。通过上式可以得到想要的采样点的坐标。另：得到的采样点的坐标未必完全为整数，改进后的LBP采用双线性插值得到该采样点的像素值：
几种不同半径不同采样点数量的LBP算子：
（二）旋转不变LBP特征：
上面已具备灰度不变性（即尺寸大小不变性），还不具备旋转不变性，研究人员在上面的基础上进行扩展，提出了具有旋转不变性的LBP特征。
首先，不断旋转圆形领域内的采样点的位置，得到一系列的LBP特征值，从这些LBP特征值中选择最小的作为LBP中心像素点的LBP特征值。做法如下： 
如上图，进行旋转，最后得到LBP特征值为15.（旋转是改变采样点二进制位置）
（三）Uniform Pattern LBP特征：
Uniform Pattern LBP，也称为等价模式或均匀模式。对一个LBP特征，假设对于半径为R的圆形区域内含有P个采样点，则会产生2p二进制表达方法。随着邻域内采样点数目的增加，二进制模式的种类以指数形式增加，不利于纹理的提取、分类、识别及存取。为解决二进制模式过多的问题，Ojalar提出采用一种”等价模式“对LBP算子进行降维。在实际图像中，绝大多数LBP模式只包括从0到1或从1到0的转变。故Ojalar将”等价模式“定义为：当某个LBP所对应的二进制数从0到1或从1到0的转变最多有两次转变时，该LBP所对应的二进制就称为一个等价模式。如00000000（0次跳变）、00000111（1次跳变）、10001111（2次跳变）均为等价模式类。除等价模式类外的模式均归为混合模式类。通过这样，模式数量由原来的2p种减少为P（P-1）+2+1种（文章中大写P均代表采样点的数量）。
具体实现：
采样点数8个，即256个LBP特征值，分成59类：跳变0次——2个，跳变1次——0个，跳变2次——56个，跳变3次——0个，跳变4次——140个，跳变5次——0个，跳变6次——56个，跳变7次——0个，跳变8次——2个。
(四）MB-LBP特征：
MB-LBP特征，全称为Multiscale Block LBP,中科院的人发明，原理和HOG特征提取有相似之处。下面是原理介绍：
首先将图像分成一个个小块，再将每个小块分成一个个小的区域，小区域内的灰度值的平均值即为当前小区域的灰度值，与周围小区域灰度进行比较形成LBP特征，生成的LBP特征成为MB-LBP：如图：
同时，作者对得到的MB-LBP特征值进行均值模式编码，通过对得到的特征图求直方图，得到了LBP特征值0-255之间(0-255即直方图中的bin)的特征数量，通过对bin中的数值进行排序，通过权衡，将排序在前63位的特征值看作是等价模式类，其他的为混合模式类，总共64类，作者在论文中称之为SEMB-LBP(Statistically Effective MB-LBP )。（在此介绍一下直方图方法，首先得到的LBP特征值的二进制最多256种，而后对整个图像的LBP特征值的二进制统计、排序，前63位即为等价模式，后面均为混合模式类）。类似于等价模式LBP，等价模式的LBP的等价模式类为58种，混合模式类1种，共59种。二者除了等价模式类的数量不同之外，主要区别在于：对等价模式类的定义不同，等价模式LBP是根据0-1的跳变次数定义的，而SEMB-LBP是通过对直方图排序得到的。
ThirdBleed:
LBPH——图像的LBP特征向量：
LBPH，Local Binary Patterns Histograms，即LBP特征的统计直方图，LBPH将LBP特征与图像的空间信息结合在一起。这种表示方法由Ahonen等人在论文[3]中提出，他们将LBP特征图像分成m个局部块，并提取每个局部块的直方图，然后将这些直方图依次连接在一起形成LBP特征的统计直方图，即LBPH。
一幅图像具体的计算LBPH的过程（以Opencv中的人脸识别为例）：
1. 计算图像的LBP特征图像，已经介绍。
2. 将LBP特征图像进行分块，Opencv中默认将LBP特征图像分成8行8列64块区域
3. 计算每块区域特征图像的直方图cell_LBPH，将直方图进行归一化，直方图大小为1*numPatterns
4. 将上面计算的每块区域特征图像的直方图按分块的空间顺序依次排列成一行，形成LBP特征向量，大小为1*（numPatterns*64）
5. 用机器学习的方法对LBP特征向量进行训练，用来检测和识别目标
举例说明LBPH的维度：
采样点为8个，如果用的是原始的LBP或Extended LBP特征，其LBP特征值的模式为256种，则一幅图像的LBP特征向量维度为：64*256=16384维，
而如果使用的UniformPatternLBP特征，其LBP值的模式为59种，其特征向量维度为：64*59=3776维，可以看出，使用等价模式特征，其特征向量的维度大大减少，
这意味着使用机器学习方法进行学习的时间将大大减少，而性能上没有受到很大影响。
下面，进入一篇一次的源代码和实战环节，上代码：
实战环节：
目前，Opencv内，暂无LBP简便的接口函数，如若使用，可复制上面代码，或下面例子。
LBP在人脸识别部分的应用：
#include<iostream> #include<opencv2\core\core.hpp> #include<opencv2\highgui\highgui.hpp> #include<opencv2\imgproc\imgproc.hpp> #include<opencv2\contrib\contrib.hpp> using namespace std; using namespace cv; int main(int argc,char* argv[]) { vector<Mat> images; vector<int> labels; char buff[10]; for(int i=1;i<8;i++) { sprintf(buff,"0%d.tif",i); Mat image = imread(buff); Mat grayImage; cvtColor(image,grayImage,COLOR_BGR2GRAY); images.push_back(grayImage); labels.push_back(1); } for(int i=8;i<12;i++) { sprintf(buff,"0%d.tif",i); Mat image = imread(buff); Mat grayImage; cvtColor(image,grayImage,COLOR_BGR2GRAY); images.push_back(grayImage); labels.push_back(2); } Ptr<FaceRecognizer> p = createLBPHFaceRecognizer(); p->train(images,labels); Mat test= imread("12.tif"); Mat grayImage; cvtColor(test,grayImage,COLOR_BGR2GRAY); int result = p->predict(grayImage); cout<<result<<endl; system("pause"); return 0; }
原始LBP特征计算代码：
template <typename _tp> void getOriginLBPFeature(InputArray _src,OutputArray _dst) { Mat src = _src.getMat(); _dst.create(src.rows-2,src.cols-2,CV_8UC1); Mat dst = _dst.getMat(); dst.setTo(0); 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 lbpCode = 0; lbpCode |= (src.at<_tp>(i-1,j-1) > center) << 7; lbpCode |= (src.at<_tp>(i-1,j ) > center) << 6; lbpCode |= (src.at<_tp>(i-1,j+1) > center) << 5; lbpCode |= (src.at<_tp>(i ,j+1) > center) << 4; lbpCode |= (src.at<_tp>(i+1,j+1) > center) << 3; lbpCode |= (src.at<_tp>(i+1,j ) > center) << 2; lbpCode |= (src.at<_tp>(i+1,j-1) > center) << 1; lbpCode |= (src.at<_tp>(i ,j-1) > center) << 0; dst.at<uchar>(i-1,j-1) = lbpCode; } } }
圆形LBP特征计算：
template <typename _tp> void getCircularLBPFeature(InputArray _src,OutputArray _dst,int radius,int neighbors) { Mat src = _src.getMat(); //LBP特征图像的行数和列数的计算要准确 _dst.create(src.rows-2*radius,src.cols-2*radius,CV_8UC1); Mat dst = _dst.getMat(); dst.setTo(0); //循环处理每个像素 for(int i=radius;i<src.rows-radius;i++) { for(int j=radius;j<src.cols-radius;j++) { //获得中心像素点的灰度值 _tp center = src.at<_tp>(i,j); unsigned char lbpCode = 0; for(int k=0;k<neighbors;k++) { //根据公式计算第k个采样点的坐标，这个地方可以优化，不必每次都进行计算radius*cos，radius*sin float x = i + static_cast<float>(radius * cos(2.0 * CV_PI * k / neighbors)); float y = j - static_cast<float>(radius * sin(2.0 * CV_PI * k / neighbors)); //根据取整结果进行双线性插值，得到第k个采样点的灰度值 //1.分别对x，y进行上下取整 int x1 = static_cast<int>(floor(x)); int x2 = static_cast<int>(ceil(x)); int y1 = static_cast<int>(floor(y)); int y2 = static_cast<int>(ceil(y)); //2.计算四个点(x1,y1),(x1,y2),(x2,y1),(x2,y2)的权重 //下面的权重计算方式有个问题，如果四个点都相等，则权重全为0，计算出来的插值为0 //float w1 = (x2-x)*(y2-y); //(x1,y1) //float w2 = (x2-x)*(y-y1); //(x1,y2) //float w3 = (x-x1)*(y2-y); //(x2,y1) //float w4 = (x-x1)*(y-y1); //(x2,y2) //将坐标映射到0-1之间 float tx = x - x1; float ty = y - y1; //根据0-1之间的x，y的权重计算公式计算权重 float w1 = (1-tx) * (1-ty); float w2 = tx * (1-ty); float w3 = (1-tx) * ty; float w4 = tx * ty; //3.根据双线性插值公式计算第k个采样点的灰度值 float neighbor = src.at<_tp>(x1,y1) * w1 + src.at<_tp>(x1,y2) *w2 + src.at<_tp>(x2,y1) * w3 +src.at<_tp>(x2,y2) *w4; //通过比较获得LBP值，并按顺序排列起来 lbpCode |= (neighbor>center) <<(neighbors-k-1); } dst.at<uchar>(i-radius,j-radius) = lbpCode; } } } //圆形LBP特征计算，效率优化版本，声明时默认neighbors=8 template <typename _tp> void getCircularLBPFeatureOptimization(InputArray _src,OutputArray _dst,int radius,int neighbors) { Mat src = _src.getMat(); //LBP特征图像的行数和列数的计算要准确 _dst.create(src.rows-2*radius,src.cols-2*radius,CV_8UC1); Mat dst = _dst.getMat(); dst.setTo(0); for(int k=0;k<neighbors;k++) { //计算采样点对于中心点坐标的偏移量rx，ry float rx = static_cast<float>(radius * cos(2.0 * CV_PI * k / neighbors)); float ry = -static_cast<float>(radius * sin(2.0 * CV_PI * k / neighbors)); //为双线性插值做准备 //对采样点偏移量分别进行上下取整 int x1 = static_cast<int>(floor(rx)); int x2 = static_cast<int>(ceil(rx)); int y1 = static_cast<int>(floor(ry)); int y2 = static_cast<int>(ceil(ry)); //将坐标偏移量映射到0-1之间 float tx = rx - x1; float ty = ry - y1; //根据0-1之间的x，y的权重计算公式计算权重，权重与坐标具体位置无关，与坐标间的差值有关 float w1 = (1-tx) * (1-ty); float w2 = tx * (1-ty); float w3 = (1-tx) * ty; float w4 = tx * ty; //循环处理每个像素 for(int i=radius;i<src.rows-radius;i++) { for(int j=radius;j<src.cols-radius;j++) { //获得中心像素点的灰度值 _tp center = src.at<_tp>(i,j); //根据双线性插值公式计算第k个采样点的灰度值 float neighbor = src.at<_tp>(i+x1,j+y1) * w1 + src.at<_tp>(i+x1,j+y2) *w2 + src.at<_tp>(i+x2,j+y1) * w3 +src.at<_tp>(i+x2,j+y2) *w4; //LBP特征图像的每个邻居的LBP值累加，累加通过与操作完成，对应的LBP值通过移位取得 dst.at<uchar>(i-radius,j-radius) |= (neighbor>center) <<(neighbors-k-1); } } } }
旋转不变圆形LBP特征计算：
template <typename _tp> void getRotationInvariantLBPFeature(InputArray _src,OutputArray _dst,int radius,int neighbors) { Mat src = _src.getMat(); //LBP特征图像的行数和列数的计算要准确 _dst.create(src.rows-2*radius,src.cols-2*radius,CV_8UC1); Mat dst = _dst.getMat(); dst.setTo(0); for(int k=0;k<neighbors;k++) { //计算采样点对于中心点坐标的偏移量rx，ry float rx = static_cast<float>(radius * cos(2.0 * CV_PI * k / neighbors)); float ry = -static_cast<float>(radius * sin(2.0 * CV_PI * k / neighbors)); //为双线性插值做准备 //对采样点偏移量分别进行上下取整 int x1 = static_cast<int>(floor(rx)); int x2 = static_cast<int>(ceil(rx)); int y1 = static_cast<int>(floor(ry)); int y2 = static_cast<int>(ceil(ry)); //将坐标偏移量映射到0-1之间 float tx = rx - x1; float ty = ry - y1; //根据0-1之间的x，y的权重计算公式计算权重，权重与坐标具体位置无关，与坐标间的差值有关 float w1 = (1-tx) * (1-ty); float w2 = tx * (1-ty); float w3 = (1-tx) * ty; float w4 = tx * ty; //循环处理每个像素 for(int i=radius;i<src.rows-radius;i++) { for(int j=radius;j<src.cols-radius;j++) { //获得中心像素点的灰度值 _tp center = src.at<_tp>(i,j); //根据双线性插值公式计算第k个采样点的灰度值 float neighbor = src.at<_tp>(i+x1,j+y1) * w1 + src.at<_tp>(i+x1,j+y2) *w2 + src.at<_tp>(i+x2,j+y1) * w3 +src.at<_tp>(i+x2,j+y2) *w4; //LBP特征图像的每个邻居的LBP值累加，累加通过与操作完成，对应的LBP值通过移位取得 dst.at<uchar>(i-radius,j-radius) |= (neighbor>center) <<(neighbors-k-1); } } } //进行旋转不变处理 for(int i=0;i<dst.rows;i++) { for(int j=0;j<dst.cols;j++) { unsigned char currentValue = dst.at<uchar>(i,j); unsigned char minValue = currentValue; for(int k=1;k<neighbors;k++) { //循环左移 unsigned char temp = (currentValue>>(neighbors-k)) | (currentValue<<k); if(temp < minValue) { minValue = temp; } } dst.at<uchar>(i,j) = minValue; } } }
均匀（等价）模式：
template <typename _tp> void getUniformPatternLBPFeature(InputArray _src,OutputArray _dst,int radius,int neighbors) { Mat src = _src.getMat(); //LBP特征图像的行数和列数的计算要准确 _dst.create(src.rows-2*radius,src.cols-2*radius,CV_8UC1); Mat dst = _dst.getMat(); dst.setTo(0); //LBP特征值对应图像灰度编码表，直接默认采样点为8位 uchar temp = 1; uchar table[256] = {0}; for(int i=0;i<256;i++) { if(getHopTimes(i)<3) { table[i] = temp; temp++; } } //是否进行UniformPattern编码的标志 bool flag = false; //计算LBP特征图 for(int k=0;k<neighbors;k++) { if(k==neighbors-1) { flag = true; } //计算采样点对于中心点坐标的偏移量rx，ry float rx = static_cast<float>(radius * cos(2.0 * CV_PI * k / neighbors)); float ry = -static_cast<float>(radius * sin(2.0 * CV_PI * k / neighbors)); //为双线性插值做准备 //对采样点偏移量分别进行上下取整 int x1 = static_cast<int>(floor(rx)); int x2 = static_cast<int>(ceil(rx)); int y1 = static_cast<int>(floor(ry)); int y2 = static_cast<int>(ceil(ry)); //将坐标偏移量映射到0-1之间 float tx = rx - x1; float ty = ry - y1; //根据0-1之间的x，y的权重计算公式计算权重，权重与坐标具体位置无关，与坐标间的差值有关 float w1 = (1-tx) * (1-ty); float w2 = tx * (1-ty); float w3 = (1-tx) * ty; float w4 = tx * ty; //循环处理每个像素 for(int i=radius;i<src.rows-radius;i++) { for(int j=radius;j<src.cols-radius;j++) { //获得中心像素点的灰度值 _tp center = src.at<_tp>(i,j); //根据双线性插值公式计算第k个采样点的灰度值 float neighbor = src.at<_tp>(i+x1,j+y1) * w1 + src.at<_tp>(i+x1,j+y2) *w2 + src.at<_tp>(i+x2,j+y1) * w3 +src.at<_tp>(i+x2,j+y2) *w4; //LBP特征图像的每个邻居的LBP值累加，累加通过与操作完成，对应的LBP值通过移位取得 dst.at<uchar>(i-radius,j-radius) |= (neighbor>center) <<(neighbors-k-1); //进行LBP特征的UniformPattern编码 if(flag) { dst.at<uchar>(i-radius,j-radius) = table[dst.at<uchar>(i-radius,j-radius)]; } } } } } //计算跳变次数 int getHopTimes(int n) { int count = 0; bitset<8> binaryCode = n; for(int i=0;i<8;i++) { if(binaryCode[i] != binaryCode[(i+1)%8]) { count++; } } return count; }
MB-LBP代码：
//MB-LBP特征的计算 void getMultiScaleBlockLBPFeature(InputArray _src,OutputArray _dst,int scale) { Mat src = _src.getMat(); Mat dst = _dst.getMat(); //定义并计算积分图像 int cellSize = scale / 3; int offset = cellSize / 2; Mat cellImage(src.rows-2*offset,src.cols-2*offset,CV_8UC1); for(int i=offset;i<src.rows-offset;i++) { for(int j=offset;j<src.cols-offset;j++) { int temp = 0; for(int m=-offset;m<offset+1;m++) { for(int n=-offset;n<offset+1;n++) { temp += src.at<uchar>(i+n,j+m); } } temp /= (cellSize*cellSize); cellImage.at<uchar>(i-cellSize/2,j-cellSize/2) = uchar(temp); } } getOriginLBPFeature<uchar>(cellImage,dst); }
MB-LBP编码的计算：
//求SEMB-LBP void SEMB_LBPFeature(InputArray _src,OutputArray _dst,int scale) { Mat dst=_dst.getMat(); Mat MB_LBPImage; getMultiScaleBlockLBPFeature(_src,MB_LBPImage,scale); //imshow("dst",dst); Mat histMat; int histSize = 256; float range[] = {float(0),float(255)}; const float* ranges = {range}; //计算LBP特征值0-255的直方图 calcHist(&MB_LBPImage,1,0,Mat(),histMat,1,&histSize,&ranges,true,false); histMat.reshape(1,1); vector<float> histVector(histMat.rows*histMat.cols); uchar table[256]; memset(table,64,256); if(histMat.isContinuous()) { //histVector = (int *)(histMat.data); //将直方图histMat变为vector向量histVector histVector.assign((float*)histMat.datastart,(float*)histMat.dataend); vector<float> histVectorCopy(histVector); //对histVector进行排序，即对LBP特征值的数量进行排序，降序排列 sort(histVector.begin(),histVector.end(),greater<float>()); for(int i=0;i<63;i++) { for(int j=0;j<histVectorCopy.size();j++) { if(histVectorCopy[j]==histVector[i]) { //得到类似于Uniform的编码表 table[j]=i; } } } } dst = MB_LBPImage; //根据编码表得到SEMB-LBP for(int i=0;i<dst.rows;i++) { for(int j=0;j<dst.cols;j++) { dst.at<uchar>(i,j) = table[dst.at<uchar>(i,j)]; } } }
LBPH特征图像的计算：
//计算LBP特征图像的直方图LBPH Mat getLBPH(InputArray _src,int numPatterns,int grid_x,int grid_y,bool normed) { Mat src = _src.getMat(); int width = src.cols / grid_x; int height = src.rows / grid_y; //定义LBPH的行和列，grid_x*grid_y表示将图像分割成这么些块，numPatterns表示LBP值的模式种类 Mat result = Mat::zeros(grid_x * grid_y,numPatterns,CV_32FC1); if(src.empty()) { return result.reshape(1,1); } int resultRowIndex = 0; //对图像进行分割，分割成grid_x*grid_y块，grid_x，grid_y默认为8 for(int i=0;i<grid_x;i++) { for(int j=0;j<grid_y;j++) { //图像分块 Mat src_cell = Mat(src,Range(i*height,(i+1)*height),Range(j*width,(j+1)*width)); //计算直方图 Mat hist_cell = getLocalRegionLBPH(src_cell,0,(numPattern-1),true); //将直方图放到result中 Mat rowResult = result.row(resultRowIndex); hist_cell.reshape(1,1).convertTo(rowResult,CV_32FC1); resultRowIndex++; } } return result.reshape(1,1); } //计算一个LBP特征图像块的直方图 Mat getLocalRegionLBPH(const Mat& src,int minValue,int maxValue,bool normed) { //定义存储直方图的矩阵 Mat result; //计算得到直方图bin的数目，直方图数组的大小 int histSize = maxValue - minValue + 1; //定义直方图每一维的bin的变化范围 float range[] = { static_cast<float>(minValue),static_cast<float>(maxValue + 1) }; //定义直方图所有bin的变化范围 const float* ranges = { range }; //计算直方图，src是要计算直方图的图像，1是要计算直方图的图像数目，0是计算直方图所用的图像的通道序号，从0索引 //Mat()是要用的掩模，result为输出的直方图，1为输出的直方图的维度，histSize直方图在每一维的变化范围 //ranges，所有直方图的变化范围（起点和终点） calcHist(&src,1,0,Mat(),result,1,&histSize,&ranges,true,false); //归一化 if(normed) { result /= (int)src.total(); } //结果表示成只有1行的矩阵 return result.reshape(1,1); }
标签：extend 处理 ges 声明 转变 降维 接口 计算 read
原文地址：https://www.cnblogs.com/urglyfish/p/12424087.html
