【OpenCV流程+代码分析】Opencv HOG行人检测 源码分析

【原文：http://blog.csdn.net/ttransposition/article/details/11874285】

OpenCV demo演示见本人的另一篇灌水博客 http://blog.csdn.net/soidnhp/article/details/11720801

本人源码分析见 http://blog.csdn.net/soidnhp/article/details/11880425

参考文献：《N. Dalal and B. Triggs, “Histograms of Oriented Gradients for Human Detection,”Proc. IEEE Conf. Computer Vision and Pattern Recognition,2005.》

参考链接 http://www.cnblogs.com/tornadomeet/archive/2012/08/15/2640754.html

一、基本思想

     上图是目标检测的基本流程。

     HOG属于特征提取，它统计梯度直方图特征。具体来说就是将梯度方向（0->360°）划分为9个区间，将图像化为16x16的若干个block,每个block在化为4个cell（8x8）。对每一个cell,算出每一点的梯度方向和模，按梯度方向增加对应bin的值，最终综合N个cell的梯度直方图形成一个高维描述子向量。实际实现的时候会有各种插值。

     选用的分类器是经典的SVM。

    检测框架为经典的滑动窗口法，即在位置空间和尺度空间遍历搜索检测。

二、基本概念

      原始图像打完补丁后就直接用固定的窗口在图像中移动，计算检测窗口下的梯度，形成描述子向量，然后就直接SVM了

三、HOG算法流程

算法流程比较简单：

1、gamma校正

       r=0.5,暗区对比度提高，亮区对比度下降

2、计算梯度

      微分算子[-1 0 1]，取RGB通道中模值最大的为该像素点的梯度。

      插值策略：对与该点梯度方向相邻的两个bin按距离进行线性插值。

3 、权值

   高斯权值：与到block中心负相关，对于图中的大圆圈

   cell中心权值：到对称cell中心的“距离”正相关，对应下图中小方块到十字的距离。

  这一部分比较复杂，  每一个像素点还要对cell插值。

1）F,J,G,K区域内的像素点对四个cell都有贡献，比如P4对cell 0 的权重是倒对称cell中心即cell 3的“距离” P4-cell 3 即图中绿色虚线的“长度”，对其它cell 的权值依次类推

2）B,C,E,I,N,O,H,L区域的像素点要对两个cell中心插值。比如P2虽然处在cell 1中，但是对cell 0 也有贡献，对虚线中的红，绿两个十字所在的cell 也有贡献。那对cell 0的权重计算方法同P4。

取到对称cell 中心的 “距离”，即到绿色中心的“距离”。

3）A，D，M，P，区域的点对周围的四个cell也有贡献，但是block覆盖的只有一个cell,自然只要对其本身所在的cell插值即可。比如P1,到对称cell 中心的“距离”，即图中的cell中心。

但是要注意：cell的编号顺序是从上到下，从左到右，即（cell 0 cell 1 cell 2 cell 3）但是四个cell的偏移量存储顺序却是（cell 0 ->cell 2 ->cell 1->cell 3)

  

 

 

4、归一化

L2 Hys归一化，比较简单

5、获取整个检测窗口内的所有block的梯度直方图组成一个很高很高维的描述子向量

用查表替代了八重循环，大大减少了时间开销。

最笨的方法是依次循环：

1.检测窗口在输入图像中滑动

2.block在检测窗口win中滑动

3.cell在block中滑动

4.在cell中循环获取像素的梯度值

每一层循环都是2维的这样下来就是八重循环…………子子孙孙无穷尽也

作者通过预先计算好的pixData,blockData基本上化为了3重循环。

1.循环图像中的每一个检测窗口win

2.循环检测窗口内的每一个block

3.循环每一个block中的像素点，getblock()

每一层都是一维。

6、SVM分类

     计算到分类超平面的距离

四、HOG算法OpenCV实现流程

五、源码分析

http://blog.csdn.net/soidnhp/article/details/11880425

前一篇博客大体讲了下思路，对比较难理解的关系有些图示 http://blog.csdn.net/soidnhp/article/details/11874285  

[cpp]  view plain copy

1. /*M/// 
2. // 
3. //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 
4. // 
5. //  By downloading, copying, installing or using the software you agree to this license. 
6. //  If you do not agree to this license, do not download, install, 
7. //  copy or use the software. 
8. // 
9. // 
10. //                           License Agreement 
11. //                For Open Source Computer Vision Library 
12. // 
13. // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 
14. // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 
15. // Third party copyrights are property of their respective owners. 
16. // 
17. // Redistribution and use in source and binary forms, with or without modification, 
18. // are permitted provided that the following conditions are met: 
19. // 
20. //   * Redistribution's of source code must retain the above copyright notice, 
21. //     this list of conditions and the following disclaimer. 
22. // 
23. //   * Redistribution's in binary form must reproduce the above copyright notice, 
24. //     this list of conditions and the following disclaimer in the documentation 
25. //     and/or other materials provided with the distribution. 
26. // 
27. //   * The name of the copyright holders may not be used to endorse or promote products 
28. //     derived from this software without specific prior written permission. 
29. // 
30. // This software is provided by the copyright holders and contributors "as is" and 
31. // any express or implied warranties, including, but not limited to, the implied 
32. // warranties of merchantability and fitness for a particular purpose are disclaimed. 
33. // In no event shall the Intel Corporation or contributors be liable for any direct, 
34. // indirect, incidental, special, exemplary, or consequential damages 
35. // (including, but not limited to, procurement of substitute goods or services; 
36. // loss of use, data, or profits; or business interruption) however caused 
37. // and on any theory of liability, whether in contract, strict liability, 
38. // or tort (including negligence or otherwise) arising in any way out of 
39. // the use of this software, even if advised of the possibility of such damage. 
40. // 
41. //M*/  
42. #include <stdio.h>  
43. #include "precomp.hpp"  //包含了 objdetect.hpp   
44. #include <iterator>  
45. #ifdef HAVE_IPP  
46. #include "ipp.h"  
47. #endif  
48. /****************************************************************************************\ 
49.       The code below is implementation of HOG (Histogram-of-Oriented Gradients) 
50.       descriptor and object detection, introduced by Navneet Dalal and Bill Triggs. 
51.  
52.       The computed feature vectors are compatible with the 
53.       INRIA Object Detection and Localization Toolkit 
54.       (http://pascal.inrialpes.fr/soft/olt/) 
55. \****************************************************************************************/  
56.   
57. namespace cv  
58. {  
59.   
60. size_t HOGDescriptor::getDescriptorSize() const  
61. {  
62.     CV_Assert(blockSize.width % cellSize.width == 0 &&  
63.         blockSize.height % cellSize.height == 0);  
64.     CV_Assert((winSize.width - blockSize.width) % blockStride.width == 0 &&  
65.         (winSize.height - blockSize.height) % blockStride.height == 0 );  
66.     return (size_t)nbins*  
67.         (blockSize.width/cellSize.width)*  
68.         (blockSize.height/cellSize.height)*  
69.         ((winSize.width - blockSize.width)/blockStride.width + 1)*  
70.         ((winSize.height - blockSize.height)/blockStride.height + 1);//描述向量总长度  
71. }  
72.   
73. double HOGDescriptor::getWinSigma() const  
74. {  
75.     return winSigma >= 0 ? winSigma : (blockSize.width + blockSize.height)/8.; //默认-1  
76. }  
77.   
78. bool HOGDescriptor::checkDetectorSize() const  
79. {  
80.     size_t detectorSize = svmDetector.size(), descriptorSize = getDescriptorSize();  
81.     return detectorSize == 0 ||  
82.         detectorSize == descriptorSize ||  
83.         detectorSize == descriptorSize + 1;  
84. }  
85.   
86. void HOGDescriptor::setSVMDetector(InputArray _svmDetector)  
87. {  
88.     _svmDetector.getMat().convertTo(svmDetector, CV_32F);  
89.     CV_Assert( checkDetectorSize() );  
90. }  
91.   
92. #define CV_TYPE_NAME_HOG_DESCRIPTOR "opencv-object-detector-hog"  
93.   
94. bool HOGDescriptor::read(FileNode& obj)  
95. {  
96.     if( !obj.isMap() )  
97.         return false;  
98.     FileNodeIterator it = obj["winSize"].begin();  
99.     it >> winSize.width >> winSize.height;  
100.     it = obj["blockSize"].begin();  
101.     it >> blockSize.width >> blockSize.height;  
102.     it = obj["blockStride"].begin();  
103.     it >> blockStride.width >> blockStride.height;  
104.     it = obj["cellSize"].begin();  
105.     it >> cellSize.width >> cellSize.height;  
106.     obj["nbins"] >> nbins;  
107.     obj["derivAperture"] >> derivAperture;  
108.     obj["winSigma"] >> winSigma;  
109.     obj["histogramNormType"] >> histogramNormType;  
110.     obj["L2HysThreshold"] >> L2HysThreshold;  
111.     obj["gammaCorrection"] >> gammaCorrection;  
112.     obj["nlevels"] >> nlevels;  
113.   
114.     FileNode vecNode = obj["SVMDetector"];  
115.     if( vecNode.isSeq() )  
116.     {  
117.         vecNode >> svmDetector;  
118.         CV_Assert(checkDetectorSize());  
119.     }  
120.     return true;  
121. }  
122.   
123. void HOGDescriptor::write(FileStorage& fs, const String& objName) const  
124. {  
125.     if( !objName.empty() )  
126.         fs << objName;  
127.   
128.     fs << "{" CV_TYPE_NAME_HOG_DESCRIPTOR  
129.     << "winSize" << winSize  
130.     << "blockSize" << blockSize  
131.     << "blockStride" << blockStride  
132.     << "cellSize" << cellSize  
133.     << "nbins" << nbins  
134.     << "derivAperture" << derivAperture  
135.     << "winSigma" << getWinSigma()  
136.     << "histogramNormType" << histogramNormType  
137.     << "L2HysThreshold" << L2HysThreshold  
138.     << "gammaCorrection" << gammaCorrection  
139.     << "nlevels" << nlevels;  
140.     if( !svmDetector.empty() )  
141.         fs << "SVMDetector" << svmDetector;  
142.     fs << "}";  
143. }  
144.   
145. bool HOGDescriptor::load(const String& filename, const String& objname)  
146. {  
147.     FileStorage fs(filename, FileStorage::READ);  
148.     FileNode obj = !objname.empty() ? fs[objname] : fs.getFirstTopLevelNode();  
149.     return read(obj);  
150. }  
151.   
152. void HOGDescriptor::save(const String& filename, const String& objName) const  
153. {  
154.     FileStorage fs(filename, FileStorage::WRITE);  
155.     write(fs, !objName.empty() ? objName : FileStorage::getDefaultObjectName(filename));  
156. }  
157.   
158. void HOGDescriptor::copyTo(HOGDescriptor& c) const  
159. {  
160.     c.winSize = winSize;  
161.     c.blockSize = blockSize;  
162.     c.blockStride = blockStride;  
163.     c.cellSize = cellSize;  
164.     c.nbins = nbins;  
165.     c.derivAperture = derivAperture;  
166.     c.winSigma = winSigma;  
167.     c.histogramNormType = histogramNormType;  
168.     c.L2HysThreshold = L2HysThreshold;  
169.     c.gammaCorrection = gammaCorrection;  
170.     c.svmDetector = svmDetector;  
171.     c.nlevels = nlevels;  
172. }  
173. //返回 grad：梯度的模在与梯度方向相邻的两个bin的插值值，qangle：与梯度方向相邻的两个bin的编号  
174. void HOGDescriptor::computeGradient(const Mat& img, Mat& grad, Mat& qangle,  
175.                                     Size paddingTL, Size paddingBR) const  
176. {  
177.     CV_Assert( img.type() == CV_8U || img.type() == CV_8UC3 );  
178.   
179.     Size gradsize(img.cols + paddingTL.width + paddingBR.width,  
180.                   img.rows + paddingTL.height + paddingBR.height);  
181.     grad.create(gradsize, CV_32FC2);  // <magnitude*(1-alpha), magnitude*alpha>，与该点梯度方向相邻两个bin的梯度模值，由该点线性插值得到  
182.     qangle.create(gradsize, CV_8UC2); // [0..nbins-1] - quantized gradient orientation，与该点梯度方向相邻两个bin的编号  
183.     Size wholeSize;  
184.     Point roiofs;  
185.     img.locateROI(wholeSize, roiofs);   //img如果是一个大图像IMG的Region of interesting,那么IMG和img共享内存  
186.                                         //比如IMG(120x120),img取自IMG的一部分TL坐标（10,10），BR坐标（109,109）那么尺寸为（100x100）  
187.                                         //这个函数就返回父矩阵IMG的size（120x120），以及img在IMG中的坐标偏移（roiofs.x=10,roiofs.y=10）  
188.     /* 
189.     Locates the matrix header within a parent matrix. 
190.     wholeSize – Output parameter that contains the size of the whole matrix containing *this as a part 
191.     ofs – Output parameter that contains an offset of *this inside the whole matrix. 
192.     */  
193.     int i, x, y;  
194.     int cn = img.channels();  
195.   
196.     Mat_<float> _lut(1, 256); //gamma 校正Look up table,Mat_ 简化版的 Mat,元素访问直接 用（x,y），无需 .at,但是速度是一样的  
197.     const float* lut = &_lut(0,0);  //只能读  
198.   
199.     if( gammaCorrection )  
200.         for( i = 0; i < 256; i++ )  
201.             _lut(0,i) = std::sqrt((float)i);    //gammma 校正 r=0.5,暗区对比度提高，亮区对比度下降  
202.     else  
203.         for( i = 0; i < 256; i++ )  
204.             _lut(0,i) = (float)i;  
205.   
206.     AutoBuffer<int> mapbuf(gradsize.width + gradsize.height + 4); //自动buffer，就不需要我们malloc，free  
207.     int* xmap = (int*)mapbuf + 1;  
208.     int* ymap = xmap + gradsize.width + 2;  
209.   
210.     const int borderType = (int)BORDER_REFLECT_101;  
211.     //一种很奇怪的插值方式，扩展出来的边缘用原图像中的像素值，并没有真正扩展存储空间  
212.     //比如说原图为 100x100，现在要访问（-10，-10）的值，但是内存里面不不存在这个值，这种插值方法就是在原图像中找个像素点（比如（5,6））的值作为（-10,-10）的值  
213.     //也就是将扩展后的坐标范围比如（120x120）映射到（100x100）。x,y坐标分别映射，映射表存在xmap,ymap。上面的例子中xmap[-10]=5,ymap[-10]=6  
214.     for( x = -1; x < gradsize.width + 1; x++ )  
215.         xmap[x] = borderInterpolate(x - paddingTL.width + roiofs.x,wholeSize.width, borderType) - roiofs.x;  
216.     for( y = -1; y < gradsize.height + 1; y++ )  
217.         ymap[y] = borderInterpolate(y - paddingTL.height + roiofs.y,wholeSize.height, borderType) - roiofs.y;  
218.   
219.     // x- & y- derivatives for the whole row  
220.     int width = gradsize.width;  
221.     AutoBuffer<float> _dbuf(width*4);  
222.     float* dbuf = _dbuf;  
223.     Mat Dx(1, width, CV_32F, dbuf);  
224.     Mat Dy(1, width, CV_32F, dbuf + width);  
225.     Mat Mag(1, width, CV_32F, dbuf + width*2);  
226.     Mat Angle(1, width, CV_32F, dbuf + width*3);  
227.   
228.     int _nbins = nbins;  
229.     float angleScale = (float)(_nbins/CV_PI);   //算某一弧度，对应落在哪一个bin的scale  
230. #ifdef HAVE_IPP //intel的ipp库，优化  
231.     Mat lutimg(img.rows,img.cols,CV_MAKETYPE(CV_32F,cn));   //cn ,为1/3，对于类型 CV_32FC1、CV_32FC3  
232.     Mat hidxs(1, width, CV_32F);  
233.     Ipp32f* pHidxs  = (Ipp32f*)hidxs.data;  
234.     Ipp32f* pAngles = (Ipp32f*)Angle.data;  
235.   
236.     IppiSize roiSize;  
237.     roiSize.width = img.cols;  
238.     roiSize.height = img.rows;  
239.   
240.     //对原始图像，进行gamma校正，结果保存在 imglutPtr  
241.     for( y = 0; y < roiSize.height; y++ )  
242.     {  
243.        const uchar* imgPtr = img.data + y*img.step;  
244.        float* imglutPtr = (float*)(lutimg.data + y*lutimg.step);  
245.   
246.        for( x = 0; x < roiSize.width*cn; x++ )  
247.        {  
248.           imglutPtr[x] = lut[imgPtr[x]];    //查表 gamma校正  
249.        }  
250.     }  
251.   
252. #endif  
253.     //好长的循环体，计算了四个梯度的四个量 Dx，Dy, Angle,Mag,最终是保存了Angle,Mag两个量给后续的工作用  
254.     for( y = 0; y < gradsize.height; y++ )  
255.     {  
256.         //行指针(加上了补丁)  
257. #ifdef HAVE_IPP  
258.         const float* imgPtr  = (float*)(lutimg.data + lutimg.step*ymap[y]);  
259.         const float* prevPtr = (float*)(lutimg.data + lutimg.step*ymap[y-1]);  
260.         const float* nextPtr = (float*)(lutimg.data + lutimg.step*ymap[y+1]);  
261. #else  
262.         const uchar* imgPtr  = img.data + img.step*ymap[y];  
263.         const uchar* prevPtr = img.data + img.step*ymap[y-1];  
264.         const uchar* nextPtr = img.data + img.step*ymap[y+1];  
265. #endif  
266.         float* gradPtr = (float*)grad.ptr(y);   //Returns a pointer to the specified matrix row.  
267.         uchar* qanglePtr = (uchar*)qangle.ptr(y);  
268.           
269.         //计算 水平和垂直梯度 保存在 dbuf 的前两段  
270.         if( cn == 1 )  
271.         {  
272.             for( x = 0; x < width; x++ )  
273.             {  
274.                 int x1 = xmap[x];  
275. #ifdef HAVE_IPP  
276.                 dbuf[x] = (float)(imgPtr[xmap[x+1]] - imgPtr[xmap[x-1]]);   //水平微分模板 [-1 0 1]  
277.                 dbuf[width + x] = (float)(nextPtr[x1] - prevPtr[x1]);       //垂直微分模板 [-1 0 1]'  
278. #else  
279.                 dbuf[x] = (float)(lut[imgPtr[xmap[x+1]]] - lut[imgPtr[xmap[x-1]]]);     //dbuf length: width*4  
280.                 dbuf[width + x] = (float)(lut[nextPtr[x1]] - lut[prevPtr[x1]]);     //使用了IPP优化，就已经gamm校正了，这里是先gamm校正然后在计算梯度  
281. #endif  
282.             }  
283.         }  
284.         else    取B,G,R通道中梯度模最大的梯度作为该点的梯度，  
285.         {  
286.             for( x = 0; x < width; x++ )  
287.             {  
288.                 int x1 = xmap[x]*3; //height*width*element,element:8UC3/32FC3  
289.                 float dx0, dy0, dx, dy, mag0, mag;  
290. #ifdef HAVE_IPP  
291.                 const float* p2 = imgPtr + xmap[x+1]*3;   
292.                 const float* p0 = imgPtr + xmap[x-1]*3;   
293.                 //R通道的梯度  
294.                 dx0 = p2[2] - p0[2];  
295.                 dy0 = nextPtr[x1+2] - prevPtr[x1+2];      
296.                 mag0 = dx0*dx0 + dy0*dy0;  
297.                 //G通道的梯度  
298.                 dx = p2[1] - p0[1];  
299.                 dy = nextPtr[x1+1] - prevPtr[x1+1];  
300.                 mag = dx*dx + dy*dy;  
301.           
302.                 if( mag0 < mag ) //取G,R通道中梯度模最大的  
303.                 {  
304.                     dx0 = dx;  
305.                     dy0 = dy;  
306.                     mag0 = mag;  
307.                 }  
308.                 //B通道的梯度  
309.                 dx = p2[0] - p0[0];  
310.                 dy = nextPtr[x1] - prevPtr[x1];  
311.                 mag = dx*dx + dy*dy;  
312. #else  
313.                 const uchar* p2 = imgPtr + xmap[x+1]*3;  
314.                 const uchar* p0 = imgPtr + xmap[x-1]*3;  
315.   
316.                 dx0 = lut[p2[2]] - lut[p0[2]];  
317.                 dy0 = lut[nextPtr[x1+2]] - lut[prevPtr[x1+2]];  
318.                 mag0 = dx0*dx0 + dy0*dy0;  
319.   
320.                 dx = lut[p2[1]] - lut[p0[1]];  
321.                 dy = lut[nextPtr[x1+1]] - lut[prevPtr[x1+1]];  
322.                 mag = dx*dx + dy*dy;  
323.   
324.                 if( mag0 < mag )  
325.                 {  
326.                     dx0 = dx;  
327.                     dy0 = dy;  
328.                     mag0 = mag;  
329.                 }  
330.   
331.                 dx = lut[p2[0]] - lut[p0[0]];  
332.                 dy = lut[nextPtr[x1]] - lut[prevPtr[x1]];  
333.                 mag = dx*dx + dy*dy;  
334.  #endif  
335.                 if( mag0 < mag ) //取B,G,R通道中梯度模最大的  
336.                 {  
337.                     dx0 = dx;  
338.                     dy0 = dy;  
339.                     mag0 = mag;  
340.                 }  
341.   
342.                 dbuf[x] = dx0;  
343.                 dbuf[x+width] = dy0;  
344.             }  
345.         }  
346. #ifdef HAVE_IPP  
347.         ippsCartToPolar_32f((const Ipp32f*)Dx.data, (const Ipp32f*)Dy.data, (Ipp32f*)Mag.data, pAngles, width);  
348.         for( x = 0; x < width; x++ )  
349.         {  
350.            if(pAngles[x] < 0.f)  
351.              pAngles[x] += (Ipp32f)(CV_PI*2.);  
352.         }  
353.   
354.         ippsNormalize_32f(pAngles, pAngles, width, 0.5f/angleScale, 1.f/angleScale);  
355.         ippsFloor_32f(pAngles,(Ipp32f*)hidxs.data,width);  
356.         ippsSub_32f_I((Ipp32f*)hidxs.data,pAngles,width);  
357.         ippsMul_32f_I((Ipp32f*)Mag.data,pAngles,width);  
358.   
359.         ippsSub_32f_I(pAngles,(Ipp32f*)Mag.data,width);  
360.         ippsRealToCplx_32f((Ipp32f*)Mag.data,pAngles,(Ipp32fc*)gradPtr,width);  
361. #else  
362.         //计算梯度的模和角度，默认结果为弧度  
363.         cartToPolar( Dx, Dy, Mag, Angle, false );   //Calculates the magnitude and angle of 2D vectors. angle(I) = atan2(y(I); x(I))  
364. #endif  
365.         for( x = 0; x < width; x++ )  
366.         {  
367. #ifdef HAVE_IPP  
368.             int hidx = (int)pHidxs[x];  
369. #else  
370.             //保存该梯度方向在左右相邻的bin的模，本来只有一个模何来的两个？插值！  
371.             //线性插值，比如某点算出来应该属于 bin 7.6,但是我们的bin都是整数的，四舍五入，把他划分到bin 8又太粗糙了  
372.             //那就按该点到bin7,bin8的距离分配，这样部分属于8，部分属于7。  
373.             float mag = dbuf[x+width*2], angle = dbuf[x+width*3]*angleScale - 0.5f; // 每一格 pi/9, 那现在算 t落在哪一格自然是 t/(pi/9)  
374.             int hidx = cvFloor(angle);  //向下取整  
375.             angle -= hidx;  
376.             gradPtr[x*2] = mag*(1.f - angle);   //binx的大小是梯度方向和模的共同体现  
377.             gradPtr[x*2+1] = mag*angle;  
378. #endif  
379.             if( hidx < 0 )  
380.                 hidx += _nbins;  
381.             else if( hidx >= _nbins )  
382.                 hidx -= _nbins;  
383.             assert( (unsigned)hidx < (unsigned)_nbins );  
384.               
385.             //保存与该梯度方向相邻的左右两个bin编号  
386.             qanglePtr[x*2] = (uchar)hidx;   //也是向下取整  
387.             hidx++;  
388.             hidx &= hidx < _nbins ? -1 : 0;  // hidx &= ( (hidx < _nbins ) ? -1 : 0;)，如果hidx < nbins good;如果超过了，就算子bin 0 ；-1的补码是全1  
389.             qanglePtr[x*2+1] = (uchar)hidx;  
390.         }  
391.     }  
392. }  
393.   
394.   
395. struct HOGCache  
396. {  
397.     struct BlockData  
398.     {  
399.         BlockData() : histOfs(0), imgOffset() {}  
400.         int histOfs;  
401.         Point imgOffset;  
402.     };  
403.   
404.     struct PixData  
405.     {  
406.         size_t gradOfs, qangleOfs;  
407.         int histOfs[4];  
408.         float histWeights[4];  
409.         float gradWeight;  
410.     };  
411.   
412.     HOGCache();  
413.     HOGCache(const HOGDescriptor* descriptor,  
414.         const Mat& img, Size paddingTL, Size paddingBR,  
415.         bool useCache, Size cacheStride);  
416.     virtual ~HOGCache() {};  
417.     virtual void init(const HOGDescriptor* descriptor,  
418.         const Mat& img, Size paddingTL, Size paddingBR,  
419.         bool useCache, Size cacheStride);  
420.   
421.     Size windowsInImage(Size imageSize, Size winStride) const;  
422.     Rect getWindow(Size imageSize, Size winStride, int idx) const;  
423.   
424.     const float* getBlock(Point pt, float* buf);  
425.     virtual void normalizeBlockHistogram(float* histogram) const;  
426.   
427.     vector<PixData> pixData;  
428.     vector<BlockData> blockData;  
429.   
430.     bool useCache;  
431.     vector<int> ymaxCached;  
432.     Size winSize, cacheStride;  
433.     Size nblocks, ncells;  
434.     int blockHistogramSize;  
435.     int count1, count2, count4;  
436.     Point imgoffset;  
437.     Mat_<float> blockCache;  
438.     Mat_<uchar> blockCacheFlags;  
439.   
440.     Mat grad, qangle;  
441.     const HOGDescriptor* descriptor;  
442. };  
443.   
444.   
445. HOGCache::HOGCache()  
446. {  
447.     useCache = false;  
448.     blockHistogramSize = count1 = count2 = count4 = 0;  
449.     descriptor = 0;  
450. }  
451.   
452. HOGCache::HOGCache(const HOGDescriptor* _descriptor,  
453.         const Mat& _img, Size _paddingTL, Size _paddingBR,  
454.         bool _useCache, Size _cacheStride)  
455. {  
456.     init(_descriptor, _img, _paddingTL, _paddingBR, _useCache, _cacheStride);  
457. }  
458.   
459. void HOGCache::init(const HOGDescriptor* _descriptor,  
460.         const Mat& _img, Size _paddingTL, Size _paddingBR,  
461.         bool _useCache, Size _cacheStride)  
462. {  
463.     descriptor = _descriptor;  
464.     cacheStride = _cacheStride;  
465.     useCache = _useCache;  
466.     /*--------------------------------------计算梯度----------------------------------------------*/  
467.     //返回值  
468.     //size：img.cols + paddingTL.width + paddingBR.width,img.rows + paddingTL.height + paddingBR.height,类型 CV_32FC2  
469.     //grad：梯度的模在与梯度方向相邻的两个bin的插值值  
470.     //qangle：与梯度方向相邻的两个bin的编号  
471.     descriptor->computeGradient(_img, grad, qangle, _paddingTL, _paddingBR);  
472.     imgoffset = _paddingTL;  
473.   
474.     winSize = descriptor->winSize;   //默认值：winSize(64,128)  
475.     Size blockSize = descriptor->blockSize;//blockSize(16,16)  
476.     Size blockStride = descriptor->blockStride;//lockStride(8,8)  
477.     Size cellSize = descriptor->cellSize;//cellSize(8,8)  
478.     int i, j, nbins = descriptor->nbins;//nbins(9)  
479.     int rawBlockSize = blockSize.width*blockSize.height;  
480.   
481.     nblocks = Size((winSize.width - blockSize.width)/blockStride.width + 1,  
482.                    (winSize.height - blockSize.height)/blockStride.height + 1);  
483.            //这种算法非常直观，也许你会觉得可以和下面一样直接除，但是当(winSize.height - blockSize.height) % blockStride.height 不为0时，就不一定  
484.            //比如 blockSize=4,blockStride=3,winSize.width =9,那么直接除9/3=3，但是只能有两个block, 4|3|2,只能移动一次  
485.     ncells = Size(blockSize.width/cellSize.width, blockSize.height/cellSize.height);  
486.     blockHistogramSize = ncells.width*ncells.height*nbins;//默认2*2*9  
487.   
488.     if( useCache )  //  
489.     {  
490.         Size cacheSize((grad.cols - blockSize.width)/cacheStride.width+1,  
491.                        (winSize.height/cacheStride.height)+1);  
492.         blockCache.create(cacheSize.height, cacheSize.width*blockHistogramSize);  
493.         blockCacheFlags.create(cacheSize);  
494.         size_t cacheRows = blockCache.rows;  
495.         ymaxCached.resize(cacheRows);  
496.         for(size_t ii = 0; ii < cacheRows; ii++ )  
497.             ymaxCached[ii] = -1;  
498.     }  
499.   
500.     Mat_<float> weights(blockSize);//16*16 高斯模板  
501.     float sigma = (float)descriptor->getWinSigma();//-1  
502.     float scale = 1.f/(sigma*sigma*2);  
503.   
504.     for(i = 0; i < blockSize.height; i++)  
505.         for(j = 0; j < blockSize.width; j++)  
506.         {  
507.             float di = i - blockSize.height*0.5f;  
508.             float dj = j - blockSize.width*0.5f;//中心  
509.             weights(i,j) = std::exp(-(di*di + dj*dj)*scale);//weights(i,j)=exp(-(distance/sigma)^2)  
510.         }  
511.   
512.     blockData.resize(nblocks.width*nblocks.height);  
513.     pixData.resize(rawBlockSize*3);// vector::resize(newsize,value),不是Mat::resize,16*16*3个结构体  
514.     /*  
515.     vector<PixData> pixData; 
516.     struct PixData{ 
517.         size_t gradOfs, qangleOfs; 
518.         int histOfs[4]; 
519.         float histWeights[4]; 
520.         float gradWeight; 
521.     }; 
522.     */  
523.     // Initialize 2 lookup tables, pixData & blockData.  
524.     // Here is why:  
525.     //  
526.     // The detection algorithm runs in 4 nested loops (at each pyramid layer):  
527.     //  loop over the windows within the input image  
528.     //    loop over the blocks within each window  
529.     //      loop over the cells within each block  
530.     //        loop over the pixels in each cell  
531.     //  
532.     // As each of the loops runs over a 2-dimensional array,  
533.     // we could get 8(!) nested loops in total, which is very-very slow.  
534.     //  
535.     // To speed the things up, we do the following:  
536.     //   1. loop over windows is unrolled in the HOGDescriptor::{compute|detect} methods;  
537.     //         inside we compute the current search window using getWindow() method.  
538.     //         Yes, it involves some overhead (function call + couple of divisions),  
539.     //         but it's tiny in fact.  
540.     //   2. loop over the blocks is also unrolled. Inside we use pre-computed blockData[j]  
541.     //         to set up gradient and histogram pointers.  
542.     //   3. loops over cells and pixels in each cell are merged  
543.     //       (since there is no overlap between cells, each pixel in the block is processed once)  
544.     //      and also unrolled. Inside we use PixData[k] to access the gradient values and  
545.     //      update the histogram  
546.     //  
547.     count1 = count2 = count4 = 0;  
548.     for( j = 0; j < blockSize.width; j++ )//16,先水平，再垂直  
549.         for( i = 0; i < blockSize.height; i++ )//16  
550.         {  
551.             PixData* data = 0;  
552.             float cellX = (j+0.5f)/cellSize.width - 0.5f;   //这是干什么 ？？？  
553.             float cellY = (i+0.5f)/cellSize.height - 0.5f;  
554.             int icellX0 = cvFloor(cellX);   //-1（j=0..3）,0(j=4..11),1(j=12..15)  
555.             int icellY0 = cvFloor(cellY);     
556.             int icellX1 = icellX0 + 1, icellY1 = icellY0 + 1;//0 1 2   
557.             cellX -= icellX0;  
558.             cellY -= icellY0;  
559.               
560.             if( (unsigned)icellX0 < (unsigned)ncells.width &&    // icellX0 == 0  
561.                 (unsigned)icellX1 < (unsigned)ncells.width ) //判断条件时特别小心，int 转成了 unsigned,(unsigned)(-1)=2^32-1，真对这作者无语  
562.             {  
563.                 //  icellX0 == 0，icellY0 == 0 对相邻的四个cell都有贡献，即F,J,G,K区域  
564.                 if( (unsigned)icellY0 < (unsigned)ncells.height && // cellX，cellY 范围（0,1）  
565.                     (unsigned)icellY1 < (unsigned)ncells.height )  
566.                 {  
567.                     data = &pixData[rawBlockSize*2 + (count4++)];  
568.                     data->histOfs[0] = (icellX0*ncells.height + icellY0)*nbins;//cell 0 在整个block的bin中的偏移  
569.                     data->histWeights[0] = (1.f - cellX)*(1.f - cellY);  //到对称中心的“距离”即cell 3  
570.                     data->histOfs[1] = (icellX1*ncells.height + icellY0)*nbins;//cell 1的偏移 2*9  
571.                     data->histWeights[1] = cellX*(1.f - cellY);         //到对称中心的“距离”即 cell 2  
572.                     data->histOfs[2] = (icellX0*ncells.height + icellY1)*nbins;//cell 2的偏移 1*9  
573.                     data->histWeights[2] = (1.f - cellX)*cellY;         //到对称中心的“距离”即 cell 1  
574.                     data->histOfs[3] = (icellX1*ncells.height + icellY1)*nbins;//cell 3的偏移3*9  
575.                     data->histWeights[3] = cellX*cellY;                 //到对称中心的“距离”即 cell 0  
576.                 }  
577.                 else    // icellX0 == 0，icellY0 == -1/1，对左右相邻的两个cell有贡献，即B,C,N,O  
578.                 {  
579.                     // cellX 范围（0,1），cellY 范围 （0.5,1）/（0,0.5）  
580.                     data = &pixData[rawBlockSize + (count2++)];  
581.                     //下部分的cellY范围也落在（0.5,1），icellY1==icellY0 == 1  
582.                     if( (unsigned)icellY0 < (unsigned)ncells.height )//icellY0 == 1  
583.                     {  
584.                         icellY1 = icellY0;  
585.                         cellY = 1.f - cellY;  
586.                     }  
587.                     data->histOfs[0] = (icellX0*ncells.height + icellY1)*nbins;// 上部分0；下部分1  
588.                     data->histWeights[0] = (1.f - cellX)*cellY;  
589.                     data->histOfs[1] = (icellX1*ncells.height + icellY1)*nbins;// 上部分2；下部分3  
590.                     data->histWeights[1] = cellX*cellY;  
591.                     data->histOfs[2] = data->histOfs[3] = 0;// 均为0  
592.                     data->histWeights[2] = data->histWeights[3] = 0;  
593.                 }  
594.             }  
595.             else //icellX0 == -1/1,cellX范围（0.5,1）/（0,0.5）  
596.             {  
597.                 //右部分的cellX范围也落在（0.5,1），icellX1==icellX0 == 1  
598.                 if( (unsigned)icellX0 < (unsigned)ncells.width )  
599.                 {  
600.                     icellX1 = icellX0;  
601.                     cellX = 1.f - cellX;  
602.                 }  
603.                 //E,H,I,L  
604.                 if( (unsigned)icellY0 < (unsigned)ncells.height &&  
605.                     (unsigned)icellY1 < (unsigned)ncells.height )  
606.                 {  
607.                     data = &pixData[rawBlockSize + (count2++)];  
608.                     data->histOfs[0] = (icellX1*ncells.height + icellY0)*nbins;//左：0，右：2*9  
609.                     data->histWeights[0] = cellX*(1.f - cellY);  
610.                     data->histOfs[1] = (icellX1*ncells.height + icellY1)*nbins;//左：1*9 右：3*9  
611.                     data->histWeights[1] = cellX*cellY;  
612.                     data->histOfs[2] = data->histOfs[3] = 0;  
613.                     data->histWeights[2] = data->histWeights[3] = 0;  
614.                 }  
615.                 // A,D,M,P  
616.                 else  
617.                 {  
618.                     data = &pixData[count1++];  
619.                     if( (unsigned)icellY0 < (unsigned)ncells.height )  
620.                     {  
621.                         icellY1 = icellY0;  
622.                         cellY = 1.f - cellY;  
623.                     }  
624.                     data->histOfs[0] = (icellX1*ncells.height + icellY1)*nbins;  
625.                     data->histWeights[0] = cellX*cellY;  
626.                     data->histOfs[1] = data->histOfs[2] = data->histOfs[3] = 0;  
627.                     data->histWeights[1] = data->histWeights[2] = data->histWeights[3] = 0;  
628.                 }  
629.             }  
630.             data->gradOfs = (grad.cols*i + j)*2; //block窗口的（0,0）位置有相对于整个图像的偏移，此偏移为相对于block(0,0)的偏移  
631.             data->qangleOfs = (qangle.cols*i + j)*2;//计算方式很古怪，但是你画张图就明白了（grad.cols*i多算的==+j少算的），实际上 block窗口的（0,0）的offset加上此offset就可以直接在grad中找到对应的梯度  
632.             data->gradWeight = weights(i,j); //该点的高斯权值，大小与到block中心的距离成反比  
633.         }  
634.   
635.     assert( count1 + count2 + count4 == rawBlockSize );//16*16  
636.     // defragment pixData,整理碎片.  
637.     //数据合并  xxx.........yyy.........zzz.........->xxxyyyzzz..................  
638.     //（.表示未赋值空间，x为count1存储的数据，y为count2存储的数据...）  
639.     for( j = 0; j < count2; j++ )  
640.         pixData[j + count1] = pixData[j + rawBlockSize];  
641.     for( j = 0; j < count4; j++ )  
642.         pixData[j + count1 + count2] = pixData[j + rawBlockSize*2];  
643.     count2 += count1;  
644.     count4 += count2;  
645.   
646.     // initialize blockData  
647.     /* 
648.     struct BlockData{ 
649.         BlockData() : histOfs(0), imgOffset() {} 
650.         int histOfs; 
651.         Point imgOffset; 
652.     }; 
653.     */  
654.     for( j = 0; j < nblocks.width; j++ )  
655.         for( i = 0; i < nblocks.height; i++ )  
656.         {  
657.             BlockData& data = blockData[j*nblocks.height + i];  
658.             data.histOfs = (j*nblocks.height + i)*blockHistogramSize;  
659.             data.imgOffset = Point(j*blockStride.width,i*blockStride.height);  
660.         }  
661. }  
662.   
663.   
664. const float* HOGCache::getBlock(Point pt, float* buf)  
665. {  
666.     float* blockHist = buf;  
667.     assert(descriptor != 0);  
668.   
669.     Size blockSize = descriptor->blockSize;  
670.     pt += imgoffset; //imgoffset:padingTL,先前减去pading，现在又加过来，为嘛？？？？  
671.   
672.     CV_Assert( (unsigned)pt.x <= (unsigned)(grad.cols - blockSize.width) &&  
673.                (unsigned)pt.y <= (unsigned)(grad.rows - blockSize.height) );  
674.   
675.     if( useCache ) //默认未使用  
676.     {  
677.         CV_Assert( pt.x % cacheStride.width == 0 &&  
678.                    pt.y % cacheStride.height == 0 );  
679.         Point cacheIdx(pt.x/cacheStride.width,  
680.                       (pt.y/cacheStride.height) % blockCache.rows);  
681.         if( pt.y != ymaxCached[cacheIdx.y] )  
682.         {  
683.             Mat_<uchar> cacheRow = blockCacheFlags.row(cacheIdx.y);  
684.             cacheRow = (uchar)0;  
685.             ymaxCached[cacheIdx.y] = pt.y;  
686.         }  
687.   
688.         blockHist = &blockCache[cacheIdx.y][cacheIdx.x*blockHistogramSize];  
689.         uchar& computedFlag = blockCacheFlags(cacheIdx.y, cacheIdx.x);  
690.         if( computedFlag != 0 )  
691.             return blockHist;  
692.         computedFlag = (uchar)1; // set it at once, before actual computing  
693.     }  
694.   
695.     int k, C1 = count1, C2 = count2, C4 = count4;//64,128,256  
696.     const float* gradPtr = (const float*)(grad.data + grad.step*pt.y) + pt.x*2;//block(0,0)在与其梯度方向相邻的两个bin上的插值分量  
697.     const uchar* qanglePtr = qangle.data + qangle.step*pt.y + pt.x*2;//与block(0,0)梯度方向相邻的两个bin的bin编号  
698.   
699.     CV_Assert( blockHist != 0 );  
700. #ifdef HAVE_IPP  
701.     ippsZero_32f(blockHist,blockHistogramSize);  
702. #else  
703.     for( k = 0; k < blockHistogramSize; k++ )  
704.         blockHist[k] = 0.f;  
705. #endif  
706.   
707.     const PixData* _pixData = &pixData[0];//pixData在init中已经计算好了，相对于block（0,0）的偏移  
708.     //ADMP  
709.     for( k = 0; k < C1; k++ )  
710.     {  
711.         const PixData& pk = _pixData[k];  
712.         const float* a = gradPtr + pk.gradOfs;//该点的梯度指针  
713.         float w = pk.gradWeight*pk.histWeights[0];  
714.         const uchar* h = qanglePtr + pk.qangleOfs;//该点的梯度编号指针  
715.         int h0 = h[0], h1 = h[1];//梯度编号  
716.         float* hist = blockHist + pk.histOfs[0];//该点的hist指针  
717.         float t0 = hist[h0] + a[0]*w;  
718.         float t1 = hist[h1] + a[1]*w;  
719.         hist[h0] = t0; hist[h1] = t1;  
720.     }  
721.     //BCEINPHL  
722.     for( ; k < C2; k++ )  
723.     {  
724.         const PixData& pk = _pixData[k];  
725.         const float* a = gradPtr + pk.gradOfs;  
726.         float w, t0, t1, a0 = a[0], a1 = a[1];  
727.         const uchar* h = qanglePtr + pk.qangleOfs;  
728.         int h0 = h[0], h1 = h[1];  
729.   
730.         float* hist = blockHist + pk.histOfs[0];  
731.         w = pk.gradWeight*pk.histWeights[0];  
732.         t0 = hist[h0] + a0*w;  
733.         t1 = hist[h1] + a1*w;  
734.         hist[h0] = t0; hist[h1] = t1;  
735.   
736.         hist = blockHist + pk.histOfs[1];  
737.         w = pk.gradWeight*pk.histWeights[1];  
738.         t0 = hist[h0] + a0*w;  
739.         t1 = hist[h1] + a1*w;  
740.         hist[h0] = t0; hist[h1] = t1;  
741.     }  
742.     //FGJK  
743.     for( ; k < C4; k++ )  
744.     {  
745.         const PixData& pk = _pixData[k];  
746.         const float* a = gradPtr + pk.gradOfs;  
747.         float w, t0, t1, a0 = a[0], a1 = a[1];  
748.         const uchar* h = qanglePtr + pk.qangleOfs;  
749.         int h0 = h[0], h1 = h[1];  
750.   
751.         float* hist = blockHist + pk.histOfs[0];  
752.         w = pk.gradWeight*pk.histWeights[0];  
753.         t0 = hist[h0] + a0*w;  
754.         t1 = hist[h1] + a1*w;  
755.         hist[h0] = t0; hist[h1] = t1;  
756.   
757.         hist = blockHist + pk.histOfs[1];  
758.         w = pk.gradWeight*pk.histWeights[1];  
759.         t0 = hist[h0] + a0*w;  
760.         t1 = hist[h1] + a1*w;  
761.         hist[h0] = t0; hist[h1] = t1;  
762.   
763.         hist = blockHist + pk.histOfs[2];  
764.         w = pk.gradWeight*pk.histWeights[2];  
765.         t0 = hist[h0] + a0*w;  
766.         t1 = hist[h1] + a1*w;  
767.         hist[h0] = t0; hist[h1] = t1;  
768.   
769.         hist = blockHist + pk.histOfs[3];  
770.         w = pk.gradWeight*pk.histWeights[3];  
771.         t0 = hist[h0] + a0*w;  
772.         t1 = hist[h1] + a1*w;  
773.         hist[h0] = t0; hist[h1] = t1;  
774.     }  
775.   
776.     normalizeBlockHistogram(blockHist);  
777.   
778.     return blockHist;  
779. }  
780.   
781. //L2HysThreshold：先L2归一化，再限制所有的值的范围（0,0.2），再重新L2归一化  
782. void HOGCache::normalizeBlockHistogram(float* _hist) const  
783. {  
784.     float* hist = &_hist[0];  
785. #ifdef HAVE_IPP  
786.     size_t sz = blockHistogramSize;  
787. #else  
788.     size_t i, sz = blockHistogramSize;  
789. #endif  
790.   
791.     float sum = 0;  
792. #ifdef HAVE_IPP  
793.     ippsDotProd_32f(hist,hist,sz,&sum);  
794. #else  
795.     for( i = 0; i < sz; i++ )  
796.         sum += hist[i]*hist[i];  
797. #endif  
798.   
799.     float scale = 1.f/(std::sqrt(sum)+sz*0.1f), thresh = (float)descriptor->L2HysThreshold;  
800. #ifdef HAVE_IPP  
801.     ippsMulC_32f_I(scale,hist,sz);  
802.     ippsThreshold_32f_I( hist, sz, thresh, ippCmpGreater );  
803.     ippsDotProd_32f(hist,hist,sz,&sum);  
804. #else  
805.     for( i = 0, sum = 0; i < sz; i++ )  
806.     {  
807.         hist[i] = std::min(hist[i]*scale, thresh);  
808.         sum += hist[i]*hist[i];  
809.     }  
810. #endif  
811.   
812.     scale = 1.f/(std::sqrt(sum)+1e-3f);  
813. #ifdef HAVE_IPP  
814.     ippsMulC_32f_I(scale,hist,sz);  
815. #else  
816.     for( i = 0; i < sz; i++ )  
817.         hist[i] *= scale;  
818. #endif  
819. }  
820.   
821.   
822. Size HOGCache::windowsInImage(Size imageSize, Size winStride) const  
823. {  
824.     return Size((imageSize.width - winSize.width)/winStride.width + 1,  
825.                 (imageSize.height - winSize.height)/winStride.height + 1);  
826. }  
827.   
828. Rect HOGCache::getWindow(Size imageSize, Size winStride, int idx) const  
829. {  
830.     int nwindowsX = (imageSize.width - winSize.width)/winStride.width + 1;  
831.     int y = idx / nwindowsX;  
832.     int x = idx - nwindowsX*y;  
833.     return Rect( x*winStride.width, y*winStride.height, winSize.width, winSize.height );  
834. }  
835.   
836.   
837. void HOGDescriptor::compute(const Mat& img, vector<float>& descriptors,  
838.                             Size winStride, Size padding,  
839.                             const vector<Point>& locations) const  
840. {  
841.     if( winStride == Size() )  
842.         winStride = cellSize;  
843.     Size cacheStride(gcd(winStride.width, blockStride.width),  
844.                      gcd(winStride.height, blockStride.height));  
845.     size_t nwindows = locations.size();  
846.     padding.width = (int)alignSize(std::max(padding.width, 0), cacheStride.width);  
847.     padding.height = (int)alignSize(std::max(padding.height, 0), cacheStride.height);  
848.     Size paddedImgSize(img.cols + padding.width*2, img.rows + padding.height*2);  
849.   
850.     HOGCache cache(this, img, padding, padding, nwindows == 0, cacheStride);  
851.   
852.     if( !nwindows )  
853.         nwindows = cache.windowsInImage(paddedImgSize, winStride).area();  
854.   
855.     const HOGCache::BlockData* blockData = &cache.blockData[0];  
856.   
857.     int nblocks = cache.nblocks.area();  
858.     int blockHistogramSize = cache.blockHistogramSize;  
859.     size_t dsize = getDescriptorSize(); //检测窗口内描述子的总长度，即总bin数  
860.     descriptors.resize(dsize*nwindows);  //整张图片的描述子长度  
861.   
862.     for( size_t i = 0; i < nwindows; i++ )  
863.     {  
864.         float* descriptor = &descriptors[i*dsize];  
865.   
866.         Point pt0;  
867.         if( !locations.empty() )  
868.         {  
869.             pt0 = locations[i];  
870.             if( pt0.x < -padding.width || pt0.x > img.cols + padding.width - winSize.width ||  
871.                 pt0.y < -padding.height || pt0.y > img.rows + padding.height - winSize.height )  
872.                 continue;  
873.         }  
874.         else//默认是这种情况  
875.         {  
876.             pt0 = cache.getWindow(paddedImgSize, winStride, (int)i).tl() - Point(padding);  
877.             CV_Assert(pt0.x % cacheStride.width == 0 && pt0.y % cacheStride.height == 0);  
878.         }  
879.   
880.         for( int j = 0; j < nblocks; j++ )  
881.         {  
882.             const HOGCache::BlockData& bj = blockData[j];  
883.             Point pt = pt0 + bj.imgOffset;  
884.   
885.             float* dst = descriptor + bj.histOfs;  
886.             const float* src = cache.getBlock(pt, dst);  
887.             if( src != dst )  
888. #ifdef HAVE_IPP  
889.                ippsCopy_32f(src,dst,blockHistogramSize);  
890. #else  
891.                 for( int k = 0; k < blockHistogramSize; k++ )  
892.                     dst[k] = src[k];  
893. #endif  
894.         }  
895.     }  
896. }  
897.   
898.   
899. void HOGDescriptor::detect(const Mat& img,  
900.     vector<Point>& hits, vector<double>& weights, double hitThreshold,  
901.     Size winStride, Size padding, const vector<Point>& locations) const  
902.     /* 
903.     img – Source image. CV_8UC1 and CV_8UC4 types are supported for now. 
904.     found_locations – Left-top corner points of detected objects boundaries. 
905.     hit_threshold – Threshold for the distance between features and SVM classifying plane. 
906.     win_stride – Window stride. It must be a multiple of block stride. 
907.     padding – Mock parameter to keep the CPU interface compatibility. It must be (0,0). 
908.     */  
909.     //hog->detect(smallerImg, locations, hitsWeights, hitThreshold, winStride, padding);  
910.     //smallerImg size:(cvRound(img.cols/scale), cvRound(img.rows/scale));  
911. {  
912.     hits.clear();  
913.     if( svmDetector.empty() )  
914.         return;  
915.   
916.     if( winStride == Size() )//未指定winStride的情况下，winStride==（8,8）  
917.         winStride = cellSize;  
918.     Size cacheStride(gcd(winStride.width, blockStride.width),  
919.                      gcd(winStride.height, blockStride.height));// gcd,求最大公约数，默认结果（8,8）  
920.     size_t nwindows = locations.size(); // 默认：0  
921.     //对于我们自己设定的LTpading=BRpading=pading,进行调整使得pading的宽高与casheStride的宽高对齐，类似于4字节补充对齐  
922.     padding.width = (int)alignSize(std::max(padding.width, 0), cacheStride.width);//alignSize(m, n)，返回n的倍数中大于等于m的最小值  
923.     padding.height = (int)alignSize(std::max(padding.height, 0), cacheStride.height);  
924.     Size paddedImgSize(img.cols + padding.width*2, img.rows + padding.height*2);  
925.     /*--------------------------------------------------------------------*/  
926.     //  1.计算梯度的模，方向  
927.     //  2.预先计算好了一个block的bin基偏移、高斯权重、插值距离  
928.     HOGCache cache(this, img, padding, padding, nwindows == 0, cacheStride);    //调用了，computeGradient，计算了pading后的梯度  
929.                                                                                 //Note:尺度变化时，重新计算了梯度  
930.                                                                                 //histOfs = (j*nblocks.height + i)*blockHistogramSize;  
931.                                                                                 //imgOffset = Point(j*blockStride.width,i*blockStride.height);  
932.   
933.     if( !nwindows )  
934.         nwindows = cache.windowsInImage(paddedImgSize, winStride).area();//整个img 的检测窗口数  
935.   
936.     const HOGCache::BlockData* blockData = &cache.blockData[0];  
937.   
938.     int nblocks = cache.nblocks.area(); //检测窗口内的block数  
939.     int blockHistogramSize = cache.blockHistogramSize; //一个block的histogram的bin总数，2*2*9  
940.     size_t dsize = getDescriptorSize();//一个窗口的描述子总数  
941.   
942.     double rho = svmDetector.size() > dsize ? svmDetector[dsize] : 0;// > 成立的情况，即svm的 惩罚项系数 C 不为0  
943.     vector<float> blockHist(blockHistogramSize);  
944.   
945.     for( size_t i = 0; i < nwindows; i++ )  
946.     {  
947.         Point pt0;  
948.         if( !locations.empty() )  
949.         {  
950.             pt0 = locations[i];  
951.             if( pt0.x < -padding.width || pt0.x > img.cols + padding.width - winSize.width ||  
952.                 pt0.y < -padding.height || pt0.y > img.rows + padding.height - winSize.height )  
953.                 continue;  
954.         }  
955.         else  
956.         {  
957.             //得到第i个检测窗口在pading之后的图像中的区域，这里减去pading,后面geitblock又pt += imgoffset;  
958.             pt0 = cache.getWindow(paddedImgSize, winStride, (int)i).tl()- Point(padding);     
959.             CV_Assert(pt0.x % cacheStride.width == 0 && pt0.y % cacheStride.height == 0);  
960.         }  
961.         double s = rho;  
962.         const float* svmVec = &svmDetector[0];  
963. #ifdef HAVE_IPP  
964.         int j;  
965. #else  
966.         int j, k;  
967. #endif  
968.         for( j = 0; j < nblocks; j++, svmVec += blockHistogramSize )  
969.         {  
970.             const HOGCache::BlockData& bj = blockData[j];//检测窗口中第j个block  
971.             // .histOfs = (j*nblocks.height + i)*blockHistogramSize;  
972.             // .imgOffset = Point(j*blockStride.width,i*blockStride.height);  
973.             Point pt = pt0 + bj.imgOffset;  //得到第i个检测窗口中第j个block在pading之后的图像中的TL坐标  
974.             //得到以pt为TL坐标的block的hist（2*2*9）数据  
975.             const float* vec = cache.getBlock(pt, &blockHist[0]);  
976. #ifdef HAVE_IPP  
977.             Ipp32f partSum;  
978.             ippsDotProd_32f(vec,svmVec,blockHistogramSize,&partSum);  
979.             s += (double)partSum;  
980. #else  
981.             //计算到分类超平面的距离  
982.             for( k = 0; k <= blockHistogramSize - 4; k += 4 )  
983.                 s += vec[k]*svmVec[k] + vec[k+1]*svmVec[k+1] +  
984.                     vec[k+2]*svmVec[k+2] + vec[k+3]*svmVec[k+3];  
985.             for( ; k < blockHistogramSize; k++ )  
986.                 s += vec[k]*svmVec[k];  
987. #endif  
988.         }  
989.         if( s >= hitThreshold )  
990.         {  
991.             hits.push_back(pt0);  
992.             weights.push_back(s);  
993.         }  
994.     }  
995. }  
996.   
997. void HOGDescriptor::detect(const Mat& img, vector<Point>& hits, double hitThreshold,  
998.                            Size winStride, Size padding, const vector<Point>& locations) const  
999. {  
1000.     vector<double> weightsV;  
1001.     detect(img, hits, weightsV, hitThreshold, winStride, padding, locations);  
1002. }  
1003.   
1004. class HOGInvoker : public ParallelLoopBody  
1005. {  
1006. public:  
1007.     HOGInvoker( const HOGDescriptor* _hog, const Mat& _img,  
1008.                 double _hitThreshold, Size _winStride, Size _padding,  
1009.                 const double* _levelScale, std::vector<Rect> * _vec, Mutex* _mtx,  
1010.                 std::vector<double>* _weights=0, std::vector<double>* _scales=0 )  
1011.     {  
1012.         hog = _hog;  
1013.         img = _img;  
1014.         hitThreshold = _hitThreshold;  
1015.         winStride = _winStride;  
1016.         padding = _padding;  
1017.         levelScale = _levelScale;  
1018.         vec = _vec;  
1019.         weights = _weights;  
1020.         scales = _scales;  
1021.         mtx = _mtx;  
1022.     }  
1023.   
1024.     void operator()( const Range& range ) const  
1025.     {  
1026.         int i, i1 = range.start, i2 = range.end;  
1027.         double minScale = i1 > 0 ? levelScale[i1] : i2 > 1 ? levelScale[i1+1] : std::max(img.cols, img.rows);  
1028.         Size maxSz(cvCeil(img.cols/minScale), cvCeil(img.rows/minScale));  
1029.         Mat smallerImgBuf(maxSz, img.type());  
1030.         vector<Point> locations;  
1031.         vector<double> hitsWeights;  
1032.   
1033.         for( i = i1; i < i2; i++ )  
1034.         {  
1035.             double scale = levelScale[i];  
1036.             Size sz(cvRound(img.cols/scale), cvRound(img.rows/scale));//cvRound：四舍五入  
1037.             Mat smallerImg(sz, img.type(), smallerImgBuf.data);  
1038.             if( sz == img.size() )  //scale==1，不需要用 smallerImgBuf的空间，所以最大的内存应该是 scale==levelScale[i1+1]的情况  
1039.                 smallerImg = Mat(sz, img.type(), img.data, img.step);//共享数据  
1040.             else  
1041.                 resize(img, smallerImg, sz);//dst的内存空间超过src时，dst的空间是不是并没有缩小呢，  
1042.                                             //也就是说是不是先释放内存，再按照新的size重新申请,从程序上看一直霸占原始内存空间才能起到减少内存申请释放所耗费的时间  
1043.             hog->detect(smallerImg, locations, hitsWeights, hitThreshold, winStride, padding);  
1044.             Size scaledWinSize = Size(cvRound(hog->winSize.width*scale), cvRound(hog->winSize.height*scale));  
1045.   
1046.             mtx->lock();  
1047.             for( size_t j = 0; j < locations.size(); j++ )  
1048.             {  
1049.                 vec->push_back(Rect(cvRound(locations[j].x*scale),  
1050.                                     cvRound(locations[j].y*scale),  
1051.                                     scaledWinSize.width, scaledWinSize.height));//恢复为原图像中的位置  
1052.                 if (scales)  
1053.                 {  
1054.                     scales->push_back(scale);  
1055.                 }  
1056.             }  
1057.             mtx->unlock();  
1058.   
1059.             if (weights && (!hitsWeights.empty()))  
1060.             {  
1061.                 mtx->lock();  
1062.                 for (size_t j = 0; j < locations.size(); j++)  
1063.                 {  
1064.                     weights->push_back(hitsWeights[j]);  
1065.                 }  
1066.                 mtx->unlock();  
1067.             }  
1068.         }  
1069.     }  
1070.   
1071.     const HOGDescriptor* hog;  
1072.     Mat img;  
1073.     double hitThreshold;  
1074.     Size winStride;  
1075.     Size padding;  
1076.     const double* levelScale;  
1077.     std::vector<Rect>* vec;  
1078.     std::vector<double>* weights;  
1079.     std::vector<double>* scales;  
1080.     Mutex* mtx;  
1081. };  
1082.   
1083.   
1084. void HOGDescriptor::detectMultiScale(  
1085.     const Mat& img, vector<Rect>& foundLocations, vector<double>& foundWeights,  
1086.     double hitThreshold, Size winStride, Size padding,  
1087.     double scale0, double finalThreshold, bool useMeanshiftGrouping) const  
1088.     /* 
1089.     img – Source image. 
1090.     foundLocations – Detected objects boundaries. 
1091.     foundWeights   -   
1092.     hit_threshold – Threshold for the distance between features and SVM classifying plane，到分类超平面的距离，越大则要求越严格，一般设为0. 
1093.     win_stride – Window stride. It must be a multiple of block stride. 
1094.     padding – Mock parameter to keep the CPU interface compatibility. It must be (0,0). 
1095.     scale0 – Coefficient of the detection window increase. 
1096.     group_threshold – Coefficient to regulate the similarity threshold（相似性阈值）. When detected, some  
1097.     objects can be covered by many rectangles. 0 means not to perform groupin 
1098.     */  
1099. {  
1100.     double scale = 1.;  
1101.     int levels = 0;  
1102.   
1103.     vector<double> levelScale;  
1104.     //要使检测窗口的尺度变大有两种方案，法一：图像尺寸不变，增大检测窗口的大小；法二：反过来，检测窗口不变，缩小图片  
1105.     //这里使用的正是第二种方法  
1106.     for( levels = 0; levels < nlevels; levels++ )    //默认值：64  
1107.     {  
1108.         levelScale.push_back(scale);  
1109.         if( cvRound(img.cols/scale) < winSize.width ||   // 小于64层尺度的尺度数由是由图形的尺寸 和 scale0 决定的，  
1110.             cvRound(img.rows/scale) < winSize.height || //当图像缩放到已经小于检测窗口时就已经不能在增加尺度了  
1111.             scale0 <= 1 )  
1112.             break;  
1113.         scale *= scale0;  
1114.     }  
1115.     levels = std::max(levels, 1);  
1116.     levelScale.resize(levels);  
1117.   
1118.     std::vector<Rect> allCandidates;  
1119.     std::vector<double> tempScales;  
1120.     std::vector<double> tempWeights;  
1121.     std::vector<double> foundScales;  
1122.     Mutex mtx;  
1123.     //[begin，end)  
1124.     //TBB，参考 http://blog.csdn.net/zoufeiyy/article/details/1887579  
1125.     parallel_for_(Range(0, (int)levelScale.size()),  
1126.                  HOGInvoker(this, img, hitThreshold, winStride, padding, &levelScale[0], &allCandidates, &mtx, &tempWeights, &tempScales));  
1127.   
1128.     std::copy(tempScales.begin(), tempScales.end(), back_inserter(foundScales));//把tempScales的内容添加到 foundScales 后面  
1129.     foundLocations.clear();  
1130.     std::copy(allCandidates.begin(), allCandidates.end(), back_inserter(foundLocations));  
1131.     foundWeights.clear();  
1132.     std::copy(tempWeights.begin(), tempWeights.end(), back_inserter(foundWeights));  
1133.   
1134.     if ( useMeanshiftGrouping )  
1135.     {  
1136.         groupRectangles_meanshift(foundLocations, foundWeights, foundScales, finalThreshold, winSize);  
1137.     }  
1138.     else  
1139.     {  
1140.         groupRectangles(foundLocations, (int)finalThreshold, 0.2);  
1141.     }  
1142. }  
1143.   
1144. void HOGDescriptor::detectMultiScale(const Mat& img, vector<Rect>& foundLocations,  
1145.                                      double hitThreshold, Size winStride, Size padding,  
1146.                                      double scale0, double finalThreshold, bool useMeanshiftGrouping) const  
1147. {  
1148.     vector<double> foundWeights;  
1149.     detectMultiScale(img, foundLocations, foundWeights, hitThreshold, winStride,  
1150.                      padding, scale0, finalThreshold, useMeanshiftGrouping);  
1151. }  
1152.   
1153. typedef RTTIImpl<HOGDescriptor> HOGRTTI;  
1154.   
1155. CvType hog_type( CV_TYPE_NAME_HOG_DESCRIPTOR, HOGRTTI::isInstance,  
1156.                  HOGRTTI::release, HOGRTTI::read, HOGRTTI::write, HOGRTTI::clone);  
1157.   
1158. vector<float> HOGDescriptor::getDefaultPeopleDetector()  
1159. {  
1160.     static const float detector[] = {  
1161.        0.05359386f, -0.14721455f, -0.05532170f, 0.05077307f,  
1162.        0.11547081f, -0.04268804f, 0.04635834f, -0.05468199f, 0.08232084f,  
1163.        0.10424068f, -0.02294518f, 0.01108519f, 0.01378693f, 0.11193510f,  
1164.        0.01268418f, 0.08528346f, -0.06309239f, 0.13054633f, 0.08100729f,  
1165.        -0.05209739f, -0.04315529f, 0.09341384f, 0.11035026f, -0.07596218f,  
1166.        -0.05517511f, -0.04465296f, 0.02947334f, 0.04555536f,  
1167.        -3.55954492e-003f, 0.07818956f, 0.07730991f, 0.07890715f, 0.06222893f,  
1168.        0.09001380f, -0.03574381f, 0.03414327f, 0.05677258f, -0.04773581f,  
1169.        0.03746637f, -0.03521175f, 0.06955440f, -0.03849038f, 0.01052293f,  
1170.        0.01736112f, 0.10867710f, 0.08748853f, 3.29739624e-003f, 0.10907028f,  
1171.        0.07913758f, 0.10393070f, 0.02091867f, 0.11594022f, 0.13182420f,  
1172.        0.09879354f, 0.05362710f, -0.06745391f, -7.01260753e-003f,  
1173.        5.24702156e-003f, 0.03236255f, 0.01407916f, 0.02207983f, 0.02537322f,  
1174.        0.04547948f, 0.07200756f, 0.03129894f, -0.06274468f, 0.02107014f,  
1175.        0.06035208f, 0.08636236f, 4.53164103e-003f, 0.02193363f, 0.02309801f,  
1176.        0.05568166f, -0.02645093f, 0.04448695f, 0.02837519f, 0.08975694f,  
1177.        0.04461516f, 0.08975355f, 0.07514391f, 0.02306982f, 0.10410084f,  
1178.        0.06368385f, 0.05943464f, 4.58420580e-003f, 0.05220337f, 0.06675851f,  
1179.        0.08358569f, 0.06712101f, 0.06559004f, -0.03930482f, -9.15936660e-003f,  
1180.        -0.05897915f, 0.02816453f, 0.05032348f, 0.06780671f, 0.03377650f,  
1181.        -6.09417039e-004f, -0.01795146f, -0.03083684f, -0.01302475f,  
1182.        -0.02972313f, 7.88706727e-003f, -0.03525961f, -2.50397739e-003f,  
1183.        0.05245084f, 0.11791293f, -0.02167498f, 0.05299332f, 0.06640524f,  
1184.        0.05190265f, -8.27316567e-003f, 0.03033127f, 0.05842173f,  
1185.        -4.01050318e-003f, -6.25105947e-003f, 0.05862958f, -0.02465461f,  
1186.        0.05546781f, -0.08228195f, -0.07234028f, 0.04640540f, -0.01308254f,  
1187.        -0.02506191f, 0.03100746f, -0.04665651f, -0.04591486f, 0.02949927f,  
1188.        0.06035462f, 0.02244646f, -0.01698639f, 0.01040041f, 0.01131170f,  
1189.        0.05419579f, -0.02130277f, -0.04321722f, -0.03665198f, 0.01126490f,  
1190.        -0.02606488f, -0.02228328f, -0.02255680f, -0.03427236f,  
1191.        -7.75165204e-003f, -0.06195229f, 8.21638294e-003f, 0.09535975f,  
1192.        -0.03709979f, -0.06942501f, 0.14579427f, -0.05448192f, -0.02055904f,  
1193.        0.05747357f, 0.02781788f, -0.07077577f, -0.05178314f, -0.10429011f,  
1194.        -0.11235505f, 0.07529039f, -0.07559302f, -0.08786739f, 0.02983843f,  
1195.        0.02667585f, 0.01382199f, -0.01797496f, -0.03141199f, -0.02098101f,  
1196.        0.09029204f, 0.04955018f, 0.13718739f, 0.11379953f, 1.80019124e-003f,  
1197.        -0.04577610f, -1.11108483e-003f, -0.09470536f, -0.11596080f,  
1198.        0.04489342f, 0.01784211f, 3.06850672e-003f, 0.10781866f,  
1199.        3.36498418e-003f, -0.10842580f, -0.07436839f, -0.10535070f,  
1200.        -0.01866805f, 0.16057891f, -5.07316366e-003f, -0.04295658f,  
1201.        -5.90488780e-003f, 8.82003549e-003f, -0.01492646f, -0.05029279f,  
1202.        -0.12875880f, 8.78831954e-004f, -0.01297184f, -0.07592774f,  
1203.        -0.02668831f, -6.93787413e-004f, 0.02406698f, -0.01773298f,  
1204.        -0.03855745f, -0.05877856f, 0.03259695f, 0.12826584f, 0.06292590f,  
1205.        -4.10733931e-003f, 0.10996531f, 0.01332991f, 0.02088735f, 0.04037504f,  
1206.        -0.05210760f, 0.07760046f, 0.06399347f, -0.05751930f, -0.10053057f,  
1207.        0.07505023f, -0.02139782f, 0.01796176f, 2.34400877e-003f, -0.04208319f,  
1208.        0.07355055f, 0.05093350f, -0.02996780f, -0.02219072f, 0.03355330f,  
1209.        0.04418742f, -0.05580705f, -0.05037573f, -0.04548179f, 0.01379514f,  
1210.        0.02150671f, -0.02194211f, -0.13682702f, 0.05464972f, 0.01608082f,  
1211.        0.05309116f, 0.04701022f, 1.33690401e-003f, 0.07575664f, 0.09625306f,  
1212.        8.92647635e-003f, -0.02819123f, 0.10866830f, -0.03439325f,  
1213.        -0.07092371f, -0.06004780f, -0.02712298f, -7.07467366e-003f,  
1214.        -0.01637020f, 0.01336790f, -0.10313606f, 0.04906582f, -0.05732445f,  
1215.        -0.02731079f, 0.01042235f, -0.08340668f, 0.03686501f, 0.06108340f,  
1216.        0.01322748f, -0.07809529f, 0.03774724f, -0.03413248f, -0.06096525f,  
1217.        -0.04212124f, -0.07982176f, -1.25973229e-003f, -0.03045501f,  
1218.        -0.01236493f, -0.06312395f, 0.04789570f, -0.04602066f, 0.08576570f,  
1219.        0.02521080f, 0.02988098f, 0.10314583f, 0.07060035f, 0.04520544f,  
1220.        -0.04426654f, 0.13146530f, 0.08386490f, 0.02164590f, -2.12280243e-003f,  
1221.        -0.03686353f, -0.02074944f, -0.03829959f, -0.01530596f, 0.02689708f,  
1222.        0.11867401f, -0.06043470f, -0.02785023f, -0.04775074f, 0.04878745f,  
1223.        0.06350956f, 0.03494788f, 0.01467400f, 1.17890188e-003f, 0.04379614f,  
1224.        2.03681854e-003f, -0.03958609f, -0.01072688f, 6.43705716e-003f,  
1225.        0.02996500f, -0.03418507f, -0.01960307f, -0.01219154f,  
1226.        -4.37000440e-003f, -0.02549453f, 0.02646318f, -0.01632513f,  
1227.        6.46516960e-003f, -0.01929734f, 4.78711911e-003f, 0.04962371f,  
1228.        0.03809111f, 0.07265724f, 0.05758125f, -0.03741554f, 0.01648608f,  
1229.        -8.45285598e-003f, 0.03996826f, -0.08185477f, 0.02638875f,  
1230.        -0.04026615f, -0.02744674f, -0.04071517f, 1.05096330e-003f,  
1231.        -0.04741232f, -0.06733172f, 8.70434940e-003f, -0.02192543f,  
1232.        1.35350740e-003f, -0.03056974f, -0.02975521f, -0.02887780f,  
1233.        -0.01210713f, -0.04828526f, -0.09066251f, -0.09969629f, -0.03665164f,  
1234.        -8.88111943e-004f, -0.06826669f, -0.01866150f, -0.03627640f,  
1235.        -0.01408288f, 0.01874239f, -0.02075835f, 0.09145175f, -0.03547291f,  
1236.        0.05396780f, 0.04198981f, 0.01301925f, -0.03384354f, -0.12201976f,  
1237.        0.06830920f, -0.03715654f, 9.55848210e-003f, 5.05685573e-003f,  
1238.        0.05659294f, 3.90764466e-003f, 0.02808490f, -0.05518097f, -0.03711621f,  
1239.        -0.02835565f, -0.04420464f, -0.01031947f, 0.01883466f,  
1240.        -8.49525444e-003f, -0.09419250f, -0.01269387f, -0.02133371f,  
1241.        -0.10190815f, -0.07844430f, 2.43644323e-003f, -4.09610150e-003f,  
1242.        0.01202551f, -0.06452291f, -0.10593818f, -0.02464746f, -0.02199699f,  
1243.        -0.07401930f, 0.07285886f, 8.87513801e-004f, 9.97662079e-003f,  
1244.        8.46779719e-003f, 0.03730333f, -0.02905126f, 0.03573337f, -0.04393689f,  
1245.        -0.12014472f, 0.03176554f, -2.76015815e-003f, 0.10824566f, 0.05090732f,  
1246.        -3.30179278e-003f, -0.05123822f, 5.04784798e-003f, -0.05664124f,  
1247.        -5.99415926e-003f, -0.05341901f, -0.01221393f, 0.01291318f,  
1248.        9.91760660e-003f, -7.56987557e-003f, -0.06193124f, -2.24549137e-003f,  
1249.        0.01987562f, -0.02018840f, -0.06975540f, -0.06601523f, -0.03349112f,  
1250.        -0.08910118f, -0.03371435f, -0.07406893f, -0.02248047f, -0.06159951f,  
1251.        2.77751544e-003f, -0.05723337f, -0.04792468f, 0.07518548f,  
1252.        2.77279224e-003f, 0.04211938f, 0.03100502f, 0.05278448f, 0.03954679f,  
1253.        -0.03006846f, -0.03851741f, -0.02792403f, -0.02875333f, 0.01531280f,  
1254.        0.02186953f, -0.01989829f, 2.50679464e-003f, -0.10258728f,  
1255.        -0.04785743f, -0.02887216f, 3.85063468e-003f, 0.01112236f,  
1256.        8.29218887e-003f, -0.04822981f, -0.04503597f, -0.03713100f,  
1257.        -0.06988008f, -0.11002295f, -2.69209221e-003f, 1.85383670e-003f,  
1258.        -0.05921049f, -0.06105053f, -0.08458050f, -0.04527602f,  
1259.        8.90329306e-004f, -0.05875023f, -2.68602883e-003f, -0.01591195f,  
1260.        0.03631859f, 0.05493166f, 0.07300330f, 5.53333294e-003f, 0.06400407f,  
1261.        0.01847740f, -5.76280477e-003f, -0.03210877f, 4.25160583e-003f,  
1262.        0.01166520f, -1.44864211e-003f, 0.02253744f, -0.03367080f, 0.06983195f,  
1263.        -4.22323542e-003f, -8.89401045e-003f, -0.07943393f, 0.05199728f,  
1264.        0.06065201f, 0.04133492f, 1.44032843e-003f, -0.09585235f, -0.03964731f,  
1265.        0.04232114f, 0.01750465f, -0.04487902f, -7.59733608e-003f, 0.02011171f,  
1266.        0.04673622f, 0.09011173f, -0.07869188f, -0.04682482f, -0.05080139f,  
1267.        -3.99383716e-003f, -0.05346331f, 0.01085723f, -0.03599333f,  
1268.        -0.07097908f, 0.03551549f, 0.02680387f, 0.03471529f, 0.01790393f,  
1269.        0.05471273f, 9.62048303e-003f, -0.03180215f, 0.05864431f, 0.02330614f,  
1270.        0.01633144f, -0.05616681f, -0.10245429f, -0.08302189f, 0.07291322f,  
1271.        -0.01972590f, -0.02619633f, -0.02485327f, -0.04627592f,  
1272.        1.48853404e-003f, 0.05514185f, -0.01270860f, -0.01948900f, 0.06373586f,  
1273.        0.05002292f, -0.03009798f, 8.76216311e-003f, -0.02474238f,  
1274.        -0.05504891f, 1.74034527e-003f, -0.03333667f, 0.01524987f, 0.11663762f,  
1275.        -1.32344989e-003f, -0.06608453f, 0.05687166f, -6.89525274e-004f,  
1276.        -0.04402352f, 0.09450210f, -0.04222684f, -0.05360983f, 0.01779531f,  
1277.        0.02561388f, -0.11075410f, -8.77790991e-003f, -0.01099504f,  
1278.        -0.10380266f, 0.03103457f, -0.02105741f, -0.07371717f, 0.05146710f,  
1279.        0.10581432f, -0.08617968f, -0.02892107f, 0.01092199f, 0.14551543f,  
1280.        -2.24320893e-003f, -0.05818033f, -0.07390742f, 0.05701261f,  
1281.        0.12937020f, -0.04986651f, 0.10182415f, 0.05028650f, 0.12515625f,  
1282.        0.09175041f, 0.06404983f, 0.01523394f, 0.09460562f, 0.06106631f,  
1283.        -0.14266998f, -0.02926703f, 0.02762171f, 0.02164151f,  
1284.        -9.58488265e-004f, -0.04231362f, -0.09866509f, 0.04322244f,  
1285.        0.05872034f, -0.04838847f, 0.06319253f, 0.02443798f, -0.03606876f,  
1286.        9.38737206e-003f, 0.04289991f, -0.01027411f, 0.08156885f, 0.08751175f,  
1287.        -0.13191354f, 8.16054735e-003f, -0.01452161f, 0.02952677f, 0.03615945f,  
1288.        -2.09128903e-003f, 0.02246693f, 0.09623287f, 0.09412123f, -0.02924758f,  
1289.        -0.07815186f, -0.02203079f, -2.02566991e-003f, 0.01094733f,  
1290.        -0.01442332f, 0.02838561f, 0.11882371f, 7.28798332e-003f, -0.10345965f,  
1291.        0.07561217f, -0.02049661f, 4.44177445e-003f, 0.01609347f, -0.04893158f,  
1292.        -0.08758243f, -7.67420698e-003f, 0.08862378f, 0.06098121f, 0.06565887f,  
1293.        7.32981879e-003f, 0.03558407f, -0.03874352f, -0.02490055f,  
1294.        -0.06771075f, 0.09939223f, -0.01066077f, 0.01382995f, -0.07289080f,  
1295.        7.47184316e-003f, 0.10621431f, -0.02878659f, 0.02383525f, -0.03274646f,  
1296.        0.02137008f, 0.03837290f, 0.02450992f, -0.04296818f, -0.02895143f,  
1297.        0.05327370f, 0.01499020f, 0.04998732f, 0.12938657f, 0.09391870f,  
1298.        0.04292390f, -0.03359194f, -0.06809492f, 0.01125796f, 0.17290455f,  
1299.        -0.03430733f, -0.06255233f, -0.01813114f, 0.11726857f, -0.06127599f,  
1300.        -0.08677909f, -0.03429872f, 0.04684938f, 0.08161420f, 0.03538774f,  
1301.        0.01833884f, 0.11321855f, 0.03261845f, -0.04826299f, 0.01752407f,  
1302.        -0.01796414f, -0.10464549f, -3.30041884e-003f, 2.29343961e-004f,  
1303.        0.01457292f, -0.02132982f, -0.02602923f, -9.87351313e-003f,  
1304.        0.04273872f, -0.02103316f, -0.07994065f, 0.02614958f, -0.02111666f,  
1305.        -0.06964913f, -0.13453490f, -0.06861878f, -6.09341264e-003f,  
1306.        0.08251446f, 0.15612499f, 2.46531400e-003f, 8.88424646e-003f,  
1307.        -0.04152999f, 0.02054853f, 0.05277953f, -0.03087788f, 0.02817579f,  
1308.        0.13939077f, 0.07641046f, -0.03627627f, -0.03015098f, -0.04041540f,  
1309.        -0.01360690f, -0.06227205f, -0.02738223f, 0.13577610f, 0.15235767f,  
1310.        -0.05392922f, -0.11175954f, 0.02157129f, 0.01146481f, -0.05264937f,  
1311.        -0.06595174f, -0.02749175f, 0.11812254f, 0.17404149f, -0.06137035f,  
1312.        -0.11003478f, -0.01351621f, -0.01745916f, -0.08577441f, -0.04469909f,  
1313.        -0.06106115f, 0.10559758f, 0.20806813f, -0.09174948f, 7.09621934e-004f,  
1314.        0.03579374f, 0.07215115f, 0.02221742f, 0.01827742f, -7.90785067e-003f,  
1315.        0.01489554f, 0.14519960f, -0.06425831f, 0.02990399f, -1.80181325e-003f,  
1316.        -0.01401528f, -0.04171134f, -3.70530109e-003f, -0.09090481f,  
1317.        0.09520713f, 0.08845516f, -0.02651753f, -0.03016730f, 0.02562448f,  
1318.        0.03563816f, -0.03817881f, 0.01433385f, 0.02256983f, 0.02872120f,  
1319.        0.01001934f, -0.06332260f, 0.04338406f, 0.07001807f, -0.04705722f,  
1320.        -0.07318907f, 0.02630457f, 0.03106382f, 0.06648342f, 0.10913180f,  
1321.        -0.01630815f, 0.02910308f, 0.02895109f, 0.08040254f, 0.06969310f,  
1322.        0.06797734f, 6.08639978e-003f, 4.16588830e-003f, 0.08926726f,  
1323.        -0.03123648f, 0.02700146f, 0.01168734f, -0.01631594f, 4.61015804e-003f,  
1324.        8.51359498e-003f, -0.03544224f, 0.03571994f, 4.29766066e-003f,  
1325.        -0.01970077f, -8.79793242e-003f, 0.09607988f, 0.01544222f,  
1326.        -0.03923707f, 0.07308586f, 0.06061262f, 1.31683104e-004f,  
1327.        -7.98222050e-003f, 0.02399261f, -0.06084389f, -0.02743429f,  
1328.        -0.05475523f, -0.04131311f, 0.03559756f, 0.03055342f, 0.02981433f,  
1329.        0.14860515f, 0.01766787f, 0.02945257f, 0.04898238f, 0.01026922f,  
1330.        0.02811658f, 0.08267091f, 0.02732154f, -0.01237693f, 0.11760156f,  
1331.        0.03802063f, -0.03309754f, 5.24957618e-003f, -0.02460510f, 0.02691451f,  
1332.        0.05399988f, -0.10133506f, 0.06385437f, -0.01818005f, 0.02259503f,  
1333.        0.03573135f, 0.01042848f, -0.04153402f, -0.04043029f, 0.01643575f,  
1334.        0.08326677f, 4.61383024e-004f, -0.05308095f, -0.08536223f,  
1335.        -1.61011645e-003f, -0.02163720f, -0.01783352f, 0.03859637f,  
1336.        0.08498885f, -0.01725216f, 0.08625131f, 0.10995087f, 0.09177644f,  
1337.        0.08498347f, 0.07646490f, 0.05580502f, 0.02693516f, 0.09996913f,  
1338.        0.09070327f, 0.06667200f, 0.05873008f, -0.02247842f, 0.07772321f,  
1339.        0.12408436f, 0.12629253f, -8.41997913e-004f, 0.01477783f, 0.09165990f,  
1340.        -2.98401713e-003f, -0.06466447f, -0.07057302f, 2.09516948e-004f,  
1341.        0.02210209f, -0.02158809f, -0.08602506f, -0.02284836f,  
1342.        4.01876355e-003f, 9.56660323e-003f, -0.02073978f, -0.04635138f,  
1343.        -7.59423291e-003f, -0.01377393f, -0.04559359f, -0.13284740f,  
1344.        -0.08671406f, -0.03654395f, 0.01142869f, 0.03287891f, -0.04392983f,  
1345.        0.06142959f, 0.17710890f, 0.10385257f, 0.01329137f, 0.10067633f,  
1346.        0.12450829f, -0.04476709f, 0.09049144f, 0.04589312f, 0.11167907f,  
1347.        0.08587538f, 0.04767583f, 1.67188141e-003f, 0.02359802f, -0.03808852f,  
1348.        0.03126272f, -0.01919029f, -0.05698918f, -0.02365112f, -0.06519032f,  
1349.        -0.05599358f, -0.07097308f, -0.03301812f, -0.04719102f, -0.02566297f,  
1350.        0.01324074f, -0.09230672f, -0.05518232f, -0.04712864f, -0.03380903f,  
1351.        -0.06719479f, 0.01183908f, -0.09326738f, 0.01642865f, 0.03789867f,  
1352.        -6.61567831e-003f, 0.07796386f, 0.07246574f, 0.04706347f, -0.02523437f,  
1353.        -0.01696830f, -0.08068866f, 0.06030888f, 0.10527060f, -0.06611756f,  
1354.        0.02977346f, 0.02621830f, 0.01913855f, -0.08479366f, -0.06322418f,  
1355.        -0.13570616f, -0.07644490f, 9.31900274e-003f, -0.08095149f,  
1356.        -0.10197903f, -0.05204025f, 0.01413151f, -0.07800411f, -0.01885122f,  
1357.        -0.07509381f, -0.10136326f, -0.05212355f, -0.09944065f,  
1358.        -1.33606605e-003f, -0.06342617f, -0.04178550f, -0.12373723f,  
1359.        -0.02832736f, -0.06057501f, 0.05830070f, 0.07604282f, -0.06462587f,  
1360.        8.02447461e-003f, 0.11580125f, 0.12332212f, 0.01978462f,  
1361.        -2.72378162e-003f, 0.05850752f, -0.04674481f, 0.05148062f,  
1362.        -2.62542837e-003f, 0.11253355f, 0.09893716f, 0.09785093f, -0.04659257f,  
1363.        -0.01102429f, -0.07002308f, 0.03088913f, -0.02565549f, -0.07671449f,  
1364.        3.17443861e-003f, -0.10783514f, -0.02314270f, -0.11089555f,  
1365.        -0.01024768f, 0.03116021f, -0.04964825f, 0.02281825f, 5.50005678e-003f,  
1366.        -0.08427856f, -0.14685495f, -0.07719755f, -0.13342668f, -0.04525511f,  
1367.        -0.09914210f, 0.02588859f, 0.03469279f, 0.04664020f, 0.11688190f,  
1368.        0.09647275f, 0.10857815f, -0.01448726f, 0.04299758f, -0.06763151f,  
1369.        1.33257592e-003f, 0.14331576f, 0.07574340f, 0.09166205f, 0.05674926f,  
1370.        0.11325553f, -0.01106494f, 0.02062161f, -0.11484840f, -0.07492137f,  
1371.        -0.02864293f, -0.01275638f, -0.06946032f, -0.10101652f, -0.04113498f,  
1372.        -0.02214783f, -0.01273942f, -0.07480393f, -0.10556041f, -0.07622112f,  
1373.        -0.09988393f, -0.11453961f, -0.12073903f, -0.09412795f, -0.07146588f,  
1374.        -0.04054537f, -0.06127083f, 0.04221122f, 0.07688113f, 0.04099256f,  
1375.        0.12663734f, 0.14683802f, 0.21761774f, 0.12525328f, 0.18431792f,  
1376.        -1.66402373e-003f, 2.37777247e-003f, 0.01445475f, 0.03509416f,  
1377.        0.02654697f, 0.01716739f, 0.05374011f, 0.02944174f, 0.11323927f,  
1378.        -0.01485456f, -0.01611330f, -1.85554172e-003f, -0.01708549f,  
1379.        -0.05435753f, -0.05302101f, 0.05260378f, -0.03582945f,  
1380.        -3.42867890e-004f, 1.36076682e-003f, -0.04436073f, -0.04228432f,  
1381.        0.03281291f, -0.05480836f, -0.10197772f, -0.07206279f, -0.10741059f,  
1382.        -0.02366946f, 0.10278475f, -2.74783419e-003f, -0.03242477f,  
1383.        0.02308955f, 0.02835869f, 0.10348799f, 0.19580358f, 0.10252027f,  
1384.        0.08039929f, 0.05525554f, -0.13250865f, -0.14395352f, 3.13586881e-003f,  
1385.        -0.03387071f, 8.94669443e-003f, 0.05406157f, -4.97324532e-003f,  
1386.        -0.01189114f, 2.82919413e-004f, -0.03901557f, -0.04898705f,  
1387.        0.02164520f, -0.01382906f, -0.01850416f, 0.01869347f, -0.02450060f,  
1388.        0.02291678f, 0.08196463f, 0.03309153f, -0.10629974f, 0.02473924f,  
1389.        0.05344394f, -0.02404823f, -0.03243643f, -5.55244600e-003f,  
1390.        -0.08009996f, 0.02811539f, 0.04235742f, 0.01859004f, 0.04902123f,  
1391.        -0.01438252f, -0.01526853f, 0.02044195f, -0.05008660f, 0.04244113f,  
1392.        0.07611816f, 0.04950470f, -0.06020549f, -4.26026015e-003f, 0.13133512f,  
1393.        -0.01438738f, -0.01958807f, -0.04044152f, -0.12425045f,  
1394.        2.84353318e-003f, -0.05042776f, -0.09121484f, 7.34345755e-003f,  
1395.        0.09388847f, 0.11800314f, 4.72295098e-003f, 4.44378285e-003f,  
1396.        -0.07984917f, -0.03613737f, 0.04490915f, -0.02246483f, 0.04681071f,  
1397.        0.05240871f, 0.02157206f, -0.04603431f, -0.01197929f, -0.02748779f,  
1398.        0.13621049f, 0.08812155f, -0.07802048f, 4.86458559e-003f, -0.01598836f,  
1399.        0.01024450f, -0.03463517f, -0.02304239f, -0.08692665f, 0.06655128f,  
1400.        0.05785803f, -0.12640759f, 0.02307472f, 0.07337402f, 0.07525434f,  
1401.        0.04943763f, -0.02241034f, -0.09978238f, 0.14487994f, -0.06570521f,  
1402.        -0.07855482f, 0.02830222f, -5.29603509e-004f, -0.04669895f,  
1403.        -0.11822784f, -0.12246452f, -0.15365660f, -0.02969127f, 0.08078201f,  
1404.        0.13512598f, 0.11505685f, 0.04740673f, 0.01376022f, -0.05852978f,  
1405.        -0.01537809f, -0.05541119f, 0.02491065f, -0.02870786f, 0.02760978f,  
1406.        0.23836176f, 0.22347429f, 0.10306466f, -0.06919070f, -0.10132039f,  
1407.        -0.20198342f, -0.05040560f, 0.27163076f, 0.36987007f, 0.34540465f,  
1408.        0.29095781f, 0.05649706f, 0.04125737f, 0.07505883f, -0.02737836f,  
1409.        -8.43431335e-003f, 0.07368195f, 0.01653876f, -0.09402955f,  
1410.        -0.09574359f, 0.01474337f, -0.07128561f, -0.03460737f, 0.11438941f,  
1411.        0.13752601f, -0.06385452f, -0.06310338f, 8.19548313e-003f, 0.11622470f,  
1412.        5.05133113e-003f, -0.07602754f, 0.06695660f, 0.25723928f, 0.09037900f,  
1413.        0.28826267f, 0.13165380f, -0.05312614f, -0.02137198f, -0.03442232f,  
1414.        -0.06255679f, 0.03899667f, 0.18391028f, 0.26016650f, 0.03374462f,  
1415.        0.01860465f, 0.19077586f, 0.18160543f, 3.43634398e-003f, -0.03036782f,  
1416.        0.19683038f, 0.35378191f, 0.24968483f, -0.03222649f, 0.28972381f,  
1417.        0.43091634f, 0.30778357f, 0.02335266f, -0.09877399f, -6.85245218e-003f,  
1418.        0.08945240f, -0.08150686f, 0.02792493f, 0.24806842f, 0.17338486f,  
1419.        0.06231801f, -0.10432383f, -0.16653322f, -0.13197899f, -0.08531576f,  
1420.        -0.19271527f, -0.13536365f, 0.22240199f, 0.39219588f, 0.26597717f,  
1421.        -0.01231649f, 0.01016179f, 0.13379875f, 0.12018334f, -0.04852953f,  
1422.        -0.07915270f, 0.07036012f, 3.87723115e-003f, -0.06126805f,  
1423.        -0.15015170f, -0.11406515f, -0.08556531f, -0.07429333f, -0.16115491f,  
1424.        0.13214062f, 0.25691369f, 0.05697750f, 0.06861912f, -6.02903729e-003f,  
1425.        -7.94562511e-003f, 0.04799571f, 0.06695165f, -0.01926842f, 0.06206308f,  
1426.        0.13450983f, -0.06381495f, -2.98370165e-003f, -0.03482971f,  
1427.        7.53991678e-003f, 0.03895611f, 0.11464261f, 0.01669971f,  
1428.        8.27818643e-003f, -7.49160210e-003f, -0.11712562f, -0.10650621f,  
1429.        -0.10353880f, -0.04994106f, -7.65618810e-004f, 0.03023767f,  
1430.        -0.04759270f, -0.07302686f, -0.05825012f, -0.13156348f, -0.10639747f,  
1431.        -0.19393684f, -0.09973683f, -0.07918908f, 4.63177625e-004f,  
1432.        -6.61382044e-004f, 0.15853868f, 0.08561199f, -0.07660093f,  
1433.        -0.08015265f, -0.06164073f, 0.01882577f, -7.29908410e-004f,  
1434.        0.06840892f, 0.03843764f, 0.20274927f, 0.22028814f, -5.26101235e-003f,  
1435.        0.01452435f, -0.06331623f, 0.02865064f, 0.05673740f, 0.12171564f,  
1436.        0.03837196f, 0.03555467f, -0.02662914f, -0.10280123f, -0.06526285f,  
1437.        -0.11066351f, -0.08988424f, -0.10103678f, 8.10526591e-003f,  
1438.        5.95238712e-003f, 0.02617721f, -0.01705742f, -0.10897956f,  
1439.        -0.08004991f, -0.11271993f, -0.06185647f, -0.06103712f, 0.01597041f,  
1440.        -0.05923606f, 0.09410726f, 0.22858568f, 0.03263380f, 0.06772990f,  
1441.        -0.09003516f, 0.01017870f, 0.01931688f, 0.08628357f, -0.01430009f,  
1442.        0.10954945f, 0.16612452f, -0.02434544f, -0.03310068f, -0.04236627f,  
1443.        0.01212392f, -6.15046406e-003f, 0.06954194f, 0.03015283f, 0.01787957f,  
1444.        0.02781667f, -0.05561153f, -8.96244217e-003f, -0.04971489f,  
1445.        0.07510284f, 0.01775282f, 0.05889897f, -0.07981427f, 0.03647643f,  
1446.        -3.73833324e-003f, -0.08894575f, -0.06429435f, -0.08068276f,  
1447.        0.03567704f, -0.07131936f, -7.21910037e-003f, -0.09566668f,  
1448.        0.17886090f, 0.14911725f, 0.02070032f, -0.05017120f, -0.04992622f,  
1449.        0.01570143f, -0.09906903f, 0.06456193f, 0.15329507f, 0.18820767f,  
1450.        0.11689861f, -0.01178513f, -0.02225163f, -0.01905318f, 0.10271224f,  
1451.        -7.27029052e-003f, 0.11664233f, 0.14796902f, 0.07771893f, 0.02400013f,  
1452.        -0.05361797f, -0.01972888f, 0.01376177f, 0.06740040f, -0.06525395f,  
1453.        0.05726178f, -0.02404981f, -0.14018567f, -0.02074987f, -0.04621970f,  
1454.        -0.04688627f, -0.01842059f, 0.07722727f, -0.04852883f, 0.01529004f,  
1455.        -0.19639495f, 0.10817073f, 0.03795860f, -0.09435206f, -0.07984378f,  
1456.        -0.03383440f, 0.11081333f, 0.02237366f, 0.12703256f, 0.21613893f,  
1457.        0.02918790f, 4.66472283e-003f, -0.10274266f, -0.04854131f,  
1458.        -3.46305710e-003f, 0.08652268f, 0.02251546f, 0.09636052f, 0.17180754f,  
1459.        -0.09272388f, 4.59174305e-004f, -0.11723048f, -0.12210111f,  
1460.        -0.15547538f, 0.07218186f, -0.05297846f, 0.03779940f, 0.05150875f,  
1461.        -0.03802310f, 0.03870645f, -0.15250699f, -0.08696499f, -0.02021560f,  
1462.        0.04118926f, -0.15177974f, 0.01577647f, 0.10249301f, 7.50041893e-003f,  
1463.        0.01721806f, -0.06828983f, -0.02397596f, -0.06598977f, -0.04317593f,  
1464.        -0.08064980f, 6.66632550e-003f, 0.03333484f, 0.07093620f, 0.08231064f,  
1465.        -0.06577903f, -0.06698844f, -0.06984019f, -0.06508023f, -0.14145090f,  
1466.        -0.02393239f, 0.06485303f, 8.83263443e-003f, 0.09251080f, -0.07557579f,  
1467.        -0.05067699f, -0.09798748f, -0.06703258f, -0.14056294f, 0.03245994f,  
1468.        0.12554143f, 0.01761621f, 0.12980327f, -0.04081950f, -0.11906909f,  
1469.        -0.14813015f, -0.08376863f, -0.12200681f, 0.04988137f, 0.05424247f,  
1470.        -3.90952639e-003f, 0.03255733f, -0.12717837f, -0.07461493f,  
1471.        -0.05703964f, -0.01736189f, -0.08026433f, -0.05433894f, -0.01719359f,  
1472.        0.02886275f, 0.01772653f, -0.09163518f, 3.57789593e-003f, -0.10129993f,  
1473.        -0.02653764f, -0.08131415f, -0.03847986f, -7.62157550e-004f,  
1474.        0.06486648f, 0.19675669f, -0.04919156f, -0.07059129f, -0.04857785f,  
1475.        -0.01042383f, -0.08328653f, 0.03660302f, -0.03696846f, 0.04969259f,  
1476.        0.08241162f, -0.12514858f, -0.06122676f, -0.03750202f,  
1477.        6.52989605e-003f, -0.10247213f, 0.02568346f, 4.51781414e-003f,  
1478.        -0.03734229f, -0.01131264f, -0.05412074f, 8.89345480e-004f,  
1479.        -0.12388977f, -0.05959237f, -0.12418608f, -0.06151643f, -0.07310260f,  
1480.        0.02441575f, 0.07023528f, -0.07548289f, -7.57147965e-004f,  
1481.        -0.09061348f, -0.08112976f, -0.06920306f, 9.54394229e-003f,  
1482.        -0.01219902f, 1.21273217e-003f, -8.88989680e-003f, -0.08309301f,  
1483.        -0.04552661f, -0.10739882f, -0.05691034f, -0.13928030f, 0.09027749f,  
1484.        0.15123098f, 0.03175976f, 0.17763577f, 3.29913251e-004f, 0.05151888f,  
1485.        -0.09844074f, -0.09475287f, -0.08571247f, 0.16241577f, 0.19336018f,  
1486.        8.57454538e-003f, 0.11474732f, -0.01493934f, 0.03352379f, -0.08966240f,  
1487.        -0.02322310f, 0.02663568f, 0.05448750f, -0.03536883f, -0.07210463f,  
1488.        -0.06807277f, -0.03121621f, -0.05932408f, -0.17282860f, -0.15873498f,  
1489.        -0.04956378f, 0.01603377f, -0.12385946f, 0.13878587f, 0.21468069f,  
1490.        0.13510075f, 0.20992437f, 0.08845878f, 0.08104013f, 0.03754176f,  
1491.        0.12173114f, 0.11103114f, 0.10643122f, 0.13941477f, 0.11640384f,  
1492.        0.14786847f, 0.01218238f, 0.01160753f, 0.03547940f, 0.08794311f,  
1493.        -0.01695384f, -0.07692261f, -0.08236158f, 6.79194089e-003f,  
1494.        -0.02458403f, 0.13022894f, 0.10953187f, 0.09857773f, 0.04735930f,  
1495.        -0.04353498f, -0.15173385f, -0.17904443f, -0.10450364f, -0.13418166f,  
1496.        -0.06633098f, -0.03170381f, -0.06839000f, -0.11350126f, -0.06983913f,  
1497.        0.19083543f, 0.17604128f, 0.07730632f, 0.10022651f, 0.36428109f,  
1498.        0.28291923f, 0.12688625f, 0.15942036f, 0.14064661f, -0.11201853f,  
1499.        -0.13969108f, -0.09088077f, -0.14107047f, 0.05117374f,  
1500.        -2.63348082e-003f, -0.10794610f, -0.09715455f, -0.05284977f,  
1501.        0.01565668f, 0.05031200f, 0.07021113f, -0.02963028f, 0.01766960f,  
1502.        0.08333644f, -0.03211382f, 4.90096770e-003f, 0.05186674f, -0.05045737f,  
1503.        -0.09624767f, -0.02525997f, 0.06916669f, 0.01213916f, 0.05333899f,  
1504.        -0.03443280f, -0.10055527f, -0.06291115f, 5.42851724e-003f,  
1505.        -6.30360236e-003f, 0.02270257f, -0.01769792f, 0.03273688f, 0.07746078f,  
1506.        7.77099328e-003f, 0.05041346f, 0.01648103f, -0.02321534f, -0.09930186f,  
1507.        -0.02293853f, 0.02034990f, -0.08324204f, 0.08510064f, -0.03732836f,  
1508.        -0.06465405f, -0.06086946f, 0.13680504f, -0.11469388f, -0.03896406f,  
1509.        -0.07142810f, 2.67581246e-003f, -0.03639632f, -0.09849060f,  
1510.        -0.11014334f, 0.17489147f, 0.17610909f, -0.16091567f, -0.07248894f,  
1511.        0.01567141f, 0.23742996f, 0.07552249f, -0.06270349f, -0.07303379f,  
1512.        0.25442186f, 0.16903116f, -0.08168741f, -0.05913896f, -0.03954096f,  
1513.        6.81776879e-003f, -0.05615319f, -0.07303037f, -0.12176382f,  
1514.        0.12385108f, 0.22084464f, -0.05543206f, -0.03310431f, 0.05731593f,  
1515.        0.19481890f, 0.04016430f, -0.06480758f, -0.12353460f, 0.18733442f,  
1516.        -0.09631214f, -0.11192076f, 0.12404587f, 0.15671748f, 0.19256128f,  
1517.        0.10895617f, 0.03391477f, -0.13032004f, -0.05626907f, -0.09025607f,  
1518.        0.23485197f, 0.27812332f, 0.26725492f, 0.07255980f, 0.16565137f,  
1519.        0.22388470f, 0.07441066f, -0.21003133f, -0.08075339f, -0.15031935f,  
1520.        0.07023834f, 0.10872041f, 0.18156518f, 0.20037253f, 0.13571967f,  
1521.        -0.11915682f, -0.11131983f, -0.18878011f, 0.06074620f, 0.20578890f,  
1522.        0.12413109f, 0.03930207f, 0.29176015f, 0.29502738f, 0.27856228f,  
1523.        -0.01803601f, 0.16646385f, 0.19268319f, 0.01900682f, 0.06026287f,  
1524.        2.35868432e-003f, 0.01558199f, 0.02707230f, 0.11383014f, 0.12103992f,  
1525.        0.03907350f, 0.04637353f, 0.09020995f, 0.11919726f, -3.63007211e-003f,  
1526.        0.02220155f, 0.10336831f, 0.17351882f, 0.12259731f, 0.18983354f,  
1527.        0.15736865f, 0.01160725f, -0.01690723f, -9.69582412e-004f, 0.07213813f,  
1528.        0.01161613f, 0.17864859f, 0.24486147f, 0.18208991f, 0.20177495f,  
1529.        0.05972528f, -8.93934630e-003f, -0.02316955f, 0.14436610f, 0.14114498f,  
1530.        0.05520950f, 0.06353590f, -0.19124921f, 0.10174713f, 0.29414919f,  
1531.        0.26448128f, 0.09344960f, 0.15284036f, 0.19797507f, 0.11369792f,  
1532.        -0.12722753f, -0.21396367f, -0.02008235f, -0.06566695f, -0.01662150f,  
1533.        -0.03937003f, 0.04778343f, 0.05017274f, -0.02299062f, -0.20208496f,  
1534.        -0.06395898f, 0.13721776f, 0.22544557f, 0.14888357f, 0.08687132f,  
1535.        0.27088094f, 0.32206613f, 0.09782200f, -0.18523243f, -0.17232181f,  
1536.        -0.01041531f, 0.04008654f, 0.04199702f, -0.08081299f, -0.03755421f,  
1537.        -0.04809646f, -0.05222081f, -0.21709201f, -0.06622940f, 0.02945281f,  
1538.        -0.04600435f, -0.05256077f, -0.08432942f, 0.02848100f, 0.03490564f,  
1539.        8.28621630e-003f, -0.11051246f, -0.11210597f, -0.01998289f,  
1540.        -0.05369405f, -0.08869293f, -0.18799506f, -0.05436598f, -0.05011634f,  
1541.        -0.05419716f, -0.06151857f, -0.10827805f, 0.04346735f, 0.04016083f,  
1542.        0.01520820f, -0.12173316f, -0.04880285f, -0.01101406f, 0.03250847f,  
1543.        -0.06009551f, -0.03082932f, -0.02295134f, -0.06856834f, -0.08775249f,  
1544.        -0.23793389f, -0.09174541f, -0.05538322f, -0.04321031f, -0.11874759f,  
1545.        -0.04221844f, -0.06070468f, 0.01194489f, 0.02608565f, -0.03892140f,  
1546.        -0.01643151f, -0.02602034f, -0.01305472f, 0.03920100f, -0.06514261f,  
1547.        0.01126918f, -6.27710763e-003f, -0.02720047f, -0.11133634f,  
1548.        0.03300330f, 0.02398472f, 0.04079665f, -0.10564448f, 0.05966159f,  
1549.        0.01195221f, -0.03179441f, -0.01692590f, -0.06177841f, 0.01841576f,  
1550.        -5.51078189e-003f, -0.06821765f, -0.03191888f, -0.09545476f,  
1551.        0.03030550f, -0.04896152f, -0.02914624f, -0.13283344f, -0.04783419f,  
1552.        6.07836898e-003f, -0.01449538f, -0.13358212f, -0.09687774f,  
1553.        -0.02813793f, 0.01213498f, 0.06650011f, -0.02039067f, 0.13356198f,  
1554.        0.05986415f, -9.12760664e-003f, -0.18780160f, -0.11992817f,  
1555.        -0.06342237f, 0.01229534f, 0.07143231f, 0.10713009f, 0.11085765f,  
1556.        0.06569190f, -0.02956399f, -0.16288325f, -0.13993549f, -0.01292515f,  
1557.        0.03833013f, 0.09130384f, -0.05086257f, 0.05617329f, -0.03896667f,  
1558.        -0.06282311f, -0.11490010f, -0.14264110f, -0.04530499f, 0.01598189f,  
1559.        0.09167797f, 0.08663294f, 0.04885277f, -0.05741219f, -0.07565769f,  
1560.        -0.17136464f, -0.02619422f, -0.02477579f, 0.02679587f, 0.11621952f,  
1561.        0.08788391f, 0.15520640f, 0.04709549f, 0.04504483f, -0.10214074f,  
1562.        -0.12293372f, -0.04820546f, -0.05484834f, 0.05473754f, 0.07346445f,  
1563.        0.05577277f, -0.08209965f, 0.03462975f, -0.20962234f, -0.09324598f,  
1564.        3.79481679e-003f, 0.03617633f, 0.16742408f, 0.07058107f, 0.10204960f,  
1565.        -0.06795346f, 3.22807301e-003f, -0.12589309f, -0.17496960f,  
1566.        0.02078314f, -0.07694324f, 0.12184640f, 0.08997164f, 0.04793497f,  
1567.        -0.11383379f, -0.08046359f, -0.25716835f, -0.08080962f,  
1568.        6.80711539e-003f, -0.02930280f, -3.04938294e-003f, -0.11106286f,  
1569.        -0.04628860f, -0.07821649f, 7.70127494e-003f, -0.10247706f,  
1570.        1.21042714e-003f, 0.20573859f, -0.03241005f, 8.42972286e-003f,  
1571.        0.01946464f, -0.01197973f, -0.14579976f, 0.04233614f,  
1572.        -4.14096704e-003f, -0.06866436f, -0.02431862f, -0.13529138f,  
1573.        1.25891645e-003f, -0.11425111f, -0.04303651f, -0.01694815f,  
1574.        0.05720210f, -0.16040207f, 0.02772896f, 0.05498345f, -0.15010567f,  
1575.        0.01450866f, 0.02350303f, -0.04301004f, -0.04951802f, 0.21702233f,  
1576.        -0.03159155f, -0.01963303f, 0.18232647f, -0.03263875f,  
1577.        -2.88476888e-003f, 0.01587562f, -1.94303901e-003f, -0.07789494f,  
1578.        0.04674156f, -6.25576358e-003f, 0.08925962f, 0.21353747f, 0.01254677f,  
1579.        -0.06999976f, -0.05931328f, -0.01884327f, -0.04306272f, 0.11794136f,  
1580.        0.03842728f, -0.03907030f, 0.05636114f, -0.09766009f, -0.02104000f,  
1581.        8.72711372e-003f, -0.02736877f, -0.05112274f, 0.16996814f, 0.02955785f,  
1582.        0.02094014f, 0.08414304f, -0.03335762f, -0.03617457f, -0.05808248f,  
1583.        -0.08872101f, 0.02927705f, 0.27077839f, 0.06075108f, 0.07478261f,  
1584.        0.15282831f, -0.03908454f, -0.05101782f, -9.51998029e-003f,  
1585.        -0.03272416f, -0.08735625f, 0.07633440f, -0.07185312f, 0.13841286f,  
1586.        0.07812646f, -0.12901451f, -0.05488589f, -0.05644578f, -0.03290703f,  
1587.        -0.11184757f, 0.03751570f, -0.05978153f, -0.09155276f, 0.05657315f,  
1588.        -0.04328186f, -0.03047933f, -0.01413135f, -0.10181040f, -0.01384013f,  
1589.        0.20132534f, -0.01536873f, -0.07641169f, 0.05906778f, -0.07833145f,  
1590.        -0.01523801f, -0.07502609f, -0.09461885f, -0.15013233f, 0.16050665f,  
1591.        0.09021381f, 0.08473236f, 0.03386267f, -0.09147339f, -0.09170618f,  
1592.        -0.08498498f, -0.05119187f, -0.10431040f, 0.01041618f, -0.03064913f,  
1593.        0.09340212f, 0.06448522f, -0.03881054f, -0.04985436f, -0.14794017f,  
1594.        -0.05200112f, -0.02144495f, 0.04000821f, 0.12420804f, -0.01851651f,  
1595.        -0.04116732f, -0.11951703f, -0.04879033f, -0.08722515f, -0.08454733f,  
1596.        -0.10549165f, 0.11251976f, 0.10766345f, 0.19201984f, 0.06128913f,  
1597.        -0.02734615f, -0.08834923f, -0.16999826f, -0.03548348f,  
1598.        -5.36092324e-003f, 0.08297954f, 0.07226378f, 0.04194529f, 0.04668673f,  
1599.        8.73902347e-003f, 0.06980139f, 0.05652480f, 0.05879445f, 0.02477076f,  
1600.        0.02451423f, 0.12433673f, 0.05600227f, 0.06886370f, 0.03863076f,  
1601.        0.07459056f, 0.02264139f, 0.01495469f, 0.06344220f, 0.06945208f,  
1602.        0.02931899f, 0.11719371f, 0.04527427f, 0.03248192f, 2.08271481e-003f,  
1603.        0.02044626f, 0.11403449f, 0.04303892f, 0.06444661f, 0.04959024f,  
1604.        0.08174094f, 0.09240247f, 0.04894639f, 0.02252937f, -0.01652530f,  
1605.        0.07587013f, 0.06064249f, 0.13954395f, 0.02772832f, 0.07093039f,  
1606.        0.08501238f, 0.01701301f, 0.09055722f, 0.33421436f, 0.20163782f,  
1607.        0.09821030f, 0.07951369f, 0.08695120f, -0.12757730f, -0.13865978f,  
1608.        -0.06610068f, -0.10985506f, 0.03406816f, -0.01116336f, -0.07281768f,  
1609.        -0.13525715f, -0.12844718f, 0.08956250f, 0.09171610f, 0.10092317f,  
1610.        0.23385370f, 0.34489515f, 0.09901748f, 0.02002922f, 0.12335990f,  
1611.        0.07606190f, -0.14899330f, -0.15634622f, -0.06494618f, -0.01760547f,  
1612.        0.03404277f, -0.13208845f, -0.12101169f, -0.18294574f, -0.16560709f,  
1613.        0.02183887f, -0.02752613f, 0.01813638f, 0.02000757f, 0.01319924f,  
1614.        0.08030242f, 0.01220535f, 2.98233377e-003f, -0.01307070f, 0.05970297f,  
1615.        -0.05345284f, -0.03381982f, -9.87543724e-003f, -0.06869387f,  
1616.        0.03956730f, -0.03108176f, -0.05732809f, 0.02172386f, 0.04159765f,  
1617.        2.62783933e-003f, 0.04813229f, 0.09358983f, -8.18389002e-003f,  
1618.        0.01724574f, -0.02547474f, -0.04967288f, -0.02390376f, 0.06640504f,  
1619.        -0.06306566f, 0.01137518f, 0.05589378f, -0.08237787f, 0.02455001f,  
1620.        -0.03059422f, -0.08953978f, 0.06851497f, 0.07190268f, -0.07610799f,  
1621.        7.87237938e-003f, -7.85830803e-003f, 0.06006952f, -0.01126728f,  
1622.        -2.85743061e-003f, -0.04772895f, 0.01884944f, 0.15005857f,  
1623.        -0.06268821f, -0.01989072f, 0.01138399f, 0.08760451f, 0.03879007f,  
1624.        -9.66926850e-003f, -0.08012961f, 0.06414555f, -0.01362950f,  
1625.        -0.09135523f, 0.01755159f, 0.04459474f, 0.09650917f, 0.05219948f,  
1626.        -2.19440833e-003f, -0.07037939f, -0.01599054f, 0.13103317f,  
1627.        -0.02492603f, -0.01032540f, -0.02903307f, 0.04489160f, 0.05148086f,  
1628.        0.01858173f, -0.02919228f, 0.08299296f, -0.04590359f, -0.15745632f,  
1629.        -0.09068198f, -0.02972453f, 0.12985018f, 0.22320485f, 0.24261914f,  
1630.        0.03642650f, -0.05506422f, 2.67413049e-003f, -0.03834032f, 0.06449424f,  
1631.        0.03834866f, 0.03816991f, 0.25039271f, 0.34212017f, 0.32433882f,  
1632.        0.18824573f, -0.08599839f, -0.17599408f, -0.15317015f, -0.09913155f,  
1633.        -0.02856072f, -0.05304699f, -1.06437842e-003f, -0.06641813f,  
1634.        -0.07509298f, 0.01463361f, -0.07551918f, -0.04510373f,  
1635.        -8.44620075e-003f, 0.01772176f, 0.04068235f, 0.20295307f, 0.15719447f,  
1636.        0.05712103f, 0.26296997f, 0.14657754f, 0.01547317f, -0.05052776f,  
1637.        -0.03881342f, -0.01437883f, -0.04930177f, 0.11719568f, 0.24098417f,  
1638.        0.26468599f, 0.31698579f, 0.10103608f, -0.01096375f, -0.01367013f,  
1639.        0.17104232f, 0.20065314f, 2.67622480e-003f, -0.01190034f, 0.18301608f,  
1640.        0.09459770f, -0.06357619f, -0.06473801f, 0.01377906f, -0.10032775f,  
1641.        -0.06388740f, 3.80393048e-003f, 0.06206078f, 0.10349120f, 0.26804337f,  
1642.        8.17918684e-003f, -0.02314351f, 9.34422202e-003f, 0.09198381f,  
1643.        0.03681326f, -8.77339672e-003f, -0.09662418f, -0.02715708f,  
1644.        0.13503517f, 0.08962728f, -6.57071499e-003f, -0.03201199f, 0.28510824f,  
1645.        0.32095715f, 0.18512695f, -0.14230858f, -0.14048551f, -0.07181299f,  
1646.        -0.08575408f, -0.08661680f, -0.17416079f, 7.54326640e-004f,  
1647.        0.05601677f, 0.13585392f, -0.04960437f, -0.07708392f, 0.10676333f,  
1648.        -0.04407546f, -0.07209078f, 0.03663663f, 0.28949317f, 0.41127121f,  
1649.        0.27431169f, -0.06900328f, -0.21474190f, -0.15578632f, -0.19555484f,  
1650.        -0.15209621f, -0.11269179f, 0.07416003f, 0.18991330f, 0.26858172f,  
1651.        0.01952259f, 0.01017922f, 0.02159843f, -4.95165400e-003f, -0.04368168f,  
1652.        -0.12721671f, -0.06673957f, -0.11275250f, 0.04413409f, 0.05578312f,  
1653.        0.03896771f, 0.03566417f, -0.05871816f, -0.07388090f, -0.17965563f,  
1654.        -0.08570268f, -0.15273231f, -0.06022318f, -0.06999847f,  
1655.        -6.81510568e-003f, 0.06294262f, -6.54901436e-004f, -0.01128654f,  
1656.        -0.02289657f, 0.04849290f, 0.04140804f, 0.23681939f, 0.14545733f,  
1657.        0.01989965f, 0.12032662f, 3.87463090e-003f, -6.02597650e-003f,  
1658.        -0.05919775f, -0.03067224f, -0.07787777f, 0.10834727f, 0.02153730f,  
1659.        0.02765649f, 0.03975543f, -0.12182906f, -0.04900113f, -0.09940100f,  
1660.        -0.06453611f, -0.13757215f, -0.03721382f, 0.02827376f, -0.04351249f,  
1661.        0.01907038f, -0.10284120f, -0.05671160f, -0.10760647f, -0.09624009f,  
1662.        -0.09565596f, -0.01303654f, 0.03080539f, 0.01416511f, 0.05846142f,  
1663.        -5.42971538e-003f, 0.06221476f, -0.03320325f, -0.06791797f,  
1664.        -0.05791342f, 0.12851369f, 0.14990346f, 0.03634374f, 0.14262885f,  
1665.        0.04330391f, 0.05032569f, -0.05631914f, 0.01606137f, 0.04387223f,  
1666.        0.22344995f, 0.15722635f, -0.04693628f, 0.03006579f, -2.52882647e-003f,  
1667.        0.05717621f, -0.07529724f, -0.02848588f, -0.06868757f,  
1668.        -4.51729307e-003f, 0.06466042f, -0.05935378f, -0.04704857f,  
1669.        -0.07363959f, 0.04843248f, -0.13421375f, -0.09789340f, -0.10255270f,  
1670.        0.03509852f, 0.04751543f, -0.03822323f, 0.09740467f, 0.04762916f,  
1671.        0.03940146f, -0.08283259f, 0.09552965f, 0.05038739f, 0.21258622f,  
1672.        0.09646992f, 0.03241193f, 0.05167701f, 0.04614570f, 0.04330090f,  
1673.        -0.02671840f, -0.06259909f, -0.02301898f, 0.18829170f, 0.10522786f,  
1674.        0.04313190f, 0.01670948f, -0.08421925f, 0.05911417f, -0.10582602f,  
1675.        -0.04855484f, -0.08373898f, 0.07775915f, 0.03723533f, -0.12047344f,  
1676.        4.86345543e-003f, -0.10520902f, 0.06571782f, -0.07528137f,  
1677.        -0.03245651f, -0.09869066f, -0.02917477f, -0.18293270f, 0.14810945f,  
1678.        9.24033765e-003f, -0.04354914f, 0.02266885f, -0.11872729f,  
1679.        -0.04016589f, 0.02830229f, 0.22539048f, 0.20565644f, 0.16701797f,  
1680.        0.09019924f, 0.01300652f, 0.09760600f, -0.03675831f, -0.01935448f,  
1681.        -0.06894835f, 0.08077277f, 0.19047537f, 0.11312226f, 0.04106043f,  
1682.        -0.11187182f, 0.04312806f, -0.18548580f, -0.11287174f, -0.08794551f,  
1683.        0.02078281f, -0.15295486f, 0.11806386f, -0.01103218f, -0.15971117f,  
1684.        0.02153538f, -0.05232147f, -0.10835317f, -0.13910367f, 0.05920752f,  
1685.        -0.10122602f, 0.20174250f, 0.09105796f, -0.01881348f, 0.09559010f,  
1686.        -0.03725745f, -0.09442931f, -0.09763174f, 0.05854454f, 0.08287182f,  
1687.        0.12919849f, 0.08594352f, -2.49806582e-003f, 0.02398440f,  
1688.        5.67950122e-003f, -0.06296340f, -0.12993270f, 0.03855852f, 0.05186560f,  
1689.        0.10839908f, -0.03380463f, -0.12654832f, -0.05399339f, -0.07456800f,  
1690.        -0.04736232f, -0.10164231f, 0.07496139f, 0.08125214f, 0.07656177f,  
1691.        -0.04999603f, -0.12823077f, -0.07692395f, -0.11317524f, -0.09118655f,  
1692.        -0.05695669f, 0.10477209f, 0.07468581f, 0.01630048f, -8.00961629e-003f,  
1693.        -0.06582128f, -0.04019095f, -0.04682907f, -0.01907842f, -0.10997720f,  
1694.        0.04911406f, 0.02931030f, 0.04197735f, -0.05773980f, -0.09670641f,  
1695.        -0.03594951f, -0.03402121f, -0.07149299f, -0.10566200f, 0.10601286f,  
1696.        0.06340689f, -0.01518632f, -5.96402306e-003f, -0.07628012f,  
1697.        -3.52779147e-003f, -0.02683854f, -0.10265494f, -0.02680815f,  
1698.        0.16338381f, 0.03103515f, 0.02296976f, 0.01624348f, -0.10831620f,  
1699.        -0.02314233f, -0.04789969f, -0.05530700f, -0.06461314f, 0.10494506f,  
1700.        0.04642856f, -0.07592955f, -0.06197905f, -0.09042154f, -0.01445521f,  
1701.        -0.04297818f, -0.11262015f, -0.11430512f, 0.03174541f, -0.03677487f,  
1702.        -0.02963996f, -0.06610169f, -0.13292049f, -0.07059067f, -0.08444111f,  
1703.        -0.02640536f, -0.07136250f, 0.04559967f, 0.01459980f, 0.17989251f,  
1704.        0.04435328f, -0.12464730f, -0.02871115f, -0.10752209f, -0.03393742f,  
1705.        -0.03791408f, 0.02548251f, 0.01956050f, 0.19245651f, 0.13963254f,  
1706.        -0.05904696f, -0.07424626f, -0.10411884f, 1.54176133e-003f,  
1707.        0.01797429f, 0.13025844f, 0.04547642f, -0.05710349f, -0.10697161f,  
1708.        -0.13489437f, -0.06515755f, -0.06406886f, -4.08572936e-003f,  
1709.        -0.01336483f, 0.04368737f, -0.11259720f, -0.05701635f, -0.06469971f,  
1710.        -0.08346602f, -0.04166770f, -0.05795543f, -0.08247511f, -0.05742628f,  
1711.        0.08452254f, -0.03350224f, 0.13980860f, 0.13252275f, 0.07589617f,  
1712.        0.07539988f, 0.12155797f, 0.19087289f, 0.15050751f, 0.21250245f,  
1713.        0.14206800f, 0.01298489f, 0.07450245f, 0.06559097f, 0.01700557f,  
1714.        0.04512971f, 0.16950700f, 0.10261577f, 0.16389982f, 0.05505059f,  
1715.        -0.03453077f, 0.08622462f, 0.07935954f, 0.03976260f, 0.02036091f,  
1716.        3.95744899e-003f, 0.03267065f, 0.15235919f, 0.01297494f, -0.08109194f,  
1717.        0.01407558f, 4.40693414e-003f, -0.15157418f, -0.11390478f,  
1718.        -0.07487597f, -7.81322457e-003f, -0.02749545f, -0.10181408f,  
1719.        0.13755716f, 0.14007211f, 0.13482562f, 0.27517235f, 0.34251109f,  
1720.        0.07639657f, 0.07268607f, 0.19823882f, 0.16135791f, -0.04186463f,  
1721.        -0.12784107f, -0.09846287f, 0.03169041f, 0.10974082f, -0.15051922f,  
1722.        -0.08916726f, -0.07138767f, -0.04153349f, 6.25418453e-003f,  
1723.        0.01266654f, 0.10533249f, 0.12749144f, 0.15148053f, 0.01498513f,  
1724.        0.06305949f, -0.01247123f, -0.08778401f, -0.08551880f, -0.11955146f,  
1725.        -0.08493572f, -0.02901620f, -0.02394859f, -0.13427313f, -0.11053200f,  
1726.        -0.14413260f, -0.15203285f, 0.03972760f, -3.72127310e-004f,  
1727.        -0.04200919f, 0.06105104f, 0.01904975f, -0.01106191f,  
1728.        -7.27445772e-003f, -0.01520341f, 1.10228511e-003f, -0.04949187f,  
1729.        -0.08013099f, 5.72071038e-003f, 0.08415454f, -0.06523152f, 0.03664081f,  
1730.        -0.02673042f, -0.12066154f, -0.03702074f, 0.06006580f, 0.01628682f,  
1731.        -6.17772620e-003f, 0.08192339f, -3.41629819e-003f, 0.02870512f,  
1732.        0.05807141f, 0.04959986f, 0.04618251f, -0.04901629f, -0.10579574f,  
1733.        0.02274442f, 0.12070961f, 2.23597488e-003f, 0.09831765f, -0.03019848f,  
1734.        -0.11181970f, -0.04961075f, 0.02498928f, -0.03714991f, -0.01619653f,  
1735.        0.02643486f, -7.62964319e-003f, -0.02882290f, -0.06242594f,  
1736.        -0.08439861f, 0.07220893f, 0.07263952f, 0.01561574f, 0.03091968f,  
1737.        0.01708712f, -0.03797151f, -3.18561122e-003f, 0.01624021f,  
1738.        -0.02828573f, 0.11284444f, -1.32280716e-003f, -0.07784860f,  
1739.        -0.07209100f, 0.03372242f, 0.12154529f, 0.02278104f, -0.05275500f,  
1740.        -0.01918484f, 0.12989293f, 0.05424401f, 0.02333086f, 0.04029022f,  
1741.        0.12392918f, 0.09495489f, 0.09190340f, 0.07935889f, 8.76816828e-003f,  
1742.        0.17148446f, -8.51302687e-003f, -0.08011249f, -0.06796283f,  
1743.        0.04884845f, 0.01112272f, -0.07835306f, -1.14811445e-003f,  
1744.        -0.03440760f, 0.02845243f, 0.07695542f, -0.07069533f, -0.01151784f,  
1745.        -8.53884313e-003f, -0.01662786f, -0.04163864f, 0.05400505f,  
1746.        0.02859163f, 0.02921852f, 0.05003135f, -6.85718050e-003f, -0.01632611f,  
1747.        0.07780217f, 0.04042810f, -0.01216440f, 3.60914599e-003f, -0.06322435f,  
1748.        0.09516726f, 0.12877031f, -9.69162490e-003f, 0.01031179f, 0.05180895f,  
1749.        -9.34659224e-003f, -0.01644533f, -0.04849347f, -0.04343236f,  
1750.        0.10514783f, 0.08046635f, -0.04615205f, -0.03975486f, -0.01485525f,  
1751.        0.13096830f, -0.01517950f, -0.06571898f, -0.04016372f, 0.01849786f,  
1752.        0.02439670f, 0.08067258f, 1.74824719e-003f, 0.07053747f, 0.08819518f,  
1753.        -5.08352555e-003f, -0.06550863f, -0.08266170f, -0.07780605f,  
1754.        0.01453450f, -0.08756890f, 0.01096501f, -8.71319138e-003f, 0.10110464f,  
1755.        0.02420769f, -0.06708383f, 0.02007811f, 5.93133038e-003f, 0.05398923f,  
1756.        0.07538138f, 0.02049227f, 0.02242589f, 0.04011070f, -1.44875818e-003f,  
1757.        -4.19115182e-003f, 0.06367654f, 0.02506934f, 0.02434536f, 0.05879405f,  
1758.        -8.22952855e-003f, -0.01242441f, 0.04224926f, -0.01754923f,  
1759.        0.05958161f, 0.03818886f, -0.01830363f, -0.04308917f, -0.04422197f,  
1760.        -0.02432721f, 0.02264866f, 2.03751423e-003f, 0.01197031f, 0.04439203f,  
1761.        0.12169247f, 0.03602713f, -0.02599251f, -1.98226492e-003f, 0.02046336f,  
1762.        -0.02639058f, -1.91242550e-003f, -0.09334669f, -0.03595153f,  
1763.        -9.88179818e-003f, -0.06848445f, -0.04666303f, -0.09955736f,  
1764.        -0.04206430f, 0.02609075f, 9.09005292e-003f, -0.07138551f,  
1765.        -4.22313227e-004f, 0.01766645f, 0.02756404f, 0.01308276f, 0.04052891f,  
1766.        0.02387515f, 0.05337298f, 0.02500631f, -0.04970853f, -0.12467445f,  
1767.        0.17604403f, 0.12256411f, -0.07512254f, 8.70451052e-003f, -0.05697548f,  
1768.        -0.03626474f, -8.76623299e-003f, -0.01210897f, -0.09451522f,  
1769.        0.07490732f, -0.02008001f, -0.02681278f, -0.06463405f, -0.01517507f,  
1770.        7.33757764e-003f, 6.07147906e-003f, -0.09316964f, -0.04575328f,  
1771.        0.13261597f, 0.15424870f, -0.01655918f, -0.02772390f, -0.05243644f,  
1772.        -0.02356456f, -0.02351753f, -0.10211615f, -0.12873036f, 0.14549787f,  
1773.        0.12519856f, 4.38762689e-003f, 0.02795992f, 0.05170322f, 0.09223596f,  
1774.        0.05890015f, 0.02376701f, -0.02777346f, 0.09506908f, 0.02328936f,  
1775.        -0.02319928f, -0.03218696f, -0.01527841f, -0.01016694f, -0.02674719f,  
1776.        0.05137179f, 0.01980666f, 0.06544447f, -0.01746171f, 0.01026380f,  
1777.        0.01561806f, 7.97004555e-004f, 0.07601810f, 0.01907250f, -0.03083035f,  
1778.        -0.05987392f, 0.09242783f, 0.14555025f, 0.01035827f, 0.03092401f,  
1779.        -0.09562709f, -0.03802354f, 0.02531144f, 0.03079449f, -0.07100715f,  
1780.        0.03330721f, -2.69116857e-003f, 0.03167490f, 0.05744999f, 0.03259895f,  
1781.        1.91266940e-003f, 0.03194578f, 0.07389776f, 0.02198060f, 0.07633314f,  
1782.        0.03293105f, -0.09103648f, 0.04718142f, 0.06102672f, -0.01003063f,  
1783.        5.85481385e-003f, -0.01522574f, 0.02323526f, 0.10584345f,  
1784.        4.35879454e-003f, 0.06107873f, 0.05868603f, -0.03115531f, 0.01214679f,  
1785.        0.08567052f, 3.93926632e-003f, -0.02521488f, -1.88425183e-003f,  
1786.        0.02038053f, -6.26854831e-004f, 0.04897438f, -0.04280585f,  
1787.        -0.04819689f, -0.04812867f, -0.01451186f, 0.05101469f,  
1788.        -9.01125465e-003f, -0.03333859f, 0.03917955f, 0.04196448f, 0.04292135f,  
1789.        0.02809529f, 0.02999715f, 0.04081348f, 9.10039060e-003f, 0.09703232f,  
1790.        0.10379741f, 0.02348725f, -4.72756615e-003f, 0.01027325f, 0.10402658f,  
1791.        0.12071823f, 0.09817299f, -0.02612033f, 0.03638414f, 0.05896405f,  
1792.        0.04865025f, 0.04793910f, -0.03882321f, -0.02962117f, -0.01222268f,  
1793.        0.04071597f, 0.01922777f, -0.02287866f, 0.03328381f, 0.01859092f,  
1794.        0.09024994f, 0.03804455f, -0.01424510f, 0.01953739f, 0.02509617f,  
1795.        -0.03390914f, -0.05663941f, -0.01641979f, 0.05848591f, 0.04639670f,  
1796.        0.02092116f, 0.12911791f, 0.19918139f, 0.07739855f, -7.25806039e-003f,  
1797.        0.04074838f, 0.03183993f, 1.39251316e-003f, -0.01428625f, 0.01865480f,  
1798.        0.08529541f, 0.13547510f, 0.11189661f, 0.03998901f, 0.09575938f,  
1799.        -0.02631102f, -0.03458253f, -0.04749985f, -0.06070716f,  
1800.        4.71884012e-003f, 0.06445789f, -0.02450038f, -0.05483776f,  
1801.        -0.04657237f, -0.02030717f, -0.03480766f, -0.09397731f, -0.06399718f,  
1802.        -0.01804585f, 5.62348310e-003f, -6.64811488e-003f, -0.06517869f,  
1803.        6.96210237e-003f, -0.01860148f, -0.04245830f, -0.05850367f,  
1804.        -3.24417115e-003f, 0.07700698f, 0.11290991f, 0.09923030f, -0.02970599f,  
1805.        0.05592411f, 0.04813979f, -0.09811195f, -0.09357996f, -0.03276114f,  
1806.        0.05218338f, 0.04141375f, 3.92977800e-003f, -0.05047480f, 0.15960084f,  
1807.        0.04612800f, -0.03114098f, -0.04650044f, -0.03249795f, -0.02425641f,  
1808.        -0.04311355f, 0.04307659f, -0.09401883f, -0.04742785f, -0.01254499f,  
1809.        -0.06598741f, 3.41369561e-003f, -0.05620445f, -7.28127593e-003f,  
1810.        -0.05998361f, -0.03274450f, -0.07376868f, 3.19015374e-003f,  
1811.        -0.07733069f, 0.05815864f, -0.02471071f, 0.03850617f, 0.13838784f,  
1812.        0.15399861f, 0.01731321f, -0.01477586f, 0.10393341f, 0.05159833f,  
1813.        -0.01945555f, -0.03427503f, -0.04867341f, 0.09237480f, 0.10732719f,  
1814.        0.06071450f, -0.01355071f, 0.01844356f, -0.03480803f, -0.03796671f,  
1815.        2.15628621e-004f, -0.05440186f, 0.01889855f, -0.01443413f,  
1816.        -0.02607902f, -0.02938001f, 0.02720689f, -0.06228397f, -0.02970936f,  
1817.        -0.03426210f, -0.10280876f, -0.06739304f, -0.05227850f, 0.03360292f,  
1818.        -0.11278441f, -0.06966180f, -0.13937433f, 9.10932291e-003f,  
1819.        2.52020749e-004f, -4.07359656e-003f, 0.12310639f, 0.09343060f,  
1820.        0.07302511f, 0.03222093f, 0.07532879f, 0.03792387f, -0.04985180f,  
1821.        0.01804602f, 0.02694195f, 0.13481498f, 0.04601225f, 0.04106982f,  
1822.        0.08511057f, 0.12314661f, 0.01320830f, 0.05044121f, -5.52943908e-003f,  
1823.        -0.08992624f, -0.02249301f, -0.08181777f, 0.06165213f, -0.03256603f,  
1824.        -0.01068920f, -0.01323473f, -0.11970232f, -0.04616347f, -0.12088681f,  
1825.        -0.06762606f, -0.08676834f, -0.06434575f, 0.01772529f, 0.03469615f,  
1826.        -0.10926618f, 0.03013873f, 0.14030397f, 0.16130108f, 0.17985588f,  
1827.        0.11281928f, 0.10530639f, 0.08905948f, 0.07733764f, 0.06695238f,  
1828.        0.02142088f, 0.06438877f, 0.09794453f, 0.05745072f, 0.02788557f,  
1829.        0.02632830f, 0.07985807f, 4.24902979e-003f, 8.47890321e-003f,  
1830.        -0.02679466f, -5.28812688e-003f, -0.02162580f, -0.07490715f,  
1831.        -0.08251337f, -0.02056576f, -0.01026194f, -1.15492963e-003f,  
1832.        -5.75720915e-004f, -0.07210591f, -0.07320981f, -0.04883312f,  
1833.        -0.10897151f, -0.07477258f, -0.08867134f, -0.09222437f, -0.10924666f,  
1834.        -0.10430276f, 0.07953499f, 0.02767959f, 0.11393359f, 0.18779543f,  
1835.        0.03313421f, 0.02143700f, 0.05852016f, -2.12067598e-003f,  
1836.        -3.76984011e-003f, 0.02774167f, -0.03124610f, 0.01465141f, 0.01616004f,  
1837.        -0.01391913f, -0.04404102f, -0.05444227f, -0.14684731f, -0.15016587f,  
1838.        0.04509468f, 1.29563001e-003f, 0.01398350f, 0.05610404f, -0.04868806f,  
1839.        -0.04776716f, -8.16873740e-003f, -2.30126386e-003f, -0.02286313f,  
1840.        0.11983398f, -0.04703261f, -0.08814441f, -0.07585249f, -0.10799607f,  
1841.        -0.03232087f, 0.01509786f, -0.04843464f, -0.03967846f, 0.09589416f,  
1842.        0.01352560f, -0.01458119f, 0.01050829f, -0.03038946f, 0.01608388f,  
1843.        1.11975556e-003f, -0.01250656f, 2.86211423e-003f, 0.04333691f,  
1844.        -0.14603497f, -0.01946543f, -0.02327525f, -0.01973944f, 0.07944400f,  
1845.        -0.02224544f, -0.06701808f, 0.03476532f, 0.11505594f, -0.02712801f,  
1846.        -0.01665113f, 0.06315716f, -0.08205860f, 0.07431999f, 0.04915778f,  
1847.        -0.04468752f, -0.01490402f, 0.07400476f, -0.11650901f, 0.05102430f,  
1848.        0.04559118f, -0.05916039f, 0.08840760f, -0.01587902f, -0.14890194f,  
1849.        0.07857784f, 0.04710254f, -0.05381983f, -0.07331945f, -0.03604643f,  
1850.        0.15611970f, 0.07649943f, -0.05959348f, -0.02776607f, 0.11098688f,  
1851.        0.03758875f, -0.04446875f, 0.04933187f, 0.01345535f, 0.06921103f,  
1852.        0.07364785f, 0.05518956f, 0.02899585f, 0.09375840f, 0.10518434f,  
1853.        -0.04420241f, 0.01915282f, -3.56386811e-003f, 0.14586878f, 0.10286101f,  
1854.        -0.04360626f, -0.12723237f, 0.09076386f, 0.11119842f, -0.06035013f,  
1855.        0.09674817f, 0.08938243f, 0.07065924f, 0.02603180f, 5.84815582e-003f,  
1856.        -0.05922065f, 0.12360309f, 3.59695964e-003f, 2.99844006e-003f,  
1857.        0.03697936f, 0.02043072f, 0.04168725f, 0.01025975f, -0.01359980f,  
1858.        -0.01600920f, 0.02581056f, 0.02329250f, 2.98100687e-003f, 0.01629762f,  
1859.        0.06652115f, 0.05855627f, 0.01237463f, -0.01297135f, 0.01761587f,  
1860.        0.05090865f, 0.06549342f, -0.04425945f, 2.43203156e-003f,  
1861.        3.07327788e-003f, 0.06678630f, -0.04303836f, 0.01082393f, -0.06476044f,  
1862.        0.04077786f, 0.12441979f, 0.08237778f, 0.07424165f, 0.04065890f,  
1863.        0.06905543f, 0.09556347f, 0.12724875f, -0.02132082f, 0.08514154f,  
1864.        -0.04175328f, -0.02666954f, 0.01897836f, 0.03317382f, 9.45465732e-003f,  
1865.        -0.01238974f, -0.04242500f, -0.01419479f, -0.03545213f, -0.02440874f,  
1866.        0.08684119f, 0.04212951f, 0.02462858f, -0.01104825f, -5.01706870e-003f,  
1867.        0.02968982f, 0.02597476f, -0.01568939f, 0.04514892f, 0.06974549f,  
1868.        0.08670278f, 0.06828108f, 0.10238872f, 0.05405957f, 0.06548470f,  
1869.        -0.03763957f, 0.01366090f, 0.07069602f, 0.05363748f, 0.04798120f,  
1870.        0.11706422f, 0.05466456f, -0.01869259f, 0.06344382f, 0.03106543f,  
1871.        0.08432506f, -0.02061096f, 0.03821088f, -6.92190882e-003f,  
1872.        6.40467042e-003f, -0.01271779f, 6.89014705e-005f, 0.04541415f,  
1873.        -0.01899539f, -0.05020239f, 0.03000903f, 0.01090422f, 4.52452758e-003f,  
1874.        0.02573632f, -0.02388454f, -0.04200457f, 1.72783900e-003f,  
1875.        -0.05978370f, -0.02720562f, 0.06573715f, 0.01154317f, 0.01265615f,  
1876.        0.07375994f, -9.19828378e-003f, -0.04914120f, 0.02124831f, 0.06455322f,  
1877.        0.04372910f, -0.03310043f, 0.03605788f, -6.78055827e-003f,  
1878.        9.36202332e-003f, 0.01747596f, -0.06406314f, -0.06812935f, 0.08080816f,  
1879.        -0.02778088f, 0.02735260f, 0.06393493f, 0.06652229f, 0.05676993f,  
1880.        0.08640018f, -7.59188086e-003f, -0.02012847f, -0.04741159f,  
1881.        -0.01657069f, -0.01624399f, 0.05547778f, -2.33309763e-003f,  
1882.        0.01120033f, 0.06141156f, -0.06285004f, -0.08732341f, -0.09313398f,  
1883.        -0.04267832f, 5.57443965e-003f, 0.04809862f, 0.01773641f,  
1884.        5.37361018e-003f, 0.14842421f, -0.06298012f, -0.02935147f, 0.11443478f,  
1885.        -0.05034208f, 5.65494271e-003f, 0.02076526f, -0.04577984f,  
1886.        -0.04735741f, 0.02961071f, -0.09307127f, -0.04417921f, -0.04990027f,  
1887.        -0.03940028f, 0.01306016f, 0.06267900f, 0.03758737f, 0.08460117f,  
1888.        0.13858789f, 0.04862388f, -0.06319809f, -0.05655516f, 0.01885816f,  
1889.        -0.03285607f, 0.03371567f, -0.07040928f, -0.04514049f, 0.01392166f,  
1890.        0.08184422f, -0.07230316f, 0.02386871f, 0.02184591f, 0.02605764f,  
1891.        -0.01033954f, 9.29878280e-003f, 7.67351175e-003f, 0.15189242f,  
1892.        0.02069071f, -0.09738296f, -0.08894105f, -0.07768748f, 0.02332268f,  
1893.        -0.01778995f, -0.03258888f, -0.08180822f, -0.08492987f, 0.02290156f,  
1894.        -0.11368170f, -0.03554465f, -0.04533844f, -0.02861580f, 0.06782424f,  
1895.        0.01113123f, 0.02453644f, 0.12721945f, 0.08084814f, -0.03607795f,  
1896.        0.01109122f, 0.04803548f, -0.03489929f, 0.03399536f, -0.05682014f,  
1897.        8.59533902e-003f, -4.27904585e-003f, 0.03230887f, -0.01300198f,  
1898.        -0.01038137f, -0.07930113f, 8.33097473e-003f, 0.02296994f,  
1899.        -0.01306500f, -0.01881626f, 0.04413369f, 0.05729880f, -0.03761553f,  
1900.        0.01942326f, 1.64540811e-003f, -0.03811319f, 0.04190650f, -0.14978096f,  
1901.        -0.04514487f, 0.01209545f, -5.46460645e-003f, -0.01647195f,  
1902.        7.63064111e-003f, -0.07494587f, 0.08415288f, 0.10020141f, -0.01228561f,  
1903.        0.06553826f, 0.04554005f, 0.07890417f, 0.03041138f, 0.01752007f,  
1904.        0.09208256f, -3.74419295e-004f, 0.10549527f, 0.04686913f, 0.01894833f,  
1905.        -0.02651412f, -4.34682379e-003f, 5.44942822e-003f, 0.01444484f,  
1906.        0.05882156f, -0.03336544f, 0.04603891f, -0.10432546f, 0.01923928f,  
1907.        0.01842845f, -0.01712168f, -0.02222766f, 0.04693324f, -0.06202956f,  
1908.        -0.01422159f, 0.08732220f, -0.07706107f, 0.02661049f, -0.04300238f,  
1909.        -0.03092422f, -0.03552184f, -0.01886088f, -0.04979934f, 0.03906401f,  
1910.        0.04608644f, 0.04966111f, 0.04275464f, -0.04621769f, -0.02653212f,  
1911.        8.57011229e-003f, 0.03839684f, 0.05818764f, 0.03880796f,  
1912.        -2.76100676e-004f, 0.03076511f, -0.03266929f, -0.05374557f,  
1913.        0.04986527f, -9.45429131e-003f, 0.03582499f, -2.64564669e-003f,  
1914.        -1.07461517e-003f, 0.02962313f, -0.01483363f, 0.03060869f, 0.02448327f,  
1915.        0.01845641f, 0.03282966f, -0.03534438f, -0.01084059f, -0.01119136f,  
1916.        -1.85360224e-003f, -5.94652840e-004f, -0.04451817f, 2.98327743e-003f,  
1917.        0.06272484f, -0.02152076f, -3.05971340e-003f, -0.05070828f,  
1918.        0.01531762f, 0.01282815f, 0.05167150f, 9.46266949e-003f,  
1919.        -3.34558333e-003f, 0.11442288f, -0.03906701f, -2.67325155e-003f,  
1920.        0.03069184f, -0.01134165f, 0.02949462f, 0.02879886f, 0.03855566f,  
1921.        -0.03450781f, 0.09142872f, -0.02156654f, 0.06075062f, -0.06220816f,  
1922.        0.01944680f, 6.68372354e-003f, -0.06656796f, 8.70784000e-003f,  
1923.        0.03456013f, 0.02434320f, -0.13236357f, -0.04177035f, -0.02069627f,  
1924.        0.01068112f, 0.01505432f, -0.07517391f, -3.83571628e-003f,  
1925.        -0.06298508f, -0.02881260f, -0.13101046f, -0.07221562f,  
1926.        -5.79945277e-003f, -8.57300125e-003f, 0.03782469f, 0.02762164f,  
1927.        0.04942456f, -0.02936396f, 0.09597211f, 0.01921411f, 0.06101191f,  
1928.        -0.04787507f, -0.01379578f, -7.40224449e-003f, -0.02220136f,  
1929.        -0.01313756f, 7.77558051e-003f, 0.12296968f, 0.02939998f, 0.03594062f,  
1930.        -0.07788624f, -0.01133144f, 3.99316690e-004f, -0.06090347f,  
1931.        -0.01122066f, -4.68682544e-003f, 0.07633100f, -0.06748922f,  
1932.        -0.05640298f, -0.05265681f, -0.01139122f, -0.01624347f, -0.04715714f,  
1933.        -0.01099092f, 0.01048561f, 3.28499987e-003f, -0.05810167f,  
1934.        -0.07699911f, -0.03330683f, 0.04185145f, 0.03478536f, 0.02275165f,  
1935.        0.02304766f, 6.66040834e-003f, 0.10968148f, -5.93013782e-003f,  
1936.        -0.04858336f, -0.04203213f, -0.09316786f, -6.13074889e-003f,  
1937.        -0.02544625f, 0.01366201f, 9.18555818e-003f, -0.01846578f,  
1938.        -0.05622401f, -0.03989377f, -0.07810296f, 6.91275718e-003f,  
1939.        0.05957597f, -0.03901334f, 0.01572002f, -0.01193903f,  
1940.        -6.89400872e-003f, -0.03093356f, -0.04136098f, -0.01562869f,  
1941.        -0.04604580f, 0.02865234f, -0.08678447f, -0.03232484f, -0.05364593f,  
1942.        -0.01445016f, -0.07003860f, -0.08669746f, -0.04520775f, 0.04274122f,  
1943.        0.03117515f, 0.08175703f, 0.01081109f, 0.06379741f, 0.06199206f,  
1944.        0.02865988f, 0.02360346f, 0.06725410f, -0.03248780f, -9.37702879e-003f,  
1945.        0.08265898f, -0.02245839f, 0.05125763f, -0.01862395f, 0.01973453f,  
1946.        -0.01994494f, -0.10770868f, 0.03180375f, 3.23935156e-003f,  
1947.        -0.02142080f, -0.04256190f, 0.04760900f, 0.04282863f, 0.05635953f,  
1948.        -0.01870849f, 0.05540622f, -0.03042666f, 0.01455277f, -0.06630179f,  
1949.        -0.05843807f, -0.03739681f, -0.09739155f, -0.03220233f, -0.05620182f,  
1950.        -0.10381401f, 0.07400211f, 4.20676917e-003f, 0.03258535f,  
1951.        2.14308966e-003f, 0.05121966f, -0.01274337f, 0.02384761f, 0.06335578f,  
1952.        -0.07905591f, 0.08375625f, -0.07898903f, -0.06508528f, -0.02498444f,  
1953.        0.06535810f, 0.03970535f, 0.04895468f, -0.01169566f, -0.03980601f,  
1954.        0.05682293f, 0.05925463f, -0.01165808f, -0.07936699f, -0.04208954f,  
1955.        0.01333987f, 0.09051196f, 0.10098671f, -0.03974256f, 0.01238771f,  
1956.        -0.07501741f, -0.03655440f, -0.04301528f, 0.09216860f,  
1957.        4.63579083e-004f, 0.02851115f, 0.02142735f, 1.28244064e-004f,  
1958.        0.02879687f, -0.08554889f, -0.04838862f, 0.08135369f, -0.05756533f,  
1959.        0.01413900f, 0.03451880f, -0.06619488f, -0.03053130f, 0.02961676f,  
1960.        -0.07384635f, 0.01135692f, 0.05283910f, -0.07778034f, -0.02107482f,  
1961.        -0.05511716f, -0.13473752f, 0.03030157f, 0.06722020f, -0.06218817f,  
1962.        -0.05826827f, 0.06254654f, 0.02895772f, -0.01664000f, -0.03620280f,  
1963.        -0.01612278f, -1.46097376e-003f, 0.14013411f, -8.96181818e-003f,  
1964.        -0.03250246f, 3.38630192e-003f, 2.64779478e-003f, 0.03359732f,  
1965.        -0.02411991f, -0.04229729f, 0.10666174f, -6.66579151f };  
1966.     return vector<float>(detector, detector + sizeof(detector)/sizeof(detector[0]));  
1967. }  
1968. //This function renurn 1981 SVM coeffs obtained from daimler's base.  
1969. //To use these coeffs the detection window size should be (48,96)  
1970. vector<float> HOGDescriptor::getDaimlerPeopleDetector()  
1971. {  
1972.     static const float detector[] = {  
1973.         0.294350f, -0.098796f, -0.129522f, 0.078753f,  
1974.         0.387527f, 0.261529f, 0.145939f, 0.061520f,  
1975.         0.328699f, 0.227148f, -0.066467f, -0.086723f,  
1976.         0.047559f, 0.106714f, 0.037897f, 0.111461f,  
1977.         -0.024406f, 0.304769f, 0.254676f, -0.069235f,  
1978.         0.082566f, 0.147260f, 0.326969f, 0.148888f,  
1979.         0.055270f, -0.087985f, 0.261720f, 0.143442f,  
1980.         0.026812f, 0.238212f, 0.194020f, 0.056341f,  
1981.         -0.025854f, -0.034444f, -0.156631f, 0.205174f,  
1982.         0.089008f, -0.139811f, -0.100147f, -0.037830f,  
1983.         -0.029230f, -0.055641f, 0.033248f, -0.016512f,  
1984.         0.155244f, 0.247315f, -0.124694f, -0.048414f,  
1985.         -0.062219f, 0.193683f, 0.004574f, 0.055089f,  
1986.         0.093565f, 0.167712f, 0.167581f, 0.018895f,  
1987.         0.215258f, 0.122609f, 0.090520f, -0.067219f,  
1988.         -0.049029f, -0.099615f, 0.241804f, -0.094893f,  
1989.         -0.176248f, 0.001727f, -0.134473f, 0.104442f,  
1990.         0.050942f, 0.081165f, 0.072156f, 0.121646f,  
1991.         0.002656f, -0.297974f, -0.133587f, -0.060121f,  
1992.         -0.092515f, -0.048974f, -0.084754f, -0.180111f,  
1993.         -0.038590f, 0.086283f, -0.134636f, -0.107249f,  
1994.         0.132890f, 0.141556f, 0.249425f, 0.130273f,  
1995.         -0.030031f, 0.073212f, -0.008155f, 0.019931f,  
1996.         0.071688f, 0.000300f, -0.019525f, -0.021725f,  
1997.         -0.040993f, -0.086841f, 0.070124f, 0.240033f,  
1998.         0.265350f, 0.043208f, 0.166754f, 0.091453f,  
1999.         0.060916f, -0.036972f, -0.091043f, 0.079873f,  
2000.         0.219781f, 0.158102f, -0.140618f, -0.043016f,  
2001.         0.124802f, 0.093668f, 0.103208f, 0.094872f,  
2002.         0.080541f, 0.137711f, 0.160566f, -0.169231f,  
2003.         0.013983f, 0.309508f, -0.004217f, -0.057200f,  
2004.         -0.064489f, 0.014066f, 0.361009f, 0.251328f,  
2005.         -0.080983f, -0.044183f, 0.061436f, -0.037381f,  
2006.         -0.078786f, 0.030993f, 0.066314f, 0.037683f,  
2007.         0.152325f, -0.091683f, 0.070203f, 0.217856f,  
2008.         0.036435f, -0.076462f, 0.006254f, -0.094431f,  
2009.         0.154829f, -0.023038f, -0.196961f, -0.024594f,  
2010.         0.178465f, -0.050139f, -0.045932f, -0.000965f,  
2011.         0.109112f, 0.046165f, -0.159373f, -0.008713f,  
2012.         0.041307f, 0.097129f, -0.057211f, -0.064599f,  
2013.         0.077165f, 0.176167f, 0.138322f, 0.065753f,  
2014.         -0.104950f, 0.017933f, 0.136255f, -0.011598f,  
2015.         0.047007f, 0.080550f, 0.068619f, 0.084661f,  
2016.         -0.035493f, -0.091314f, -0.041411f, 0.060971f,  
2017.         -0.101912f, -0.079870f, -0.085977f, -0.022686f,  
2018.         0.079788f, -0.098064f, -0.054603f, 0.040383f,  
2019.         0.300794f, 0.128603f, 0.094844f, 0.047407f,  
2020.         0.101825f, 0.061832f, -0.162160f, -0.204553f,  
2021.         -0.035165f, 0.101450f, -0.016641f, -0.027140f,  
2022.         -0.134392f, -0.008743f, 0.102331f, 0.114853f,  
2023.         0.009644f, 0.062823f, 0.237339f, 0.167843f,  
2024.         0.053066f, -0.012592f, 0.043158f, 0.002305f,  
2025.         0.065001f, -0.038929f, -0.020356f, 0.152343f,  
2026.         0.043469f, -0.029967f, -0.042948f, 0.032481f,  
2027.         0.068488f, -0.110840f, -0.111083f, 0.111980f,  
2028.         -0.002072f, -0.005562f, 0.082926f, 0.006635f,  
2029.         -0.108153f, 0.024242f, -0.086464f, -0.189884f,  
2030.         -0.017492f, 0.191456f, -0.007683f, -0.128769f,  
2031.         -0.038017f, -0.132380f, 0.091926f, 0.079696f,  
2032.         -0.106728f, -0.007656f, 0.172744f, 0.011576f,  
2033.         0.009883f, 0.083258f, -0.026516f, 0.145534f,  
2034.         0.153924f, -0.130290f, -0.108945f, 0.124490f,  
2035.         -0.003186f, -0.100485f, 0.015024f, -0.060512f,  
2036.         0.026288f, -0.086713f, -0.169012f, 0.076517f,  
2037.         0.215778f, 0.043701f, -0.131642f, -0.012585f,  
2038.         -0.045181f, -0.118183f, -0.241544f, -0.167293f,  
2039.         -0.020107f, -0.019917f, -0.101827f, -0.107096f,  
2040.         -0.010503f, 0.044938f, 0.189680f, 0.217119f,  
2041.         -0.046086f, 0.044508f, 0.199716f, -0.036004f,  
2042.         -0.148927f, 0.013355f, -0.078279f, 0.030451f,  
2043.         0.056301f, -0.024609f, 0.083224f, 0.099533f,  
2044.         -0.039432f, -0.138880f, 0.005482f, -0.024120f,  
2045.         -0.140468f, -0.066381f, -0.017057f, 0.009260f,  
2046.         -0.058004f, -0.028486f, -0.061610f, 0.007483f,  
2047.         -0.158309f, -0.150687f, -0.044595f, -0.105121f,  
2048.         -0.045763f, -0.006618f, -0.024419f, -0.117713f,  
2049.         -0.119366f, -0.175941f, -0.071542f, 0.119027f,  
2050.         0.111362f, 0.043080f, 0.034889f, 0.093003f,  
2051.         0.007842f, 0.057368f, -0.108834f, -0.079968f,  
2052.         0.230959f, 0.020205f, 0.011470f, 0.098877f,  
2053.         0.101310f, -0.030215f, -0.018018f, -0.059552f,  
2054.         -0.106157f, 0.021866f, -0.036471f, 0.080051f,  
2055.         0.041165f, -0.082101f, 0.117726f, 0.030961f,  
2056.         -0.054763f, -0.084102f, -0.185778f, -0.061305f,  
2057.         -0.038089f, -0.110728f, -0.264010f, 0.076675f,  
2058.         -0.077111f, -0.137644f, 0.036232f, 0.277995f,  
2059.         0.019116f, 0.107738f, 0.144003f, 0.080304f,  
2060.         0.215036f, 0.228897f, 0.072713f, 0.077773f,  
2061.         0.120168f, 0.075324f, 0.062730f, 0.122478f,  
2062.         -0.049008f, 0.164912f, 0.162450f, 0.041246f,  
2063.         0.009891f, -0.097827f, -0.038700f, -0.023027f,  
2064.         -0.120020f, 0.203364f, 0.248474f, 0.149810f,  
2065.         -0.036276f, -0.082814f, -0.090343f, -0.027143f,  
2066.         -0.075689f, -0.320310f, -0.000500f, -0.143334f,  
2067.         -0.065077f, -0.186936f, 0.129372f, 0.116431f,  
2068.         0.181699f, 0.170436f, 0.418854f, 0.460045f,  
2069.         0.333719f, 0.230515f, 0.047822f, -0.044954f,  
2070.         -0.068086f, 0.140179f, -0.044821f, 0.085550f,  
2071.         0.092483f, -0.107296f, -0.130670f, -0.206629f,  
2072.         0.114601f, -0.317869f, -0.076663f, 0.038680f,  
2073.         0.212753f, -0.016059f, -0.126526f, -0.163602f,  
2074.         0.210154f, 0.099887f, -0.126366f, 0.118453f,  
2075.         0.019309f, -0.021611f, -0.096499f, -0.111809f,  
2076.         -0.200489f, 0.142854f, 0.228840f, -0.353346f,  
2077.         -0.179151f, 0.116834f, 0.252389f, -0.031728f,  
2078.         -0.188135f, -0.158998f, 0.386523f, 0.122315f,  
2079.         0.209944f, 0.394023f, 0.359030f, 0.260717f,  
2080.         0.170335f, 0.013683f, -0.142596f, -0.026138f,  
2081.         -0.011878f, -0.150519f, 0.047159f, -0.107062f,  
2082.         -0.147347f, -0.187689f, -0.186027f, -0.208048f,  
2083.         0.058468f, -0.073026f, -0.236556f, -0.079788f,  
2084.         -0.146216f, -0.058563f, -0.101361f, -0.071294f,  
2085.         -0.071093f, 0.116919f, 0.234304f, 0.306781f,  
2086.         0.321866f, 0.240000f, 0.073261f, -0.012173f,  
2087.         0.026479f, 0.050173f, 0.166127f, 0.228955f,  
2088.         0.061905f, 0.156460f, 0.205990f, 0.120672f,  
2089.         0.037350f, 0.167884f, 0.290099f, 0.420900f,  
2090.         -0.012601f, 0.189839f, 0.306378f, 0.118383f,  
2091.         -0.095598f, -0.072360f, -0.132496f, -0.224259f,  
2092.         -0.126021f, 0.022714f, 0.284039f, 0.051369f,  
2093.         -0.000927f, -0.058735f, -0.083354f, -0.141254f,  
2094.         -0.187578f, -0.202669f, 0.048902f, 0.246597f,  
2095.         0.441863f, 0.342519f, 0.066979f, 0.215286f,  
2096.         0.188191f, -0.072240f, -0.208142f, -0.030196f,  
2097.         0.178141f, 0.136985f, -0.043374f, -0.181098f,  
2098.         0.091815f, 0.116177f, -0.126690f, -0.386625f,  
2099.         0.368165f, 0.269149f, -0.088042f, -0.028823f,  
2100.         0.092961f, 0.024099f, 0.046112f, 0.176756f,  
2101.         0.135849f, 0.124955f, 0.195467f, -0.037218f,  
2102.         0.167217f, 0.188938f, 0.053528f, -0.066561f,  
2103.         0.133721f, -0.070565f, 0.115898f, 0.152435f,  
2104.         -0.116993f, -0.110592f, -0.179005f, 0.026668f,  
2105.         0.080530f, 0.075084f, -0.070401f, 0.012497f,  
2106.         0.021849f, -0.139764f, -0.022020f, -0.096301f,  
2107.         -0.064954f, -0.127446f, -0.013806f, -0.108315f,  
2108.         0.156285f, 0.149867f, -0.011382f, 0.064532f,  
2109.         0.029168f, 0.027393f, 0.069716f, 0.153735f,  
2110.         0.038459f, 0.230714f, 0.253840f, 0.059522f,  
2111.         -0.045053f, 0.014083f, 0.071103f, 0.068747f,  
2112.         0.095887f, 0.005832f, 0.144887f, 0.026357f,  
2113.         -0.067359f, -0.044151f, -0.123283f, -0.019911f,  
2114.         0.005318f, 0.109208f, -0.003201f, -0.021734f,  
2115.         0.142025f, -0.066907f, -0.120070f, -0.188639f,  
2116.         0.012472f, -0.048704f, -0.012366f, -0.184828f,  
2117.         0.168591f, 0.267166f, 0.058208f, -0.044101f,  
2118.         0.033500f, 0.178558f, 0.104550f, 0.122418f,  
2119.         0.080177f, 0.173246f, 0.298537f, 0.064173f,  
2120.         0.053397f, 0.174341f, 0.230984f, 0.117025f,  
2121.         0.166242f, 0.227781f, 0.120623f, 0.176952f,  
2122.         -0.011393f, -0.086483f, -0.008270f, 0.051700f,  
2123.         -0.153369f, -0.058837f, -0.057639f, -0.060115f,  
2124.         0.026349f, -0.160745f, -0.037894f, -0.048575f,  
2125.         0.041052f, -0.022112f, 0.060365f, 0.051906f,  
2126.         0.162657f, 0.138519f, -0.050185f, -0.005938f,  
2127.         0.071301f, 0.127686f, 0.062342f, 0.144400f,  
2128.         0.072600f, 0.198436f, 0.246219f, -0.078185f,  
2129.         -0.036169f, 0.075934f, 0.047328f, -0.013601f,  
2130.         0.087205f, 0.019900f, 0.022606f, -0.015365f,  
2131.         -0.092506f, 0.075275f, -0.116375f, 0.050500f,  
2132.         0.045118f, 0.166567f, 0.072073f, 0.060371f,  
2133.         0.131747f, -0.169863f, -0.039352f, -0.047486f,  
2134.         -0.039797f, -0.204312f, 0.021710f, 0.129443f,  
2135.         -0.021173f, 0.173416f, -0.070794f, -0.063986f,  
2136.         0.069689f, -0.064099f, -0.123201f, -0.017372f,  
2137.         -0.206870f, 0.065863f, 0.113226f, 0.024707f,  
2138.         -0.071341f, -0.066964f, -0.098278f, -0.062927f,  
2139.         0.075840f, 0.014716f, 0.019378f, 0.132699f,  
2140.         -0.074191f, -0.089557f, -0.078446f, -0.197488f,  
2141.         -0.173665f, 0.052583f, 0.044361f, 0.113549f,  
2142.         0.098492f, 0.077379f, -0.011146f, -0.192593f,  
2143.         -0.164435f, 0.045568f, 0.205699f, 0.049187f,  
2144.         -0.082281f, 0.134874f, 0.185499f, 0.034968f,  
2145.         -0.119561f, -0.112372f, -0.115091f, -0.054042f,  
2146.         -0.183816f, -0.078100f, 0.190695f, 0.091617f,  
2147.         0.004257f, -0.041135f, -0.061453f, -0.141592f,  
2148.         -0.194809f, -0.120638f, 0.020168f, 0.109672f,  
2149.         0.067398f, -0.015238f, -0.239145f, -0.264671f,  
2150.         -0.185176f, 0.050472f, 0.020793f, 0.035678f,  
2151.         0.022839f, -0.052055f, -0.127968f, -0.113049f,  
2152.         -0.228416f, -0.258281f, -0.053437f, 0.076424f,  
2153.         0.061450f, 0.237478f, 0.003618f, -0.055865f,  
2154.         -0.108087f, -0.028937f, 0.045585f, 0.052829f,  
2155.         -0.001471f, 0.022826f, 0.059565f, -0.104430f,  
2156.         -0.077266f, -0.211882f, -0.212078f, 0.028074f,  
2157.         0.075846f, 0.016265f, 0.161879f, 0.134477f,  
2158.         0.008935f, -0.048041f, 0.074692f, 0.004928f,  
2159.         -0.025156f, 0.192874f, 0.074410f, 0.308732f,  
2160.         0.267400f, 0.094208f, -0.005251f, 0.042041f,  
2161.         -0.032148f, 0.015588f, 0.252869f, 0.175302f,  
2162.         0.022892f, 0.081673f, 0.063208f, 0.162626f,  
2163.         0.194426f, 0.233890f, 0.262292f, 0.186930f,  
2164.         0.084079f, -0.286388f, -0.213034f, -0.048867f,  
2165.         -0.207669f, -0.170050f, 0.011673f, -0.092958f,  
2166.         -0.192786f, -0.273536f, 0.230904f, 0.266732f,  
2167.         0.320519f, 0.297155f, 0.548169f, 0.304922f,  
2168.         0.132687f, 0.247333f, 0.212488f, -0.271472f,  
2169.         -0.142105f, -0.002627f, -0.119215f, 0.128383f,  
2170.         0.100079f, -0.057490f, -0.121902f, -0.228892f,  
2171.         0.202292f, -0.399795f, -0.371326f, -0.095836f,  
2172.         -0.063626f, -0.161375f, -0.311180f, -0.294797f,  
2173.         0.242122f, 0.011788f, 0.095573f, 0.322523f,  
2174.         0.511840f, 0.322880f, 0.313259f, 0.173331f,  
2175.         0.002542f, -0.029802f, 0.324766f, -0.326170f,  
2176.         -0.340547f, -0.138288f, -0.002963f, -0.114060f,  
2177.         -0.377312f, -0.442570f, 0.212446f, -0.007759f,  
2178.         -0.011576f, 0.169711f, 0.308689f, 0.317348f,  
2179.         0.539390f, 0.332845f, 0.057331f, -0.068180f,  
2180.         0.101994f, 0.266995f, 0.209570f, 0.355730f,  
2181.         0.091635f, 0.170238f, 0.125215f, 0.274154f,  
2182.         0.070223f, 0.025515f, 0.049946f, -0.000550f,  
2183.         0.043715f, -0.141843f, 0.020844f, 0.129871f,  
2184.         0.256588f, 0.105015f, 0.148339f, 0.170682f,  
2185.         0.028792f, 0.074037f, 0.160042f, 0.405137f,  
2186.         0.246187f, 0.352160f, 0.168951f, 0.222263f,  
2187.         0.264439f, 0.065945f, 0.021963f, -0.075084f,  
2188.         0.093105f, 0.027318f, 0.098864f, 0.057566f,  
2189.         -0.080282f, 0.185032f, 0.314419f, 0.333727f,  
2190.         0.125798f, 0.294919f, 0.386002f, 0.217619f,  
2191.         -0.183517f, -0.278622f, -0.002342f, -0.027821f,  
2192.         -0.134266f, -0.331843f, -0.008296f, 0.124564f,  
2193.         0.053712f, -0.369016f, -0.095036f, 0.209381f,  
2194.         0.423760f, 0.371760f, 0.106397f, 0.369408f,  
2195.         0.485608f, 0.231201f, -0.138685f, -0.349208f,  
2196.         -0.070083f, 0.028991f, -0.081630f, -0.395992f,  
2197.         -0.146791f, -0.027354f, 0.063396f, -0.272484f,  
2198.         0.058299f, 0.338207f, 0.110767f, -0.052642f,  
2199.         -0.233848f, -0.027448f, 0.030328f, 0.155572f,  
2200.         -0.093826f, 0.019331f, 0.120638f, 0.006292f,  
2201.         -0.106083f, -0.236290f, -0.140933f, -0.088067f,  
2202.         -0.025138f, -0.208395f, -0.025502f, 0.144192f,  
2203.         -0.048353f, -0.106144f, -0.305121f, -0.114147f,  
2204.         0.090963f, 0.327727f, 0.035606f, -0.093779f,  
2205.         0.002651f, -0.171081f, -0.188131f, -0.216571f,  
2206.         -0.209101f, -0.054402f, 0.157147f, -0.057127f,  
2207.         0.066584f, 0.008988f, 0.041191f, 0.034456f,  
2208.         -0.078255f, 0.052099f, -0.022239f, 0.066981f,  
2209.         -0.117520f, -0.072637f, 0.062512f, 0.037570f,  
2210.         -0.057544f, -0.312359f, 0.034357f, -0.031549f,  
2211.         0.002566f, -0.207375f, -0.070654f, -0.018786f,  
2212.         -0.044815f, -0.012814f, -0.076320f, 0.078183f,  
2213.         0.023877f, 0.117078f, 0.022292f, -0.205424f,  
2214.         -0.060430f, -0.017296f, -0.004827f, -0.321036f,  
2215.         -0.092155f, 0.038837f, 0.073190f, -0.067513f,  
2216.         0.026521f, 0.171945f, 0.087318f, 0.034495f,  
2217.         -0.034089f, 0.154410f, -0.061431f, 0.007435f,  
2218.         -0.111094f, -0.095976f, 0.014741f, -0.132324f,  
2219.         -0.029517f, -0.192160f, 0.098667f, 0.020762f,  
2220.         0.177050f, -0.064510f, -0.054437f, -0.058678f,  
2221.         -0.001858f, 0.167602f, 0.015735f, 0.054338f,  
2222.         0.016477f, 0.186381f, -0.010667f, 0.054692f,  
2223.         0.126742f, 0.013140f, 0.090353f, -0.133608f,  
2224.         -0.018017f, -0.152619f, 0.027600f, -0.138700f,  
2225.         -0.050274f, 0.045141f, -0.118731f, 0.094797f,  
2226.         -0.167605f, 0.097461f, -0.009131f, 0.199920f,  
2227.         -0.052976f, 0.158194f, 0.178568f, -0.107600f,  
2228.         0.009671f, -0.084072f, -0.040258f, -0.205673f,  
2229.         0.102891f, 0.223511f, 0.042699f, 0.118548f,  
2230.         -0.021274f, 0.110997f, -0.155121f, 0.027696f,  
2231.         -0.149968f, 0.051552f, -0.129219f, 0.173524f,  
2232.         0.073972f, -0.189045f, -0.034523f, -0.106655f,  
2233.         -0.011843f, -0.197381f, 0.219413f, 0.183197f,  
2234.         -0.054920f, 0.144955f, 0.036517f, -0.085412f,  
2235.         -0.229070f, -0.143710f, -0.049486f, 0.156634f,  
2236.         -0.008673f, -0.064778f, 0.082344f, 0.145673f,  
2237.         0.002912f, -0.210121f, -0.116564f, 0.078425f,  
2238.         0.220908f, -0.067594f, 0.048610f, 0.084912f,  
2239.         -0.066202f, -0.112515f, -0.217767f, -0.082640f,  
2240.         -0.017414f, 0.230265f, -0.070735f, 0.066073f,  
2241.         0.215256f, 0.071157f, -0.087220f, -0.202235f,  
2242.         -0.011918f, 0.099562f, 0.174716f, -0.063845f,  
2243.         -0.121055f, 0.014367f, 0.132709f, -0.005060f,  
2244.         -0.244606f, -0.179693f, -0.134690f, 0.023239f,  
2245.         -0.193116f, -0.076975f, -0.021164f, -0.001938f,  
2246.         -0.163799f, -0.111437f, -0.210362f, -0.166376f,  
2247.         0.034754f, 0.010036f, -0.021917f, 0.068014f,  
2248.         -0.086893f, -0.251746f, -0.267171f, 0.037383f,  
2249.         0.003966f, 0.033571f, -0.151506f, 0.025437f,  
2250.         -0.020626f, -0.308454f, -0.343143f, -0.092263f,  
2251.         -0.026261f, -0.028345f, 0.036036f, 0.035169f,  
2252.         0.129470f, 0.122205f, 0.015661f, -0.070612f,  
2253.         -0.094333f, -0.066055f, -0.041083f, 0.159146f,  
2254.         0.073184f, 0.110044f, 0.174471f, 0.078069f,  
2255.         -0.014881f, 0.008116f, 0.013209f, 0.075857f,  
2256.         0.195605f, 0.062714f, 0.067955f, 0.056544f,  
2257.         -0.153908f, -0.141749f, -0.072550f, 0.033523f,  
2258.         -0.024665f, 0.134487f, 0.079076f, 0.133562f,  
2259.         0.227130f, 0.018054f, 0.004928f, 0.169162f,  
2260.         0.065152f, 0.072160f, 0.131631f, 0.096303f,  
2261.         0.054288f, 0.106256f, 0.114632f, 0.119038f,  
2262.         0.515200f, 0.247429f, 0.199134f, 0.211957f,  
2263.         0.127558f, -0.294684f, -0.194890f, -0.049988f,  
2264.         -0.112247f, -0.008122f, -0.006176f, 0.037035f,  
2265.         -0.110881f, -0.249989f, 0.152434f, 0.234621f,  
2266.         0.153340f, 0.349283f, 0.683049f, 0.157174f,  
2267.         0.124844f, 0.099136f, 0.064407f, -0.248400f,  
2268.         -0.155323f, -0.026498f, -0.023450f, 0.049051f,  
2269.         -0.114187f, 0.007195f, -0.176825f, -0.376926f,  
2270.         0.366159f, -0.179938f, -0.148508f, 0.006043f,  
2271.         0.170048f, 0.097866f, -0.102658f, -0.260430f,  
2272.         0.248868f, 0.037019f, -0.118111f, 0.078176f,  
2273.         0.194171f, 0.211328f, 0.368612f, 0.361213f,  
2274.         0.130013f, 0.094650f, 0.227396f, -0.178058f,  
2275.         -0.114782f, -0.008093f, 0.231080f, -0.011843f,  
2276.         -0.097917f, -0.325788f, 0.141879f, 0.119738f,  
2277.         -0.230427f, -0.117419f, -0.114153f, 0.037903f,  
2278.         0.116383f, 0.218773f, -0.101884f, 0.059466f,  
2279.         0.119255f, 0.010874f, -0.031449f, 0.045996f,  
2280.         0.119931f, 0.273760f, 0.311700f, 0.261794f,  
2281.         0.194809f, 0.339829f, 0.239449f, 0.064140f,  
2282.         0.077597f, 0.098996f, 0.143534f, 0.184602f,  
2283.         0.037507f, 0.225494f, 0.096142f, -0.147370f,  
2284.         -0.207833f, -0.174742f, -0.086391f, -0.038942f,  
2285.         0.159577f, -0.088492f, -0.000989f, 0.108154f,  
2286.         -0.025890f, -0.072713f, 0.025997f, -0.006803f,  
2287.         -0.086879f, -0.011290f, -0.269200f, -0.103450f,  
2288.         -0.124910f, -0.116340f, 0.141459f, 0.208800f,  
2289.         0.042268f, 0.265034f, 0.516474f, 0.217591f,  
2290.         -0.018843f, -0.313328f, -0.168363f, 0.047129f,  
2291.         0.090480f, -0.109852f, -0.018761f, 0.210669f,  
2292.         0.281269f, -0.043591f, -0.034147f, -0.237772f,  
2293.         -0.134843f, -0.072481f, -0.103831f, 0.038355f,  
2294.         0.308619f, 0.148023f, -0.045867f, -0.123950f,  
2295.         -0.210860f, -0.064973f, -0.036308f, -0.046731f,  
2296.         -0.022099f, 0.095776f, 0.409423f, 0.060635f,  
2297.         -0.065196f, 0.051828f, 0.027981f, -0.009609f,  
2298.         -0.137681f, -0.095011f, -0.019045f, 0.177278f,  
2299.         0.009759f, -0.092119f, -0.016958f, -0.133860f,  
2300.         -0.118421f, -0.032039f, -0.006214f, -0.084541f,  
2301.         0.063971f, -0.073642f, 0.165676f, 0.110443f,  
2302.         0.044131f, 0.046568f, 0.053292f, -0.055466f,  
2303.         0.015512f, 0.371947f, 0.232102f, -0.016923f,  
2304.         0.103979f, -0.091758f, 0.005907f, 0.209100f,  
2305.         0.157433f, 0.030518f, 0.250366f, 0.062322f,  
2306.         0.036720f, 0.094676f, 0.017306f, -0.010328f,  
2307.         -0.079012f, 0.016781f, -0.112435f, 0.061795f,  
2308.         0.042543f, -0.126799f, -0.009975f, -0.056760f,  
2309.         0.046424f, -0.194712f, -0.139399f, -0.037731f,  
2310.         0.157989f, -0.016261f, 0.123345f, 0.230563f,  
2311.         0.083300f, -0.016392f, 0.059567f, -0.016035f,  
2312.         -0.064767f, 0.231945f, 0.156629f, 0.034602f,  
2313.         0.145628f, 0.041315f, 0.034535f, 0.019967f,  
2314.         -0.089188f, -0.012091f, 0.307857f, 0.211405f,  
2315.         -0.025091f, -0.148249f, -0.129384f, 0.063536f,  
2316.         -0.068603f, -0.067941f, -0.035104f, 0.210832f,  
2317.         0.063810f, 0.062764f, -0.089889f, -0.030554f,  
2318.         0.014791f, -0.053362f, -0.037818f, -0.196640f,  
2319.         0.008388f, -0.082654f, 0.143056f, 0.064221f,  
2320.         0.069795f, 0.191040f, 0.097321f, -0.028679f,  
2321.         0.075794f, 0.313154f, 0.086240f, 0.207643f,  
2322.         0.017809f, 0.122867f, 0.224586f, 0.167403f,  
2323.         -0.023884f, 0.047434f, 0.344091f, 0.187745f,  
2324.         0.136177f, 0.141738f, 0.063799f, 0.045233f,  
2325.         -0.077342f, -0.003525f, -0.165041f, -0.025616f,  
2326.         -0.073745f, 0.164439f, 0.011200f, -0.145896f,  
2327.         -0.027954f, -0.061987f, -0.039874f, -0.142775f,  
2328.         0.151042f, -0.038238f, 0.053152f, 0.078615f,  
2329.         0.086061f, 0.100593f, 0.128046f, -0.071006f,  
2330.         -0.116558f, 0.208445f, 0.051086f, 0.076843f,  
2331.         0.023191f, -0.084781f, -0.011790f, 0.147807f,  
2332.         -0.048554f, -0.113932f, 0.283322f, 0.190934f,  
2333.         0.092789f, 0.033018f, -0.142428f, -0.142480f,  
2334.         -0.099023f, -0.041020f, -0.042760f, 0.203295f,  
2335.         -0.053475f, 0.042424f, 0.222839f, -0.019167f,  
2336.         -0.133176f, -0.276216f, -0.031998f, 0.117290f,  
2337.         0.177827f, -0.059973f, -0.064744f, -0.117040f,  
2338.         -0.155482f, -0.099531f, 0.164121f, -0.026682f,  
2339.         -0.093810f, 0.238993f, -0.006506f, 0.007830f,  
2340.         0.065819f, -0.203643f, -0.100925f, -0.053652f,  
2341.         -0.130770f, 0.026277f, 0.131796f, 0.032742f,  
2342.         0.127186f, 0.116694f, -0.161122f, -0.279773f,  
2343.         -0.252515f, -0.002638f, 0.042812f, 0.096776f,  
2344.         -0.123280f, 0.064858f, -0.010455f, -0.219760f,  
2345.         -0.239331f, -0.104363f, -0.058022f, -0.053584f,  
2346.         0.025611f, 0.005129f, -0.100418f, -0.045712f,  
2347.         -0.194418f, -0.126366f, -0.030530f, 0.051168f,  
2348.         0.215959f, 0.172402f, -0.054700f, -0.185995f,  
2349.         -0.278360f, -0.193693f, -0.040309f, 0.003735f,  
2350.         -0.007770f, 0.123556f, 0.190179f, -0.077315f,  
2351.         0.117403f, 0.212942f, 0.012160f, 0.000113f,  
2352.         0.027331f, 0.040202f, 0.033293f, 0.219438f,  
2353.         0.184174f, 0.259349f, 0.311206f, 0.082547f,  
2354.         -0.047875f, -0.078417f, 0.010746f, 0.082620f,  
2355.         0.311931f, 0.307605f, 0.003863f, 0.021405f,  
2356.         -0.026388f, -0.019572f, 0.020582f, -0.059353f,  
2357.         0.025199f, 0.261319f, 0.086316f, 0.143614f,  
2358.         0.107780f, 0.003900f, -0.188397f, -0.038563f,  
2359.         -0.106045f, -0.125154f, -0.010509f, 0.054021f,  
2360.         0.242130f, 0.279152f, 0.215546f, 0.346995f,  
2361.         0.440856f, 0.237452f, 0.234154f, 0.301646f,  
2362.         0.168929f, -0.208358f, -0.126848f, 0.010260f,  
2363.         0.121018f, -0.062975f, -0.052848f, 0.050341f,  
2364.         -0.061103f, -0.266482f, 0.107186f, 0.140221f,  
2365.         0.280065f, 0.287889f, 0.373198f, 0.151596f,  
2366.         0.013593f, 0.115616f, 0.014616f, -0.281710f,  
2367.         -0.237597f, -0.117305f, -0.000034f, -0.136739f,  
2368.         -0.196275f, -0.095225f, -0.125310f, -0.250514f,  
2369.         0.236804f, -0.071805f, -0.037421f, 0.048230f,  
2370.         0.321596f, 0.063632f, 0.024039f, -0.029133f,  
2371.         0.230983f, 0.160593f, -0.154355f, -0.013086f,  
2372.         -0.079929f, 0.094692f, 0.160391f, 0.180239f,  
2373.         0.053895f, 0.100759f, 0.288631f, 0.038191f,  
2374.         0.181692f, 0.229682f, 0.440166f, 0.063401f,  
2375.         0.006273f, 0.020865f, 0.338695f, 0.256244f,  
2376.         -0.043927f, 0.115617f, 0.003296f, 0.173965f,  
2377.         0.021318f, -0.040936f, -0.118932f, 0.182380f,  
2378.         0.235922f, -0.053233f, -0.015053f, -0.101057f,  
2379.         0.095341f, 0.051111f, 0.161831f, 0.032614f,  
2380.         0.159496f, 0.072375f, 0.025089f, 0.023748f,  
2381.         0.029151f, 0.161284f, -0.117717f, -0.036191f,  
2382.         -0.176822f, -0.162006f, 0.226542f, -0.078329f,  
2383.         0.043079f, -0.119172f, 0.054614f, -0.101365f,  
2384.         -0.064541f, -0.115304f, 0.135170f, 0.298872f,  
2385.         0.098060f, 0.089428f, -0.007497f, 0.110391f,  
2386.         -0.028824f, 0.020835f, -0.036804f, 0.125411f,  
2387.         0.192105f, -0.048931f, 0.003086f, -0.010681f,  
2388.         0.074698f, -0.016263f, 0.096063f, 0.060267f,  
2389.         -0.007277f, 0.139139f, -0.080635f, 0.036628f,  
2390.         0.086058f, 0.131979f, 0.085707f, 0.025301f,  
2391.         0.226094f, 0.194759f, 0.042193f, -0.157846f,  
2392.         -0.068402f, -0.141450f, -0.112659f, -0.076305f,  
2393.         -0.069085f, -0.114332f, -0.102005f, 0.132193f,  
2394.         -0.067042f, 0.106643f, 0.198964f, 0.171616f,  
2395.         0.167237f, -0.033730f, -0.026755f, 0.083621f,  
2396.         0.149459f, -0.002799f, -0.000318f, 0.011753f,  
2397.         0.065889f, -0.089375f, -0.049610f, 0.224579f,  
2398.         0.216548f, -0.034908f, -0.017851f, -0.088144f,  
2399.         0.007530f, 0.240268f, 0.073270f, 0.013263f,  
2400.         0.175323f, 0.012082f, 0.093993f, 0.015282f,  
2401.         0.105854f, 0.107990f, 0.077798f, -0.096166f,  
2402.         -0.079607f, 0.177820f, 0.142392f, 0.033337f,  
2403.         -0.078100f, -0.081616f, -0.046993f, 0.139459f,  
2404.         0.020272f, -0.123161f, 0.175269f, 0.105217f,  
2405.         0.057328f, 0.080909f, -0.012612f, -0.097081f,  
2406.         0.082060f, -0.096716f, -0.063921f, 0.201884f,  
2407.         0.128166f, -0.035051f, -0.032227f, -0.068139f,  
2408.         -0.115915f, 0.095080f, -0.086007f, -0.067543f,  
2409.         0.030776f, 0.032712f, 0.088937f, 0.054336f,  
2410.         -0.039329f, -0.114022f, 0.171672f, -0.112321f,  
2411.         -0.217646f, 0.065186f, 0.060223f, 0.192174f,  
2412.         0.055580f, -0.131107f, -0.144338f, 0.056730f,  
2413.         -0.034707f, -0.081616f, -0.135298f, -0.000614f,  
2414.         0.087189f, 0.014614f, 0.067709f, 0.107689f,  
2415.         0.225780f, 0.084361f, -0.008544f, 0.051649f,  
2416.         -0.048369f, -0.037739f, -0.060710f, 0.002654f,  
2417.         0.016935f, 0.085563f, -0.015961f, -0.019265f,  
2418.         0.111788f, 0.062376f, 0.202019f, 0.047713f,  
2419.         0.042261f, 0.069716f, 0.242913f, 0.021052f,  
2420.         -0.072812f, -0.155920f, -0.026436f, 0.035621f,  
2421.         -0.079300f, -0.028787f, -0.048329f, 0.084718f,  
2422.         -0.060565f, -0.083750f, -0.164075f, -0.040742f,  
2423.         -0.086219f, 0.015271f, -0.005204f, -0.016038f,  
2424.         0.045816f, -0.050433f, -0.077652f, 0.117109f,  
2425.         0.009611f, -0.009045f, -0.008634f, -0.055373f,  
2426.         -0.085968f, 0.028527f, -0.054736f, -0.168089f,  
2427.         0.175839f, 0.071205f, -0.023603f, 0.037907f,  
2428.         -0.004561f, -0.022634f, 0.123831f, 0.094469f,  
2429.         -0.072920f, -0.133642f, -0.014032f, -0.142754f,  
2430.         -0.026999f, -0.199409f, 0.013268f, 0.226989f,  
2431.         0.048650f, -0.170988f, -0.050141f, 0.007880f,  
2432.         0.061880f, 0.019078f, -0.043578f, -0.038139f,  
2433.         0.134814f, 0.054097f, -0.081670f, 0.176838f,  
2434.         0.047920f, -0.038176f, 0.050406f, -0.107181f,  
2435.         -0.036279f, 0.027060f, 0.081594f, -0.002820f,  
2436.         0.090507f, -0.033338f, -0.059571f, 0.013404f,  
2437.         -0.099860f, 0.073371f, 0.342805f, 0.098305f,  
2438.         -0.150910f, -0.020822f, -0.056960f, 0.046262f,  
2439.         -0.043413f, -0.149405f, -0.129105f, -0.010899f,  
2440.         -0.014229f, -0.179949f, -0.113044f, -0.049468f,  
2441.         -0.065513f, 0.090269f, -0.011919f, 0.087846f,  
2442.         0.095796f, 0.146127f, 0.101599f, 0.078066f,  
2443.         -0.084348f, -0.100002f, -0.020134f, -0.050169f,  
2444.         0.062122f, 0.014640f, 0.019143f, 0.036543f,  
2445.         0.180924f, -0.013976f, -0.066768f, -0.001090f,  
2446.         -0.070419f, -0.004839f, -0.001504f, 0.034483f,  
2447.         -0.044954f, -0.050336f, -0.088638f, -0.174782f,  
2448.         -0.116082f, -0.205507f, 0.015587f, -0.042839f,  
2449.         -0.096879f, -0.144097f, -0.050268f, -0.196796f,  
2450.         0.109639f, 0.271411f, 0.173732f, 0.108070f,  
2451.         0.156437f, 0.124255f, 0.097242f, 0.238693f,  
2452.         0.083941f, 0.109105f, 0.223940f, 0.267188f,  
2453.         0.027385f, 0.025819f, 0.125070f, 0.093738f,  
2454.         0.040353f, 0.038645f, -0.012730f, 0.144063f,  
2455.         0.052931f, -0.009138f, 0.084193f, 0.160272f,  
2456.         -0.041366f, 0.011951f, -0.121446f, -0.106713f,  
2457.         -0.047566f, 0.047984f, -0.255224f, -0.076116f,  
2458.         0.098685f, -0.150845f, -0.171513f, -0.156590f,  
2459.         0.058331f, 0.187493f, 0.413018f, 0.554265f,  
2460.         0.372242f, 0.237943f, 0.124571f, 0.110829f,  
2461.         0.010322f, -0.174477f, -0.067627f, -0.001979f,  
2462.         0.142913f, 0.040597f, 0.019907f, 0.025963f,  
2463.         -0.043585f, -0.120732f, 0.099937f, 0.091059f,  
2464.         0.247307f, 0.204226f, -0.042753f, -0.068580f,  
2465.         -0.119002f, 0.026722f, 0.034853f, -0.060934f,  
2466.         -0.025054f, -0.093026f, -0.035372f, -0.233209f,  
2467.         -0.049869f, -0.039151f, -0.022279f, -0.065380f,  
2468.         -9.063785f};  
2469.         return vector<float>(detector, detector + sizeof(detector)/sizeof(detector[0]));  
2470. }  
2471.   
2472. class HOGConfInvoker : public ParallelLoopBody  
2473. {  
2474. public:  
2475.        HOGConfInvoker( const HOGDescriptor* _hog, const Mat& _img,  
2476.                                double _hitThreshold, Size _padding,  
2477.                                std::vector<DetectionROI>* locs,  
2478.                                std::vector<Rect>* _vec, Mutex* _mtx )  
2479.        {  
2480.                hog = _hog;  
2481.                img = _img;  
2482.                hitThreshold = _hitThreshold;  
2483.                padding = _padding;  
2484.                locations = locs;  
2485.                vec = _vec;  
2486.                mtx = _mtx;  
2487.        }  
2488.   
2489.        void operator()( const Range& range ) const  
2490.        {  
2491.                int i, i1 = range.start, i2 = range.end;  
2492.   
2493.                Size maxSz(cvCeil(img.cols/(*locations)[0].scale), cvCeil(img.rows/(*locations)[0].scale));  
2494.                Mat smallerImgBuf(maxSz, img.type());  
2495.                vector<Point> dets;  
2496.   
2497.                for( i = i1; i < i2; i++ )  
2498.                {  
2499.                        double scale = (*locations)[i].scale;  
2500.   
2501.                        Size sz(cvRound(img.cols / scale), cvRound(img.rows / scale));  
2502.                        Mat smallerImg(sz, img.type(), smallerImgBuf.data);  
2503.   
2504.                        if( sz == img.size() )  
2505.                                smallerImg = Mat(sz, img.type(), img.data, img.step);  
2506.                        else  
2507.                                resize(img, smallerImg, sz);  
2508.   
2509.                        hog->detectROI(smallerImg, (*locations)[i].locations, dets, (*locations)[i].confidences, hitThreshold, Size(), padding);  
2510.                        Size scaledWinSize = Size(cvRound(hog->winSize.width*scale), cvRound(hog->winSize.height*scale));  
2511.                        mtx->lock();  
2512.                        for( size_t j = 0; j < dets.size(); j++ )  
2513.                        {  
2514.                                vec->push_back(Rect(cvRound(dets[j].x*scale),  
2515.                                                                        cvRound(dets[j].y*scale),  
2516.                                                                        scaledWinSize.width, scaledWinSize.height));  
2517.                        }  
2518.                        mtx->unlock();  
2519.                }  
2520.        }  
2521.   
2522.        const HOGDescriptor* hog;  
2523.        Mat img;  
2524.        double hitThreshold;  
2525.        std::vector<DetectionROI>* locations;  
2526.        Size padding;  
2527.        std::vector<Rect>* vec;  
2528.        Mutex* mtx;  
2529. };  
2530.   
2531. void HOGDescriptor::detectROI(const cv::Mat& img, const vector<cv::Point> &locations,  
2532.                                        CV_OUT std::vector<cv::Point>& foundLocations, CV_OUT std::vector<double>& confidences,  
2533.                                        double hitThreshold, cv::Size winStride,  
2534.                                        cv::Size padding) const  
2535. {  
2536.    foundLocations.clear();  
2537.   
2538.    confidences.clear();  
2539.   
2540.    if( svmDetector.empty() )  
2541.        return;  
2542.   
2543.    if( locations.empty() )  
2544.        return;  
2545.   
2546.    if( winStride == Size() )  
2547.        winStride = cellSize;  
2548.   
2549.    Size cacheStride(gcd(winStride.width, blockStride.width),  
2550.                                     gcd(winStride.height, blockStride.height));  
2551.   
2552.    size_t nwindows = locations.size();  
2553.    padding.width = (int)alignSize(std::max(padding.width, 0), cacheStride.width);  
2554.    padding.height = (int)alignSize(std::max(padding.height, 0), cacheStride.height);  
2555.    Size paddedImgSize(img.cols + padding.width*2, img.rows + padding.height*2);  
2556.   
2557.    // HOGCache cache(this, img, padding, padding, nwindows == 0, cacheStride);  
2558.    HOGCache cache(this, img, padding, padding, true, cacheStride);  
2559.    if( !nwindows )  
2560.            nwindows = cache.windowsInImage(paddedImgSize, winStride).area();  
2561.   
2562.    const HOGCache::BlockData* blockData = &cache.blockData[0];  
2563.   
2564.    int nblocks = cache.nblocks.area();  
2565.    int blockHistogramSize = cache.blockHistogramSize;  
2566.    size_t dsize = getDescriptorSize();  
2567.   
2568.    double rho = svmDetector.size() > dsize ? svmDetector[dsize] : 0;  
2569.    vector<float> blockHist(blockHistogramSize);  
2570.   
2571.    for( size_t i = 0; i < nwindows; i++ )  
2572.    {  
2573.            Point pt0;  
2574.            pt0 = locations[i];  
2575.            if( pt0.x < -padding.width || pt0.x > img.cols + padding.width - winSize.width ||  
2576.                    pt0.y < -padding.height || pt0.y > img.rows + padding.height - winSize.height )  
2577.            {  
2578.                // out of image  
2579.                confidences.push_back(-10.0);  
2580.                continue;  
2581.            }  
2582.   
2583.            double s = rho;  
2584.            const float* svmVec = &svmDetector[0];  
2585.            int j, k;  
2586.   
2587.            for( j = 0; j < nblocks; j++, svmVec += blockHistogramSize )  
2588.            {  
2589.                    const HOGCache::BlockData& bj = blockData[j];  
2590.                    Point pt = pt0 + bj.imgOffset;  
2591.                    // need to devide this into 4 parts!  
2592.                    const float* vec = cache.getBlock(pt, &blockHist[0]);  
2593.                    for( k = 0; k <= blockHistogramSize - 4; k += 4 )  
2594.                            s += vec[k]*svmVec[k] + vec[k+1]*svmVec[k+1] +  
2595.                                    vec[k+2]*svmVec[k+2] + vec[k+3]*svmVec[k+3];  
2596.                    for( ; k < blockHistogramSize; k++ )  
2597.                            s += vec[k]*svmVec[k];  
2598.            }  
2599.            // cv::waitKey();  
2600.            confidences.push_back(s);  
2601.   
2602.            if( s >= hitThreshold )  
2603.                    foundLocations.push_back(pt0);  
2604.    }  
2605.  }  
2606.   
2607. void HOGDescriptor::detectMultiScaleROI(const cv::Mat& img,  
2608.                                                            CV_OUT std::vector<cv::Rect>& foundLocations,  
2609.                                                            std::vector<DetectionROI>& locations,  
2610.                                                            double hitThreshold,  
2611.                                                            int groupThreshold) const  
2612. {  
2613.    std::vector<Rect> allCandidates;  
2614.    Mutex mtx;  
2615.   
2616.    parallel_for_(Range(0, (int)locations.size()),  
2617.                         HOGConfInvoker(this, img, hitThreshold, Size(8, 8), &locations, &allCandidates, &mtx));  
2618.   
2619.    foundLocations.resize(allCandidates.size());  
2620.    std::copy(allCandidates.begin(), allCandidates.end(), foundLocations.begin());  
2621.    cv::groupRectangles(foundLocations, groupThreshold, 0.2);  
2622. }  
2623.   
2624. void HOGDescriptor::readALTModel(std::string modelfile)  
2625. {  
2626.    // read model from SVMlight format..  
2627.    FILE *modelfl;  
2628.    if ((modelfl = fopen(modelfile.c_str(), "rb")) == NULL)  
2629.    {  
2630.        std::string eerr("file not exist");  
2631.        std::string efile(__FILE__);  
2632.        std::string efunc(__FUNCTION__);  
2633.        throw Exception(CV_StsError, eerr, efile, efunc, __LINE__);  
2634.    }  
2635.    char version_buffer[10];  
2636.    if (!fread (&version_buffer,sizeof(char),10,modelfl))  
2637.    {  
2638.        std::string eerr("version?");  
2639.        std::string efile(__FILE__);  
2640.        std::string efunc(__FUNCTION__);  
2641.        throw Exception(CV_StsError, eerr, efile, efunc, __LINE__);  
2642.    }  
2643.    if(strcmp(version_buffer,"V6.01")) {  
2644.        std::string eerr("version doesnot match");  
2645.        std::string efile(__FILE__);  
2646.        std::string efunc(__FUNCTION__);  
2647.        throw Exception(CV_StsError, eerr, efile, efunc, __LINE__);  
2648.    }  
2649.    /* read version number */  
2650.    int version = 0;  
2651.    if (!fread (&version,sizeof(int),1,modelfl))  
2652.    { throw Exception(); }  
2653.    if (version < 200)  
2654.    {  
2655.        std::string eerr("version doesnot match");  
2656.        std::string efile(__FILE__);  
2657.        std::string efunc(__FUNCTION__);  
2658.        throw Exception();  
2659.    }  
2660.    int kernel_type;  
2661.    size_t nread;  
2662.    nread=fread(&(kernel_type),sizeof(int),1,modelfl);  
2663.   
2664.    {// ignore these  
2665.        int poly_degree;  
2666.        nread=fread(&(poly_degree),sizeof(int),1,modelfl);  
2667.   
2668.        double rbf_gamma;  
2669.        nread=fread(&(rbf_gamma),sizeof(double), 1, modelfl);  
2670.        double coef_lin;  
2671.        nread=fread(&(coef_lin),sizeof(double),1,modelfl);  
2672.        double coef_const;  
2673.        nread=fread(&(coef_const),sizeof(double),1,modelfl);  
2674.        int l;  
2675.        nread=fread(&l,sizeof(int),1,modelfl);  
2676.        char* custom = new char[l];  
2677.        nread=fread(custom,sizeof(char),l,modelfl);  
2678.        delete[] custom;  
2679.    }  
2680.    int totwords;  
2681.    nread=fread(&(totwords),sizeof(int),1,modelfl);  
2682.    {// ignore these  
2683.        int totdoc;  
2684.        nread=fread(&(totdoc),sizeof(int),1,modelfl);  
2685.        int sv_num;  
2686.        nread=fread(&(sv_num), sizeof(int),1,modelfl);  
2687.    }  
2688.   
2689.    double linearbias;  
2690.    nread=fread(&linearbias, sizeof(double), 1, modelfl);  
2691.   
2692.    std::vector<float> detector;  
2693.    detector.clear();  
2694.    if(kernel_type == 0) { /* linear kernel */  
2695.        /* save linear wts also */  
2696.        double *linearwt = new double[totwords+1];  
2697.        int length = totwords;  
2698.        nread = fread(linearwt, sizeof(double), totwords + 1, modelfl);  
2699.        if(nread != static_cast<size_t>(length) + 1)  
2700.            throw Exception();  
2701.   
2702.        for(int i = 0; i < length; i++)  
2703.            detector.push_back((float)linearwt[i]);  
2704.   
2705.        detector.push_back((float)-linearbias);  
2706.        setSVMDetector(detector);  
2707.        delete [] linearwt;  
2708.    } else {  
2709.        throw Exception();  
2710.    }  
2711.    fclose(modelfl);  
2712. }  
2713.   
2714. }