【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  

 /*M///////////////////////////////////////////////////////////////////////////////////////
 //
 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 //
 //  By downloading, copying, installing or using the software you agree to this license.
 //  If you do not agree to this license, do not download, install,
 //  copy or use the software.
 //
 //
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,
 // are permitted provided that the following conditions are met:
 //
 //   * Redistribution's of source code must retain the above copyright notice,
 //     this list of conditions and the following disclaimer.
 //
 //   * Redistribution's in binary form must reproduce the above copyright notice,
 //     this list of conditions and the following disclaimer in the documentation
 //     and/or other materials provided with the distribution.
 //
 //   * The name of the copyright holders may not be used to endorse or promote products
 //     derived from this software without specific prior written permission.
 //
 // This software is provided by the copyright holders and contributors "as is" and
 // any express or implied warranties, including, but not limited to, the implied
 // warranties of merchantability and fitness for a particular purpose are disclaimed.
 // In no event shall the Intel Corporation or contributors be liable for any direct,
 // indirect, incidental, special, exemplary, or consequential damages
 // (including, but not limited to, procurement of substitute goods or services;
 // loss of use, data, or profits; or business interruption) however caused
 // and on any theory of liability, whether in contract, strict liability,
 // or tort (including negligence or otherwise) arising in any way out of
 // the use of this software, even if advised of the possibility of such damage.
 //
 //M*/
 #include
 #include "precomp.hpp"  //包含了 objdetect.hpp
 #include
 #ifdef HAVE_IPP
 #include "ipp.h"
 #endif
 /****************************************************************************************\
       The code below is implementation of HOG (Histogram-of-Oriented Gradients)
       descriptor and object detection, introduced by Navneet Dalal and Bill Triggs.

       The computed feature vectors are compatible with the
       INRIA Object Detection and Localization Toolkit
       (http://pascal.inrialpes.fr/soft/olt/)
 \****************************************************************************************/

 namespace cv
 {

 size_t HOGDescriptor::getDescriptorSize() const
 {
     CV_Assert(blockSize.width % cellSize.width == 0 &&
         blockSize.height % cellSize.height == 0);
     CV_Assert((winSize.width - blockSize.width) % blockStride.width == 0 &&
         (winSize.height - blockSize.height) % blockStride.height == 0 );
     return (size_t)nbins*
         (blockSize.width/cellSize.width)*
         (blockSize.height/cellSize.height)*
         ((winSize.width - blockSize.width)/blockStride.width + 1)*
         ((winSize.height - blockSize.height)/blockStride.height + 1);//描述向量总长度
 }

 double HOGDescriptor::getWinSigma() const
 {
     return winSigma >= 0 ? winSigma : (blockSize.width + blockSize.height)/8.; //默认-1
 }

 bool HOGDescriptor::checkDetectorSize() const
 {
     size_t detectorSize = svmDetector.size(), descriptorSize = getDescriptorSize();
     return detectorSize == 0 ||
         detectorSize == descriptorSize ||
         detectorSize == descriptorSize + 1;
 }

 void HOGDescriptor::setSVMDetector(InputArray _svmDetector)
 {
     _svmDetector.getMat().convertTo(svmDetector, CV_32F);
     CV_Assert( checkDetectorSize() );
 }

 #define CV_TYPE_NAME_HOG_DESCRIPTOR "opencv-object-detector-hog"

 bool HOGDescriptor::read(FileNode& obj)
 {
     if( !obj.isMap() )
         return false;
     FileNodeIterator it = obj["winSize"].begin();
     it >> winSize.width >> winSize.height;
     it = obj["blockSize"].begin();
     it >> blockSize.width >> blockSize.height;
     it = obj["blockStride"].begin();
     it >> blockStride.width >> blockStride.height;
     it = obj["cellSize"].begin();
     it >> cellSize.width >> cellSize.height;
     obj["nbins"] >> nbins;
     obj["derivAperture"] >> derivAperture;
     obj["winSigma"] >> winSigma;
     obj["histogramNormType"] >> histogramNormType;
     obj["L2HysThreshold"] >> L2HysThreshold;
     obj["gammaCorrection"] >> gammaCorrection;
     obj["nlevels"] >> nlevels;

     FileNode vecNode = obj["SVMDetector"];
     if( vecNode.isSeq() )
     {
         vecNode >> svmDetector;
         CV_Assert(checkDetectorSize());
     }
     return true;
 }

 void HOGDescriptor::write(FileStorage& fs, const String& objName) const
 {
     if( !objName.empty() )
         fs << objName;

     fs << "{" CV_TYPE_NAME_HOG_DESCRIPTOR
     << "winSize" << winSize
     << "blockSize" << blockSize
     << "blockStride" << blockStride
     << "cellSize" << cellSize
     << "nbins" << nbins
     << "derivAperture" << derivAperture
     << "winSigma" << getWinSigma()
     << "histogramNormType" << histogramNormType
     << "L2HysThreshold" << L2HysThreshold
     << "gammaCorrection" << gammaCorrection
     << "nlevels" << nlevels;
     if( !svmDetector.empty() )
         fs << "SVMDetector" << svmDetector;
     fs << "}";
 }

 bool HOGDescriptor::load(const String& filename, const String& objname)
 {
     FileStorage fs(filename, FileStorage::READ);
     FileNode obj = !objname.empty() ? fs[objname] : fs.getFirstTopLevelNode();
     return read(obj);
 }

 void HOGDescriptor::save(const String& filename, const String& objName) const
 {
     FileStorage fs(filename, FileStorage::WRITE);
     write(fs, !objName.empty() ? objName : FileStorage::getDefaultObjectName(filename));
 }

 void HOGDescriptor::copyTo(HOGDescriptor& c) const
 {
     c.winSize = winSize;
     c.blockSize = blockSize;
     c.blockStride = blockStride;
     c.cellSize = cellSize;
     c.nbins = nbins;
     c.derivAperture = derivAperture;
     c.winSigma = winSigma;
     c.histogramNormType = histogramNormType;
     c.L2HysThreshold = L2HysThreshold;
     c.gammaCorrection = gammaCorrection;
     c.svmDetector = svmDetector;
     c.nlevels = nlevels;
 }
 //返回 grad：梯度的模在与梯度方向相邻的两个bin的插值值，qangle：与梯度方向相邻的两个bin的编号
 void HOGDescriptor::computeGradient(const Mat& img, Mat& grad, Mat& qangle,
                                     Size paddingTL, Size paddingBR) const
 {
     CV_Assert( img.type() == CV_8U || img.type() == CV_8UC3 );

     Size gradsize(img.cols + paddingTL.width + paddingBR.width,
                   img.rows + paddingTL.height + paddingBR.height);
     grad.create(gradsize, CV_32FC2);  // ，与该点梯度方向相邻两个bin的梯度模值，由该点线性插值得到
     qangle.create(gradsize, CV_8UC2); // [0..nbins-1] - quantized gradient orientation，与该点梯度方向相邻两个bin的编号
     Size wholeSize;
     Point roiofs;
     img.locateROI(wholeSize, roiofs);   //img如果是一个大图像IMG的Region of interesting,那么IMG和img共享内存
                                         //比如IMG(120x120),img取自IMG的一部分TL坐标（10,10），BR坐标（109,109）那么尺寸为（100x100）
                                         //这个函数就返回父矩阵IMG的size（120x120），以及img在IMG中的坐标偏移（roiofs.x=10,roiofs.y=10）
     /*
     Locates the matrix header within a parent matrix.
     wholeSize – Output parameter that contains the size of the whole matrix containing *this as a part
     ofs – Output parameter that contains an offset of *this inside the whole matrix.
     */
     int i, x, y;
     int cn = img.channels();

     Mat_<float> _lut(1, 256); //gamma 校正Look up table,Mat_ 简化版的 Mat,元素访问直接 用（x,y），无需 .at,但是速度是一样的
     const float* lut = &_lut(0,0);  //只能读

     if( gammaCorrection )
         for( i = 0; i < 256; i++ )
             _lut(0,i) = std::sqrt((float)i);    //gammma 校正 r=0.5,暗区对比度提高，亮区对比度下降
     else
         for( i = 0; i < 256; i++ )
             _lut(0,i) = (float)i;

     AutoBuffer<int> mapbuf(gradsize.width + gradsize.height + 4); //自动buffer，就不需要我们malloc，free
     int* xmap = (int*)mapbuf + 1;
     int* ymap = xmap + gradsize.width + 2;

     const int borderType = (int)BORDER_REFLECT_101;
     //一种很奇怪的插值方式，扩展出来的边缘用原图像中的像素值，并没有真正扩展存储空间
     //比如说原图为 100x100，现在要访问（-10，-10）的值，但是内存里面不不存在这个值，这种插值方法就是在原图像中找个像素点（比如（5,6））的值作为（-10,-10）的值
     //也就是将扩展后的坐标范围比如（120x120）映射到（100x100）。x,y坐标分别映射，映射表存在xmap,ymap。上面的例子中xmap[-10]=5,ymap[-10]=6
     for( x = -1; x < gradsize.width + 1; x++ )
         xmap[x] = borderInterpolate(x - paddingTL.width + roiofs.x,wholeSize.width, borderType) - roiofs.x;
     for( y = -1; y < gradsize.height + 1; y++ )
         ymap[y] = borderInterpolate(y - paddingTL.height + roiofs.y,wholeSize.height, borderType) - roiofs.y;

     // x- & y- derivatives for the whole row
     int width = gradsize.width;
     AutoBuffer<float> _dbuf(width*4);
     float* dbuf = _dbuf;
     Mat Dx(1, width, CV_32F, dbuf);
     Mat Dy(1, width, CV_32F, dbuf + width);
     Mat Mag(1, width, CV_32F, dbuf + width*2);
     Mat Angle(1, width, CV_32F, dbuf + width*3);

     int _nbins = nbins;
     float angleScale = (float)(_nbins/CV_PI);   //算某一弧度，对应落在哪一个bin的scale
 #ifdef HAVE_IPP //intel的ipp库，优化
     Mat lutimg(img.rows,img.cols,CV_MAKETYPE(CV_32F,cn));   //cn ,为1/3，对于类型 CV_32FC1、CV_32FC3
     Mat hidxs(1, width, CV_32F);
     Ipp32f* pHidxs  = (Ipp32f*)hidxs.data;
     Ipp32f* pAngles = (Ipp32f*)Angle.data;

     IppiSize roiSize;
     roiSize.width = img.cols;
     roiSize.height = img.rows;

     //对原始图像，进行gamma校正，结果保存在 imglutPtr
     for( y = 0; y < roiSize.height; y++ )
     {
        const uchar* imgPtr = img.data + y*img.step;
        float* imglutPtr = (float*)(lutimg.data + y*lutimg.step);

        for( x = 0; x < roiSize.width*cn; x++ )
        {
           imglutPtr[x] = lut[imgPtr[x]];    //查表 gamma校正
        }
     }

 #endif
     //好长的循环体，计算了四个梯度的四个量 Dx，Dy, Angle,Mag,最终是保存了Angle,Mag两个量给后续的工作用
     for( y = 0; y < gradsize.height; y++ )
     {
         //行指针(加上了补丁)
 #ifdef HAVE_IPP
         const float* imgPtr  = (float*)(lutimg.data + lutimg.step*ymap[y]);
         const float* prevPtr = (float*)(lutimg.data + lutimg.step*ymap[y-1]);
         const float* nextPtr = (float*)(lutimg.data + lutimg.step*ymap[y+1]);
 #else
         const uchar* imgPtr  = img.data + img.step*ymap[y];
         const uchar* prevPtr = img.data + img.step*ymap[y-1];
         const uchar* nextPtr = img.data + img.step*ymap[y+1];
 #endif
         float* gradPtr = (float*)grad.ptr(y);   //Returns a pointer to the specified matrix row.
         uchar* qanglePtr = (uchar*)qangle.ptr(y);

         //计算 水平和垂直梯度 保存在 dbuf 的前两段
         if( cn == 1 )
         {
             for( x = 0; x < width; x++ )
             {
                 int x1 = xmap[x];
 #ifdef HAVE_IPP
                 dbuf[x] = (float)(imgPtr[xmap[x+1]] - imgPtr[xmap[x-1]]);   //水平微分模板 [-1 0 1]
                 dbuf[width + x] = (float)(nextPtr[x1] - prevPtr[x1]);       //垂直微分模板 [-1 0 1]'
 #else
                 dbuf[x] = (float)(lut[imgPtr[xmap[x+1]]] - lut[imgPtr[xmap[x-1]]]);     //dbuf length: width*4
                 dbuf[width + x] = (float)(lut[nextPtr[x1]] - lut[prevPtr[x1]]);     //使用了IPP优化，就已经gamm校正了，这里是先gamm校正然后在计算梯度
 #endif
             }
         }
         else    ////取B,G,R通道中梯度模最大的梯度作为该点的梯度，
         {
             for( x = 0; x < width; x++ )
             {
                 int x1 = xmap[x]*3; //height*width*element,element:8UC3/32FC3
                 float dx0, dy0, dx, dy, mag0, mag;
 #ifdef HAVE_IPP
                 const float* p2 = imgPtr + xmap[x+1]*3;
                 const float* p0 = imgPtr + xmap[x-1]*3;
                 //R通道的梯度
                 dx0 = p2[2] - p0[2];
                 dy0 = nextPtr[x1+2] - prevPtr[x1+2];
                 mag0 = dx0*dx0 + dy0*dy0;
                 //G通道的梯度
                 dx = p2[1] - p0[1];
                 dy = nextPtr[x1+1] - prevPtr[x1+1];
                 mag = dx*dx + dy*dy;

                 if( mag0 < mag ) //取G,R通道中梯度模最大的
                 {
                     dx0 = dx;
                     dy0 = dy;
                     mag0 = mag;
                 }
                 //B通道的梯度
                 dx = p2[0] - p0[0];
                 dy = nextPtr[x1] - prevPtr[x1];
                 mag = dx*dx + dy*dy;
 #else
                 const uchar* p2 = imgPtr + xmap[x+1]*3;
                 const uchar* p0 = imgPtr + xmap[x-1]*3;

                 dx0 = lut[p2[2]] - lut[p0[2]];
                 dy0 = lut[nextPtr[x1+2]] - lut[prevPtr[x1+2]];
                 mag0 = dx0*dx0 + dy0*dy0;

                 dx = lut[p2[1]] - lut[p0[1]];
                 dy = lut[nextPtr[x1+1]] - lut[prevPtr[x1+1]];
                 mag = dx*dx + dy*dy;

                 if( mag0 < mag )
                 {
                     dx0 = dx;
                     dy0 = dy;
                     mag0 = mag;
                 }

                 dx = lut[p2[0]] - lut[p0[0]];
                 dy = lut[nextPtr[x1]] - lut[prevPtr[x1]];
                 mag = dx*dx + dy*dy;
  #endif
                 if( mag0 < mag ) //取B,G,R通道中梯度模最大的
                 {
                     dx0 = dx;
                     dy0 = dy;
                     mag0 = mag;
                 }

                 dbuf[x] = dx0;
                 dbuf[x+width] = dy0;
             }
         }
 #ifdef HAVE_IPP
         ippsCartToPolar_32f((const Ipp32f*)Dx.data, (const Ipp32f*)Dy.data, (Ipp32f*)Mag.data, pAngles, width);
         for( x = 0; x < width; x++ )
         {
            if(pAngles[x] < 0.f)
              pAngles[x] += (Ipp32f)(CV_PI*2.);
         }

         ippsNormalize_32f(pAngles, pAngles, width, 0.5f/angleScale, 1.f/angleScale);
         ippsFloor_32f(pAngles,(Ipp32f*)hidxs.data,width);
         ippsSub_32f_I((Ipp32f*)hidxs.data,pAngles,width);
         ippsMul_32f_I((Ipp32f*)Mag.data,pAngles,width);

         ippsSub_32f_I(pAngles,(Ipp32f*)Mag.data,width);
         ippsRealToCplx_32f((Ipp32f*)Mag.data,pAngles,(Ipp32fc*)gradPtr,width);
 #else
         //计算梯度的模和角度，默认结果为弧度
         cartToPolar( Dx, Dy, Mag, Angle, false );   //Calculates the magnitude and angle of 2D vectors. angle(I) = atan2(y(I); x(I))
 #endif
         for( x = 0; x < width; x++ )
         {
 #ifdef HAVE_IPP
             int hidx = (int)pHidxs[x];
 #else
             //保存该梯度方向在左右相邻的bin的模，本来只有一个模何来的两个？插值！
             //线性插值，比如某点算出来应该属于 bin 7.6,但是我们的bin都是整数的，四舍五入，把他划分到bin 8又太粗糙了
             //那就按该点到bin7,bin8的距离分配，这样部分属于8，部分属于7。
             float mag = dbuf[x+width*2], angle = dbuf[x+width*3]*angleScale - 0.5f; // 每一格 pi/9, 那现在算 t落在哪一格自然是 t/(pi/9)
             int hidx = cvFloor(angle);  //向下取整
             angle -= hidx;
             gradPtr[x*2] = mag*(1.f - angle);   //binx的大小是梯度方向和模的共同体现
             gradPtr[x*2+1] = mag*angle;
 #endif
             if( hidx < 0 )
                 hidx += _nbins;
             else if( hidx >= _nbins )
                 hidx -= _nbins;
             assert( (unsigned)hidx < (unsigned)_nbins );

             //保存与该梯度方向相邻的左右两个bin编号
             qanglePtr[x*2] = (uchar)hidx;   //也是向下取整
             hidx++;
             hidx &= hidx < _nbins ? -1 : 0;  // hidx &= ( (hidx < _nbins ) ? -1 : 0;)，如果hidx < nbins good;如果超过了，就算子bin 0 ；-1的补码是全1
             qanglePtr[x*2+1] = (uchar)hidx;
         }
     }
 }


 struct HOGCache
 {
     struct BlockData
     {
         BlockData() : histOfs(0), imgOffset() {}
         int histOfs;
         Point imgOffset;
     };

     struct PixData
     {
         size_t gradOfs, qangleOfs;
         int histOfs[4];
         float histWeights[4];
         float gradWeight;
     };

     HOGCache();
     HOGCache(const HOGDescriptor* descriptor,
         const Mat& img, Size paddingTL, Size paddingBR,
         bool useCache, Size cacheStride);
     virtual ~HOGCache() {};
     virtual void init(const HOGDescriptor* descriptor,
         const Mat& img, Size paddingTL, Size paddingBR,
         bool useCache, Size cacheStride);

     Size windowsInImage(Size imageSize, Size winStride) const;
     Rect getWindow(Size imageSize, Size winStride, int idx) const;

     const float* getBlock(Point pt, float* buf);
     virtual void normalizeBlockHistogram(float* histogram) const;

     vector pixData;
     vector blockData;

     bool useCache;
     vector<int> ymaxCached;
     Size winSize, cacheStride;
     Size nblocks, ncells;
     int blockHistogramSize;
     int count1, count2, count4;
     Point imgoffset;
     Mat_<float> blockCache;
     Mat_ blockCacheFlags;

     Mat grad, qangle;
     const HOGDescriptor* descriptor;
 };


 HOGCache::HOGCache()
 {
     useCache = false;
     blockHistogramSize = count1 = count2 = count4 = 0;
     descriptor = 0;
 }

 HOGCache::HOGCache(const HOGDescriptor* _descriptor,
         const Mat& _img, Size _paddingTL, Size _paddingBR,
         bool _useCache, Size _cacheStride)
 {
     init(_descriptor, _img, _paddingTL, _paddingBR, _useCache, _cacheStride);
 }

 void HOGCache::init(const HOGDescriptor* _descriptor,
         const Mat& _img, Size _paddingTL, Size _paddingBR,
         bool _useCache, Size _cacheStride)
 {
     descriptor = _descriptor;
     cacheStride = _cacheStride;
     useCache = _useCache;
     /*--------------------------------------计算梯度----------------------------------------------*/
     //返回值
     //size：img.cols + paddingTL.width + paddingBR.width,img.rows + paddingTL.height + paddingBR.height,类型 CV_32FC2
     //grad：梯度的模在与梯度方向相邻的两个bin的插值值
     //qangle：与梯度方向相邻的两个bin的编号
     descriptor->computeGradient(_img, grad, qangle, _paddingTL, _paddingBR);
     imgoffset = _paddingTL;

     winSize = descriptor->winSize;   //默认值：winSize(64,128)
     Size blockSize = descriptor->blockSize;//blockSize(16,16)
     Size blockStride = descriptor->blockStride;//lockStride(8,8)
     Size cellSize = descriptor->cellSize;//cellSize(8,8)
     int i, j, nbins = descriptor->nbins;//nbins(9)
     int rawBlockSize = blockSize.width*blockSize.height;

     nblocks = Size((winSize.width - blockSize.width)/blockStride.width + 1,
                    (winSize.height - blockSize.height)/blockStride.height + 1);
            //这种算法非常直观，也许你会觉得可以和下面一样直接除，但是当(winSize.height - blockSize.height) % blockStride.height 不为0时，就不一定
            //比如 blockSize=4,blockStride=3,winSize.width =9,那么直接除9/3=3，但是只能有两个block, 4|3|2,只能移动一次
     ncells = Size(blockSize.width/cellSize.width, blockSize.height/cellSize.height);
     blockHistogramSize = ncells.width*ncells.height*nbins;//默认2*2*9

     if( useCache )  //
     {
         Size cacheSize((grad.cols - blockSize.width)/cacheStride.width+1,
                        (winSize.height/cacheStride.height)+1);
         blockCache.create(cacheSize.height, cacheSize.width*blockHistogramSize);
         blockCacheFlags.create(cacheSize);
         size_t cacheRows = blockCache.rows;
         ymaxCached.resize(cacheRows);
         for(size_t ii = 0; ii < cacheRows; ii++ )
             ymaxCached[ii] = -1;
     }

     Mat_<float> weights(blockSize);//16*16 高斯模板
     float sigma = (float)descriptor->getWinSigma();//-1
     float scale = 1.f/(sigma*sigma*2);

     for(i = 0; i < blockSize.height; i++)
         for(j = 0; j < blockSize.width; j++)
         {
             float di = i - blockSize.height*0.5f;
             float dj = j - blockSize.width*0.5f;//中心
             weights(i,j) = std::exp(-(di*di + dj*dj)*scale);//weights(i,j)=exp(-(distance/sigma)^2)
         }

     blockData.resize(nblocks.width*nblocks.height);
     pixData.resize(rawBlockSize*3);// vector::resize(newsize,value),不是Mat::resize,16*16*3个结构体
     /*
     vector pixData;
     struct PixData{
         size_t gradOfs, qangleOfs;
         int histOfs[4];
         float histWeights[4];
         float gradWeight;
     };
     */
     // Initialize 2 lookup tables, pixData & blockData.
     // Here is why:
     //
     // The detection algorithm runs in 4 nested loops (at each pyramid layer):
     //  loop over the windows within the input image
     //    loop over the blocks within each window
     //      loop over the cells within each block
     //        loop over the pixels in each cell
     //
     // As each of the loops runs over a 2-dimensional array,
     // we could get 8(!) nested loops in total, which is very-very slow.
     //
     // To speed the things up, we do the following:
     //   1. loop over windows is unrolled in the HOGDescriptor::{compute|detect} methods;
     //         inside we compute the current search window using getWindow() method.
     //         Yes, it involves some overhead (function call + couple of divisions),
     //         but it's tiny in fact.
     //   2. loop over the blocks is also unrolled. Inside we use pre-computed blockData[j]
     //         to set up gradient and histogram pointers.
     //   3. loops over cells and pixels in each cell are merged
     //       (since there is no overlap between cells, each pixel in the block is processed once)
     //      and also unrolled. Inside we use PixData[k] to access the gradient values and
     //      update the histogram
     //
     count1 = count2 = count4 = 0;
     for( j = 0; j < blockSize.width; j++ )//16,先水平，再垂直
         for( i = 0; i < blockSize.height; i++ )//16
         {
             PixData* data = 0;
             float cellX = (j+0.5f)/cellSize.width - 0.5f;   //这是干什么 ？？？
             float cellY = (i+0.5f)/cellSize.height - 0.5f;
             int icellX0 = cvFloor(cellX);   //-1（j=0..3）,0(j=4..11),1(j=12..15)
             int icellY0 = cvFloor(cellY);
             int icellX1 = icellX0 + 1, icellY1 = icellY0 + 1;//0 1 2
             cellX -= icellX0;
             cellY -= icellY0;

             if( (unsigned)icellX0 < (unsigned)ncells.width &&    // icellX0 == 0
                 (unsigned)icellX1 < (unsigned)ncells.width ) //判断条件时特别小心，int 转成了 unsigned,(unsigned)(-1)=2^32-1，真对这作者无语
             {
                 //  icellX0 == 0，icellY0 == 0 对相邻的四个cell都有贡献，即F,J,G,K区域
                 if( (unsigned)icellY0 < (unsigned)ncells.height && // cellX，cellY 范围（0,1）
                     (unsigned)icellY1 < (unsigned)ncells.height )
                 {
                     data = &pixData[rawBlockSize*2 + (count4++)];
                     data->histOfs[0] = (icellX0*ncells.height + icellY0)*nbins;//cell 0 在整个block的bin中的偏移
                     data->histWeights[0] = (1.f - cellX)*(1.f - cellY);  //到对称中心的“距离”即cell 3
                     data->histOfs[1] = (icellX1*ncells.height + icellY0)*nbins;//cell 1的偏移 2*9
                     data->histWeights[1] = cellX*(1.f - cellY);         //到对称中心的“距离”即 cell 2
                     data->histOfs[2] = (icellX0*ncells.height + icellY1)*nbins;//cell 2的偏移 1*9
                     data->histWeights[2] = (1.f - cellX)*cellY;         //到对称中心的“距离”即 cell 1
                     data->histOfs[3] = (icellX1*ncells.height + icellY1)*nbins;//cell 3的偏移3*9
                     data->histWeights[3] = cellX*cellY;                 //到对称中心的“距离”即 cell 0
                 }
                 else    // icellX0 == 0，icellY0 == -1/1，对左右相邻的两个cell有贡献，即B,C,N,O
                 {
                     // cellX 范围（0,1），cellY 范围 （0.5,1）/（0,0.5）
                     data = &pixData[rawBlockSize + (count2++)];
                     //下部分的cellY范围也落在（0.5,1），icellY1==icellY0 == 1
                     if( (unsigned)icellY0 < (unsigned)ncells.height )//icellY0 == 1
                     {
                         icellY1 = icellY0;
                         cellY = 1.f - cellY;
                     }
                     data->histOfs[0] = (icellX0*ncells.height + icellY1)*nbins;// 上部分0；下部分1
                     data->histWeights[0] = (1.f - cellX)*cellY;
                     data->histOfs[1] = (icellX1*ncells.height + icellY1)*nbins;// 上部分2；下部分3
                     data->histWeights[1] = cellX*cellY;
                     data->histOfs[2] = data->histOfs[3] = 0;// 均为0
                     data->histWeights[2] = data->histWeights[3] = 0;
                 }
             }
             else //icellX0 == -1/1,cellX范围（0.5,1）/（0,0.5）
             {
                 //右部分的cellX范围也落在（0.5,1），icellX1==icellX0 == 1
                 if( (unsigned)icellX0 < (unsigned)ncells.width )
                 {
                     icellX1 = icellX0;
                     cellX = 1.f - cellX;
                 }
                 //E,H,I,L
                 if( (unsigned)icellY0 < (unsigned)ncells.height &&
                     (unsigned)icellY1 < (unsigned)ncells.height )
                 {
                     data = &pixData[rawBlockSize + (count2++)];
                     data->histOfs[0] = (icellX1*ncells.height + icellY0)*nbins;//左：0，右：2*9
                     data->histWeights[0] = cellX*(1.f - cellY);
                     data->histOfs[1] = (icellX1*ncells.height + icellY1)*nbins;//左：1*9 右：3*9
                     data->histWeights[1] = cellX*cellY;
                     data->histOfs[2] = data->histOfs[3] = 0;
                     data->histWeights[2] = data->histWeights[3] = 0;
                 }
                 // A,D,M,P
                 else
                 {
                     data = &pixData[count1++];
                     if( (unsigned)icellY0 < (unsigned)ncells.height )
                     {
                         icellY1 = icellY0;
                         cellY = 1.f - cellY;
                     }
                     data->histOfs[0] = (icellX1*ncells.height + icellY1)*nbins;
                     data->histWeights[0] = cellX*cellY;
                     data->histOfs[1] = data->histOfs[2] = data->histOfs[3] = 0;
                     data->histWeights[1] = data->histWeights[2] = data->histWeights[3] = 0;
                 }
             }
             data->gradOfs = (grad.cols*i + j)*2; //block窗口的（0,0）位置有相对于整个图像的偏移，此偏移为相对于block(0,0)的偏移
             data->qangleOfs = (qangle.cols*i + j)*2;//计算方式很古怪，但是你画张图就明白了（grad.cols*i多算的==+j少算的），实际上 block窗口的（0,0）的offset加上此offset就可以直接在grad中找到对应的梯度
             data->gradWeight = weights(i,j); //该点的高斯权值，大小与到block中心的距离成反比
         }

     assert( count1 + count2 + count4 == rawBlockSize );//16*16
     // defragment pixData,整理碎片.
     //数据合并  xxx.........yyy.........zzz.........->xxxyyyzzz..................
     //（.表示未赋值空间，x为count1存储的数据，y为count2存储的数据...）
     for( j = 0; j < count2; j++ )
         pixData[j + count1] = pixData[j + rawBlockSize];
     for( j = 0; j < count4; j++ )
         pixData[j + count1 + count2] = pixData[j + rawBlockSize*2];
     count2 += count1;
     count4 += count2;

     // initialize blockData
     /*
     struct BlockData{
         BlockData() : histOfs(0), imgOffset() {}
         int histOfs;
         Point imgOffset;
     };
     */
     for( j = 0; j < nblocks.width; j++ )
         for( i = 0; i < nblocks.height; i++ )
         {
             BlockData& data = blockData[j*nblocks.height + i];
             data.histOfs = (j*nblocks.height + i)*blockHistogramSize;
             data.imgOffset = Point(j*blockStride.width,i*blockStride.height);
         }
 }


 const float* HOGCache::getBlock(Point pt, float* buf)
 {
     float* blockHist = buf;
     assert(descriptor != 0);

     Size blockSize = descriptor->blockSize;
     pt += imgoffset; //imgoffset:padingTL,先前减去pading，现在又加过来，为嘛？？？？

     CV_Assert( (unsigned)pt.x <= (unsigned)(grad.cols - blockSize.width) &&
                (unsigned)pt.y <= (unsigned)(grad.rows - blockSize.height) );

     if( useCache ) //默认未使用
     {
         CV_Assert( pt.x % cacheStride.width == 0 &&
                    pt.y % cacheStride.height == 0 );
         Point cacheIdx(pt.x/cacheStride.width,
                       (pt.y/cacheStride.height) % blockCache.rows);
         if( pt.y != ymaxCached[cacheIdx.y] )
         {
             Mat_ cacheRow = blockCacheFlags.row(cacheIdx.y);
             cacheRow = (uchar)0;
             ymaxCached[cacheIdx.y] = pt.y;
         }

         blockHist = &blockCache[cacheIdx.y][cacheIdx.x*blockHistogramSize];
         uchar& computedFlag = blockCacheFlags(cacheIdx.y, cacheIdx.x);
         if( computedFlag != 0 )
             return blockHist;
         computedFlag = (uchar)1; // set it at once, before actual computing
     }

     int k, C1 = count1, C2 = count2, C4 = count4;//64,128,256
     const float* gradPtr = (const float*)(grad.data + grad.step*pt.y) + pt.x*2;//block(0,0)在与其梯度方向相邻的两个bin上的插值分量
     const uchar* qanglePtr = qangle.data + qangle.step*pt.y + pt.x*2;//与block(0,0)梯度方向相邻的两个bin的bin编号

     CV_Assert( blockHist != 0 );
 #ifdef HAVE_IPP
     ippsZero_32f(blockHist,blockHistogramSize);
 #else
     for( k = 0; k < blockHistogramSize; k++ )
         blockHist[k] = 0.f;
 #endif

     const PixData* _pixData = &pixData[0];//pixData在init中已经计算好了，相对于block（0,0）的偏移
     //ADMP
     for( k = 0; k < C1; k++ )
     {
         const PixData& pk = _pixData[k];
         const float* a = gradPtr + pk.gradOfs;//该点的梯度指针
         float w = pk.gradWeight*pk.histWeights[0];
         const uchar* h = qanglePtr + pk.qangleOfs;//该点的梯度编号指针
         int h0 = h[0], h1 = h[1];//梯度编号
         float* hist = blockHist + pk.histOfs[0];//该点的hist指针
         float t0 = hist[h0] + a[0]*w;
         float t1 = hist[h1] + a[1]*w;
         hist[h0] = t0; hist[h1] = t1;
     }
     //BCEINPHL
     for( ; k < C2; k++ )
     {
         const PixData& pk = _pixData[k];
         const float* a = gradPtr + pk.gradOfs;
         float w, t0, t1, a0 = a[0], a1 = a[1];
         const uchar* h = qanglePtr + pk.qangleOfs;
         int h0 = h[0], h1 = h[1];

         float* hist = blockHist + pk.histOfs[0];
         w = pk.gradWeight*pk.histWeights[0];
         t0 = hist[h0] + a0*w;
         t1 = hist[h1] + a1*w;
         hist[h0] = t0; hist[h1] = t1;

         hist = blockHist + pk.histOfs[1];
         w = pk.gradWeight*pk.histWeights[1];
         t0 = hist[h0] + a0*w;
         t1 = hist[h1] + a1*w;
         hist[h0] = t0; hist[h1] = t1;
     }
     //FGJK
     for( ; k < C4; k++ )
     {
         const PixData& pk = _pixData[k];
         const float* a = gradPtr + pk.gradOfs;
         float w, t0, t1, a0 = a[0], a1 = a[1];
         const uchar* h = qanglePtr + pk.qangleOfs;
         int h0 = h[0], h1 = h[1];

         float* hist = blockHist + pk.histOfs[0];
         w = pk.gradWeight*pk.histWeights[0];
         t0 = hist[h0] + a0*w;
         t1 = hist[h1] + a1*w;
         hist[h0] = t0; hist[h1] = t1;

         hist = blockHist + pk.histOfs[1];
         w = pk.gradWeight*pk.histWeights[1];
         t0 = hist[h0] + a0*w;
         t1 = hist[h1] + a1*w;
         hist[h0] = t0; hist[h1] = t1;

         hist = blockHist + pk.histOfs[2];
         w = pk.gradWeight*pk.histWeights[2];
         t0 = hist[h0] + a0*w;
         t1 = hist[h1] + a1*w;
         hist[h0] = t0; hist[h1] = t1;

         hist = blockHist + pk.histOfs[3];
         w = pk.gradWeight*pk.histWeights[3];
         t0 = hist[h0] + a0*w;
         t1 = hist[h1] + a1*w;
         hist[h0] = t0; hist[h1] = t1;
     }

     normalizeBlockHistogram(blockHist);

     return blockHist;
 }

 //L2HysThreshold：先L2归一化，再限制所有的值的范围（0,0.2），再重新L2归一化
 void HOGCache::normalizeBlockHistogram(float* _hist) const
 {
     float* hist = &_hist[0];
 #ifdef HAVE_IPP
     size_t sz = blockHistogramSize;
 #else
     size_t i, sz = blockHistogramSize;
 #endif

     float sum = 0;
 #ifdef HAVE_IPP
     ippsDotProd_32f(hist,hist,sz,&sum);
 #else
     for( i = 0; i < sz; i++ )
         sum += hist[i]*hist[i];
 #endif

     float scale = 1.f/(std::sqrt(sum)+sz*0.1f), thresh = (float)descriptor->L2HysThreshold;
 #ifdef HAVE_IPP
     ippsMulC_32f_I(scale,hist,sz);
     ippsThreshold_32f_I( hist, sz, thresh, ippCmpGreater );
     ippsDotProd_32f(hist,hist,sz,&sum);
 #else
     for( i = 0, sum = 0; i < sz; i++ )
     {
         hist[i] = std::min(hist[i]*scale, thresh);
         sum += hist[i]*hist[i];
     }
 #endif

     scale = 1.f/(std::sqrt(sum)+1e-3f);
 #ifdef HAVE_IPP
     ippsMulC_32f_I(scale,hist,sz);
 #else
     for( i = 0; i < sz; i++ )
         hist[i] *= scale;
 #endif
 }


 Size HOGCache::windowsInImage(Size imageSize, Size winStride) const
 {
     return Size((imageSize.width - winSize.width)/winStride.width + 1,
                 (imageSize.height - winSize.height)/winStride.height + 1);
 }

 Rect HOGCache::getWindow(Size imageSize, Size winStride, int idx) const
 {
     int nwindowsX = (imageSize.width - winSize.width)/winStride.width + 1;
     int y = idx / nwindowsX;
     int x = idx - nwindowsX*y;
     return Rect( x*winStride.width, y*winStride.height, winSize.width, winSize.height );
 }


 void HOGDescriptor::compute(const Mat& img, vector<float>& descriptors,
                             Size winStride, Size padding,
                             const vector& locations) const
 {
     if( winStride == Size() )
         winStride = cellSize;
     Size cacheStride(gcd(winStride.width, blockStride.width),
                      gcd(winStride.height, blockStride.height));
     size_t nwindows = locations.size();
     padding.width = (int)alignSize(std::max(padding.width, 0), cacheStride.width);
     padding.height = (int)alignSize(std::max(padding.height, 0), cacheStride.height);
     Size paddedImgSize(img.cols + padding.width*2, img.rows + padding.height*2);

     HOGCache cache(this, img, padding, padding, nwindows == 0, cacheStride);

     if( !nwindows )
         nwindows = cache.windowsInImage(paddedImgSize, winStride).area();

     const HOGCache::BlockData* blockData = &cache.blockData[0];

     int nblocks = cache.nblocks.area();
     int blockHistogramSize = cache.blockHistogramSize;
     size_t dsize = getDescriptorSize(); //检测窗口内描述子的总长度，即总bin数
     descriptors.resize(dsize*nwindows);  //整张图片的描述子长度

     for( size_t i = 0; i < nwindows; i++ )
     {
         float* descriptor = &descriptors[i*dsize];

         Point pt0;
         if( !locations.empty() )
         {
             pt0 = locations[i];
             if( pt0.x < -padding.width || pt0.x > img.cols + padding.width - winSize.width ||
                 pt0.y < -padding.height || pt0.y > img.rows + padding.height - winSize.height )
                 continue;
         }
         else//默认是这种情况
         {
             pt0 = cache.getWindow(paddedImgSize, winStride, (int)i).tl() - Point(padding);
             CV_Assert(pt0.x % cacheStride.width == 0 && pt0.y % cacheStride.height == 0);
         }

         for( int j = 0; j < nblocks; j++ )
         {
             const HOGCache::BlockData& bj = blockData[j];
             Point pt = pt0 + bj.imgOffset;

             float* dst = descriptor + bj.histOfs;
             const float* src = cache.getBlock(pt, dst);
             if( src != dst )
 #ifdef HAVE_IPP
                ippsCopy_32f(src,dst,blockHistogramSize);
 #else
                 for( int k = 0; k < blockHistogramSize; k++ )
                     dst[k] = src[k];
 #endif
         }
     }
 }


 void HOGDescriptor::detect(const Mat& img,
     vector& hits, vector<double>& weights, double hitThreshold,
     Size winStride, Size padding, const vector& locations) const
     /*
     img – Source image. CV_8UC1 and CV_8UC4 types are supported for now.
     found_locations – Left-top corner points of detected objects boundaries.
     hit_threshold – Threshold for the distance between features and SVM classifying plane.
     win_stride – Window stride. It must be a multiple of block stride.
     padding – Mock parameter to keep the CPU interface compatibility. It must be (0,0).
     */
     //hog->detect(smallerImg, locations, hitsWeights, hitThreshold, winStride, padding);
     //smallerImg size:(cvRound(img.cols/scale), cvRound(img.rows/scale));
 {
     hits.clear();
     if( svmDetector.empty() )
         return;

     if( winStride == Size() )//未指定winStride的情况下，winStride==（8,8）
         winStride = cellSize;
     Size cacheStride(gcd(winStride.width, blockStride.width),
                      gcd(winStride.height, blockStride.height));// gcd,求最大公约数，默认结果（8,8）
     size_t nwindows = locations.size(); // 默认：0
     //对于我们自己设定的LTpading=BRpading=pading,进行调整使得pading的宽高与casheStride的宽高对齐，类似于4字节补充对齐
     padding.width = (int)alignSize(std::max(padding.width, 0), cacheStride.width);//alignSize(m, n)，返回n的倍数中大于等于m的最小值
     padding.height = (int)alignSize(std::max(padding.height, 0), cacheStride.height);
     Size paddedImgSize(img.cols + padding.width*2, img.rows + padding.height*2);
     /*--------------------------------------------------------------------*/
     //  1.计算梯度的模，方向
     //  2.预先计算好了一个block的bin基偏移、高斯权重、插值距离
     HOGCache cache(this, img, padding, padding, nwindows == 0, cacheStride);    //调用了，computeGradient，计算了pading后的梯度
                                                                                 //Note:尺度变化时，重新计算了梯度
                                                                                 //histOfs = (j*nblocks.height + i)*blockHistogramSize;
                                                                                 //imgOffset = Point(j*blockStride.width,i*blockStride.height);

     if( !nwindows )
         nwindows = cache.windowsInImage(paddedImgSize, winStride).area();//整个img 的检测窗口数

     const HOGCache::BlockData* blockData = &cache.blockData[0];

     int nblocks = cache.nblocks.area(); //检测窗口内的block数
     int blockHistogramSize = cache.blockHistogramSize; //一个block的histogram的bin总数，2*2*9
     size_t dsize = getDescriptorSize();//一个窗口的描述子总数

     double rho = svmDetector.size() > dsize ? svmDetector[dsize] : 0;// > 成立的情况，即svm的 惩罚项系数 C 不为0
     vector<float> blockHist(blockHistogramSize);

     for( size_t i = 0; i < nwindows; i++ )
     {
         Point pt0;
         if( !locations.empty() )
         {
             pt0 = locations[i];
             if( pt0.x < -padding.width || pt0.x > img.cols + padding.width - winSize.width ||
                 pt0.y < -padding.height || pt0.y > img.rows + padding.height - winSize.height )
                 continue;
         }
         else
         {
             //得到第i个检测窗口在pading之后的图像中的区域，这里减去pading,后面geitblock又pt += imgoffset;
             pt0 = cache.getWindow(paddedImgSize, winStride, (int)i).tl()- Point(padding);
             CV_Assert(pt0.x % cacheStride.width == 0 && pt0.y % cacheStride.height == 0);
         }
         double s = rho;
         const float* svmVec = &svmDetector[0];
 #ifdef HAVE_IPP
         int j;
 #else
         int j, k;
 #endif
         for( j = 0; j < nblocks; j++, svmVec += blockHistogramSize )
         {
             const HOGCache::BlockData& bj = blockData[j];//检测窗口中第j个block
             // .histOfs = (j*nblocks.height + i)*blockHistogramSize;
             // .imgOffset = Point(j*blockStride.width,i*blockStride.height);
             Point pt = pt0 + bj.imgOffset;  //得到第i个检测窗口中第j个block在pading之后的图像中的TL坐标
             //得到以pt为TL坐标的block的hist（2*2*9）数据
             const float* vec = cache.getBlock(pt, &blockHist[0]);
 #ifdef HAVE_IPP
             Ipp32f partSum;
             ippsDotProd_32f(vec,svmVec,blockHistogramSize,&partSum);
             s += (double)partSum;
 #else
             //计算到分类超平面的距离
             for( k = 0; k <= blockHistogramSize - 4; k += 4 )
                 s += vec[k]*svmVec[k] + vec[k+1]*svmVec[k+1] +
                     vec[k+2]*svmVec[k+2] + vec[k+3]*svmVec[k+3];
             for( ; k < blockHistogramSize; k++ )
                 s += vec[k]*svmVec[k];
 #endif
         }
         if( s >= hitThreshold )
         {
             hits.push_back(pt0);
             weights.push_back(s);
         }
     }
 }

 void HOGDescriptor::detect(const Mat& img, vector& hits, double hitThreshold,
                            Size winStride, Size padding, const vector& locations) const
 {
     vector<double> weightsV;
     detect(img, hits, weightsV, hitThreshold, winStride, padding, locations);
 }

 class HOGInvoker : public ParallelLoopBody
 {
 public:
     HOGInvoker( const HOGDescriptor* _hog, const Mat& _img,
                 double _hitThreshold, Size _winStride, Size _padding,
                 const double* _levelScale, std::vector * _vec, Mutex* _mtx,
                 std::vector<double>* _weights=0, std::vector<double>* _scales=0 )
     {
         hog = _hog;
         img = _img;
         hitThreshold = _hitThreshold;
         winStride = _winStride;
         padding = _padding;
         levelScale = _levelScale;
         vec = _vec;
         weights = _weights;
         scales = _scales;
         mtx = _mtx;
     }

     void operator()( const Range& range ) const
     {
         int i, i1 = range.start, i2 = range.end;
         double minScale = i1 > 0 ? levelScale[i1] : i2 > 1 ? levelScale[i1+1] : std::max(img.cols, img.rows);
         Size maxSz(cvCeil(img.cols/minScale), cvCeil(img.rows/minScale));
         Mat smallerImgBuf(maxSz, img.type());
         vector locations;
         vector<double> hitsWeights;

         for( i = i1; i < i2; i++ )
         {
             double scale = levelScale[i];
             Size sz(cvRound(img.cols/scale), cvRound(img.rows/scale));//cvRound：四舍五入
             Mat smallerImg(sz, img.type(), smallerImgBuf.data);
             if( sz == img.size() )  //scale==1，不需要用 smallerImgBuf的空间，所以最大的内存应该是 scale==levelScale[i1+1]的情况
                 smallerImg = Mat(sz, img.type(), img.data, img.step);//共享数据
             else
                 resize(img, smallerImg, sz);//dst的内存空间超过src时，dst的空间是不是并没有缩小呢，
                                             //也就是说是不是先释放内存，再按照新的size重新申请,从程序上看一直霸占原始内存空间才能起到减少内存申请释放所耗费的时间
             hog->detect(smallerImg, locations, hitsWeights, hitThreshold, winStride, padding);
             Size scaledWinSize = Size(cvRound(hog->winSize.width*scale), cvRound(hog->winSize.height*scale));

             mtx->lock();
             for( size_t j = 0; j < locations.size(); j++ )
             {
                 vec->push_back(Rect(cvRound(locations[j].x*scale),
                                     cvRound(locations[j].y*scale),
                                     scaledWinSize.width, scaledWinSize.height));//恢复为原图像中的位置
                 if (scales)
                 {
                     scales->push_back(scale);
                 }
             }
             mtx->unlock();

             if (weights && (!hitsWeights.empty()))
             {
                 mtx->lock();
                 for (size_t j = 0; j < locations.size(); j++)
                 {
                     weights->push_back(hitsWeights[j]);
                 }
                 mtx->unlock();
             }
         }
     }

     const HOGDescriptor* hog;
     Mat img;
     double hitThreshold;
     Size winStride;
     Size padding;
     const double* levelScale;
     std::vector* vec;
     std::vector<double>* weights;
     std::vector<double>* scales;
     Mutex* mtx;
 };


 void HOGDescriptor::detectMultiScale(
     const Mat& img, vector& foundLocations, vector<double>& foundWeights,
     double hitThreshold, Size winStride, Size padding,
     double scale0, double finalThreshold, bool useMeanshiftGrouping) const
     /*
     img – Source image.
     foundLocations – Detected objects boundaries.
     foundWeights   -
     hit_threshold – Threshold for the distance between features and SVM classifying plane，到分类超平面的距离，越大则要求越严格，一般设为0.
     win_stride – Window stride. It must be a multiple of block stride.
     padding – Mock parameter to keep the CPU interface compatibility. It must be (0,0).
     scale0 – Coefficient of the detection window increase.
     group_threshold – Coefficient to regulate the similarity threshold（相似性阈值）. When detected, some
     objects can be covered by many rectangles. 0 means not to perform groupin
     */
 {
     double scale = 1.;
     int levels = 0;

     vector<double> levelScale;
     //要使检测窗口的尺度变大有两种方案，法一：图像尺寸不变，增大检测窗口的大小；法二：反过来，检测窗口不变，缩小图片
     //这里使用的正是第二种方法
     for( levels = 0; levels < nlevels; levels++ )    //默认值：64
     {
         levelScale.push_back(scale);
         if( cvRound(img.cols/scale) < winSize.width ||   // 小于64层尺度的尺度数由是由图形的尺寸 和 scale0 决定的，
             cvRound(img.rows/scale) < winSize.height || //当图像缩放到已经小于检测窗口时就已经不能在增加尺度了
             scale0 <= 1 )
             break;
         scale *= scale0;
     }
     levels = std::max(levels, 1);
     levelScale.resize(levels);

     std::vector allCandidates;
     std::vector<double> tempScales;
     std::vector<double> tempWeights;
     std::vector<double> foundScales;
     Mutex mtx;
     //[begin，end)
     //TBB，参考 http://blog.csdn.net/zoufeiyy/article/details/1887579
     parallel_for_(Range(0, (int)levelScale.size()),
                  HOGInvoker(this, img, hitThreshold, winStride, padding, &levelScale[0], &allCandidates, &mtx, &tempWeights, &tempScales));

     std::copy(tempScales.begin(), tempScales.end(), back_inserter(foundScales));//把tempScales的内容添加到 foundScales 后面
     foundLocations.clear();
     std::copy(allCandidates.begin(), allCandidates.end(), back_inserter(foundLocations));
     foundWeights.clear();
     std::copy(tempWeights.begin(), tempWeights.end(), back_inserter(foundWeights));

     if ( useMeanshiftGrouping )
     {
         groupRectangles_meanshift(foundLocations, foundWeights, foundScales, finalThreshold, winSize);
     }
     else
     {
         groupRectangles(foundLocations, (int)finalThreshold, 0.2);
     }
 }

 void HOGDescriptor::detectMultiScale(const Mat& img, vector& foundLocations,
                                      double hitThreshold, Size winStride, Size padding,
                                      double scale0, double finalThreshold, bool useMeanshiftGrouping) const
 {
     vector<double> foundWeights;
     detectMultiScale(img, foundLocations, foundWeights, hitThreshold, winStride,
                      padding, scale0, finalThreshold, useMeanshiftGrouping);
 }

 typedef RTTIImpl HOGRTTI;

 CvType hog_type( CV_TYPE_NAME_HOG_DESCRIPTOR, HOGRTTI::isInstance,
                  HOGRTTI::release, HOGRTTI::read, HOGRTTI::write, HOGRTTI::clone);

 vector<float> HOGDescriptor::getDefaultPeopleDetector()
 {
     static const float detector[] = {
        0.05359386f, -0.14721455f, -0.05532170f, 0.05077307f,
        0.11547081f, -0.04268804f, 0.04635834f, -0.05468199f, 0.08232084f,
        0.10424068f, -0.02294518f, 0.01108519f, 0.01378693f, 0.11193510f,
        0.01268418f, 0.08528346f, -0.06309239f, 0.13054633f, 0.08100729f,
        -0.05209739f, -0.04315529f, 0.09341384f, 0.11035026f, -0.07596218f,
        -0.05517511f, -0.04465296f, 0.02947334f, 0.04555536f,
        -3.55954492e-003f, 0.07818956f, 0.07730991f, 0.07890715f, 0.06222893f,
        0.09001380f, -0.03574381f, 0.03414327f, 0.05677258f, -0.04773581f,
        0.03746637f, -0.03521175f, 0.06955440f, -0.03849038f, 0.01052293f,
        0.01736112f, 0.10867710f, 0.08748853f, 3.29739624e-003f, 0.10907028f,
        0.07913758f, 0.10393070f, 0.02091867f, 0.11594022f, 0.13182420f,
        0.09879354f, 0.05362710f, -0.06745391f, -7.01260753e-003f,
        5.24702156e-003f, 0.03236255f, 0.01407916f, 0.02207983f, 0.02537322f,
        0.04547948f, 0.07200756f, 0.03129894f, -0.06274468f, 0.02107014f,
        0.06035208f, 0.08636236f, 4.53164103e-003f, 0.02193363f, 0.02309801f,
        0.05568166f, -0.02645093f, 0.04448695f, 0.02837519f, 0.08975694f,
        0.04461516f, 0.08975355f, 0.07514391f, 0.02306982f, 0.10410084f,
        0.06368385f, 0.05943464f, 4.58420580e-003f, 0.05220337f, 0.06675851f,
        0.08358569f, 0.06712101f, 0.06559004f, -0.03930482f, -9.15936660e-003f,
        -0.05897915f, 0.02816453f, 0.05032348f, 0.06780671f, 0.03377650f,
        -6.09417039e-004f, -0.01795146f, -0.03083684f, -0.01302475f,
        -0.02972313f, 7.88706727e-003f, -0.03525961f, -2.50397739e-003f,
        0.05245084f, 0.11791293f, -0.02167498f, 0.05299332f, 0.06640524f,
        0.05190265f, -8.27316567e-003f, 0.03033127f, 0.05842173f,
        -4.01050318e-003f, -6.25105947e-003f, 0.05862958f, -0.02465461f,
        0.05546781f, -0.08228195f, -0.07234028f, 0.04640540f, -0.01308254f,
        -0.02506191f, 0.03100746f, -0.04665651f, -0.04591486f, 0.02949927f,
        0.06035462f, 0.02244646f, -0.01698639f, 0.01040041f, 0.01131170f,
        0.05419579f, -0.02130277f, -0.04321722f, -0.03665198f, 0.01126490f,
        -0.02606488f, -0.02228328f, -0.02255680f, -0.03427236f,
        -7.75165204e-003f, -0.06195229f, 8.21638294e-003f, 0.09535975f,
        -0.03709979f, -0.06942501f, 0.14579427f, -0.05448192f, -0.02055904f,
        0.05747357f, 0.02781788f, -0.07077577f, -0.05178314f, -0.10429011f,
        -0.11235505f, 0.07529039f, -0.07559302f, -0.08786739f, 0.02983843f,
        0.02667585f, 0.01382199f, -0.01797496f, -0.03141199f, -0.02098101f,
        0.09029204f, 0.04955018f, 0.13718739f, 0.11379953f, 1.80019124e-003f,
        -0.04577610f, -1.11108483e-003f, -0.09470536f, -0.11596080f,
        0.04489342f, 0.01784211f, 3.06850672e-003f, 0.10781866f,
        3.36498418e-003f, -0.10842580f, -0.07436839f, -0.10535070f,
        -0.01866805f, 0.16057891f, -5.07316366e-003f, -0.04295658f,
        -5.90488780e-003f, 8.82003549e-003f, -0.01492646f, -0.05029279f,
        -0.12875880f, 8.78831954e-004f, -0.01297184f, -0.07592774f,
        -0.02668831f, -6.93787413e-004f, 0.02406698f, -0.01773298f,
        -0.03855745f, -0.05877856f, 0.03259695f, 0.12826584f, 0.06292590f,
        -4.10733931e-003f, 0.10996531f, 0.01332991f, 0.02088735f, 0.04037504f,
        -0.05210760f, 0.07760046f, 0.06399347f, -0.05751930f, -0.10053057f,
        0.07505023f, -0.02139782f, 0.01796176f, 2.34400877e-003f, -0.04208319f,
        0.07355055f, 0.05093350f, -0.02996780f, -0.02219072f, 0.03355330f,
        0.04418742f, -0.05580705f, -0.05037573f, -0.04548179f, 0.01379514f,
        0.02150671f, -0.02194211f, -0.13682702f, 0.05464972f, 0.01608082f,
        0.05309116f, 0.04701022f, 1.33690401e-003f, 0.07575664f, 0.09625306f,
        8.92647635e-003f, -0.02819123f, 0.10866830f, -0.03439325f,
        -0.07092371f, -0.06004780f, -0.02712298f, -7.07467366e-003f,
        -0.01637020f, 0.01336790f, -0.10313606f, 0.04906582f, -0.05732445f,
        -0.02731079f, 0.01042235f, -0.08340668f, 0.03686501f, 0.06108340f,
        0.01322748f, -0.07809529f, 0.03774724f, -0.03413248f, -0.06096525f,
        -0.04212124f, -0.07982176f, -1.25973229e-003f, -0.03045501f,
        -0.01236493f, -0.06312395f, 0.04789570f, -0.04602066f, 0.08576570f,
        0.02521080f, 0.02988098f, 0.10314583f, 0.07060035f, 0.04520544f,
        -0.04426654f, 0.13146530f, 0.08386490f, 0.02164590f, -2.12280243e-003f,
        -0.03686353f, -0.02074944f, -0.03829959f, -0.01530596f, 0.02689708f,
        0.11867401f, -0.06043470f, -0.02785023f, -0.04775074f, 0.04878745f,
        0.06350956f, 0.03494788f, 0.01467400f, 1.17890188e-003f, 0.04379614f,
        2.03681854e-003f, -0.03958609f, -0.01072688f, 6.43705716e-003f,
        0.02996500f, -0.03418507f, -0.01960307f, -0.01219154f,
        -4.37000440e-003f, -0.02549453f, 0.02646318f, -0.01632513f,
        6.46516960e-003f, -0.01929734f, 4.78711911e-003f, 0.04962371f,
        0.03809111f, 0.07265724f, 0.05758125f, -0.03741554f, 0.01648608f,
        -8.45285598e-003f, 0.03996826f, -0.08185477f, 0.02638875f,
        -0.04026615f, -0.02744674f, -0.04071517f, 1.05096330e-003f,
        -0.04741232f, -0.06733172f, 8.70434940e-003f, -0.02192543f,
        1.35350740e-003f, -0.03056974f, -0.02975521f, -0.02887780f,
        -0.01210713f, -0.04828526f, -0.09066251f, -0.09969629f, -0.03665164f,
        -8.88111943e-004f, -0.06826669f, -0.01866150f, -0.03627640f,
        -0.01408288f, 0.01874239f, -0.02075835f, 0.09145175f, -0.03547291f,
        0.05396780f, 0.04198981f, 0.01301925f, -0.03384354f, -0.12201976f,
        0.06830920f, -0.03715654f, 9.55848210e-003f, 5.05685573e-003f,
        0.05659294f, 3.90764466e-003f, 0.02808490f, -0.05518097f, -0.03711621f,
        -0.02835565f, -0.04420464f, -0.01031947f, 0.01883466f,
        -8.49525444e-003f, -0.09419250f, -0.01269387f, -0.02133371f,
        -0.10190815f, -0.07844430f, 2.43644323e-003f, -4.09610150e-003f,
        0.01202551f, -0.06452291f, -0.10593818f, -0.02464746f, -0.02199699f,
        -0.07401930f, 0.07285886f, 8.87513801e-004f, 9.97662079e-003f,
        8.46779719e-003f, 0.03730333f, -0.02905126f, 0.03573337f, -0.04393689f,
        -0.12014472f, 0.03176554f, -2.76015815e-003f, 0.10824566f, 0.05090732f,
        -3.30179278e-003f, -0.05123822f, 5.04784798e-003f, -0.05664124f,
        -5.99415926e-003f, -0.05341901f, -0.01221393f, 0.01291318f,
        9.91760660e-003f, -7.56987557e-003f, -0.06193124f, -2.24549137e-003f,
        0.01987562f, -0.02018840f, -0.06975540f, -0.06601523f, -0.03349112f,
        -0.08910118f, -0.03371435f, -0.07406893f, -0.02248047f, -0.06159951f,
        2.77751544e-003f, -0.05723337f, -0.04792468f, 0.07518548f,
        2.77279224e-003f, 0.04211938f, 0.03100502f, 0.05278448f, 0.03954679f,
        -0.03006846f, -0.03851741f, -0.02792403f, -0.02875333f, 0.01531280f,
        0.02186953f, -0.01989829f, 2.50679464e-003f, -0.10258728f,
        -0.04785743f, -0.02887216f, 3.85063468e-003f, 0.01112236f,
        8.29218887e-003f, -0.04822981f, -0.04503597f, -0.03713100f,
        -0.06988008f, -0.11002295f, -2.69209221e-003f, 1.85383670e-003f,
        -0.05921049f, -0.06105053f, -0.08458050f, -0.04527602f,
        8.90329306e-004f, -0.05875023f, -2.68602883e-003f, -0.01591195f,
        0.03631859f, 0.05493166f, 0.07300330f, 5.53333294e-003f, 0.06400407f,
        0.01847740f, -5.76280477e-003f, -0.03210877f, 4.25160583e-003f,
        0.01166520f, -1.44864211e-003f, 0.02253744f, -0.03367080f, 0.06983195f,
        -4.22323542e-003f, -8.89401045e-003f, -0.07943393f, 0.05199728f,
        0.06065201f, 0.04133492f, 1.44032843e-003f, -0.09585235f, -0.03964731f,
        0.04232114f, 0.01750465f, -0.04487902f, -7.59733608e-003f, 0.02011171f,
        0.04673622f, 0.09011173f, -0.07869188f, -0.04682482f, -0.05080139f,
        -3.99383716e-003f, -0.05346331f, 0.01085723f, -0.03599333f,
        -0.07097908f, 0.03551549f, 0.02680387f, 0.03471529f, 0.01790393f,
        0.05471273f, 9.62048303e-003f, -0.03180215f, 0.05864431f, 0.02330614f,
        0.01633144f, -0.05616681f, -0.10245429f, -0.08302189f, 0.07291322f,
        -0.01972590f, -0.02619633f, -0.02485327f, -0.04627592f,
        1.48853404e-003f, 0.05514185f, -0.01270860f, -0.01948900f, 0.06373586f,
        0.05002292f, -0.03009798f, 8.76216311e-003f, -0.02474238f,
        -0.05504891f, 1.74034527e-003f, -0.03333667f, 0.01524987f, 0.11663762f,
        -1.32344989e-003f, -0.06608453f, 0.05687166f, -6.89525274e-004f,
        -0.04402352f, 0.09450210f, -0.04222684f, -0.05360983f, 0.01779531f,
        0.02561388f, -0.11075410f, -8.77790991e-003f, -0.01099504f,
        -0.10380266f, 0.03103457f, -0.02105741f, -0.07371717f, 0.05146710f,
        0.10581432f, -0.08617968f, -0.02892107f, 0.01092199f, 0.14551543f,
        -2.24320893e-003f, -0.05818033f, -0.07390742f, 0.05701261f,
        0.12937020f, -0.04986651f, 0.10182415f, 0.05028650f, 0.12515625f,
        0.09175041f, 0.06404983f, 0.01523394f, 0.09460562f, 0.06106631f,
        -0.14266998f, -0.02926703f, 0.02762171f, 0.02164151f,
        -9.58488265e-004f, -0.04231362f, -0.09866509f, 0.04322244f,
        0.05872034f, -0.04838847f, 0.06319253f, 0.02443798f, -0.03606876f,
        9.38737206e-003f, 0.04289991f, -0.01027411f, 0.08156885f, 0.08751175f,
        -0.13191354f, 8.16054735e-003f, -0.01452161f, 0.02952677f, 0.03615945f,
        -2.09128903e-003f, 0.02246693f, 0.09623287f, 0.09412123f, -0.02924758f,
        -0.07815186f, -0.02203079f, -2.02566991e-003f, 0.01094733f,
        -0.01442332f, 0.02838561f, 0.11882371f, 7.28798332e-003f, -0.10345965f,
        0.07561217f, -0.02049661f, 4.44177445e-003f, 0.01609347f, -0.04893158f,
        -0.08758243f, -7.67420698e-003f, 0.08862378f, 0.06098121f, 0.06565887f,
        7.32981879e-003f, 0.03558407f, -0.03874352f, -0.02490055f,
        -0.06771075f, 0.09939223f, -0.01066077f, 0.01382995f, -0.07289080f,
        7.47184316e-003f, 0.10621431f, -0.02878659f, 0.02383525f, -0.03274646f,
        0.02137008f, 0.03837290f, 0.02450992f, -0.04296818f, -0.02895143f,
        0.05327370f, 0.01499020f, 0.04998732f, 0.12938657f, 0.09391870f,
        0.04292390f, -0.03359194f, -0.06809492f, 0.01125796f, 0.17290455f,
        -0.03430733f, -0.06255233f, -0.01813114f, 0.11726857f, -0.06127599f,
        -0.08677909f, -0.03429872f, 0.04684938f, 0.08161420f, 0.03538774f,
        0.01833884f, 0.11321855f, 0.03261845f, -0.04826299f, 0.01752407f,
        -0.01796414f, -0.10464549f, -3.30041884e-003f, 2.29343961e-004f,
        0.01457292f, -0.02132982f, -0.02602923f, -9.87351313e-003f,
        0.04273872f, -0.02103316f, -0.07994065f, 0.02614958f, -0.02111666f,
        -0.06964913f, -0.13453490f, -0.06861878f, -6.09341264e-003f,
        0.08251446f, 0.15612499f, 2.46531400e-003f, 8.88424646e-003f,
        -0.04152999f, 0.02054853f, 0.05277953f, -0.03087788f, 0.02817579f,
        0.13939077f, 0.07641046f, -0.03627627f, -0.03015098f, -0.04041540f,
        -0.01360690f, -0.06227205f, -0.02738223f, 0.13577610f, 0.15235767f,
        -0.05392922f, -0.11175954f, 0.02157129f, 0.01146481f, -0.05264937f,
        -0.06595174f, -0.02749175f, 0.11812254f, 0.17404149f, -0.06137035f,
        -0.11003478f, -0.01351621f, -0.01745916f, -0.08577441f, -0.04469909f,
        -0.06106115f, 0.10559758f, 0.20806813f, -0.09174948f, 7.09621934e-004f,
        0.03579374f, 0.07215115f, 0.02221742f, 0.01827742f, -7.90785067e-003f,
        0.01489554f, 0.14519960f, -0.06425831f, 0.02990399f, -1.80181325e-003f,
        -0.01401528f, -0.04171134f, -3.70530109e-003f, -0.09090481f,
        0.09520713f, 0.08845516f, -0.02651753f, -0.03016730f, 0.02562448f,
        0.03563816f, -0.03817881f, 0.01433385f, 0.02256983f, 0.02872120f,
        0.01001934f, -0.06332260f, 0.04338406f, 0.07001807f, -0.04705722f,
        -0.07318907f, 0.02630457f, 0.03106382f, 0.06648342f, 0.10913180f,
        -0.01630815f, 0.02910308f, 0.02895109f, 0.08040254f, 0.06969310f,
        0.06797734f, 6.08639978e-003f, 4.16588830e-003f, 0.08926726f,
        -0.03123648f, 0.02700146f, 0.01168734f, -0.01631594f, 4.61015804e-003f,
        8.51359498e-003f, -0.03544224f, 0.03571994f, 4.29766066e-003f,
        -0.01970077f, -8.79793242e-003f, 0.09607988f, 0.01544222f,
        -0.03923707f, 0.07308586f, 0.06061262f, 1.31683104e-004f,
        -7.98222050e-003f, 0.02399261f, -0.06084389f, -0.02743429f,
        -0.05475523f, -0.04131311f, 0.03559756f, 0.03055342f, 0.02981433f,
        0.14860515f, 0.01766787f, 0.02945257f, 0.04898238f, 0.01026922f,
        0.02811658f, 0.08267091f, 0.02732154f, -0.01237693f, 0.11760156f,
        0.03802063f, -0.03309754f, 5.24957618e-003f, -0.02460510f, 0.02691451f,
        0.05399988f, -0.10133506f, 0.06385437f, -0.01818005f, 0.02259503f,
        0.03573135f, 0.01042848f, -0.04153402f, -0.04043029f, 0.01643575f,
        0.08326677f, 4.61383024e-004f, -0.05308095f, -0.08536223f,
        -1.61011645e-003f, -0.02163720f, -0.01783352f, 0.03859637f,
        0.08498885f, -0.01725216f, 0.08625131f, 0.10995087f, 0.09177644f,
        0.08498347f, 0.07646490f, 0.05580502f, 0.02693516f, 0.09996913f,
        0.09070327f, 0.06667200f, 0.05873008f, -0.02247842f, 0.07772321f,
        0.12408436f, 0.12629253f, -8.41997913e-004f, 0.01477783f, 0.09165990f,
        -2.98401713e-003f, -0.06466447f, -0.07057302f, 2.09516948e-004f,
        0.02210209f, -0.02158809f, -0.08602506f, -0.02284836f,
        4.01876355e-003f, 9.56660323e-003f, -0.02073978f, -0.04635138f,
        -7.59423291e-003f, -0.01377393f, -0.04559359f, -0.13284740f,
        -0.08671406f, -0.03654395f, 0.01142869f, 0.03287891f, -0.04392983f,
        0.06142959f, 0.17710890f, 0.10385257f, 0.01329137f, 0.10067633f,
        0.12450829f, -0.04476709f, 0.09049144f, 0.04589312f, 0.11167907f,
        0.08587538f, 0.04767583f, 1.67188141e-003f, 0.02359802f, -0.03808852f,
        0.03126272f, -0.01919029f, -0.05698918f, -0.02365112f, -0.06519032f,
        -0.05599358f, -0.07097308f, -0.03301812f, -0.04719102f, -0.02566297f,
        0.01324074f, -0.09230672f, -0.05518232f, -0.04712864f, -0.03380903f,
        -0.06719479f, 0.01183908f, -0.09326738f, 0.01642865f, 0.03789867f,
        -6.61567831e-003f, 0.07796386f, 0.07246574f, 0.04706347f, -0.02523437f,
        -0.01696830f, -0.08068866f, 0.06030888f, 0.10527060f, -0.06611756f,
        0.02977346f, 0.02621830f, 0.01913855f, -0.08479366f, -0.06322418f,
        -0.13570616f, -0.07644490f, 9.31900274e-003f, -0.08095149f,
        -0.10197903f, -0.05204025f, 0.01413151f, -0.07800411f, -0.01885122f,
        -0.07509381f, -0.10136326f, -0.05212355f, -0.09944065f,
        -1.33606605e-003f, -0.06342617f, -0.04178550f, -0.12373723f,
        -0.02832736f, -0.06057501f, 0.05830070f, 0.07604282f, -0.06462587f,
        8.02447461e-003f, 0.11580125f, 0.12332212f, 0.01978462f,
        -2.72378162e-003f, 0.05850752f, -0.04674481f, 0.05148062f,
        -2.62542837e-003f, 0.11253355f, 0.09893716f, 0.09785093f, -0.04659257f,
        -0.01102429f, -0.07002308f, 0.03088913f, -0.02565549f, -0.07671449f,
        3.17443861e-003f, -0.10783514f, -0.02314270f, -0.11089555f,
        -0.01024768f, 0.03116021f, -0.04964825f, 0.02281825f, 5.50005678e-003f,
        -0.08427856f, -0.14685495f, -0.07719755f, -0.13342668f, -0.04525511f,
        -0.09914210f, 0.02588859f, 0.03469279f, 0.04664020f, 0.11688190f,
        0.09647275f, 0.10857815f, -0.01448726f, 0.04299758f, -0.06763151f,
        1.33257592e-003f, 0.14331576f, 0.07574340f, 0.09166205f, 0.05674926f,
        0.11325553f, -0.01106494f, 0.02062161f, -0.11484840f, -0.07492137f,
        -0.02864293f, -0.01275638f, -0.06946032f, -0.10101652f, -0.04113498f,
        -0.02214783f, -0.01273942f, -0.07480393f, -0.10556041f, -0.07622112f,
        -0.09988393f, -0.11453961f, -0.12073903f, -0.09412795f, -0.07146588f,
        -0.04054537f, -0.06127083f, 0.04221122f, 0.07688113f, 0.04099256f,
        0.12663734f, 0.14683802f, 0.21761774f, 0.12525328f, 0.18431792f,
        -1.66402373e-003f, 2.37777247e-003f, 0.01445475f, 0.03509416f,
        0.02654697f, 0.01716739f, 0.05374011f, 0.02944174f, 0.11323927f,
        -0.01485456f, -0.01611330f, -1.85554172e-003f, -0.01708549f,
        -0.05435753f, -0.05302101f, 0.05260378f, -0.03582945f,
        -3.42867890e-004f, 1.36076682e-003f, -0.04436073f, -0.04228432f,
        0.03281291f, -0.05480836f, -0.10197772f, -0.07206279f, -0.10741059f,
        -0.02366946f, 0.10278475f, -2.74783419e-003f, -0.03242477f,
        0.02308955f, 0.02835869f, 0.10348799f, 0.19580358f, 0.10252027f,
        0.08039929f, 0.05525554f, -0.13250865f, -0.14395352f, 3.13586881e-003f,
        -0.03387071f, 8.94669443e-003f, 0.05406157f, -4.97324532e-003f,
        -0.01189114f, 2.82919413e-004f, -0.03901557f, -0.04898705f,
        0.02164520f, -0.01382906f, -0.01850416f, 0.01869347f, -0.02450060f,
        0.02291678f, 0.08196463f, 0.03309153f, -0.10629974f, 0.02473924f,
        0.05344394f, -0.02404823f, -0.03243643f, -5.55244600e-003f,
        -0.08009996f, 0.02811539f, 0.04235742f, 0.01859004f, 0.04902123f,
        -0.01438252f, -0.01526853f, 0.02044195f, -0.05008660f, 0.04244113f,
        0.07611816f, 0.04950470f, -0.06020549f, -4.26026015e-003f, 0.13133512f,
        -0.01438738f, -0.01958807f, -0.04044152f, -0.12425045f,
        2.84353318e-003f, -0.05042776f, -0.09121484f, 7.34345755e-003f,
        0.09388847f, 0.11800314f, 4.72295098e-003f, 4.44378285e-003f,
        -0.07984917f, -0.03613737f, 0.04490915f, -0.02246483f, 0.04681071f,
        0.05240871f, 0.02157206f, -0.04603431f, -0.01197929f, -0.02748779f,
        0.13621049f, 0.08812155f, -0.07802048f, 4.86458559e-003f, -0.01598836f,
        0.01024450f, -0.03463517f, -0.02304239f, -0.08692665f, 0.06655128f,
        0.05785803f, -0.12640759f, 0.02307472f, 0.07337402f, 0.07525434f,
        0.04943763f, -0.02241034f, -0.09978238f, 0.14487994f, -0.06570521f,
        -0.07855482f, 0.02830222f, -5.29603509e-004f, -0.04669895f,
        -0.11822784f, -0.12246452f, -0.15365660f, -0.02969127f, 0.08078201f,
        0.13512598f, 0.11505685f, 0.04740673f, 0.01376022f, -0.05852978f,
        -0.01537809f, -0.05541119f, 0.02491065f, -0.02870786f, 0.02760978f,
        0.23836176f, 0.22347429f, 0.10306466f, -0.06919070f, -0.10132039f,
        -0.20198342f, -0.05040560f, 0.27163076f, 0.36987007f, 0.34540465f,
        0.29095781f, 0.05649706f, 0.04125737f, 0.07505883f, -0.02737836f,
        -8.43431335e-003f, 0.07368195f, 0.01653876f, -0.09402955f,
        -0.09574359f, 0.01474337f, -0.07128561f, -0.03460737f, 0.11438941f,
        0.13752601f, -0.06385452f, -0.06310338f, 8.19548313e-003f, 0.11622470f,
        5.05133113e-003f, -0.07602754f, 0.06695660f, 0.25723928f, 0.09037900f,
        0.28826267f, 0.13165380f, -0.05312614f, -0.02137198f, -0.03442232f,
        -0.06255679f, 0.03899667f, 0.18391028f, 0.26016650f, 0.03374462f,
        0.01860465f, 0.19077586f, 0.18160543f, 3.43634398e-003f, -0.03036782f,
        0.19683038f, 0.35378191f, 0.24968483f, -0.03222649f, 0.28972381f,
        0.43091634f, 0.30778357f, 0.02335266f, -0.09877399f, -6.85245218e-003f,
        0.08945240f, -0.08150686f, 0.02792493f, 0.24806842f, 0.17338486f,
        0.06231801f, -0.10432383f, -0.16653322f, -0.13197899f, -0.08531576f,
        -0.19271527f, -0.13536365f, 0.22240199f, 0.39219588f, 0.26597717f,
        -0.01231649f, 0.01016179f, 0.13379875f, 0.12018334f, -0.04852953f,
        -0.07915270f, 0.07036012f, 3.87723115e-003f, -0.06126805f,
        -0.15015170f, -0.11406515f, -0.08556531f, -0.07429333f, -0.16115491f,
        0.13214062f, 0.25691369f, 0.05697750f, 0.06861912f, -6.02903729e-003f,
        -7.94562511e-003f, 0.04799571f, 0.06695165f, -0.01926842f, 0.06206308f,
        0.13450983f, -0.06381495f, -2.98370165e-003f, -0.03482971f,
        7.53991678e-003f, 0.03895611f, 0.11464261f, 0.01669971f,
        8.27818643e-003f, -7.49160210e-003f, -0.11712562f, -0.10650621f,
        -0.10353880f, -0.04994106f, -7.65618810e-004f, 0.03023767f,
        -0.04759270f, -0.07302686f, -0.05825012f, -0.13156348f, -0.10639747f,
        -0.19393684f, -0.09973683f, -0.07918908f, 4.63177625e-004f,
        -6.61382044e-004f, 0.15853868f, 0.08561199f, -0.07660093f,
        -0.08015265f, -0.06164073f, 0.01882577f, -7.29908410e-004f,
        0.06840892f, 0.03843764f, 0.20274927f, 0.22028814f, -5.26101235e-003f,
        0.01452435f, -0.06331623f, 0.02865064f, 0.05673740f, 0.12171564f,
        0.03837196f, 0.03555467f, -0.02662914f, -0.10280123f, -0.06526285f,
        -0.11066351f, -0.08988424f, -0.10103678f, 8.10526591e-003f,
        5.95238712e-003f, 0.02617721f, -0.01705742f, -0.10897956f,
        -0.08004991f, -0.11271993f, -0.06185647f, -0.06103712f, 0.01597041f,
        -0.05923606f, 0.09410726f, 0.22858568f, 0.03263380f, 0.06772990f,
        -0.09003516f, 0.01017870f, 0.01931688f, 0.08628357f, -0.01430009f,
        0.10954945f, 0.16612452f, -0.02434544f, -0.03310068f, -0.04236627f,
        0.01212392f, -6.15046406e-003f, 0.06954194f, 0.03015283f, 0.01787957f,
        0.02781667f, -0.05561153f, -8.96244217e-003f, -0.04971489f,
        0.07510284f, 0.01775282f, 0.05889897f, -0.07981427f, 0.03647643f,
        -3.73833324e-003f, -0.08894575f, -0.06429435f, -0.08068276f,
        0.03567704f, -0.07131936f, -7.21910037e-003f, -0.09566668f,
        0.17886090f, 0.14911725f, 0.02070032f, -0.05017120f, -0.04992622f,
        0.01570143f, -0.09906903f, 0.06456193f, 0.15329507f, 0.18820767f,
        0.11689861f, -0.01178513f, -0.02225163f, -0.01905318f, 0.10271224f,
        -7.27029052e-003f, 0.11664233f, 0.14796902f, 0.07771893f, 0.02400013f,
        -0.05361797f, -0.01972888f, 0.01376177f, 0.06740040f, -0.06525395f,
        0.05726178f, -0.02404981f, -0.14018567f, -0.02074987f, -0.04621970f,
        -0.04688627f, -0.01842059f, 0.07722727f, -0.04852883f, 0.01529004f,
        -0.19639495f, 0.10817073f, 0.03795860f, -0.09435206f, -0.07984378f,
        -0.03383440f, 0.11081333f, 0.02237366f, 0.12703256f, 0.21613893f,
        0.02918790f, 4.66472283e-003f, -0.10274266f, -0.04854131f,
        -3.46305710e-003f, 0.08652268f, 0.02251546f, 0.09636052f, 0.17180754f,
        -0.09272388f, 4.59174305e-004f, -0.11723048f, -0.12210111f,
        -0.15547538f, 0.07218186f, -0.05297846f, 0.03779940f, 0.05150875f,
        -0.03802310f, 0.03870645f, -0.15250699f, -0.08696499f, -0.02021560f,
        0.04118926f, -0.15177974f, 0.01577647f, 0.10249301f, 7.50041893e-003f,
        0.01721806f, -0.06828983f, -0.02397596f, -0.06598977f, -0.04317593f,
        -0.08064980f, 6.66632550e-003f, 0.03333484f, 0.07093620f, 0.08231064f,
        -0.06577903f, -0.06698844f, -0.06984019f, -0.06508023f, -0.14145090f,
        -0.02393239f, 0.06485303f, 8.83263443e-003f, 0.09251080f, -0.07557579f,
        -0.05067699f, -0.09798748f, -0.06703258f, -0.14056294f, 0.03245994f,
        0.12554143f, 0.01761621f, 0.12980327f, -0.04081950f, -0.11906909f,
        -0.14813015f, -0.08376863f, -0.12200681f, 0.04988137f, 0.05424247f,
        -3.90952639e-003f, 0.03255733f, -0.12717837f, -0.07461493f,
        -0.05703964f, -0.01736189f, -0.08026433f, -0.05433894f, -0.01719359f,
        0.02886275f, 0.01772653f, -0.09163518f, 3.57789593e-003f, -0.10129993f,
        -0.02653764f, -0.08131415f, -0.03847986f, -7.62157550e-004f,
        0.06486648f, 0.19675669f, -0.04919156f, -0.07059129f, -0.04857785f,
        -0.01042383f, -0.08328653f, 0.03660302f, -0.03696846f, 0.04969259f,
        0.08241162f, -0.12514858f, -0.06122676f, -0.03750202f,
        6.52989605e-003f, -0.10247213f, 0.02568346f, 4.51781414e-003f,
        -0.03734229f, -0.01131264f, -0.05412074f, 8.89345480e-004f,
        -0.12388977f, -0.05959237f, -0.12418608f, -0.06151643f, -0.07310260f,
        0.02441575f, 0.07023528f, -0.07548289f, -7.57147965e-004f,
        -0.09061348f, -0.08112976f, -0.06920306f, 9.54394229e-003f,
        -0.01219902f, 1.21273217e-003f, -8.88989680e-003f, -0.08309301f,
        -0.04552661f, -0.10739882f, -0.05691034f, -0.13928030f, 0.09027749f,
        0.15123098f, 0.03175976f, 0.17763577f, 3.29913251e-004f, 0.05151888f,
        -0.09844074f, -0.09475287f, -0.08571247f, 0.16241577f, 0.19336018f,
        8.57454538e-003f, 0.11474732f, -0.01493934f, 0.03352379f, -0.08966240f,
        -0.02322310f, 0.02663568f, 0.05448750f, -0.03536883f, -0.07210463f,
        -0.06807277f, -0.03121621f, -0.05932408f, -0.17282860f, -0.15873498f,
        -0.04956378f, 0.01603377f, -0.12385946f, 0.13878587f, 0.21468069f,
        0.13510075f, 0.20992437f, 0.08845878f, 0.08104013f, 0.03754176f,
        0.12173114f, 0.11103114f, 0.10643122f, 0.13941477f, 0.11640384f,
        0.14786847f, 0.01218238f, 0.01160753f, 0.03547940f, 0.08794311f,
        -0.01695384f, -0.07692261f, -0.08236158f, 6.79194089e-003f,
        -0.02458403f, 0.13022894f, 0.10953187f, 0.09857773f, 0.04735930f,
        -0.04353498f, -0.15173385f, -0.17904443f, -0.10450364f, -0.13418166f,
        -0.06633098f, -0.03170381f, -0.06839000f, -0.11350126f, -0.06983913f,
        0.19083543f, 0.17604128f, 0.07730632f, 0.10022651f, 0.36428109f,
        0.28291923f, 0.12688625f, 0.15942036f, 0.14064661f, -0.11201853f,
        -0.13969108f, -0.09088077f, -0.14107047f, 0.05117374f,
        -2.63348082e-003f, -0.10794610f, -0.09715455f, -0.05284977f,
        0.01565668f, 0.05031200f, 0.07021113f, -0.02963028f, 0.01766960f,
        0.08333644f, -0.03211382f, 4.90096770e-003f, 0.05186674f, -0.05045737f,