2）积分图像的概念

[cpp] view plaincopy

1. //! computes the integral image
2. CV_EXPORTS_W void integral( InputArray src, OutputArray sum, int sdepth=-1 );
3. //! computes the integral image and integral for the squared image
4. CV_EXPORTS_AS(integral2) void integral( InputArray src, OutputArray sum,OutputArray sqsum, int sdepth=-1 );
5. //! computes the integral image, integral for the squared image and the tilted integral image
6. CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum,OutputArray sqsum, int sdepth=-1 );

[cpp] view plaincopy

1. /********************************************************************************************************
2. 文件说明:
3. HOG特征描述符的实现
4. 算法思路:
5. 1)将图片加载入内存，并且利用cvtColor将图像转换为grayImg
6. 2)利用一阶微分算子Sobel函数，分别计算出grayImg图像X方向和Y方向上的一阶微分/梯度图像
7. 3)根据得到的两幅梯度图像(X方向上的梯度图像和Y方向上的梯度图像)，然后利用cartToPolar函数，计算出这
8. 两幅梯度图像所对应的角度矩阵图像angleMat和梯度幅值矩阵图像magnMat
9. 4)将角度矩阵图像angleMat里面的像素强度值归一化为强度范围在[0，9）这9个范围，每一个范围就代表HOG中
10. 的一个bins
11. 5)以角度为为索引，将梯度幅值图像矩阵magnMat按照九个方向的梯度角度拆分为9幅梯度幅值图像矩阵
12. 6)根据这9个角度，每个角度所对应的梯度幅值图像矩阵，并且利用OpenCv中的积分函数integral分别计算出这9
13. 幅图像所对应的积分图像
14. ==============至此，我们9个梯度方向上，分别对应的的9幅梯度幅值积分图已经计算完毕==================
15. 7)计算整幅图像的梯度方向直方图HOG:要计算整幅图像的，需要先计算每个Block的HOG；要计算每个Block的HOG
16. 要先计算每个Cell的HOG
17. 8)计算单个Cell的HOG:由于9个梯度方向上的9张梯度幅值积分图像已经计算出来，所以这一步的计算很简单，只需
18. 要记性加减计算，具体的函数为cacHOGinCell
19. 9)计算单个Block的HOG:将计算出来的4个Cell的HOG组成一个Block的HOG
20. 10)计算整幅图像的HOG:将计算出来的所有的Block的HOG梯度方向直方图的特征向量首尾相接组成一个维度很大的
21. 整幅图像的梯度方向直方图的HOG特征向量，这个特征向量就是整幅图像的梯度方向直方图特征，这个特征
22. 向量也可以被用于SVM的分类
23. 算法难点:
24. 1)积分图像的概念:网上有关积分图像的Blog一大推，但是很多讲的都不准确，最好的办法是看OpenCv的官方文档
25. 关乎积分函数的讲解，可以结合网上的资料看
26. 2)笛卡尔空间坐标和极坐标的转换(关键是理解一些它们之间相互转换的前提条件)
27. 3)L1范数和L2范数:在使用归一化normalize函数时，考虑一些CV_L2到底是向量的L2范数还是矩阵的L2范数，自己
28. 可以推到一下公式
29. 4)关于HOG的论文，没有使用到积分图的概念，其实在HOG中使用积分图像加速了HOG的计算速度，如果使用先计算
30. 梯度，在计算各个区域的梯度方向和梯度幅值的话，这样计算了太大，会导致HOG的性能有所下降
31. 5)还有，这里的每个Cell的大小是20p*20p,每个Block的大小为4个Cell；当然如果用于行人检测的话，也可以使用
32. 其他的3*3或者5*5组合
33. 开发环境:
34. Win7 + OpenCv2.4.8 + VS2012
35. 时间地点:
36. 陕西师范大学 2017.3.14
37. 作    者:
38. 九 月
39. *********************************************************************************************************/
40. #include <opencv2/opencv.hpp>
41. #include <opencv2/highgui/highgui.hpp>
42. #include <opencv2/nonfree/features2d.hpp>
43. #include <iostream>
44. using namespace cv;
45. using namespace std;
46. #define NBINS 9
47. #define THETA 180 / NBINS
48. #define CELLSIZE 20
49. #define BLOCKSIZE 2
50. #define R (CELLSIZE * (BLOCKSIZE) * 0.5)
51. /********************************************************************************************************
52. 函数功能:
53. 计算积分图像
54. 参数说明:
55. Mat& srcMat-----------------------存储每个cellHOG特征的行特征向量
56. 2)cv::Rect roi--------------------单个cell的矩形位置
57. 3)std::vector<Mat>& integrals-----存储的9幅积分图像，每一幅积分图像代表一个角度范围或者一个bins
58. *********************************************************************************************************/
59. // 计算积分图
60. std::vector<Mat> CalculateIntegralHOG(Mat& srcMat)
61. {
62. //【1】计算一阶微分的梯度图像
63. cv::Mat   sobelMatX;
64. cv::Mat   sobelMatY;
65. cv::Sobel(srcMat, sobelMatX, CV_32F, 1, 0);
66. cv::Sobel(srcMat, sobelMatY, CV_32F, 0, 1);
67. std::vector<Mat> bins(NBINS);
68. for (int i = 0; i < NBINS; i++)
69. {
70. bins[i] = Mat::zeros(srcMat.size(), CV_32F);
71. }
72. cv::Mat   magnMat;
73. cv::Mat   angleMat;
74. //【2】坐标转换,根据每一个点X方向和Y方向上的梯度，实现笛卡尔坐标和极坐标的转换
75. cartToPolar(sobelMatX, sobelMatY, magnMat, angleMat, true);
76. //【3】下面这这两行代码起始是做安全处理的，因为在将笛卡尔坐标转换为极坐标之后，角度的范围在[0,360]
77. //     下面这两行代码让所有的角度收缩在[0,180]这个返回
78. add(angleMat, Scalar(180), angleMat, angleMat<0);                //如果angleMat<0，则加180
79. add(angleMat, Scalar(-180), angleMat, angleMat >= 180);          //如果angleMat>=180，则减180
80. //【4】下面这行代码将角度矩阵转换为一个灰度值范围在[0,9]之间的图像
81. angleMat /= THETA;
82. //【5】下面这个循环，其实是将图像的梯度幅值矩阵按九个不同方向的梯度角度，将每个角度范围内相应点的梯度幅值
83. //     存储在相应的矩阵图像之上，其实就是将梯度幅值矩阵图像按照不同的梯度幅值角度分为9幅梯度幅值的图像
84. for (int y = 0; y < srcMat.rows; y++)
85. {
86. for (int x = 0; x < srcMat.cols; x++)
87. {
88. int ind = angleMat.at<float>(y, x);
89. bins[ind].at<float>(y, x) += magnMat.at<float>(y, x);
90. }
91. }
92. //【6】根据上面生成的9张不同角度的梯度幅值矩阵生成9张不同的梯度幅值的积分图像，至此以后，
93. //     积分图像的每一点就代表，这一点左上角，所有梯度幅值之和；生成的9幅积分图也就是9个
94. //     bins，不同bins上的HOG强度
95. std::vector<Mat> integrals(NBINS);
96. for (int i = 0; i < NBINS; i++)
97. {
98. integral(bins[i], integrals[i]);
99. }
100. return integrals;
101. }
102. /********************************************************************************************************
103. 函数功能:
104. 计算单个cell HOG特征
105. 参数说明:
106. 1)cv::Mat& HOGCellMat-------------存储每个cellHOG特征的行特征向量
107. 2)cv::Rect roi--------------------单个cell的矩形位置
108. 3)std::vector<Mat>& integrals-----存储的9幅积分图像，每一幅积分图像代表一个角度范围或者一个bins
109. *********************************************************************************************************/
110. void cacHOGinCell(cv::Mat& HOGCellMat,cv::Rect roi,std::vector<Mat>& integrals)
111. {
112. //【1】通过9幅积分图像快速实现HOG的计算，HOG这个直方图有9个bins，每个bins就对应一张积分图像
113. int x0 = roi.x;                              //确定单个矩形cell的左上角点坐标
114. int y0 = roi.y;
115. int x1 = x0 + roi.width;
116. int y1 = y0 + roi.height;                    //确定单个矩形cell的右下角点坐标
117. for(int i = 0;i <NBINS; i++)
118. {
119. //【2】根据矩形的左上角点和右下角点的坐标
120. cv::Mat integral = integrals[i];
121. float a = integral.at<double>(y0,x0);
122. float b = integral.at<double>(y1,x1);
123. float c = integral.at<double>(y0,x1);
124. float d = integral.at<double>(y1,x0);
125. HOGCellMat.at<float>(0,i) = b - c - d +a;//每循环一次，计算一个梯度方向上的HOG特征，其实就是
126. //每循环一次，就计算梯度方向直方图上的一个bins
127. }
128. }
129. /********************************************************************************************************
130. 函数功能:
131. 获取当前窗口的HOG直方图----此块其实就是在计算单个Block的HOG梯度方向直方图
132. 参数说明:
133. 1)cv::Point pt--------------------单个Block的中心点坐标
134. 2)std::vector<cv::Mat>& integrals-----存储的9幅积分图像，每一幅积分图像代表一个角度范围或者一个bins
135. *********************************************************************************************************/
136. cv::Mat getHog(cv::Point pt,std::vector<cv::Mat>& integrals)
137. {
138. if(pt.x - R<0||pt.y-R<0||pt.x+R>=integrals[0].cols||pt.y+R>=integrals[0].rows)
139. {
140. return cv::Mat();
141. }
142. //【1】BLOCK的HOG直方图---具体的来说，BLOCKSIZE*BLOCKSIZE即4个cell的HOG特征直方图特征向量
143. //     组成一个BLOCK的HOG特征直方图的特征向量
144. cv::Mat    hist(cv::Size(NBINS*BLOCKSIZE*BLOCKSIZE,1),CV_32F);
145. cv::Point  t1(0,pt.y-R);
146. int c = 0;
147. //【2】遍历块:通过下面这两个循环，就遍历了4个cell，并且将4个cell的HOG特征向量组成了一个
148. //     维数比较大的BLOCK的HOG特征向量
149. for(int i=0;i<BLOCKSIZE;i++)
150. {
151. t1.x = pt.x - R;
152. for(int j=0;j<BLOCKSIZE;j++)
153. {
154. //【3】获取当前窗口，进行局部HOG直方图计算
155. cv::Rect roi(t1,t1+cv::Point(CELLSIZE,CELLSIZE));
156. cv::Mat  hist_temp = hist.colRange(c,c+NBINS);
157. //【4】根据roi确定的矩形区域，计算单个cell的HOG直方图(其本质就是一个行特征向量)
158. cacHOGinCell(hist_temp,roi,integrals);
159. t1.x += CELLSIZE;
160. c += NBINS;
161. }
162. t1.y = CELLSIZE;
163. }//for i
164. //【3】利用范数2进行归一化
165. cv::normalize(hist,hist,1,0,NORM_L2);
166. return hist;
167. }
168. /********************************************************************************************************
169. 函数功能:
170. 计算整幅图像的HOG梯度方向直方图---HOG特征
171. 参数说明:
172. cv::Mat srcImage------原始的输入彩色图像
173. *********************************************************************************************************/
174. std::vector<Mat> cacHOGFeature(cv::Mat srcImage)
175. {
176. cv::Mat          grayImage;
177. std::vector<Mat> HOGMatVector;
178. cv::cvtColor(srcImage, grayImage, CV_RGB2GRAY);
179. grayImage.convertTo(grayImage, CV_8UC1);
180. //【1】9个不同梯度方向上的9张梯度幅值的积分图像的生成
181. std::vector<Mat> integrals = CalculateIntegralHOG(grayImage);
182. Mat image = grayImage.clone();
183. image *= 0.5;
184. //【2】变量全图像，计算最终的梯度方向直方图HOG
185. cv::Mat HOGBlockMat(Size(NBINS, 1), CV_32F);
186. for (int y = CELLSIZE / 2; y < grayImage.rows; y += CELLSIZE)
187. {
188. for (int x = CELLSIZE / 2; x < grayImage.cols; x += CELLSIZE)
189. {
190. //【3】获取当前窗口HOG，其实当前的窗口就是一个Block，每个Block由四个cell组成，每个Cell为20*20
191. //     此块，计算的就是单个Block的梯度方向直方图HOG
192. cv::Mat hist = getHog(Point(x, y), integrals);
193. if (hist.empty())continue;
194. HOGBlockMat = Scalar(0);
195. for (int i = 0; i < NBINS; i++)
196. {
197. for (int j = 0; j < BLOCKSIZE; j++)
198. {
199. HOGBlockMat.at<float>(0, i) += hist.at<float>(0, i + j*NBINS);
200. }
201. }
202. //【4】L2范数归一化:对其得到的每个Block的的矩阵进行L2范数归一化，使其转变为一个Block的HOG特征向量
203. normalize(HOGBlockMat, HOGBlockMat, 1, 0, CV_L2);
204. //【5】最后，每得到一个Block的HOG特征向量就存入HOGMatVector，这个HOGMatVector其实就是整个图像的HOG特征向量，
205. //     当然，现在这个HOGMatVector还是个二维数组的形式，如果想要利用SVM对其进行分类的话，还需要将其拉伸为一
206. //     维特征向量
207. HOGMatVector.push_back(HOGBlockMat);
208. Point center(x, y);
209. //【6】绘制HOG特征图
210. for (int i = 0; i < NBINS; i++)
211. {
212. double theta = (i * THETA ) * CV_PI / 180.0;
213. Point rd(CELLSIZE*0.5*cos(theta), CELLSIZE*0.5*sin(theta));
214. Point rp = center - rd;
215. Point lp = center + rd;
216. line(image, rp, lp, Scalar(255 * HOGBlockMat.at<float>(0, i), 255, 255));
217. }
218. }
219. }
220. imshow("out", image);
221. return HOGMatVector;
222. }
223. /********************************************************************************************************
224. 模块功能:
225. 控制台应用程序的入口:Main函数
226. *********************************************************************************************************/
227. int main()
228. {
229. cv::Mat srcImage = cv::imread(".\\images\\hand1.jpg");
230. if (srcImage.empty())
231. return -1;
232. cv::imshow("srcImage ", srcImage);
233. std::vector<Mat> HOGFeatureMat = cacHOGFeature(srcImage);
234. cv::waitKey(0);
235. return 0;
236. }