人脸识别经典算法实现（三）——LBP算法

转自：https://blog.csdn.net/freedom098/article/details/52088179

第三种算法称之为LBP算法，这个算法的思路与PCA和Fisher有很大不同，他是考虑局部特征算子，并不是全局考虑。

这种算法定义了一种LBP特征，这种特征与我们经常见到的Haar特征、HoG特征没有啥太大不同，都是特征算子，只是算法不同。因此，我们按照理解特征算子一类的算法去理解LBP就可以了。

注意，LBP对关照不敏感，为什么？因为LBP算子是一种相对性质的数量关系，相比于PCA或者Fsiher，直接使用灰度值去参与运算，LBP更能反映出的是一种变化趋势。

最后一次当个搬运工

http://blog.csdn.net/feirose/article/details/39552977，LBP算子写的不算太清楚，但是整个算法的完整流程讲明白了，而且最后如何判定的直方图交叉核和卡方检验都有说明。

http://blog.csdn.net/pi9nc/article/details/18623971，这个博客的LBP算子说得很好，而且有opencv的例程。

注意，这里的样本图像组织形式与前面两个算法又有不同，因为他不需要把图像变成列向量，因此图像矩阵不需要做什么处理就可以加入列表备用了。

代码如下：

 

1. #encoding=utf-8

2. import numpy as np

3. import os

4. import cv2

5.  

6. class LBP(object):

7. def __init__(self,threshold,dsize,blockNum):

8. self.dsize = dsize # 统一尺寸大小

9. self.blockNum = blockNum # 分割块数目

10. self.threshold = threshold # 阈值，暂未使用

11.  

12. def loadImg(self,fileName,dsize):

13. '''

14. 载入图像，灰度化处理，统一尺寸，直方图均衡化

15. :param fileName: 图像文件名

16. :param dsize: 统一尺寸大小。元组形式

17. :return: 图像矩阵

18. '''

19. img = cv2.imread(fileName)

20. retImg = cv2.resize(img,dsize)

21. retImg = cv2.cvtColor(retImg,cv2.COLOR_RGB2GRAY)

22. retImg = cv2.equalizeHist(retImg)

23. # cv2.imshow('img',retImg)

24. # cv2.waitKey()

25. return retImg

26.  

27. def loadImagesList(self,dirName):

28. '''

29. 加载图像矩阵列表

30. :param dirName:文件夹路径

31. :return: 包含最原始的图像矩阵的列表和标签矩阵

32. '''

33. imgList = []

34. label = []

35. for parent,dirnames,filenames in os.walk(dirName):

36. # print parent

37. # print dirnames

38. # print filenames

39. for dirname in dirnames:

40. for subParent,subDirName,subFilenames in os.walk(parent+'/'+dirname):

41. for filename in subFilenames:

42. img = self.loadImg(subParent+'/'+filename,self.dsize)

43. imgList.append(img) # 原始图像矩阵不做任何处理，直接加入列表

44. label.append(subParent+'/'+filename)

45. return imgList,label

46.  
47.  

48. def getHopCounter(self,num):

49. '''

50. 计算二进制序列是否只变化两次

51. :param num: 数字

52. :return: 01变化次数

53. '''

54. binNum = bin(num)

55. binStr = str(binNum)[2:]

56. n = len(binStr)

57. if n < 8:

58. binStr = "0"*(8-n)+binStr

59. n = len(binStr)

60. counter = 0

61. for i in range(n):

62. if i != n-1:

63. if binStr[i+1] != binStr[i]:

64. counter += 1

65. else:

66. if binStr[0] != binStr[i]:

67. counter += 1

68. return counter

69.  

70. def createTable(self):

71. '''

72. 生成均匀对应字典

73. :return: 均匀LBP特征对应字典

74. '''

75. self.table = {}

76. temp = 1

77. print type(temp)

78. for i in range(256):

79. if self.getHopCounter(i) <= 2:

80. self.table[i] = temp

81. temp += 1

82. else:

83. self.table[i] = 0

84. return self.table

85.  

86. def getLBPfeature(self,img):

87. '''

88. 计算LBP特征

89. :param img:图像矩阵

90. :return: LBP特征图

91. '''

92. m = img.shape[0];n = img.shape[1]

93. neighbor = [0]*8

94. featureMap = np.mat(np.zeros((m,n)))

95. for y in xrange(1,m-1):

96. for x in xrange(1,n-1):

97. neighbor[0] = img[y-1,x-1]

98. neighbor[1] = img[y-1,x]

99. neighbor[2] = img[y-1,x+1]

100. neighbor[3] = img[y,x+1]

101. neighbor[4] = img[y+1,x+1]

102. neighbor[5] = img[y+1,x]

103. neighbor[6] = img[y+1,x-1]

104. neighbor[7] = img[y,x-1]

105. center = img[y,x]

106. temp = 0

107. for k in range(8):

108. temp += (neighbor[k] >= center)*(1<<k)

109. featureMap[y,x] = self.table[temp]

110. featureMap = featureMap.astype('uint8') # 数据类型转换为无符号8位型，如不转换则默认为float64位，影响最终效果

111. return featureMap

112.  

113. def calcHist(self,roi):

114. '''

115. 计算直方图

116. :param roi:图像区域

117. :return: 直方图矩阵

118. '''

119. hist = cv2.calcHist([roi],[0],None,[59],[0,256]) # 第四个参数是直方图的横坐标数目，经过均匀化降维后这里一共有59种像素

120. return hist

121.  

122. def compare(self,sampleImg,testImg):

123. '''

124. 比较函数，这里使用的是欧氏距离排序，也可以使用KNN，在此处更改

125. :param sampleImg: 样本图像矩阵

126. :param testImg: 测试图像矩阵

127. :return: k2值

128. '''

129. testImg = cv2.resize(testImg,self.dsize)

130. testImg = cv2.cvtColor(testImg,cv2.COLOR_RGB2GRAY)

131. testFeatureMap = self.getLBPfeature(testImg)

132. sampleFeatureMap = self.getLBPfeature(sampleImg)

133. # 计算步长，分割整个图像为小块

134. ystep = self.dsize[0]/self.blockNum

135. xstep = self.dsize[1]/self.blockNum

136. k2 = 0

137. for y in xrange(0,self.dsize[0],ystep):

138. for x in xrange(0,self.dsize[1],xstep):

139. testroi = testFeatureMap[y:y+ystep,x:x+xstep]

140. sampleroi =sampleFeatureMap[y:y+ystep,x:x+xstep]

141. testHist = self.calcHist(testroi)

142. sampleHist = self.calcHist(sampleroi)

143. k2 += np.sum((sampleHist-testHist)**2)/np.sum((sampleHist+testHist))

144. print 'k2的值为',k2

145. return k2

146.  

147. def predict(self,dirName,testImgName):

148. '''

149. 预测函数

150. :param dirName:样本图像文件夹路径

151. :param testImgName: 测试图像文件名

152. :return: 最相近图像名称

153. '''

154. table = self.createTable()

155. testImg = cv2.imread(testImgName)

156. imgList,label = self.loadImagesList(dirName)

157. k2List = []

158. for img in imgList:

159. k2 = self.compare(img,testImg)

160. k2List.append(k2)

161. order = np.argsort(k2List)

162. return label[order[0]]

163.  

164. if __name__ == "__main__":

165.  

166. lbp = LBP(20,(50,50),5)

167. ans = lbp.predict('d:/face','d:/face_test/9.bmp')

168. print ans