LBP特征的实现及LBP+SVM分类

最新推荐文章于 2021-10-26 21:31:19 发布
最新推荐文章于 2021-10-26 21:31:19 发布
阅读量7.2k 收藏 21
点赞数 3
分类专栏： 机器学习

LBP原理

LBP的原理比较简单，网上有很多很不错的文章，这里给出几篇我认为不错的文章
目标检测的图像特征提取之（二）LBP特征

LBP local binary patterns 人脸特征提取方法

LBP特征学习及实现

如果大家想深入了解LBP,可以读一读论文
[2002 PAMI] Multiresolution gray-scale and rotation
[2006 PAMI] Face Description with Local Binary Patterns Application to Face Recognition

LBP特征向量提取的步骤

（1）计算图像中每个像素点的LBP模式(等价模式,或者旋转不变+等价模式)。
（2）然后计算每个cell的LBP特征值直方图，然后对该直方图进行归一化处理(每个cell中，对于每个bin,h[i]/=sum,sum就是一副图像中所有等价类的个数)。
（3）最后将得到的每个cell的统计直方图进行连接成为一个特征向量，也就是整幅图的LBP纹理特征向量；

然后便可利用SVM或者其他机器学习算法进行分类识别了。

LBP的实现

LBP.h

//////////////////////////////////////////////////////////////////////////
//  LBP.h (2.0)
// 2015-6-30，by QQ
//
// Please contact me if you find any bugs, or have any suggestions.
// Contact:
//      Telephone:15366105857
//      Email:654393155@qq.com
//      Blog: http://blog.csdn.net/qianqing13579
//////////////////////////////////////////////////////////////////////////
// updated 2016-12-12 01:12:55 by QQ, LBP 1.1,GetMinBinary()函数修改为查找表，提高了计算速度
// updated 2016-12-13 14:41:58 by QQ, LBP 2.0,先计算整幅图像的LBP特征图，然后计算每个cell的LBP直方图

#ifndef __LBP_H__
#define __LBP_H__
#include "opencv2/opencv.hpp"
#include<vector>
using namespace std;
using namespace cv;

class LBP
{
public:

    // 计算基本的256维LBP特征向量
    void ComputeLBPFeatureVector_256(const Mat &srcImage, Size cellSize,Mat &featureVector);
    void ComputeLBPImage_256(const Mat &srcImage, Mat &LBPImage);// 计算256维LBP特征图

    // 计算灰度不变+等价模式LBP特征向量(58种模式)
    void ComputeLBPFeatureVector_Uniform(const Mat &srcImage, Size cellSize, Mat &featureVector);
    void ComputeLBPImage_Uniform(const Mat &srcImage, Mat &LBPImage);// 计算等价模式LBP特征图

    // 计算灰度不变+旋转不变+等价模式LBP特征向量(9种模式)
    void ComputeLBPFeatureVector_Rotation_Uniform(const Mat &srcImage, Size cellSize, Mat &featureVector);
    void ComputeLBPImage_Rotation_Uniform(const Mat &srcImage, Mat &LBPImage); // 计算灰度不变+旋转不变+等价模式LBP特征图,使用查找表

    // Test
    void Test();// 测试灰度不变+旋转不变+等价模式LBP
    void TestGetMinBinaryLUT();

private:
    void BuildUniformPatternTable(int *table); // 计算等价模式查找表
    int GetHopCount(int i);// 获取i中0,1的跳变次数

    void ComputeLBPImage_Rotation_Uniform_2(const Mat &srcImage, Mat &LBPImage);// 计算灰度不变+旋转不变+等价模式LBP特征图,不使用查找表
    int ComputeValue9(int value58);// 计算9种等价模式
    int GetMinBinary(int binary);// 通过LUT计算最小二进制
    uchar GetMinBinary(uchar *binary); // 计算得到最小二进制

};

#endif

LBP.cpp

#include"LBP.h"

//获取i中0,1的跳变次数
int LBP::GetHopCount(int i)
{
    // 转换为二进制
    int a[8] = { 0 };
    int k = 7;
    while (i)
    {
        // 除2取余
        a[k] = i % 2;
        i/=2;
        --k;
    }

    // 计算跳变次数
    int count = 0;
    for (int k = 0; k<8; ++k)
    {
        // 注意，是循环二进制,所以需要判断是否为8
        if (a[k] != a[k + 1 == 8 ? 0 : k + 1])
        {
            ++count;
        }
    }
    return count;

}

// 建立等价模式表
// 这里为了便于建立LBP特征图，58种等价模式序号从1开始:1~58,第59类混合模式映射为0
void LBP::BuildUniformPatternTable(int *table)
{
    memset(table, 0, 256*sizeof(int));
    uchar temp = 1;
    for (int i = 0; i<256; ++i)
    {
        if (GetHopCount(i) <= 2)
        {
            table[i] = temp;
            temp++;
        }
    }

}

void LBP::ComputeLBPFeatureVector_256(const Mat &srcImage, Size cellSize, Mat &featureVector)
{
    // 参数检查，内存分配
    CV_Assert(srcImage.depth() == CV_8U&&srcImage.channels() == 1);

    Mat LBPImage;
    ComputeLBPImage_256(srcImage,LBPImage);

    // 计算cell个数
    int widthOfCell = cellSize.width;
    int heightOfCell = cellSize.height;
    int numberOfCell_X = srcImage.cols / widthOfCell;// X方向cell的个数
    int numberOfCell_Y = srcImage.rows / heightOfCell;

    // 特征向量的个数
    int numberOfDimension = 256 * numberOfCell_X*numberOfCell_Y;
    featureVector.create(1, numberOfDimension, CV_32FC1);
    featureVector.setTo(Scalar(0));

    // 计算LBP特征向量
    int stepOfCell=srcImage.cols;
    int pixelCount = cellSize.width*cellSize.height;
    float *dataOfFeatureVector=(float *)featureVector.data;

    // cell的特征向量在最终特征向量中的起始位置
    int index = -256;
    for (int y = 0; y <= numberOfCell_Y - 1; ++y)
    {
        for (int x = 0; x <= numberOfCell_X - 1; ++x)
        {
            index+=256;

            // 计算每个cell的LBP直方图
            Mat cell = LBPImage(Rect(x * widthOfCell, y * heightOfCell, widthOfCell, heightOfCell));
            uchar *rowOfCell=cell.data;
            for(int y_Cell=0;y_Cell<=cell.rows-1;++y_Cell,rowOfCell+=stepOfCell)
            {
                uchar *colOfCell=rowOfCell;
                for(int x_Cell=0;x_Cell<=cell.cols-1;++x_Cell,++colOfCell)
                {
                    ++dataOfFeatureVector[index + colOfCell[0]];
                }
            }

            // 一定要归一化！否则分类器计算误差很大
            for (int i = 0; i <= 255; ++i)
                dataOfFeatureVector[index + i] /= pixelCount;

        }
    }

}

//srcImage:灰度图
//LBPImage:LBP图
void LBP::ComputeLBPImage_256(const Mat &srcImage, Mat &LBPImage)
{
    // 参数检查，内存分配
    CV_Assert(srcImage.depth() == CV_8U&&srcImage.channels() == 1);
    LBPImage.create(srcImage.size(), srcImage.type());

    // 扩充原图像边界，便于边界处理
    Mat extendedImage;
    copyMakeBorder(srcImage, extendedImage, 1, 1, 1, 1, BORDER_DEFAULT);

    // 计算LBP特征图
    int heightOfExtendedImage = extendedImage.rows;
    int widthOfExtendedImage = extendedImage.cols;
    int widthOfLBP=LBPImage.cols;
    uchar *rowOfExtendedImage= extendedImage.data+widthOfExtendedImage+1;
    uchar *rowOfLBPImage = LBPImage.data;
    for (int y = 1; y <= heightOfExtendedImage - 2; ++y, rowOfExtendedImage += widthOfExtendedImage, rowOfLBPImage += widthOfLBP)
    {
        // 列
        uchar *colOfExtendedImage = rowOfExtendedImage;
        uchar *colOfLBPImage = rowOfLBPImage;
        for (int x = 1; x <= widthOfExtendedImage - 2; ++x,++colOfExtendedImage,++colOfLBPImage)
        {
            // 计算LBP值
            int LBPValue = 0;
            if (colOfExtendedImage[0 - widthOfExtendedImage - 1] >= colOfExtendedImage[0])
                LBPValue += 128;
            if (colOfExtendedImage[0 - widthOfExtendedImage ] >= colOfExtendedImage[0])
                LBPValue += 64;
            if (colOfExtendedImage[0 - widthOfExtendedImage +1] >= colOfExtendedImage[0])
                LBPValue += 32;
            if (colOfExtendedImage[0 +1] >= colOfExtendedImage[0])
                LBPValue += 16;
            if (colOfExtendedImage[0 + widthOfExtendedImage + 1] >= colOfExtendedImage[0])
                LBPValue += 8;
            if (colOfExtendedImage[0 + widthOfExtendedImage] >= colOfExtendedImage[0])
                LBPValue += 4;
            if (colOfExtendedImage[0 + widthOfExtendedImage - 1] >= colOfExtendedImage[0])
                LBPValue += 2;
            if (colOfExtendedImage[0 - 1] >= colOfExtendedImage[0])
                LBPValue += 1;

            colOfLBPImage[0] = LBPValue;

        }  // x

    }// y


}

// cellSize:每个cell的大小,如16*16
void LBP::ComputeLBPFeatureVector_Uniform(const Mat &srcImage, Size cellSize, Mat &featureVector)
{
    // 参数检查，内存分配
    CV_Assert(srcImage.depth() == CV_8U&&srcImage.channels() == 1);

    Mat LBPImage;
    ComputeLBPImage_Uniform(srcImage,LBPImage);

    // 计算cell个数
    int widthOfCell = cellSize.width;
    int heightOfCell = cellSize.height;
    int numberOfCell_X = srcImage.cols / widthOfCell;// X方向cell的个数
    int numberOfCell_Y = srcImage.rows / heightOfCell;

    // 特征向量的个数
    int numberOfDimension = 58 * numberOfCell_X*numberOfCell_Y;
    featureVector.create(1, numberOfDimension, CV_32FC1);
    featureVector.setTo(Scalar(0));

    // 计算LBP特征向量
    int stepOfCell=srcImage.cols;
    int index = -58;// cell的特征向量在最终特征向量中的起始位置
    float *dataOfFeatureVector=(float *)featureVector.data;
    for (int y = 0; y <= numberOfCell_Y - 1; ++y)
    {
        for (int x = 0; x <= numberOfCell_X - 1; ++x)
        {
            index+=58;

            // 计算每个cell的LBP直方图
            Mat cell = LBPImage(Rect(x * widthOfCell, y * heightOfCell, widthOfCell, heightOfCell));
            uchar *rowOfCell=cell.data;
            int sum = 0; // 每个cell的等价模式总数
            for(int y_Cell=0;y_Cell<=cell.rows-1;++y_Cell,rowOfCell+=stepOfCell)
            {
                uchar *colOfCell=rowOfCell;
                for(int x_Cell=0;x_Cell<=cell.cols-1;++x_Cell,++colOfCell)
                {
                    if(colOfCell[0]!=0)
                    {
                        // 在直方图中转化为0~57，所以是colOfCell[0] - 1
                        ++dataOfFeatureVector[index + colOfCell[0]-1];
                        ++sum;
                    }
                }
            }

            // 一定要归一化！否则分类器计算误差很大
            for (int i = 0; i <= 57; ++i)
                dataOfFeatureVector[index + i] /= sum;

        }
    }
}

// 计算等价模式LBP特征图，为了方便表示特征图，58种等价模式表示为1~58,第59种混合模式表示为0
// 注：你可以将第59类混合模式映射为任意数值，因为要突出等价模式特征，所以非等价模式设置为0比较好
void LBP::ComputeLBPImage_Uniform(const Mat &srcImage, Mat &LBPImage)
{
    // 参数检查，内存分配
    CV_Assert(srcImage.depth() == CV_8U&&srcImage.channels() == 1);
    LBPImage.create(srcImage.size(), srcImage.type());

    // 计算LBP图
    // 扩充原图像边界，便于边界处理
    Mat extendedImage;
    copyMakeBorder(srcImage, extendedImage, 1, 1, 1, 1, BORDER_DEFAULT);

    // 构建LBP 等价模式查找表
    //int table[256];
    //BuildUniformPatternTable(table);

    // LUT(256种每一种模式对应的等价模式)
    static const int table[256] = { 1, 2, 3, 4, 5, 0, 6, 7, 8, 0, 0, 0, 9, 0, 10, 11, 12, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 14, 0, 15, 16, 17, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 20, 0, 21, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25,
        0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 27, 0, 28, 29, 30, 31, 0, 32, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0
        , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 36, 37, 38, 0, 39, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42
        , 43, 44, 0, 45, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 47, 48, 49, 0, 50, 0, 0, 0, 51, 52, 53, 0, 54, 55, 56, 57, 58 };

    // 计算LBP
    int heightOfExtendedImage = extendedImage.rows;
    int widthOfExtendedImage = extendedImage.cols;
    int widthOfLBP=LBPImage.cols;
    uchar *rowOfExtendedImage = extendedImage.data+widthOfExtendedImage+1;
    uchar *rowOfLBPImage = LBPImage.data;
    for (int y = 1; y <= heightOfExtendedImage - 2; ++y,rowOfExtendedImage += widthOfExtendedImage, rowOfLBPImage += widthOfLBP)
    {
        // 列
        uchar *colOfExtendedImage = rowOfExtendedImage;
        uchar *colOfLBPImage = rowOfLBPImage;
        for (int x = 1; x <= widthOfExtendedImage - 2; ++x, ++colOfExtendedImage, ++colOfLBPImage)
        {
            // 计算LBP值
            int LBPValue = 0;
            if (colOfExtendedImage[0 - widthOfExtendedImage - 1] >= colOfExtendedImage[0])
                LBPValue += 128;
            if (colOfExtendedImage[0 - widthOfExtendedImage] >= colOfExtendedImage[0])
                LBPValue += 64;
            if (colOfExtendedImage[0 - widthOfExtendedImage + 1] >= colOfExtendedImage[0])
                LBPValue += 32;
            if (colOfExtendedImage[0 + 1] >= colOfExtendedImage[0])
                LBPValue += 16;
            if (colOfExtendedImage[0 + widthOfExtendedImage + 1] >= colOfExtendedImage[0])
                LBPValue += 8;
            if (colOfExtendedImage[0 + widthOfExtendedImage] >= colOfExtendedImage[0])
                LBPValue += 4;
            if (colOfExtendedImage[0 + widthOfExtendedImage - 1] >= colOfExtendedImage[0])
                LBPValue += 2;
            if (colOfExtendedImage[0 - 1] >= colOfExtendedImage[0])
                LBPValue += 1;

            colOfLBPImage[0] = table[LBPValue];

        } // x

    }// y
}

// 计算9种等价模式，等价模式编号也是从1开始：1~9
int LBP::ComputeValue9(int value58)
{
    int value9 = 0;
    switch (value58)
    {
    case 1: 
        value9 = 1;
        break;
    case 2:
        value9 = 2;
        break;
    case 4:
        value9 = 3;
        break;
    case 7:
        value9 = 4;
        break;
    case 11:
        value9 = 5;
        break;
    case 16:
        value9 = 6;
        break;
    case 22:
        value9 = 7;
        break;
    case 29:
        value9 = 8;
        break;
    case 58:
        value9 = 9;
        break;
    }

    return value9;

}

int LBP::GetMinBinary(int binary)
{
    static const int miniBinaryLUT[256] = { 0, 1, 1, 3, 1, 5, 3, 7, 1, 9, 5, 11, 3, 13, 7, 15, 1, 17, 9, 19, 5,
        21, 11, 23, 3, 25, 13, 27, 7, 29, 15, 31, 1, 9, 17, 25, 9, 37, 19, 39, 5, 37, 21, 43, 11, 45,
        23, 47, 3, 19, 25, 51, 13, 53, 27, 55, 7, 39, 29, 59, 15, 61, 31, 63, 1, 5, 9, 13, 17, 21, 25,
        29, 9, 37, 37, 45, 19, 53, 39, 61, 5, 21, 37, 53, 21, 85, 43, 87, 11, 43, 45, 91, 23, 87, 47, 95,
        3, 11, 19, 27, 25, 43, 51, 59, 13, 45, 53, 91, 27, 91, 55, 111, 7, 23, 39, 55, 29, 87, 59, 119, 15,
        47, 61, 111, 31, 95, 63, 127, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 9, 25, 37,
        39, 37, 43, 45, 47, 19, 51, 53, 55, 39, 59, 61, 63, 5, 13, 21, 29, 37, 45, 53, 61, 21, 53, 85,
        87, 43, 91, 87, 95, 11, 27, 43, 59, 45, 91, 91, 111, 23, 55, 87, 119, 47, 111, 95, 127, 3,
        7, 11, 15, 19, 23, 27, 31, 25, 39, 43, 47, 51, 55, 59, 63, 13, 29, 45, 61, 53, 87, 91, 95, 27, 59,
        91, 111, 55, 119, 111, 127, 7, 15, 23, 31, 39, 47, 55, 63, 29, 61, 87, 95, 59, 111, 119, 127, 15, 31, 47, 63,
        61, 95, 111, 127, 31, 63, 95, 127, 63, 127, 127, 255};

    return miniBinaryLUT[binary];
}

// 获取循环二进制的最小二进制模式
uchar LBP::GetMinBinary(uchar *binary)
{
    // 计算8个二进制
    uchar LBPValue[8] = { 0 };
    for (int i = 0; i <= 7; ++i)
    {
        LBPValue[0] += binary[i] <<(7-i);
        LBPValue[1] += binary[(i+7)%8] << (7 - i);
        LBPValue[2] += binary[(i + 6) % 8] << (7 - i);
        LBPValue[3] += binary[(i + 5) % 8] << (7 - i);
        LBPValue[4] += binary[(i + 4) % 8] << (7 - i);
        LBPValue[5] += binary[(i + 3) % 8] << (7 - i);
        LBPValue[6] += binary[(i + 2) % 8] << (7 - i);
        LBPValue[7] += binary[(i + 1) % 8] << (7 - i);
    }

    // 选择最小的
    uchar minValue = LBPValue[0];
    for (int i = 1; i <= 7; ++i)
    {
        if (LBPValue[i] < minValue)
        {
            minValue = LBPValue[i];
        }
    }

    return minValue;

}
// cellSize:每个cell的大小,如16*16
void LBP::ComputeLBPFeatureVector_Rotation_Uniform(const Mat &srcImage, Size cellSize, Mat &featureVector)
{
    // 参数检查，内存分配
    CV_Assert(srcImage.depth() == CV_8U&&srcImage.channels() == 1);

    Mat LBPImage;
    ComputeLBPImage_Rotation_Uniform(srcImage,LBPImage);

    // 计算cell个数
    int widthOfCell = cellSize.width;
    int heightOfCell = cellSize.height;
    int numberOfCell_X = srcImage.cols / widthOfCell;// X方向cell的个数
    int numberOfCell_Y = srcImage.rows / heightOfCell;

    // 特征向量的个数
    int numberOfDimension = 9 * numberOfCell_X*numberOfCell_Y;
    featureVector.create(1, numberOfDimension, CV_32FC1);
    featureVector.setTo(Scalar(0));

    // 计算LBP特征向量
    int stepOfCell=srcImage.cols;
    int index = -9;// cell的特征向量在最终特征向量中的起始位置
    float *dataOfFeatureVector=(float *)featureVector.data;
    for (int y = 0; y <= numberOfCell_Y - 1; ++y)
    {
        for (int x = 0; x <= numberOfCell_X - 1; ++x)
        {
            index+=9;

            // 计算每个cell的LBP直方图
            Mat cell = LBPImage(Rect(x * widthOfCell, y * heightOfCell, widthOfCell, heightOfCell));
            uchar *rowOfCell=cell.data;
            int sum = 0; // 每个cell的等价模式总数
            for(int y_Cell=0;y_Cell<=cell.rows-1;++y_Cell,rowOfCell+=stepOfCell)
            {
                uchar *colOfCell=rowOfCell;
                for(int x_Cell=0;x_Cell<=cell.cols-1;++x_Cell,++colOfCell)
                {
                    if(colOfCell[0]!=0)
                    {
                         // 在直方图中转化为0~8，所以是colOfCell[0] - 1
                        ++dataOfFeatureVector[index + colOfCell[0]-1];
                        ++sum;
                    }
                }
            }

            // 直方图归一化
            for (int i = 0; i <= 8; ++i)
                dataOfFeatureVector[index + i] /= sum;

        }
    }
}

void LBP::ComputeLBPImage_Rotation_Uniform(const Mat &srcImage, Mat &LBPImage)
{
    // 参数检查，内存分配
    CV_Assert(srcImage.depth() == CV_8U&&srcImage.channels() == 1);
    LBPImage.create(srcImage.size(), srcImage.type());

    // 扩充图像，处理边界情况
    Mat extendedImage;
    copyMakeBorder(srcImage, extendedImage, 1, 1, 1, 1, BORDER_DEFAULT);

    // 构建LBP 等价模式查找表
    //int table[256];
    //BuildUniformPatternTable(table);

    // 查找表
    static const int table[256] = { 1, 2, 3, 4, 5, 0, 6, 7, 8, 0, 0, 0, 9, 0, 10, 11, 12, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 14, 0, 15, 16, 17, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 20, 0, 21, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25,
        0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 27, 0, 28, 29, 30, 31, 0, 32, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0
        , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 36, 37, 38, 0, 39, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42
        , 43, 44, 0, 45, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 47, 48, 49, 0, 50, 0, 0, 0, 51, 52, 53, 0, 54, 55, 56, 57, 58 };

    int heigthOfExtendedImage = extendedImage.rows;
    int widthOfExtendedImage = extendedImage.cols;
    int widthOfLBPImage = LBPImage.cols;

    uchar *rowOfExtendedImage = extendedImage.data + widthOfExtendedImage + 1;
    uchar *rowOfLBPImage = LBPImage.data;
    for (int y = 1; y <= heigthOfExtendedImage - 2; ++y, rowOfExtendedImage += widthOfExtendedImage, rowOfLBPImage += widthOfLBPImage)
    {
        // 列
        uchar *colOfExtendedImage = rowOfExtendedImage;
        uchar *colOfLBPImage = rowOfLBPImage;
        for (int x = 1; x <= widthOfExtendedImage - 2; ++x, ++colOfExtendedImage, ++colOfLBPImage)
        {
            // 计算LBP值
            int LBPValue = 0;
            if (colOfExtendedImage[0 - widthOfExtendedImage - 1] >= colOfExtendedImage[0])
                LBPValue += 128;
            if (colOfExtendedImage[0 - widthOfExtendedImage] >= colOfExtendedImage[0])
                LBPValue += 64;
            if (colOfExtendedImage[0 - widthOfExtendedImage + 1] >= colOfExtendedImage[0])
                LBPValue += 32;
            if (colOfExtendedImage[0 + 1] >= colOfExtendedImage[0])
                LBPValue += 16;
            if (colOfExtendedImage[0 + widthOfExtendedImage + 1] >= colOfExtendedImage[0])
                LBPValue += 8;
            if (colOfExtendedImage[0 + widthOfExtendedImage] >= colOfExtendedImage[0])
                LBPValue += 4;
            if (colOfExtendedImage[0 + widthOfExtendedImage - 1] >= colOfExtendedImage[0])
                LBPValue += 2;
            if (colOfExtendedImage[0 - 1] >= colOfExtendedImage[0])
                LBPValue += 1;

            int minValue = GetMinBinary(LBPValue);

            // 计算58种等价模式LBP
            int value58 = table[minValue];

            // 计算9种等价模式
            colOfLBPImage[0] = ComputeValue9(value58);
        }

    }

}

void LBP::ComputeLBPImage_Rotation_Uniform_2(const Mat &srcImage, Mat &LBPImage)
{
    // 参数检查，内存分配
    CV_Assert(srcImage.depth() == CV_8U&&srcImage.channels() == 1);
    LBPImage.create(srcImage.size(), srcImage.type());

    // 扩充图像，处理边界情况
    Mat extendedImage;
    copyMakeBorder(srcImage, extendedImage, 1, 1, 1, 1, BORDER_DEFAULT);

    // 构建LBP 等价模式查找表
    //int table[256];
    //BuildUniformPatternTable(table);

    // 通过查找表
    static const int table[256] = { 1, 2, 3, 4, 5, 0, 6, 7, 8, 0, 0, 0, 9, 0, 10, 11, 12, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 14, 0, 15, 16, 17, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 20, 0, 21, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25,
        0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 27, 0, 28, 29, 30, 31, 0, 32, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0
        , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 36, 37, 38, 0, 39, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42
        , 43, 44, 0, 45, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 47, 48, 49, 0, 50, 0, 0, 0, 51, 52, 53, 0, 54, 55, 56, 57, 58 };

    uchar binary[8] = { 0 };// 记录每个像素的LBP值
    int heigthOfExtendedImage = extendedImage.rows;
    int widthOfExtendedImage = extendedImage.cols;
    int widthOfLBPImage = LBPImage.cols;

    uchar *rowOfExtendedImage = extendedImage.data + widthOfExtendedImage + 1;
    uchar *rowOfLBPImage = LBPImage.data;
    for (int y = 1; y <= heigthOfExtendedImage - 2; ++y, rowOfExtendedImage += widthOfExtendedImage, rowOfLBPImage += widthOfLBPImage)
    {
        // 列
        uchar *colOfExtendedImage = rowOfExtendedImage;
        uchar *colOfLBPImage = rowOfLBPImage;
        for (int x = 1; x <= widthOfExtendedImage - 2; ++x, ++colOfExtendedImage, ++colOfLBPImage)
        {
            // 计算旋转不变LBP(最小的二进制模式)
            binary[0] = colOfExtendedImage[0 - widthOfExtendedImage - 1] >= colOfExtendedImage[0] ? 1 : 0;
            binary[1] = colOfExtendedImage[0 - widthOfExtendedImage] >= colOfExtendedImage[0] ? 1 : 0;
            binary[2] = colOfExtendedImage[0 - widthOfExtendedImage + 1] >= colOfExtendedImage[0] ? 1 : 0;
            binary[3] = colOfExtendedImage[0 + 1] >= colOfExtendedImage[0] ? 1 : 0;
            binary[4] = colOfExtendedImage[0 + widthOfExtendedImage + 1] >= colOfExtendedImage[0] ? 1 : 0;
            binary[5] = colOfExtendedImage[0 + widthOfExtendedImage] >= colOfExtendedImage[0] ? 1 : 0;
            binary[6] = colOfExtendedImage[0 + widthOfExtendedImage - 1] >= colOfExtendedImage[0] ? 1 : 0;
            binary[7] = colOfExtendedImage[0 - 1] >= colOfExtendedImage[0] ? 1 : 0;

            int minValue = GetMinBinary(binary);

            // 计算58种等价模式LBP
            int value58=table[minValue];

            // 计算9种等价模式
            colOfLBPImage[0] = ComputeValue9(value58);
        }

    }
}


// 验证灰度不变+旋转不变+等价模式种类
void LBP::Test()
{
    uchar LBPValue[8] = { 0 };
    int k = 7, j;
    int temp;
    LBP lbp;
    int number[256] = { 0 };
    int numberOfMinBinary = 0;

    // 旋转不变
    for (int i = 0; i < 256; ++i)
    {
        k = 7;
        temp = i;
        while (k >= 0)
        {
            LBPValue[k] = temp & 1;
            temp = temp >> 1;
            --k;
        }
        int minBinary = lbp.GetMinBinary(LBPValue);

        // 查找有无重复的
        for (j = 0; j <= numberOfMinBinary - 1; ++j)
        {
            if (number[j] == minBinary)
                break;
        }
        if (j == numberOfMinBinary)
        {
            number[numberOfMinBinary++] = minBinary;
        }
    }
    cout << "旋转不变一共有："<<numberOfMinBinary <<"种"<< endl;

    // LUT
    static const int table[256] = { 1, 2, 3, 4, 5, 0, 6, 7, 8, 0, 0, 0, 9, 0, 10, 11, 12, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 14, 0, 15, 16, 17, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 20, 0, 21, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25,
        0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 27, 0, 28, 29, 30, 31, 0, 32, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0
        , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 36, 37, 38, 0, 39, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42
        , 43, 44, 0, 45, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 47, 48, 49, 0, 50, 0, 0, 0, 51, 52, 53, 0, 54, 55, 56, 57, 58 };

    for (int i = 0; i <= numberOfMinBinary - 1; ++i)
    {
        cout << "旋转不变的LBP："<<number[i] << " "<<"对应的等价模式：" << table[number[i]] << endl;
    }

}

void LBP::TestGetMinBinaryLUT()
{
    for (int i = 0; i <= 255; ++i)
    {
        uchar a[8] = { 0 };
        int k = 7;
        int j = i;
        while (j)
        {
            // 除2取余
            a[k] = j % 2;
            j /= 2;
            --k;
        }
        uchar minBinary=GetMinBinary(a);
        printf("%d,",minBinary);

    }
}

SVM测试程序

SVMTest.h

//////////////////////////////////////////////////////////////////////////
//  SVMTest.h
// 2016-12-12,by QQ
//
// Please contact me if you find any bugs, or have any suggestions.
// Contact:
//      Telephone:15366105857
//      Email:654393155@qq.com
//      Blog: http://blog.csdn.net/qianqing13579
//////////////////////////////////////////////////////////////////////////

#ifndef __SVMTEST__
#define __SVMTEST__

#include "opencv2/ml.hpp"
//#include"../Utility/CommonUtility.h"
//#include"../Utility/LogInterface.h"
#include<fstream>
#include"LBP.h"
using namespace cv::ml;

// if you do not need log,comment it,just like :#define LOG_WARN_SVM_TEST(...)                  //LOG4CPLUS_MACRO_FMT_BODY ("SVMTest", WARN_LOG_LEVEL, __VA_ARGS__)
#define LOG_DEBUG_SVM_TEST(...)                //LOG4CPLUS_MACRO_FMT_BODY ("SVMTest", DEBUG_LOG_LEVEL, __VA_ARGS__)
#define LOG_ERROR_SVM_TEST(...)                 //LOG4CPLUS_MACRO_FMT_BODY ("SVMTest", ERROR_LOG_LEVEL, __VA_ARGS__)
#define LOG_INFO_SVM_TEST(...)                    //LOG4CPLUS_MACRO_FMT_BODY ("SVMTest", INFO_LOG_LEVEL, __VA_ARGS__)
#define LOG_WARN_SVM_TEST(...)                  //LOG4CPLUS_MACRO_FMT_BODY ("SVMTest", WARN_LOG_LEVEL, __VA_ARGS__)
//#define CONFIG_FILE                                              "./Resource/Configuration.xml"
#define CELL_SIZE   16

class SVMTest
{
public:
    SVMTest(const string &_trainDataFileList,
              const string &_testDataFileList,
              const string &_svmModelFilePath,
              const string &_predictResultFilePath,
              SVM::Types svmType, // See SVM::Types. Default value is SVM::C_SVC.
              SVM::KernelTypes kernel,
              double c, // For SVM::C_SVC, SVM::EPS_SVR or SVM::NU_SVR. Default value is 0.
              double coef,  // For SVM::POLY or SVM::SIGMOID. Default value is 0.
              double degree, // For SVM::POLY. Default value is 0.
              double gamma, // For SVM::POLY, SVM::RBF, SVM::SIGMOID or SVM::CHI2. Default value is 1.
              double nu,  // For SVM::NU_SVC, SVM::ONE_CLASS or SVM::NU_SVR. Default value is 0.
              double p // For SVM::EPS_SVR. Default value is 0.
              );
    bool Initialize();
    virtual ~SVMTest();

    void Train();
    void Predict();

private:
    string trainDataFileList;
    string testDataFileList;
    string svmModelFilePath;
    string predictResultFilePath;

    // SVM
    Ptr<SVM> svm;

    // feature extracting(HOG,LBP,Haar,etc)
    LBP lbp;


};


#endif // SVMTEST

SVMTest.cpp

#include"SVMTest.h"

SVMTest::SVMTest(const string &_trainDataFileList,
                     const string &_testDataFileList,
                     const string &_svmModelFilePath,
                     const string &_predictResultFilePath,
                     SVM::Types svmType, // See SVM::Types. Default value is SVM::C_SVC.
                     SVM::KernelTypes kernel,
                     double c, // For SVM::C_SVC, SVM::EPS_SVR or SVM::NU_SVR. Default value is 0.
                     double coef,  // For SVM::POLY or SVM::SIGMOID. Default value is 0.
                     double degree, // For SVM::POLY. Default value is 0.
                     double gamma, // For SVM::POLY, SVM::RBF, SVM::SIGMOID or SVM::CHI2. Default value is 1.
                     double nu,  // For SVM::NU_SVC, SVM::ONE_CLASS or SVM::NU_SVR. Default value is 0.
                     double p // For SVM::EPS_SVR. Default value is 0.
                     ):
                       trainDataFileList(_trainDataFileList),
                       testDataFileList(_testDataFileList),
                       svmModelFilePath(_svmModelFilePath),
                       predictResultFilePath(_predictResultFilePath)
{
    // set svm param
    svm = SVM::create();
    svm->setC(c);
    svm->setCoef0(coef);
    svm->setDegree(degree);
    svm->setGamma(gamma);
    svm->setKernel(kernel);
    svm->setNu(nu);
    svm->setP(p);
    svm->setType(svmType);

    //svm->setTermCriteria(TermCriteria(TermCriteria::EPS, 1000, FLT_EPSILON)); // based on accuracy
    svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, 100, 1e-6)); // based on the maximum number of iterations
}

bool SVMTest::Initialize()
{
    // initialize log
    //InitializeLog("SVMTest");

   return true;

}

SVMTest::~SVMTest()
{
}

void SVMTest::Train()
{
    // 读入训练样本图片路径和类别
   std::vector<string> imagePaths;
   std::vector<int> imageClasses;
   string line;
   std::ifstream trainingData(trainDataFileList,ios::out);
   while (getline(trainingData, line))
   {
       if(line.empty())
           continue;

       stringstream stream(line);
       string imagePath,imageClass;
       stream>>imagePath;
       stream>>imageClass;

       imagePaths.push_back(imagePath);
       imageClasses.push_back(atoi(imageClass.c_str()));
   }
   trainingData.close();

   printf("%d\n",imagePaths.size());

    // extract feature
   Mat featureVectorsOfSample;
   Mat classOfSample;
   printf("get feature...\n");
   LOG_INFO_SVM_TEST("get feature...");
   for(int i=0;i<=imagePaths.size()-1;++i)
   {
       Mat srcImage=imread(imagePaths[i],-1);
       if(srcImage.empty()||srcImage.depth()!=CV_8U)
       {
           printf("%s srcImage.empty()||srcImage.depth()!=CV_8U!\n",imagePaths[i].c_str());
           LOG_ERROR_SVM_TEST("%s srcImage.empty()||srcImage.depth()!=CV_8U!",imagePaths[i].c_str());
           continue;
       }

       // extract feature
       Mat featureVector;
       lbp.ComputeLBPFeatureVector_Rotation_Uniform(srcImage,Size(CELL_SIZE,CELL_SIZE),featureVector);
       if(featureVector.empty())
           continue;

       featureVectorsOfSample.push_back(featureVector);
       classOfSample.push_back( imageClasses[i]);

        printf("get feature... %f% \n",(i+1)*100.0/imagePaths.size());
        LOG_INFO_SVM_TEST("get feature... %f",(i+1)*100.0/imagePaths.size());
   }

   printf("get feature done!\n");
   LOG_INFO_SVM_TEST("get feature done!");

    // train
    printf("training...\n");
    LOG_INFO_SVM_TEST("training...");
    double time1, time2;
    time1 = getTickCount();
    svm->train(featureVectorsOfSample, ROW_SAMPLE, classOfSample);
    time2 = getTickCount();
    printf("训练时间:%f\n", (time2 - time1)*1000. / getTickFrequency());
    LOG_INFO_SVM_TEST("训练时间:%f", (time2 - time1)*1000. / getTickFrequency());
    printf("training done!\n");
    LOG_INFO_SVM_TEST("training done!");

    // save model
    svm->save(svmModelFilePath);
}

void SVMTest::Predict()
{
    // predict
    std::vector<string> testImagePaths;
    std::vector<int> testImageClasses;
    string line;
    std::ifstream testData(testDataFileList,ios::out);
    while (getline(testData, line))
    {
        if(line.empty())
            continue;

        stringstream stream(line);
        string imagePath,imageClass;
        stream>>imagePath;
        stream>>imageClass;

        testImagePaths.push_back(imagePath);
        testImageClasses.push_back(atoi(imageClass.c_str()));

    }
    testData.close();

    printf("predicting...\n");
    LOG_INFO_SVM_TEST("predicting...");

    int numberOfRight_0=0;
    int numberOfError_0=0;
    int numberOfRight_1=0;
    int numberOfError_1=0;

    std::ofstream fileOfPredictResult(predictResultFilePath,ios::out); //最后识别的结果
    double sum_Predict=0,sum_ExtractFeature=0;
    char line2[256]={0};
    for (int i = 0; i < testImagePaths.size() ; ++i)
    {
        Mat srcImage = imread(testImagePaths[i], -1);
        if(srcImage.empty()||srcImage.depth()!=CV_8U)
        {
            printf("%s srcImage.empty()||srcImage.depth()!=CV_8U!\n",testImagePaths[i].c_str());
            LOG_ERROR_SVM_TEST("%s srcImage.empty()||srcImage.depth()!=CV_8U!",testImagePaths[i].c_str());
            continue;
        }

        // extract feature
        double time1_ExtractFeature = getTickCount();
        Mat featureVectorOfTestImage;
        lbp.ComputeLBPFeatureVector_Rotation_Uniform(srcImage,Size(CELL_SIZE,CELL_SIZE),featureVectorOfTestImage);
        if(featureVectorOfTestImage.empty())
            continue;
        double time2_ExtractFeature = getTickCount();
        sum_ExtractFeature+=(time2_ExtractFeature - time1_ExtractFeature) * 1000 / getTickFrequency();

        //对测试图片进行分类并写入文件
       double time1_Predict = getTickCount();
        int predictResult = svm->predict(featureVectorOfTestImage);
        double time2_Predict = getTickCount();
        sum_Predict += (time2_Predict - time1_Predict) * 1000 / getTickFrequency();

        sprintf(line2, "%s %d\n", testImagePaths[i].c_str(), predictResult);
        fileOfPredictResult << line2;
        LOG_INFO_SVM_TEST("%s %d", testImagePaths[i].c_str(), predictResult);

        // 0
        if((testImageClasses[i]==0)&&(predictResult==0))
        {
            ++numberOfRight_0;
        }
        if((testImageClasses[i]==0)&&(predictResult!=0))
        {
            ++numberOfError_0;
        }

        // 1
        if((testImageClasses[i]==1)&&(predictResult==1))
        {
            ++numberOfRight_1;
        }
        if((testImageClasses[i]==1)&&(predictResult!=1))
        {
            ++numberOfError_1;
        }

        printf("predicting...%f%\n", 100.0*(i+1)/testImagePaths.size());
    }
    printf("predicting done!\n");
    LOG_INFO_SVM_TEST("predicting done!");

    printf("extract feature time：%f\n", sum_ExtractFeature / testImagePaths.size());
    LOG_INFO_SVM_TEST("extract feature time：%f", sum_ExtractFeature / testImagePaths.size());
    sprintf(line2, "extract feature time：%f\n", sum_ExtractFeature / testImagePaths.size());
    fileOfPredictResult << line2;

    printf("predict time：%f\n", sum_Predict / testImagePaths.size());
    LOG_INFO_SVM_TEST("predict time：%f", sum_Predict / testImagePaths.size());
    sprintf(line2, "predict time：%f\n", sum_Predict / testImagePaths.size());
    fileOfPredictResult << line2;


    // 0
    double accuracy_0=(100.0*(numberOfRight_0)) / (numberOfError_0+numberOfRight_0);
    printf("0：%f\n",accuracy_0);
    LOG_INFO_SVM_TEST("0：%f",accuracy_0);
    sprintf(line2, "0：%f\n", accuracy_0);
    fileOfPredictResult << line2;

    // 1
    double accuracy_1=(100.0*numberOfRight_1) /(numberOfError_1+numberOfRight_1);
    printf("1：%f\n",accuracy_1);
    LOG_INFO_SVM_TEST("1：%f", accuracy_1);
    sprintf(line2, "1：%f\n",accuracy_1);
    fileOfPredictResult << line2;

    // accuracy
    double accuracy_All=(100.0*(numberOfRight_1+numberOfRight_0)) /(numberOfError_0+numberOfRight_0+numberOfError_1+numberOfRight_1);
    printf("accuracy：%f\n", accuracy_All);
    LOG_INFO_SVM_TEST("accuracy:%f", accuracy_All);
    sprintf(line2, "accuracy:%f\n", accuracy_All);
    fileOfPredictResult << line2;

    fileOfPredictResult.close();

}

程序中加入了日志，我已经在程序中注释掉了，这部分大家可以忽略。

main.cpp

#include"SVMTest.h"
int main(int argc, char *argv[])
{
    string root="/home/qq/Image2/Texture/SVMTest/";
    SVMTest svmTest(root+"Train.txt", // train filelist
                                                    root+"Test.txt", // test filelist
                                                    root+"Classifier.xml",  // classifier
                                                    root+"PredictResult.txt",  //predict result
                                                    SVM::C_SVC,  // svmType
                                                    SVM::LINEAR, // kernel
                                                    1,   // c
                                                    0,   // coef
                                                    0,   // degree
                                                    1,   // gamma
                                                    0,   // nu
                                                    0);  // p
    if(!svmTest.Initialize())
    {
        printf("initialize failed!\n");
        //LOG_ERROR_SVM_TEST("initialize failed!");
        return ;
    }

   svmTest.Train();
   svmTest.Predict();

return 0;

}

实验结果与分析

实验环境：CPU: i7-4790K,内存：16G,OS:Ubuntu 14.04,QT 5.5，OpenCV 3.1
注：很多网友说程序中的SVM报错，因为3.1中的SVM用法和2.4用法不同，所以如果你用的是2.4版本，需要更新到3.1的才可以使用.

实验中采用了2282个32X64的正样本，2278个32X64的负样本，540个测试样本
其中，正样本从下图中截取而来
这里写图片描述

负样本从下图中截取而来
这里写图片描述

正样本是草丛，负样本是路面，是我中午吃完饭散步的时候，随手拍的(-_-)

实验数据可以在这里下载

下面是我的实验结果

窗口大小原始256维等价模式旋转不变等价模式
8 x 891.67%93.89%94.26%
16 x 1695.74%95.74%98.52%
32 x 3298.51%98.52%98.70%

可以看出，本实验中窗口大小为32x32的旋转不变的等价模式识别率最高。

注意：
程序中使用的Train.txt和Test.txt每一行的格式为:
图像的绝对路径 类别
如：
/home/qq/Image2/Texture/0/Grass_0010.jpg 0

速度测试

重构后的LBP,GetMinBinary()函数采用了查找表，实验中选取窗口大小16x16,提取一幅32X64图像的旋转不变等价模式特征为0.08ms,而没用查找表的时间为0.31ms，速度的提高还是很大的。

Last Updated: 2016-12-13 19:31:07


first_adam
关注
专栏目录
matlab使用纹理特征（HOG+LBP）+svm（libsvm）对图片进行多分类
qigeyonghuming_1的博客
10-09 8167
写在前面的碎碎念 想来想去还是把祖传代码给改了，目前只是调通了代码，但是分类accuracy只有80%左右，效果差了10%，但是本着做了工作就记录一下，不然就白做了的思想，可能后期还得学习一下svm的理论知识，把svm的参数调整一下，没准会更好。不过好像工作量挺大的样子，看来我又偷懒了。 下面这些和标题没啥关系，可以跳过,祖传代码是一份传奇的代码，我还没来的时候就有了，应该是参考以下这些博客的，感谢博主GoodboyBin，参考博客：https://www.cnblogs.com/xiangbin1207/
LBP算子分类和基本思想
weixin_35657047的博客
10-29 2762
LBP算子分类和基本思想 1. LBP算子的背景 LBP算子又称为Local Binary Pattern，是一种用来描述图像局部纹理特征的算子，由于其具有灰度不变性、旋转不变性等显著优点，得以被广泛应用。LBP的另一个优点就是思想比较好理解，并且计算过程不复杂，简单易懂，这样产生的时间复杂度在可计算范围内。LBP多用于人脸识别方面，由于其对纹理识别很精细，相比较于缺陷检测，也是一个很好的方向，由...
LBP+SVM实验数据
10-25
LBP+SVM实验数据.
matlab LBP+SVM图像分类
lichen_6398的博客
09-21 5963
clc;  clear all;  close all; %%   使用SVM做识别，测试准确率 % Files = dir(fullfile('.\Car','*.jpg')); file_path =  'E:/matlab_0808/0816/people1/';% 图像文件夹路径 img_path_list = dir(strcat(file_path,'*.jpg'));%获取该文件夹...
svm简单实现python-用Python实现一个SVM分类器策略
weixin_39642622的博客
11-11 486
支持向量机(SVM)是什么意思？正好最近自己学习机器学习，看到reddit上 Please explain Support Vector Machines (SVM) like I am a 5 year old 的帖子，一个字赞！于是整理一下和大家分享。(如有错欢迎指教！)什么是SVM?支持向量机/support vector machine (SVM)。当然首先看一下wiki.Support ...
SVM+LBP(车辆、行人、人脸等目标检测)
04-25
提取样本的LBP纹理特征，使用SVM训练生成检测器，可以对视频中的车辆进行检测。
LBP.zip_LBP+SVM_LBP图像识别_SUM_图像分类 SVM_等价LBP
07-15
（1）计算图像中每个像素点的LBP模式(等价模式,或者旋转不变+等价模式)。 （2）然后计算每个cell的LBP特征值直方图，然后对该直方图进行归一化处理(每个cell中...然后便可利用SVM或者其他机器学习算法进行分类识别了。
python语言使用LBP算法提取特征向量SVM算法训练模型和识别分类整套文件（可直接运行）
02-11
python语言使用LBP算法提取特征向量SVM算法训练模型和识别分类整套文件。内有训练和测试、验证图片集，训练和测试程序分两个py文件。训练使用lbp_train.py文件，测试和验证使用均使用lbp_test.py文件，更改训练集和...
LBP_train_main.rar_LBP训练_LBP，svm_SVM LBP_lbp特征提取_train
09-24
在本项目中，LBP提取的特征作为输入数据，用于训练SVM模型，目的是建立一个能够基于LBP特征进行分类的高效模型。 "train"表示这是一个训练过程，意味着在这个项目中，开发者将使用已知的带标签数据（即带有正确分类...
LBP_PHOG特征利用SVM训练分类器
06-27
matlab的lbp+phog特征融合，再利用SVM进行训练得到分类器。修改样本路径就可以运行。
利用svm分类数字图像
05-05
利用libsvm识别数字，总共100副图片，其中0-9各10副，图像大小为28*20
基于OpenCV的LBP+SVM的人脸识别程序
01-14
本程序中，利用了LBP特征对人脸特征进行提取，并且利用SVM对提取的人脸特征进行训练和识别，其中，所用的图像处理库为 OpenCV2.4.9版本；通过对人脸库中的标准标本进行测试，算法识别率高达95%以上；
python利用支持向量机SVM进行时间序列预测（数据+源码）
05-21
python利用支持向量机SVM进行时间序列预测, 包括数据和python代码 python利用支持向量机SVM进行时间序列预测, 包括数据和python代码
python 实现 纹理图片分类识别 SVM支持向量机 图片资源与代码
06-27
题目是将图片库中的纹理图片裁剪成九份，其中五份做训练集，四份做测试集，先提取图片LBP特征 ，最后用svm支持向量机进行学习，在预测测试集里的图片是哪一类纹理。 正常情况下是需要调参的，即调整SVM的参数，但图省事只整了个循环，正常应该手动调参的。
python实现LBP方法提取图像纹理特征实现分类
热门推荐
selous的专栏
04-06 5万+
题目描述这篇博文是数字图像处理的大作业. 题目描述:给定40张不同风格的纹理图片,大小为512*512,要求将每张图片分为大小相同的9块,利用其中的5块作为训练集,剩余的4块作为测试集,构建适当的模型实现图片的分类. 图片如下图所示:分析:由于数据集太小,所以神经网络模型并不适合此类的图像处理.就需要寻找方法提取图像的纹理信息.本文采用LBP的方法提取图像的纹理信息,然后转化成直方图作为图像的特
LBP特征学习（附python实现）
weixin_33795806的博客
04-20 4405
LBP特征学习（附python实现） LBP的全称是Local Binary Pattern即局部二值模式，是局部信息提取中的一种方法，它具有旋转不变性和灰度不变性等显著的优点。在人脸识别领域有很多案例，此外，局部特征的算法还有 SIFT HOG等等。 LBP就是一种局部信息，它反应的内容是每个像素与周围像素的关系。举最基本的LBP为例，它反...
烟雾检测（2）LBP+SVM 检测python实现
qq_42242399的博客
10-26 3362
报告要求 报告的主题是video based smoke detection。 提供train、test两个数据集，每个数据集内部均有smoke和non两个文件夹，文件夹内有若干100*100大小的图片。 报告内容包括四部分：1、特征表示；2、降维及聚类；3、分类；4、模型评价及选择。 经过两个周的学习，终于结束了第二章聚类分析。上课太痛苦了，啥都听不懂还要努力听，幸好没选模式识别这个方向。 ...
【数字图像处理6】python+opencv使用LBP、HOG提取特征来分类人脸、人身
火火的博客
11-22 5123
我就是挂个标题先，想不到吧~ 文章目录实验目的实验前明确的概念一、LBP分类二、HOG分类参考资料 实验目的 选取LBP、HOG两种特征提取算法做分类，去识别人和车的图像。 实验前明确的概念 LBP、HOG是两种特征提取算法。 一、LBP分类 二、HOG分类 HOG(Histogram of Oriented Gradient)在对象识别与模式匹配中是一种常见的特征提取算法。 它是基于本地像素块进行特征直方图提取的一种算法，对象局部的变形与光照影响有很好的稳定性。 参考资料 HOG: htt
LBP特征提取与SVM分类器训练框架
由于文件名称为LBP_train_main.cpp，这表明该压缩包中可能包含了一个C++程序源代码文件，该程序实现了LBP特征提取和SVM分类器的训练。用户可以使用C++编程环境来编译和运行这个程序，以达到训练SVM分类器的目的。这...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值