本文中對人臉的LBP特徵的提取，採用了LBP的圓形運算元，通過對ORL92112人臉庫中的樣本進行識別，據統計，訓練集與測試集的準確率均達到了100%；

經LBP處理後的影象如下圖所示：

如上圖所示，左側影象為原影象，右側影象為提取出的LBP影象；利用LBP圓形運算元，可以非常清晰描述出人臉特徵；

故，可以利用LBP運算元對人臉特徵進行提取並識別，而且在處理過程中，不受影象的光照、旋轉、角度等因素的影響；

演算法的處理程式碼如下所述：

LBP演算法標頭檔案：

head.h:

#ifndef _HEAD_H
#define _HEAD_H

#include <opencv2/opencv.hpp>
#include <iostream>
#include <cassert>
#include <vector>
#include <numeric>
#include <algorithm>
#include <functional>
#include <iterator>

#endif		// _HEAD_H
 

#ifndef _LBP_H
#define _LBP_H

#include "head.h"

typedef std::vector<double> VecDouble;
typedef std::vector<int> VecInt;
typedef std::vector<float> VecFloat;

class LBP
{
public:
	LBP();
	~LBP();

public:
	
	enum LBP_TYPE
	{
		LBP_UNIFORM = 0,		// uniform LBP
		LBP_NORMAL = 1,			// lbp
		LBP_CIRCLE = 2			// circular operator of lbp
	};

public:
	// 傳統的 LBP 演算法
	void calLBP(IplImage* srcImg, IplImage* dstImg);
	// LBP 圓形運算元演算法
	void calCirLBP(IplImage* srcImg, IplImage* dstImg, int radius, int neighbor);
	// uniform LBP 演算法
	void calUniformLBP(IplImage* src, IplImage* dst);

public:
	// 設定半徑
	void setRadius(int radius) { m_radius = radius; }
	// 設定領域數
	void setNeighbors(int neighbor) { m_neighbor = neighbor; }
	// 計算特徵值
	void calLBPFeatures(IplImage* srcImg, IplImage* dstImg, VecDouble& hist, LBP_TYPE lbpType);

private:
	int m_radius;
	int m_neighbor;

};

#endif  // _LBP_H
 

#include "stdafx.h"
#include "LBP.h"
#include <iostream>
using namespace std;

LBP::LBP()
	: m_radius(0)
	, m_neighbor(0)
{

}

LBP::~LBP()
{

}
//基於舊版本的opencv的LBP演算法opencv1.0  
// 3 x 3 矩陣如下所示
// [ 1, 2, 3]
// [ 8, ij,4]
// [ 7, 6, 5]

void LBP::calLBP(IplImage* srcImg, IplImage* dstImg)
{
	// 原影象為單通道影象，目標影象為單通道影象
	assert(srcImg != NULL && srcImg->nChannels == 1);
	assert(dstImg != NULL && dstImg->nChannels == 1);

	unsigned tmp[8] = { 0 };

	// 遍歷影象
	for (int rows = 1; rows < srcImg->height - 1; ++rows)
	{
		for (int cols = 1; cols < srcImg->width - 1; ++cols)
		{
			int sum = 0;
			double center = cvGetReal2D(srcImg, rows, cols);
			
			//　順時針遍歷
			double val = 0.0;
			// 左上角
			val = cvGetReal2D(srcImg, rows - 1, cols - 1);
			val > center ? tmp[0] = 1 : tmp[0] = 0;
			// 正上方
			val = cvGetReal2D(srcImg, rows, cols - 1);
			val > center ? tmp[1] = 1 : tmp[1] = 0;
			// 右上角
			val = cvGetReal2D(srcImg, rows + 1, cols - 1);
			val > center ? tmp[2] = 1 : tmp[2] = 0;
			// 右側
			val = cvGetReal2D(srcImg, rows + 1, cols);
			val > center ? tmp[3] = 1 : tmp[3] = 0;
			// 右下角
			val = cvGetReal2D(srcImg, rows + 1, cols + 1);
			val > center ? tmp[4] = 1 : tmp[4] = 0;
			// 下方
			val = cvGetReal2D(srcImg, rows, cols + 1);
			val > center ? tmp[5] = 1 : tmp[5] = 0;
			// 左下角
			val = cvGetReal2D(srcImg, rows - 1, cols + 1);
			val > center ? tmp[6] = 1 : tmp[6] = 0;
			// 左側
			val = cvGetReal2D(srcImg, rows - 1, cols);
			val > center ? tmp[7] = 1 : tmp[7] = 0;

			// 計算 LBP 編碼
			for (int i = 0; i < 8; ++i)
			{
				sum += tmp[i] * pow(2, i);
			}
			cvSetReal2D(dstImg, rows, cols, sum);
		}

	}// end for

}

// uniform LBP,一致區域性二值模式
void LBP::calUniformLBP(IplImage *src, IplImage *dst)
{
	assert(src != NULL && src->nChannels == 1);
	assert(dst != NULL && dst->nChannels == 1);

	int tmp[8] = { 0 };

	int rows = src->height - 1;
	int cols = src->width - 1;

	for (int i = 1; i < rows; ++i)
	{
		for (int j = 1; j < cols; ++j)
		{
			int sum = 0;
			double center = cvGetReal2D(src, i, j);

			// 順時針遍歷
			double val = 0.0;
			val = cvGetReal2D(src, i - 1, j - 1);		// 左上角
			val > center ? tmp[0] = 1 : tmp[0] = 0;
			val = cvGetReal2D(src, i, j - 1);			// 正上方
			val > center ? tmp[1] = 1 : tmp[1] = 0;
			val = cvGetReal2D(src, i + 1, j - 1);		// 右上角
			val > center ? tmp[2] = 1 : tmp[2] = 0;
			val = cvGetReal2D(src, i + 1, j);			// 右側
			val > center ? tmp[3] = 1 : tmp[3] = 0;
			val = cvGetReal2D(src, i + 1, j + 1);		// 右下角
			val > center ? tmp[4] = 1 : tmp[4] = 0;
			val = cvGetReal2D(src, i, j + 1);			// 正下方
			val > center ? tmp[5] = 1 : tmp[5] = 0;
			val = cvGetReal2D(src, i - 1, j + 1);		// 左下角
			val > center ? tmp[6] = 1 : tmp[6] = 0;
			val = cvGetReal2D(src, i - 1, j);			// 左側
			val > center ? tmp[7] = 1 : tmp[7] = 0;

			//計算0、1翻轉次數
			for (int k = 0; k < 8; k++)
			{
				if (k != 7)
				{
					sum += abs(tmp[k] - tmp[k + 1]);
				}
				else
				{
					sum += abs(tmp[k] - tmp[0]);
				}
			}
			//通過翻轉次數判斷具體特徵值
			if (sum <= 2)
			{
				for (int i = 0; i < 8; ++i)
				{
					sum += tmp[i] * pow(2, (7 - i));
				}

			}
			else
			{
				sum = 5; //將不滿足的取5
			}
			cvSet2D(dst, i, j, cvScalar(sum));
		}
	}
}

// 圓形 LBP 運算元
void LBP::calCirLBP(IplImage* src, IplImage* dst, int radius, int neighbors)
{
	// 處理的影象為單通道影象
	assert(src->nChannels == 1);

	for (int i = 0; i < neighbors; ++i)
	{
		// 正弦弧度
		double sRadian = sin(2.0 * CV_PI * i / static_cast<double>(neighbors));
		// 餘弦弧度
		double cRadian = cos(2.0 * CV_PI * i / static_cast<double>(neighbors));

		// 取樣點的計算
		double x = static_cast<double>(-radius * sRadian);
		double y = static_cast<double>(radius * cRadian);

		// 下取整的值
		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));
		// 小數部分
		double tx = x - fx;
		double ty = y - fy;

		// 設定插值權重
		double w1 = (1 - tx) * (1 - ty);
		double w2 = tx * (1 - ty);
		double w3 = (1 - tx) * ty;
		double w4 = tx * ty;


		// 迴圈處理影象資料
		for (int rows = radius; rows < src->height - radius; ++rows)
		{
			for (int cols = radius; cols < src->width - radius; ++cols)
			{
				// 計算插值
				double t1 = w1 * cvGetReal2D(src, rows + fy, cols + fx);
				double t2 = w2 * cvGetReal2D(src, rows + fy, cols + cx);
				double t3 = w3 * cvGetReal2D(src, rows + cy, cols + fx);
				double t4 = w4 * cvGetReal2D(src, rows + cy, cols + cx);
				double t = t1 + t2 + t3 + t4;

				double val = cvGetReal2D(src, rows, cols);
				double epsilon = std::numeric_limits<double>::epsilon();

				uchar c = ((t > val) || abs(t - val) < epsilon);
				uchar tmp = c * pow(2, i);
				double v = cvGetReal2D(dst, rows - radius, cols - radius);
				v += tmp;
				cvSetReal2D(dst, rows - radius, cols - radius, v);
			}
		}

	}

}

// 計算 LPB 特徵值
void LBP::calLBPFeatures(IplImage* srcImg, IplImage* dstImg, VecDouble& hist, LBP_TYPE lbpType)
{
	assert(srcImg != NULL && srcImg->nChannels == 1);
	assert(dstImg != NULL && dstImg->nChannels == 1);

	// 計算 LBP 影象
	if (lbpType == LBP_NORMAL)
	{
		calLBP(srcImg, dstImg);
	}
	else if (lbpType == LBP_UNIFORM)
	{
		calUniformLBP(srcImg, dstImg);
	}
	else if (lbpType == LBP_CIRCLE)
	{
		
		try
		{
			if (m_radius == 0 || m_neighbor == 0)
			{
				throw "please call setRadius() and setNeighbor() to set values.";
			}
			else
			{
				calCirLBP(srcImg, dstImg, m_radius, m_neighbor);
			}
		}
		catch (char* e)
		{
			cout << e << endl;
		}

	}// end if

	// 計算直方圖
	VecInt vec;
	vec.resize(256);
	
	for (int i = 0; i < dstImg->width; ++i)
	{
		for (int j = 0; j < dstImg->height; ++j)
		{
			CvScalar s = cvGet2D(dstImg, j, i);
			int val = s.val[0];
			++vec[val];
		}
	}// end for

	// 將直方圖歸一化
	int maxVal = *max_element(vec.begin(), vec.end());
	int minVal = *min_element(vec.begin(), vec.end());

	for (int i = 0; i < vec.size(); ++i)
	{
		double tmp = 0.0;
		tmp = static_cast<double>(vec[i]) / static_cast<double>(maxVal);
		hist.push_back(tmp);
	}

}