c++图像处理（二十）局部二进制模式 LBP特征提取

LBP特征提取

原理：
（一）LBP特征的描述
　　原始的LBP算子定义为在33的窗口内，以窗口中心像素为阈值，将相邻的8个像素的灰度值与其进行比较，若周围像素值大于中心像素值，则该像素点的位置被标记为1，否则为0。这样，33邻域内的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算子将会产生2P种模式。很显然，随着邻域集内采样点数的增加，二进制模式的种类是急剧增加的。例如：5×5邻域内20个采样点，有220＝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（共四次跳变）（这是我的个人理解，不知道对不对）。
　　通过这样的改进，二进制模式的种类大大减少，而不会丢失任何信息。模式数量由原来的2P种减少为 P ( P-1)+2种，其中P表示邻域集内的采样点数。对于3×3邻域内8个采样点来说，二进制模式由原始的256种减少为58种，这使得特征向量的维数更少，并且可以减少高频噪声带来的影响。

代码：

原始的LBP算子

//原始的LBP算子
void Original_LBP(const QImage &image,QImage &otp)
{
    int width = image.width();
    int height = image.height();
    QImage* deal_image = new QImage((width-2),(height-2),QImage::Format_ARGB32);
    Init_Image(*deal_image,0);
    int  i = 0,j = 0;

    for(i = 1; i<height-1; i++)
    {
        for(j = 1; j<width-1; j++)
        {
            uchar center = (uchar)qGray(image.pixel(j,i));
            uchar code = 0;

            uchar f1 = (uchar)qGray(image.pixel(j - 1, i - 1));

            uchar f2 = (uchar)qGray(image.pixel(j - 1, i));

            uchar f3 = (uchar)qGray(image.pixel(j - 1, i + 1));

            uchar f4 = (uchar)qGray(image.pixel(j, i + 1));

            uchar f5 = (uchar)qGray(image.pixel(j+ 1, i + 1));

            uchar f6 = (uchar)qGray(image.pixel(j + 1, i));

            uchar f7 = (uchar)qGray(image.pixel(j + 1, i - 1));

            uchar f8 = (uchar)qGray(image.pixel(j, i - 1));



            code |= (f1 > center) << 7;

            code |= (f2 > center) << 6;

            code |= (f3 > center) << 5;

            code |= (f4 > center) << 4;

            code |= (f5 > center) << 3;

            code |= (f6 > center) << 2;

            code |= (f7 > center) << 1;

            code |= (f8 > center) << 0;


            deal_image->setPixel(j-1,i-1,qRgb(code,code,code));

        }
    }
    otp = *deal_image;

}

通常的理解的效率低LBP：

void usual_LBP(QImage &image,QImage &otp,int R,int P)
{
    int width = image.width();
    int height = image.height();
    QImage* out = new QImage(width-2*R,height-2*R,QImage::Format_ARGB32);
    Init_Image(*out,0);
    int i = 0, j = 0;
    double x=0,y=0;
    double All_p = (double)P;
    int center = 0;
    uchar lbp = 0;

    //计算领域值
    QVector<double> neighbors_x;
    QVector<double> neighbors_y;

    //计算LBP领域
    for(i = 0; i<P; i++)
    {
        x = R*cos(2.0*PI*i/All_p);
        y = -R*sin(2.0*PI*i/All_p);
        neighbors_x.push_back(x);
        neighbors_y.push_back(y);
    }

    //循环每个像素
    for(i = R; i<height-R-1; i++)
    {
        for(j = R; j<width-R-1; j++)
        {
            //中点像素值（目标）
            center = (uchar)qGray(image.pixel(j,i));

            lbp = 0;
            //LBP领域与中点的判断
            for(int k = 0; k<neighbors_x.size(); k++)
            {
                //P个点的座标
                y = i + neighbors_y[k];
                x = j + neighbors_x[k];
                //调用双线性插值
                uchar gray = (uchar)InterpBilinear(image,x,y);
                //按顺序累加
                lbp |= (gray>center) <<k;
            }
            out->setPixel(j-R,i-R,qRgb(lbp,lbp,lbp));
        }
    }

    otp = *out;
}

效率高的LBP：

void LBP(QImage &image, QImage &otp, int R, int P)
{
    int width = image.width();
    int height = image.height();
    QImage* out = new QImage(width-2*R,height-2*R,QImage::Format_ARGB32);
    Init_Image(*out,0);
    int i = 0, j = 0;
    float x=0,y=0;
    float All_p = (float)P;
    int center = 0;
    int lbp = 0;

    for(int k = 0; k<P;k++)
    {
        //圆的参数方程
        x = R*cos(2.0*PI*k/All_p);
        y = (-R)*sin(2.0*PI*k/All_p);

        //对采样点偏移量分别进行上下取整
        int fx = (int)x;
        int cx = fx+1;
        int fy = (int)y;
        int cy = fy + 1;
        //将座标偏移量映射到0-1之间
        float ty = y - fy;
        float tx = x - fx;
        //根据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(i = R; i<height-R-1;i++)
        {
            for(j = R; j<width-R-1;j++)
            {
                //获得中心像素点的灰度值
                lbp = qGray(out->pixel(j-R,i-R));
                center = qGray(image.pixel(j,i));
                float f1 = qGray(image.pixel(j+fx,i+fy));
                float f2 = qGray(image.pixel(j+fx,i+cy));
                float f3 = qGray(image.pixel(j+cx,i+fy));
                float f4 = qGray(image.pixel(j+cx,i+cy));

                //根据双线性插值公式计算第k个采样点的灰度值
                int  neighbor = (f1 * w1) + (f3 * w2) + (f2 * w3) + (f4 * w4);
                //LBP特征图像的每个邻居的LBP值累加，累加通过与操作完成，对应的LBP值通过移位取得
                lbp |= (neighbor>center) << k;
                //cout<<lbp<<endl;
                out->setPixel(j-R,i-R,qRgb(lbp,lbp,lbp));
            }
        }
    }

    otp = *out;
}