程序博客网 > 淘宝 军品

TLD（Tracking-Learning-Detection）学习与源码理解之（六） .

来源：互联网 发布：淘宝 军品 编辑：程序博客网 时间：2024/06/06 00:29

转自：http://blog.csdn.net/zouxy09/article/details/7893081

下面是自己在看论文和这些大牛的分析过程中，对代码进行了一些理解，但是由于自己接触图像处理和机器视觉没多久，另外由于自己编程能力比较弱，所以分析过程可能会有不少的错误，希望各位不吝指正。而且，因为编程很多地方不懂，所以注释得非常乱，还海涵。

TLD.h

[cpp] view plaincopyprint?
  1. #include <opencv2/opencv.hpp>  
  2. #include <tld_utils.h>  
  3. #include <LKTracker.h>  
  4. #include <FerNNClassifier.h>  
  5. #include <fstream>  
  6.   
  7.   
  8. //Bounding Boxes  
  9. struct BoundingBox : public cv::Rect {  
  10.   BoundingBox(){}  
  11.   BoundingBox(cv::Rect r): cv::Rect(r){}   //继承的话需要初始化基类  
  12. public:  
  13.   float overlap;        //Overlap with current Bounding Box  
  14.   int sidx;             //scale index  
  15. };  
  16.   
  17. //Detection structure  
  18. struct DetStruct {  
  19.     std::vector<int> bb;  
  20.     std::vector<std::vector<int> > patt;  
  21.     std::vector<float> conf1;  
  22.     std::vector<float> conf2;  
  23.     std::vector<std::vector<int> > isin;  
  24.     std::vector<cv::Mat> patch;  
  25.   };  
  26.     
  27. //Temporal structure  
  28. struct TempStruct {  
  29.     std::vector<std::vector<int> > patt;  
  30.     std::vector<float> conf;  
  31.   };  
  32.   
  33. struct OComparator{  //比较两者重合度  
  34.   OComparator(const std::vector<BoundingBox>& _grid):grid(_grid){}  
  35.   std::vector<BoundingBox> grid;  
  36.   bool operator()(int idx1,int idx2){  
  37.     return grid[idx1].overlap > grid[idx2].overlap;  
  38.   }  
  39. };  
  40.   
  41. struct CComparator{  //比较两者确信度？  
  42.   CComparator(const std::vector<float>& _conf):conf(_conf){}  
  43.   std::vector<float> conf;  
  44.   bool operator()(int idx1,int idx2){  
  45.     return conf[idx1]> conf[idx2];  
  46.   }  
  47. };  
  48.   
  49.   
  50. class TLD{  
  51. private:  
  52.   cv::PatchGenerator generator;  //PatchGenerator类用来对图像区域进行仿射变换  
  53.   FerNNClassifier classifier;  
  54.   LKTracker tracker;  
  55.     
  56.   //下面这些参数通过程序开始运行时读入parameters.yml文件进行初始化  
  57.   ///Parameters  
  58.   int bbox_step;  
  59.   int min_win;  
  60.   int patch_size;  
  61.     
  62.   //initial parameters for positive examples  
  63.   //从第一帧得到的目标的bounding box中（文件读取或者用户框定），经过几何变换得  
  64.   //到 num_closest_init * num_warps_init 个正样本  
  65.   int num_closest_init;  //最近邻窗口数 10  
  66.   int num_warps_init;  //几何变换数目 20  
  67.   int noise_init;  
  68.   float angle_init;  
  69.   float shift_init;  
  70.   float scale_init;  
  71.     
  72.   ////从跟踪得到的目标的bounding box中，经过几何变换更新正样本（添加到在线模型？）  
  73.   //update parameters for positive examples  
  74.   int num_closest_update;  
  75.   int num_warps_update;  
  76.   int noise_update;  
  77.   float angle_update;  
  78.   float shift_update;  
  79.   float scale_update;  
  80.     
  81.   //parameters for negative examples  
  82.   float bad_overlap;  
  83.   float bad_patches;  
  84.     
  85.   ///Variables  
  86. //Integral Images  积分图像，用以计算2bitBP特征（类似于haar特征的计算）  
  87. //Mat最大的优势跟STL很相似，都是对内存进行动态的管理，不需要之前用户手动的管理内存  
  88.   cv::Mat iisum;  
  89.   cv::Mat iisqsum;  
  90.   float var;  
  91.     
  92. //Training data  
  93.   //std::pair主要的作用是将两个数据组合成一个数据，两个数据可以是同一类型或者不同类型。  
  94.   //pair实质上是一个结构体，其主要的两个成员变量是first和second，这两个变量可以直接使用。  
  95.   //在这里用来表示样本，first成员为 features 特征点数组，second成员为 labels 样本类别标签  
  96.   std::vector<std::pair<std::vector<int>,int> > pX; //positive ferns <features,labels=1>  正样本  
  97.   std::vector<std::pair<std::vector<int>,int> > nX; // negative ferns <features,labels=0>  负样本  
  98.   cv::Mat pEx;  //positive NN example    
  99.   std::vector<cv::Mat> nEx; //negative NN examples  
  100.     
  101. //Test data   
  102.   std::vector<std::pair<std::vector<int>,int> > nXT; //negative data to Test  
  103.   std::vector<cv::Mat> nExT; //negative NN examples to Test  
  104.     
  105. //Last frame data  
  106.   BoundingBox lastbox;  
  107.   bool lastvalid;  
  108.   float lastconf;  
  109.     
  110. //Current frame data  
  111.   //Tracker data  
  112.   bool tracked;  
  113.   BoundingBox tbb;  
  114.   bool tvalid;  
  115.   float tconf;  
  116.     
  117.   //Detector data  
  118.   TempStruct tmp;  
  119.   DetStruct dt;  
  120.   std::vector<BoundingBox> dbb;  
  121.   std::vector<bool> dvalid;   //检测有效性？？  
  122.   std::vector<float> dconf;  //检测确信度？？  
  123.   bool detected;  
  124.   
  125.   
  126.   //Bounding Boxes  
  127.   std::vector<BoundingBox> grid;  
  128.   std::vector<cv::Size> scales;  
  129.   std::vector<int> good_boxes; //indexes of bboxes with overlap > 0.6  
  130.   std::vector<int> bad_boxes; //indexes of bboxes with overlap < 0.2  
  131.   BoundingBox bbhull; // hull of good_boxes  //good_boxes 的 壳，也就是窗口的边框  
  132.   BoundingBox best_box; // maximum overlapping bbox  
  133.   
  134. public:  
  135.   //Constructors  
  136.   TLD();  
  137.   TLD(const cv::FileNode& file);  
  138.   void read(const cv::FileNode& file);  
  139.     
  140.   //Methods   
  141.   void init(const cv::Mat& frame1,const cv::Rect &box, FILE* bb_file);  
  142.   void generatePositiveData(const cv::Mat& frame, int num_warps);  
  143.   void generateNegativeData(const cv::Mat& frame);  
  144.   void processFrame(const cv::Mat& img1,const cv::Mat& img2,std::vector<cv::Point2f>& points1,std::vector<cv::Point2f>& points2,  
  145.       BoundingBox& bbnext,bool& lastboxfound, bool tl,FILE* bb_file);  
  146.   void track(const cv::Mat& img1, const cv::Mat& img2,std::vector<cv::Point2f>& points1,std::vector<cv::Point2f>& points2);  
  147.   void detect(const cv::Mat& frame);  
  148.   void clusterConf(const std::vector<BoundingBox>& dbb,const std::vector<float>& dconf,std::vector<BoundingBox>& cbb,std::vector<float>& cconf);  
  149.   void evaluate();  
  150.   void learn(const cv::Mat& img);  
  151.     
  152.   //Tools   
  153.   void buildGrid(const cv::Mat& img, const cv::Rect& box);  
  154.   float bbOverlap(const BoundingBox& box1,const BoundingBox& box2);  
  155.   void getOverlappingBoxes(const cv::Rect& box1,int num_closest);  
  156.   void getBBHull();  
  157.   void getPattern(const cv::Mat& img, cv::Mat& pattern,cv::Scalar& mean,cv::Scalar& stdev);  
  158.   void bbPoints(std::vector<cv::Point2f>& points, const BoundingBox& bb);  
  159.   void bbPredict(const std::vector<cv::Point2f>& points1,const std::vector<cv::Point2f>& points2,  
  160.       const BoundingBox& bb1,BoundingBox& bb2);  
  161.   double getVar(const BoundingBox& box,const cv::Mat& sum,const cv::Mat& sqsum);  
  162.   bool bbComp(const BoundingBox& bb1,const BoundingBox& bb2);  
  163.   int clusterBB(const std::vector<BoundingBox>& dbb,std::vector<int>& indexes);  
  164. };  



 

TLD.cpp

[cpp] view plaincopyprint?
  1. /* 
  2.  * TLD.cpp 
  3.  * 
  4.  *  Created on: Jun 9, 2011 
  5.  *      Author: alantrrs 
  6.  */  
  7.   
  8. #include <TLD.h>  
  9. #include <stdio.h>  
  10. using namespace cv;  
  11. using namespace std;  
  12.   
  13.   
  14. TLD::TLD()  
  15. {  
  16. }  
  17. TLD::TLD(const FileNode& file){  
  18.   read(file);  
  19. }  
  20.   
  21. void TLD::read(const FileNode& file){  
  22.   ///Bounding Box Parameters  
  23.   min_win = (int)file["min_win"];  
  24.   ///Genarator Parameters  
  25.   //initial parameters for positive examples  
  26.   patch_size = (int)file["patch_size"];  
  27.   num_closest_init = (int)file["num_closest_init"];  
  28.   num_warps_init = (int)file["num_warps_init"];  
  29.   noise_init = (int)file["noise_init"];  
  30.   angle_init = (float)file["angle_init"];  
  31.   shift_init = (float)file["shift_init"];  
  32.   scale_init = (float)file["scale_init"];  
  33.   //update parameters for positive examples  
  34.   num_closest_update = (int)file["num_closest_update"];  
  35.   num_warps_update = (int)file["num_warps_update"];  
  36.   noise_update = (int)file["noise_update"];  
  37.   angle_update = (float)file["angle_update"];  
  38.   shift_update = (float)file["shift_update"];  
  39.   scale_update = (float)file["scale_update"];  
  40.   //parameters for negative examples  
  41.   bad_overlap = (float)file["overlap"];  
  42.   bad_patches = (int)file["num_patches"];  
  43.   classifier.read(file);  
  44. }  
  45.   
  46. //此函数完成准备工作   
  47. void TLD::init(const Mat& frame1, const Rect& box, FILE* bb_file){  
  48.   //bb_file = fopen("bounding_boxes.txt","w");  
  49.   //Get Bounding Boxes  
  50.   //此函数根据传入的box（目标边界框）在传入的图像frame1中构建全部的扫描窗口，并计算重叠度  
  51.     buildGrid(frame1, box);  
  52.     printf("Created %d bounding boxes\n",(int)grid.size());  //vector的成员size()用于获取向量元素的个数  
  53.       
  54.   ///Preparation  
  55.   //allocation  
  56.   //积分图像，用以计算2bitBP特征（类似于haar特征的计算）  
  57.   //Mat的创建，方式有两种：1.调用create（行，列，类型）2.Mat（行，列，类型（值））。  
  58.   iisum.create(frame1.rows+1, frame1.cols+1, CV_32F);  
  59.   iisqsum.create(frame1.rows+1, frame1.cols+1, CV_64F);  
  60.     
  61.   //Detector data中定义：std::vector<float> dconf;  检测确信度？？  
  62.   //vector 的reserve增加了vector的capacity，但是它的size没有改变！而resize改变了vector  
  63.   //的capacity同时也增加了它的size！reserve是容器预留空间，但在空间内不真正创建元素对象，  
  64.   //所以在没有添加新的对象之前，不能引用容器内的元素。  
  65.   //不管是调用resize还是reserve，二者对容器原有的元素都没有影响。  
  66.   //myVec.reserve( 100 );     // 新元素还没有构造, 此时不能用[]访问元素  
  67.   //myVec.resize( 100 );      // 用元素的默认构造函数构造了100个新的元素，可以直接操作新元素  
  68.   dconf.reserve(100);  
  69.   dbb.reserve(100);  
  70.   bbox_step =7;  
  71.     
  72.   //以下在Detector data中定义的容器都给其分配grid.size()大小（这个是一幅图像中全部的扫描窗口个数）的容量  
  73.   //Detector data中定义TempStruct tmp;    
  74.   //tmp.conf.reserve(grid.size());  
  75.   tmp.conf = vector<float>(grid.size());  
  76.   tmp.patt = vector<vector<int> >(grid.size(), vector<int>(10,0));  
  77.   //tmp.patt.reserve(grid.size());  
  78.   dt.bb.reserve(grid.size());  
  79.   good_boxes.reserve(grid.size());  
  80.   bad_boxes.reserve(grid.size());  
  81.     
  82.   //TLD中定义：cv::Mat pEx;  //positive NN example 大小为15*15图像片  
  83.   pEx.create(patch_size, patch_size, CV_64F);  
  84.     
  85.   //Init Generator  
  86.   //TLD中定义：cv::PatchGenerator generator;  //PatchGenerator类用来对图像区域进行仿射变换  
  87.   /* 
  88.   cv::PatchGenerator::PatchGenerator (     
  89.       double     _backgroundMin, 
  90.       double     _backgroundMax, 
  91.       double     _noiseRange, 
  92.       bool     _randomBlur = true, 
  93.       double     _lambdaMin = 0.6, 
  94.       double     _lambdaMax = 1.5, 
  95.       double     _thetaMin = -CV_PI, 
  96.       double     _thetaMax = CV_PI, 
  97.       double     _phiMin = -CV_PI, 
  98.       double     _phiMax = CV_PI  
  99.    )  
  100.    一般的用法是先初始化一个PatchGenerator的实例，然后RNG一个随机因子，再调用（）运算符产生一个变换后的正样本。 
  101.   */  
  102.   generator = PatchGenerator (0,0,noise_init,true,1-scale_init,1+scale_init,-angle_init*CV_PI/180,  
  103.                                 angle_init*CV_PI/180,-angle_init*CV_PI/180,angle_init*CV_PI/180);  
  104.     
  105.   //此函数根据传入的box（目标边界框），在整帧图像中的全部窗口中寻找与该box距离最小（即最相似，  
  106.   //重叠度最大）的num_closest_init个窗口，然后把这些窗口 归入good_boxes容器  
  107.   //同时，把重叠度小于0.2的，归入 bad_boxes 容器  
  108.   //首先根据overlap的比例信息选出重复区域比例大于60%并且前num_closet_init= 10个的最接近box的RectBox，  
  109.   //相当于对RectBox进行筛选。并通过BBhull函数得到这些RectBox的最大边界。  
  110.   getOverlappingBoxes(box, num_closest_init);  
  111.   printf("Found %d good boxes, %d bad boxes\n",(int)good_boxes.size(),(int)bad_boxes.size());  
  112.   printf("Best Box: %d %d %d %d\n",best_box.x, best_box.y, best_box.width, best_box.height);  
  113.   printf("Bounding box hull: %d %d %d %d\n", bbhull.x, bbhull.y, bbhull.width, bbhull.height);  
  114.     
  115.   //Correct Bounding Box  
  116.   lastbox=best_box;  
  117.   lastconf=1;  
  118.   lastvalid=true;  
  119.   //Print  
  120.   fprintf(bb_file,"%d,%d,%d,%d,%f\n",lastbox.x,lastbox.y,lastbox.br().x,lastbox.br().y,lastconf);  
  121.     
  122.   //Prepare Classifier 准备分类器  
  123.   //scales容器里是所有扫描窗口的尺度，由buildGrid()函数初始化  
  124.   classifier.prepare(scales);  
  125.     
  126.   ///Generate Data  
  127.   // Generate positive data  
  128.   generatePositiveData(frame1, num_warps_init);  
  129.     
  130.   // Set variance threshold  
  131.   Scalar stdev, mean;  
  132.   //统计best_box的均值和标准差  
  133.   ////例如需要提取图像A的某个ROI（感兴趣区域，由矩形框）的话，用Mat类的B=img(ROI)即可提取  
  134.   //frame1(best_box)就表示在frame1中提取best_box区域（目标区域）的图像片  
  135.   meanStdDev(frame1(best_box), mean, stdev);  
  136.     
  137.   //利用积分图像去计算每个待检测窗口的方差  
  138.   //cvIntegral( const CvArr* image, CvArr* sum, CvArr* sqsum=NULL, CvArr* tilted_sum=NULL );  
  139.   //计算积分图像，输入图像，sum积分图像, W+1×H+1，sqsum对象素值平方的积分图像，tilted_sum旋转45度的积分图像  
  140.   //利用积分图像，可以计算在某象素的上－右方的或者旋转的矩形区域中进行求和、求均值以及标准方差的计算，  
  141.   //并且保证运算的复杂度为O(1)。    
  142.   integral(frame1, iisum, iisqsum);  
  143.   //级联分类器模块一：方差检测模块，利用积分图计算每个待检测窗口的方差，方差大于var阈值（目标patch方差的50%）的，  
  144.   //则认为其含有前景目标方差；var 为标准差的平方  
  145.   var = pow(stdev.val[0],2) * 0.5; //getVar(best_box,iisum,iisqsum);  
  146.   cout << "variance: " << var << endl;  
  147.     
  148.   //check variance  
  149.   //getVar函数通过积分图像计算输入的best_box的方差  
  150.   double vr =  getVar(best_box, iisum, iisqsum)*0.5;  
  151.   cout << "check variance: " << vr << endl;  
  152.     
  153.   // Generate negative data  
  154.   generateNegativeData(frame1);  
  155.     
  156.   //Split Negative Ferns into Training and Testing sets (they are already shuffled)  
  157.   //将负样本放进 训练和测试集  
  158.   int half = (int)nX.size()*0.5f;  
  159.   //vector::assign函数将区间[start, end)中的值赋值给当前的vector.  
  160.   //将一半的负样本集 作为 测试集  
  161.   nXT.assign(nX.begin()+half, nX.end());  //nXT; //negative data to Test  
  162.   //然后将剩下的一半作为训练集  
  163.   nX.resize(half);  
  164.     
  165.   ///Split Negative NN Examples into Training and Testing sets  
  166.   half = (int)nEx.size()*0.5f;  
  167.   nExT.assign(nEx.begin()+half,nEx.end());  
  168.   nEx.resize(half);  
  169.     
  170.   //Merge Negative Data with Positive Data and shuffle it  
  171.   //将负样本和正样本合并，然后打乱  
  172.   vector<pair<vector<int>,int> > ferns_data(nX.size()+pX.size());  
  173.   vector<int> idx = index_shuffle(0, ferns_data.size());  
  174.   int a=0;  
  175.   for (int i=0;i<pX.size();i++){  
  176.       ferns_data[idx[a]] = pX[i];  
  177.       a++;  
  178.   }  
  179.   for (int i=0;i<nX.size();i++){  
  180.       ferns_data[idx[a]] = nX[i];  
  181.       a++;  
  182.   }  
  183.     
  184.   //Data already have been shuffled, just putting it in the same vector  
  185.   vector<cv::Mat> nn_data(nEx.size()+1);  
  186.   nn_data[0] = pEx;  
  187.   for (int i=0;i<nEx.size();i++){  
  188.       nn_data[i+1]= nEx[i];  
  189.   }  
  190.     
  191.   ///Training    
  192.   //训练 集合分类器（森林） 和 最近邻分类器   
  193.   classifier.trainF(ferns_data, 2); //bootstrap = 2  
  194.   classifier.trainNN(nn_data);  
  195.     
  196.   ///Threshold Evaluation on testing sets  
  197.   //用样本在上面得到的 集合分类器（森林） 和 最近邻分类器 中分类，评价得到最好的阈值  
  198.   classifier.evaluateTh(nXT, nExT);  
  199. }  
  200.   
  201. /* Generate Positive data 
  202.  * Inputs: 
  203.  * - good_boxes (bbP) 
  204.  * - best_box (bbP0) 
  205.  * - frame (im0) 
  206.  * Outputs: 
  207.  * - Positive fern features (pX) 
  208.  * - Positive NN examples (pEx) 
  209.  */  
  210. void TLD::generatePositiveData(const Mat& frame, int num_warps){  
  211.     /* 
  212.     CvScalar定义可存放1—4个数值的数值，常用来存储像素，其结构体如下： 
  213.     typedef struct CvScalar 
  214.     { 
  215.         double val[4]; 
  216.     }CvScalar; 
  217.     如果使用的图像是1通道的，则s.val[0]中存储数据 
  218.     如果使用的图像是3通道的，则s.val[0]，s.val[1]，s.val[2]中存储数据 
  219.     */  
  220.   Scalar mean;   //均值  
  221.   Scalar stdev;   //标准差  
  222.     
  223.   //此函数将frame图像best_box区域的图像片归一化为均值为0的15*15大小的patch，存在pEx正样本中  
  224.   getPattern(frame(best_box), pEx, mean, stdev);  
  225.     
  226.   //Get Fern features on warped patches  
  227.   Mat img;  
  228.   Mat warped;  
  229.   //void GaussianBlur(InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0,   
  230.   //                                    int borderType=BORDER_DEFAULT ) ;  
  231.   //功能：对输入的图像src进行高斯滤波后用dst输出。  
  232.   //src和dst当然分别是输入图像和输出图像。Ksize为高斯滤波器模板大小，sigmaX和sigmaY分别为高斯滤  
  233.   //波在横向和竖向的滤波系数。borderType为边缘扩展点插值类型。  
  234.   //用9*9高斯核模糊输入帧，存入img  去噪？？  
  235.   GaussianBlur(frame, img, Size(9,9), 1.5);  
  236.     
  237.   //在img图像中截取bbhull信息（bbhull是包含了位置和大小的矩形框）的图像赋给warped  
  238.   //例如需要提取图像A的某个ROI（感兴趣区域，由矩形框）的话，用Mat类的B=img(ROI)即可提取  
  239.   warped = img(bbhull);  
  240.   RNG& rng = theRNG();  //生成一个随机数  
  241.   Point2f pt(bbhull.x + (bbhull.width-1)*0.5f, bbhull.y+(bbhull.height-1)*0.5f);  //取矩形框中心的坐标  int i(2)  
  242.     
  243.   //nstructs树木（由一个特征组构建，每组特征代表图像块的不同视图表示）的个数  
  244.   //fern[nstructs] nstructs棵树的森林的数组？？  
  245.   vector<int> fern(classifier.getNumStructs());  
  246.   pX.clear();  
  247.   Mat patch;  
  248.   
  249.   //pX为处理后的RectBox最大边界处理后的像素信息，pEx最近邻的RectBox的Pattern，bbP0为最近邻的RectBox。  
  250.   if (pX.capacity() < num_warps * good_boxes.size())  
  251.     pX.reserve(num_warps * good_boxes.size());  //pX正样本个数为 仿射变换个数 * good_box的个数，故需分配至少这么大的空间  
  252.   int idx;  
  253.   for (int i=0; i< num_warps; i++){  
  254.      if (i>0)  
  255.      //PatchGenerator类用来对图像区域进行仿射变换，先RNG一个随机因子，再调用（）运算符产生一个变换后的正样本。  
  256.        generator(frame, pt, warped, bbhull.size(), rng);  
  257.        for (int b=0; b < good_boxes.size(); b++){  
  258.          idx = good_boxes[b];  //good_boxes容器保存的是 grid 的索引  
  259.          patch = img(grid[idx]);  //把img的 grid[idx] 区域（也就是bounding box重叠度高的）这一块图像片提取出来  
  260.          //getFeatures函数得到输入的patch的用于树的节点，也就是特征组的特征fern（13位的二进制代码）  
  261.          classifier.getFeatures(patch, grid[idx].sidx, fern);  //grid[idx].sidx 对应的尺度索引  
  262.          pX.push_back(make_pair(fern, 1));   //positive ferns <features, labels=1>  正样本  
  263.      }  
  264.   }  
  265.   printf("Positive examples generated: ferns:%d NN:1\n",(int)pX.size());  
  266. }  
  267.   
  268. //先对最接近box的RectBox区域得到其patch ,然后将像素信息转换为Pattern，  
  269. //具体的说就是归一化RectBox对应的patch的size（放缩至patch_size = 15*15），将2维的矩阵变成一维的向量信息，  
  270. //然后将向量信息均值设为0，调整为zero mean and unit variance（ZMUV）  
  271. //Output: resized Zero-Mean patch  
  272. void TLD::getPattern(const Mat& img, Mat& pattern, Scalar& mean, Scalar& stdev){  
  273.   //将img放缩至patch_size = 15*15，存到pattern中  
  274.   resize(img, pattern, Size(patch_size, patch_size));  
  275.     
  276.   //计算pattern这个矩阵的均值和标准差  
  277.   //Computes a mean value and a standard deviation of matrix elements.  
  278.   meanStdDev(pattern, mean, stdev);  
  279.   pattern.convertTo(pattern, CV_32F);  
  280.     
  281.   //opencv中Mat的运算符有重载， Mat可以 + Mat; + Scalar; + int / float / double 都可以  
  282.   //将矩阵所有元素减去其均值，也就是把patch的均值设为零  
  283.   pattern = pattern - mean.val[0];  
  284. }  
  285.   
  286. /* Inputs: 
  287.  * - Image 
  288.  * - bad_boxes (Boxes far from the bounding box) 
  289.  * - variance (pEx variance) 
  290.  * Outputs 
  291.  * - Negative fern features (nX) 
  292.  * - Negative NN examples (nEx) 
  293.  */  
  294. void TLD::generateNegativeData(const Mat& frame){  
  295.   //由于之前重叠度小于0.2的，都归入 bad_boxes了，所以数量挺多，下面的函数用于打乱顺序，也就是为了  
  296.   //后面随机选择bad_boxes  
  297.   random_shuffle(bad_boxes.begin(), bad_boxes.end());//Random shuffle bad_boxes indexes  
  298.   int idx;  
  299.   //Get Fern Features of the boxes with big variance (calculated using integral images)  
  300.   int a=0;  
  301.   //int num = std::min((int)bad_boxes.size(),(int)bad_patches*100); //limits the size of bad_boxes to try  
  302.   printf("negative data generation started.\n");  
  303.   vector<int> fern(classifier.getNumStructs());  
  304.   nX.reserve(bad_boxes.size());  
  305.   Mat patch;  
  306.   for (int j=0;j<bad_boxes.size();j++){  //把方差较大的bad_boxes加入负样本  
  307.       idx = bad_boxes[j];  
  308.           if (getVar(grid[idx],iisum,iisqsum)<var*0.5f)  
  309.             continue;  
  310.       patch =  frame(grid[idx]);  
  311.       classifier.getFeatures(patch, grid[idx].sidx, fern);  
  312.       nX.push_back(make_pair(fern, 0)); //得到负样本  
  313.       a++;  
  314.   }  
  315.   printf("Negative examples generated: ferns: %d ", a);  
  316.     
  317.   //random_shuffle(bad_boxes.begin(),bad_boxes.begin()+bad_patches);//Randomly selects 'bad_patches' and get the patterns for NN;  
  318.   Scalar dum1, dum2;  
  319.   //bad_patches = (int)file["num_patches"]; 在参数文件中 num_patches = 100  
  320.   nEx=vector<Mat>(bad_patches);  
  321.   for (int i=0;i<bad_patches;i++){  
  322.       idx=bad_boxes[i];  
  323.       patch = frame(grid[idx]);  
  324.       //具体的说就是归一化RectBox对应的patch的size（放缩至patch_size = 15*15）  
  325.       //由于负样本不需要均值和方差，所以就定义dum，将其舍弃  
  326.       getPattern(patch,nEx[i],dum1,dum2);  
  327.   }  
  328.   printf("NN: %d\n",(int)nEx.size());  
  329. }  
  330.   
  331. //该函数通过积分图像计算输入的box的方差  
  332. double TLD::getVar(const BoundingBox& box, const Mat& sum, const Mat& sqsum){  
  333.   double brs = sum.at<int>(box.y+box.height, box.x+box.width);  
  334.   double bls = sum.at<int>(box.y+box.height, box.x);  
  335.   double trs = sum.at<int>(box.y,box.x + box.width);  
  336.   double tls = sum.at<int>(box.y,box.x);  
  337.   double brsq = sqsum.at<double>(box.y+box.height,box.x+box.width);  
  338.   double blsq = sqsum.at<double>(box.y+box.height,box.x);  
  339.   double trsq = sqsum.at<double>(box.y,box.x+box.width);  
  340.   double tlsq = sqsum.at<double>(box.y,box.x);  
  341.     
  342.   double mean = (brs+tls-trs-bls)/((double)box.area());  
  343.   double sqmean = (brsq+tlsq-trsq-blsq)/((double)box.area());  
  344.   //方差=E(X^2)-(EX)^2   EX表示均值  
  345.   return sqmean-mean*mean;  
  346. }  
  347.   
  348. void TLD::processFrame(const cv::Mat& img1,const cv::Mat& img2,vector<Point2f>& points1,vector<Point2f>& points2,BoundingBox& bbnext, bool& lastboxfound, bool tl, FILE* bb_file){  
  349.   vector<BoundingBox> cbb;  
  350.   vector<float> cconf;  
  351.   int confident_detections=0;  
  352.   int didx; //detection index  
  353.     
  354.   ///Track  跟踪模块  
  355.   if(lastboxfound && tl){   //tl: train and learn  
  356.       //跟踪   
  357.       track(img1, img2, points1, points2);  
  358.   }  
  359.   else{  
  360.       tracked = false;  
  361.   }  
  362.     
  363.   ///Detect   检测模块  
  364.   detect(img2);  
  365.     
  366.   ///Integration   综合模块  
  367.   //TLD只跟踪单目标，所以综合模块综合跟踪器跟踪到的单个目标和检测器检测到的多个目标，然后只输出保守相似度最大的一个目标  
  368.   if (tracked){  
  369.       bbnext=tbb;  
  370.       lastconf=tconf;   //表示相关相似度的阈值  
  371.       lastvalid=tvalid;  //表示保守相似度的阈值  
  372.       printf("Tracked\n");  
  373.       if(detected){                                               //   if Detected  
  374.           //通过 重叠度 对检测器检测到的目标bounding box进行聚类，每个类其重叠度小于0.5  
  375.           clusterConf(dbb, dconf, cbb, cconf);                       //   cluster detections  
  376.           printf("Found %d clusters\n",(int)cbb.size());  
  377.           for (int i=0;i<cbb.size();i++){  
  378.               //找到与跟踪器跟踪到的box距离比较远的类（检测器检测到的box），而且它的相关相似度比跟踪器的要大  
  379.               if (bbOverlap(tbb, cbb[i])<0.5 && cconf[i]>tconf){  //  Get index of a clusters that is far from tracker and are more confident than the tracker  
  380.                   confident_detections++;  //记录满足上述条件，也就是可信度比较高的目标box的个数  
  381.                   didx=i; //detection index  
  382.               }  
  383.           }  
  384.           //如果只有一个满足上述条件的box，那么就用这个目标box来重新初始化跟踪器（也就是用检测器的结果去纠正跟踪器）  
  385.           if (confident_detections==1){                                //if there is ONE such a cluster, re-initialize the tracker  
  386.               printf("Found a better match..reinitializing tracking\n");  
  387.               bbnext=cbb[didx];  
  388.               lastconf=cconf[didx];  
  389.               lastvalid=false;  
  390.           }  
  391.           else {  
  392.               printf("%d confident cluster was found\n", confident_detections);  
  393.               int cx=0,cy=0,cw=0,ch=0;  
  394.               int close_detections=0;  
  395.               for (int i=0;i<dbb.size();i++){  
  396.                   //找到检测器检测到的box与跟踪器预测到的box距离很近（重叠度大于0.7）的box，对其坐标和大小进行累加  
  397.                   if(bbOverlap(tbb,dbb[i])>0.7){                     // Get mean of close detections  
  398.                       cx += dbb[i].x;  
  399.                       cy +=dbb[i].y;  
  400.                       cw += dbb[i].width;  
  401.                       ch += dbb[i].height;  
  402.                       close_detections++;   //记录最近邻box的个数  
  403.                       printf("weighted detection: %d %d %d %d\n",dbb[i].x,dbb[i].y,dbb[i].width,dbb[i].height);  
  404.                   }  
  405.               }  
  406.               if (close_detections>0){  
  407.                   //对与跟踪器预测到的box距离很近的box 和 跟踪器本身预测到的box 进行坐标与大小的平均作为最终的  
  408.                   //目标bounding box，但是跟踪器的权值较大  
  409.                   bbnext.x = cvRound((float)(10*tbb.x+cx)/(float)(10+close_detections));   // weighted average trackers trajectory with the close detections  
  410.                   bbnext.y = cvRound((float)(10*tbb.y+cy)/(float)(10+close_detections));  
  411.                   bbnext.width = cvRound((float)(10*tbb.width+cw)/(float)(10+close_detections));  
  412.                   bbnext.height =  cvRound((float)(10*tbb.height+ch)/(float)(10+close_detections));  
  413.                   printf("Tracker bb: %d %d %d %d\n",tbb.x,tbb.y,tbb.width,tbb.height);  
  414.                   printf("Average bb: %d %d %d %d\n",bbnext.x,bbnext.y,bbnext.width,bbnext.height);  
  415.                   printf("Weighting %d close detection(s) with tracker..\n",close_detections);  
  416.               }  
  417.               else{  
  418.                 printf("%d close detections were found\n",close_detections);  
  419.   
  420.               }  
  421.           }  
  422.       }  
  423.   }  
  424.   else{                                       //   If NOT tracking  
  425.       printf("Not tracking..\n");  
  426.       lastboxfound = false;  
  427.       lastvalid = false;  
  428.       //如果跟踪器没有跟踪到目标，但是检测器检测到了一些可能的目标box，那么同样对其进行聚类，但只是简单的  
  429.       //将聚类的cbb[0]作为新的跟踪目标box（不比较相似度了？？还是里面已经排好序了？？），重新初始化跟踪器  
  430.       if(detected){                           //  and detector is defined  
  431.           clusterConf(dbb,dconf,cbb,cconf);   //  cluster detections  
  432.           printf("Found %d clusters\n",(int)cbb.size());  
  433.           if (cconf.size()==1){  
  434.               bbnext=cbb[0];  
  435.               lastconf=cconf[0];  
  436.               printf("Confident detection..reinitializing tracker\n");  
  437.               lastboxfound = true;  
  438.           }  
  439.       }  
  440.   }  
  441.   lastbox=bbnext;  
  442.   if (lastboxfound)  
  443.     fprintf(bb_file,"%d,%d,%d,%d,%f\n",lastbox.x,lastbox.y,lastbox.br().x,lastbox.br().y,lastconf);  
  444.   else  
  445.     fprintf(bb_file,"NaN,NaN,NaN,NaN,NaN\n");  
  446.       
  447.   ///learn 学习模块  
  448.   if (lastvalid && tl)  
  449.     learn(img2);  
  450. }  
  451.   
  452. /*Inputs: 
  453. * -current frame(img2), last frame(img1), last Bbox(bbox_f[0]). 
  454. *Outputs: 
  455. *- Confidence(tconf), Predicted bounding box(tbb), Validity(tvalid), points2 (for display purposes only) 
  456. */  
  457. void TLD::track(const Mat& img1, const Mat& img2, vector<Point2f>& points1, vector<Point2f>& points2){  
  458.     
  459.   //Generate points  
  460.   //网格均匀撒点（均匀采样），在lastbox中共产生最多10*10=100个特征点，存于points1  
  461.   bbPoints(points1, lastbox);  
  462.   if (points1.size()<1){  
  463.       printf("BB= %d %d %d %d, Points not generated\n",lastbox.x,lastbox.y,lastbox.width,lastbox.height);  
  464.       tvalid=false;  
  465.       tracked=false;  
  466.       return;  
  467.   }  
  468.   vector<Point2f> points = points1;  
  469.     
  470.   //Frame-to-frame tracking with forward-backward error cheking  
  471.   //trackf2f函数完成：跟踪、计算FB error和匹配相似度sim，然后筛选出 FB_error[i] <= median(FB_error) 和   
  472.   //sim_error[i] > median(sim_error) 的特征点（跟踪结果不好的特征点），剩下的是不到50%的特征点  
  473.   tracked = tracker.trackf2f(img1, img2, points, points2);  
  474.   if (tracked){  
  475.       //Bounding box prediction  
  476.       //利用剩下的这不到一半的跟踪点输入来预测bounding box在当前帧的位置和大小 tbb  
  477.       bbPredict(points, points2, lastbox, tbb);  
  478.       //跟踪失败检测：如果FB error的中值大于10个像素（经验值），或者预测到的当前box的位置移出图像，则  
  479.       //认为跟踪错误，此时不返回bounding box；Rect::br()返回的是右下角的坐标  
  480.       //getFB()返回的是FB error的中值  
  481.       if (tracker.getFB()>10 || tbb.x>img2.cols ||  tbb.y>img2.rows || tbb.br().x < 1 || tbb.br().y <1){  
  482.           tvalid =false; //too unstable prediction or bounding box out of image  
  483.           tracked = false;  
  484.           printf("Too unstable predictions FB error=%f\n", tracker.getFB());  
  485.           return;  
  486.       }  
  487.         
  488.       //Estimate Confidence and Validity  
  489.       //评估跟踪确信度和有效性  
  490.       Mat pattern;  
  491.       Scalar mean, stdev;  
  492.       BoundingBox bb;  
  493.       bb.x = max(tbb.x,0);  
  494.       bb.y = max(tbb.y,0);  
  495.       bb.width = min(min(img2.cols-tbb.x,tbb.width), min(tbb.width, tbb.br().x));  
  496.       bb.height = min(min(img2.rows-tbb.y,tbb.height),min(tbb.height,tbb.br().y));  
  497.       //归一化img2(bb)对应的patch的size（放缩至patch_size = 15*15），存入pattern  
  498.       getPattern(img2(bb),pattern,mean,stdev);  
  499.       vector<int> isin;  
  500.       float dummy;  
  501.       //计算图像片pattern到在线模型M的保守相似度  
  502.       classifier.NNConf(pattern,isin,dummy,tconf); //Conservative Similarity  
  503.       tvalid = lastvalid;  
  504.       //保守相似度大于阈值，则评估跟踪有效  
  505.       if (tconf>classifier.thr_nn_valid){  
  506.           tvalid =true;  
  507.       }  
  508.   }  
  509.   else  
  510.     printf("No points tracked\n");  
  511.   
  512. }  
  513.   
  514. //网格均匀撒点，box共10*10=100个特征点  
  515. void TLD::bbPoints(vector<cv::Point2f>& points, const BoundingBox& bb){  
  516.   int max_pts=10;  
  517.   int margin_h=0; //采样边界  
  518.   int margin_v=0;  
  519.   //网格均匀撒点  
  520.   int stepx = ceil((bb.width-2*margin_h)/max_pts);  //ceil返回大于或者等于指定表达式的最小整数  
  521.   int stepy = ceil((bb.height-2*margin_v)/max_pts);  
  522.   //网格均匀撒点，box共10*10=100个特征点  
  523.   for (int y=bb.y+margin_v; y<bb.y+bb.height-margin_v; y+=stepy){  
  524.       for (int x=bb.x+margin_h;x<bb.x+bb.width-margin_h;x+=stepx){  
  525.           points.push_back(Point2f(x,y));  
  526.       }  
  527.   }  
  528. }  
  529.   
  530. //利用剩下的这不到一半的跟踪点输入来预测bounding box在当前帧的位置和大小  
  531. void TLD::bbPredict(const vector<cv::Point2f>& points1,const vector<cv::Point2f>& points2,  
  532.                     const BoundingBox& bb1,BoundingBox& bb2)    {  
  533.   int npoints = (int)points1.size();  
  534.   vector<float> xoff(npoints);  //位移  
  535.   vector<float> yoff(npoints);  
  536.   printf("tracked points : %d\n", npoints);  
  537.   for (int i=0;i<npoints;i++){   //计算每个特征点在两帧之间的位移  
  538.       xoff[i]=points2[i].x - points1[i].x;  
  539.       yoff[i]=points2[i].y - points1[i].y;  
  540.   }  
  541.   float dx = median(xoff);   //计算位移的中值  
  542.   float dy = median(yoff);  
  543.   float s;  
  544.   //计算bounding box尺度scale的变化：通过计算 当前特征点相互间的距离 与 先前（上一帧）特征点相互间的距离 的  
  545.   //比值，以比值的中值作为尺度的变化因子  
  546.   if (npoints>1){  
  547.       vector<float> d;  
  548.       d.reserve(npoints*(npoints-1)/2);  //等差数列求和：1+2+...+(npoints-1)  
  549.       for (int i=0;i<npoints;i++){  
  550.           for (int j=i+1;j<npoints;j++){  
  551.           //计算 当前特征点相互间的距离 与 先前（上一帧）特征点相互间的距离 的比值（位移用绝对值）  
  552.               d.push_back(norm(points2[i]-points2[j])/norm(points1[i]-points1[j]));  
  553.           }  
  554.       }  
  555.       s = median(d);  
  556.   }  
  557.   else {  
  558.       s = 1.0;  
  559.   }  
  560.   
  561.   float s1 = 0.5*(s-1)*bb1.width;  
  562.   float s2 = 0.5*(s-1)*bb1.height;  
  563.   printf("s= %f s1= %f s2= %f \n", s, s1, s2);  
  564.     
  565.   //得到当前bounding box的位置与大小信息  
  566.   //当前box的x坐标 = 前一帧box的x坐标 + 全部特征点位移的中值（可理解为box移动近似的位移） - 当前box宽的一半  
  567.   bb2.x = round( bb1.x + dx - s1);  
  568.   bb2.y = round( bb1.y + dy -s2);  
  569.   bb2.width = round(bb1.width*s);  
  570.   bb2.height = round(bb1.height*s);  
  571.   printf("predicted bb: %d %d %d %d\n",bb2.x,bb2.y,bb2.br().x,bb2.br().y);  
  572. }  
  573.   
  574. void TLD::detect(const cv::Mat& frame){  
  575.   //cleaning  
  576.   dbb.clear();  
  577.   dconf.clear();  
  578.   dt.bb.clear();  
  579.   //GetTickCount返回从操作系统启动到现在所经过的时间  
  580.   double t = (double)getTickCount();  
  581.   Mat img(frame.rows, frame.cols, CV_8U);  
  582.   integral(frame,iisum,iisqsum);   //计算frame的积分图   
  583.   GaussianBlur(frame,img,Size(9,9),1.5);  //高斯模糊，去噪？  
  584.   int numtrees = classifier.getNumStructs();  
  585.   float fern_th = classifier.getFernTh(); //getFernTh()返回thr_fern; 集合分类器的分类阈值  
  586.   vector <int> ferns(10);  
  587.   float conf;  
  588.   int a=0;  
  589.   Mat patch;  
  590.   //级联分类器模块一：方差检测模块，利用积分图计算每个待检测窗口的方差，方差大于var阈值（目标patch方差的50%）的，  
  591.   //则认为其含有前景目标  
  592.   for (int i=0; i<grid.size(); i++){  //FIXME: BottleNeck 瓶颈  
  593.       if (getVar(grid[i],iisum,iisqsum) >= var){  //计算每一个扫描窗口的方差  
  594.           a++;  
  595.           //级联分类器模块二：集合分类器检测模块  
  596.           patch = img(grid[i]);  
  597.           classifier.getFeatures(patch,grid[i].sidx,ferns); //得到该patch特征（13位的二进制代码）  
  598.           conf = classifier.measure_forest(ferns);  //计算该特征值对应的后验概率累加值  
  599.           tmp.conf[i]=conf;   //Detector data中定义TempStruct tmp;   
  600.           tmp.patt[i]=ferns;  
  601.           //如果集合分类器的后验概率的平均值大于阈值fern_th（由训练得到），就认为含有前景目标  
  602.           if (conf > numtrees*fern_th){    
  603.               dt.bb.push_back(i);  //将通过以上两个检测模块的扫描窗口记录在detect structure中  
  604.           }  
  605.       }  
  606.       else  
  607.         tmp.conf[i]=0.0;  
  608.   }  
  609.   int detections = dt.bb.size();  
  610.   printf("%d Bounding boxes passed the variance filter\n",a);  
  611.   printf("%d Initial detection from Fern Classifier\n", detections);  
  612.     
  613.   //如果通过以上两个检测模块的扫描窗口数大于100个，则只取后验概率大的前100个  
  614.   if (detections>100){   //CComparator(tmp.conf)指定比较方式？？？  
  615.       nth_element(dt.bb.begin(), dt.bb.begin()+100, dt.bb.end(), CComparator(tmp.conf));  
  616.       dt.bb.resize(100);  
  617.       detections=100;  
  618.   }  
  619. //  for (int i=0;i<detections;i++){  
  620. //        drawBox(img,grid[dt.bb[i]]);  
  621. //    }  
  622. //  imshow("detections",img);  
  623.   if (detections==0){  
  624.         detected=false;  
  625.         return;  
  626.       }  
  627.   printf("Fern detector made %d detections ",detections);  
  628.     
  629.   //两次使用getTickCount()，然后再除以getTickFrequency()，计算出来的是以秒s为单位的时间（opencv 2.0 以前是ms）  
  630.   t=(double)getTickCount()-t;    
  631.   printf("in %gms\n", t*1000/getTickFrequency());  //打印以上代码运行使用的毫秒数  
  632.     
  633.   //  Initialize detection structure  
  634.   dt.patt = vector<vector<int> >(detections,vector<int>(10,0));        //  Corresponding codes of the Ensemble Classifier  
  635.   dt.conf1 = vector<float>(detections);                                //  Relative Similarity (for final nearest neighbour classifier)  
  636.   dt.conf2 =vector<float>(detections);                                 //  Conservative Similarity (for integration with tracker)  
  637.   dt.isin = vector<vector<int> >(detections,vector<int>(3,-1));        //  Detected (isin=1) or rejected (isin=0) by nearest neighbour classifier  
  638.   dt.patch = vector<Mat>(detections,Mat(patch_size,patch_size,CV_32F));//  Corresponding patches  
  639.   int idx;  
  640.   Scalar mean, stdev;  
  641.   float nn_th = classifier.getNNTh();  
  642.   //级联分类器模块三：最近邻分类器检测模块  
  643.   for (int i=0;i<detections;i++){                                         //  for every remaining detection  
  644.       idx=dt.bb[i];                                                       //  Get the detected bounding box index  
  645.       patch = frame(grid[idx]);  
  646.       getPattern(patch,dt.patch[i],mean,stdev);                //  Get pattern within bounding box  
  647.       //计算图像片pattern到在线模型M的相关相似度和保守相似度  
  648.       classifier.NNConf(dt.patch[i],dt.isin[i],dt.conf1[i],dt.conf2[i]);  //  Evaluate nearest neighbour classifier  
  649.       dt.patt[i]=tmp.patt[idx];  
  650.       //printf("Testing feature %d, conf:%f isin:(%d|%d|%d)\n",i,dt.conf1[i],dt.isin[i][0],dt.isin[i][1],dt.isin[i][2]);  
  651.       //相关相似度大于阈值，则认为含有前景目标  
  652.       if (dt.conf1[i]>nn_th){                                               //  idx = dt.conf1 > tld.model.thr_nn; % get all indexes that made it through the nearest neighbour  
  653.           dbb.push_back(grid[idx]);                                         //  BB    = dt.bb(:,idx); % bounding boxes  
  654.           dconf.push_back(dt.conf2[i]);                                     //  Conf  = dt.conf2(:,idx); % conservative confidences  
  655.       }  
  656.   }  
  657.   //打印检测到的可能存在目标的扫描窗口数（可以通过三个级联检测器的）  
  658.   if (dbb.size()>0){  
  659.       printf("Found %d NN matches\n",(int)dbb.size());  
  660.       detected=true;  
  661.   }  
  662.   else{  
  663.       printf("No NN matches found.\n");  
  664.       detected=false;  
  665.   }  
  666. }  
  667.   
  668. //作者已经用python脚本../datasets/evaluate_vis.py来完成算法评估功能，具体见README  
  669. void TLD::evaluate(){  
  670. }  
  671.   
  672. void TLD::learn(const Mat& img){  
  673.   printf("[Learning] ");  
  674.     
  675.   ///Check consistency  
  676.   //检测一致性   
  677.   BoundingBox bb;  
  678.   bb.x = max(lastbox.x,0);  
  679.   bb.y = max(lastbox.y,0);  
  680.   bb.width = min(min(img.cols-lastbox.x,lastbox.width),min(lastbox.width,lastbox.br().x));  
  681.   bb.height = min(min(img.rows-lastbox.y,lastbox.height),min(lastbox.height,lastbox.br().y));  
  682.   Scalar mean, stdev;  
  683.   Mat pattern;  
  684.   //归一化img(bb)对应的patch的size（放缩至patch_size = 15*15），存入pattern  
  685.   getPattern(img(bb), pattern, mean, stdev);  
  686.   vector<int> isin;  
  687.   float dummy, conf;  
  688.   //计算输入图像片（跟踪器的目标box）与在线模型之间的相关相似度conf  
  689.   classifier.NNConf(pattern,isin,conf,dummy);  
  690.   if (conf<0.5) {   //如果相似度太小了，就不训练  
  691.       printf("Fast change..not training\n");  
  692.       lastvalid =false;  
  693.       return;  
  694.   }  
  695.   if (pow(stdev.val[0], 2)< var){  //如果方差太小了，也不训练  
  696.       printf("Low variance..not training\n");  
  697.       lastvalid=false;  
  698.       return;  
  699.   }  
  700.   if(isin[2]==1){   //如果被被识别为负样本，也不训练  
  701.       printf("Patch in negative data..not traing");  
  702.       lastvalid=false;  
  703.       return;  
  704.   }  
  705.     
  706.   /// Data generation  样本产生  
  707.   for (int i=0;i<grid.size();i++){   //计算所有的扫描窗口与目标box的重叠度  
  708.       grid[i].overlap = bbOverlap(lastbox, grid[i]);  
  709.   }  
  710.   //集合分类器   
  711.   vector<pair<vector<int>,int> > fern_examples;  
  712.   good_boxes.clear();    
  713.   bad_boxes.clear();  
  714.   //此函数根据传入的lastbox，在整帧图像中的全部窗口中寻找与该lastbox距离最小（即最相似，  
  715.   //重叠度最大）的num_closest_update个窗口，然后把这些窗口 归入good_boxes容器（只是把网格数组的索引存入）  
  716.   //同时，把重叠度小于0.2的，归入 bad_boxes 容器  
  717.   getOverlappingBoxes(lastbox, num_closest_update);  
  718.   if (good_boxes.size()>0)  
  719.     generatePositiveData(img, num_warps_update);  //用仿射模型产生正样本（类似于第一帧的方法，但只产生10*10=100个）  
  720.   else{  
  721.     lastvalid = false;  
  722.     printf("No good boxes..Not training");  
  723.     return;  
  724.   }  
  725.   fern_examples.reserve(pX.size() + bad_boxes.size());  
  726.   fern_examples.assign(pX.begin(), pX.end());  
  727.   int idx;  
  728.   for (int i=0;i<bad_boxes.size();i++){  
  729.       idx=bad_boxes[i];  
  730.       if (tmp.conf[idx]>=1){   //加入负样本，相似度大于1？？相似度不是出于0和1之间吗？  
  731.           fern_examples.push_back(make_pair(tmp.patt[idx],0));  
  732.       }  
  733.   }  
  734.   //最近邻分类器   
  735.   vector<Mat> nn_examples;  
  736.   nn_examples.reserve(dt.bb.size()+1);  
  737.   nn_examples.push_back(pEx);  
  738.   for (int i=0;i<dt.bb.size();i++){  
  739.       idx = dt.bb[i];  
  740.       if (bbOverlap(lastbox,grid[idx]) < bad_overlap)  
  741.         nn_examples.push_back(dt.patch[i]);  
  742.   }  
  743.     
  744.   /// Classifiers update  分类器训练  
  745.   classifier.trainF(fern_examples,2);  
  746.   classifier.trainNN(nn_examples);  
  747.   classifier.show(); //把正样本库（在线模型）包含的所有正样本显示在窗口上  
  748. }  
  749.   
  750. //检测器采用扫描窗口的策略  
  751. //此函数根据传入的box（目标边界框）在传入的图像中构建全部的扫描窗口，并计算每个窗口与box的重叠度  
  752. void TLD::buildGrid(const cv::Mat& img, const cv::Rect& box){  
  753.   const float SHIFT = 0.1;  //扫描窗口步长为 宽高的 10%  
  754.   //尺度缩放系数为1.2 （0.16151*1.2=0.19381），共21种尺度变换  
  755.   const float SCALES[] = {0.16151,0.19381,0.23257,0.27908,0.33490,0.40188,0.48225,  
  756.                           0.57870,0.69444,0.83333,1,1.20000,1.44000,1.72800,  
  757.                           2.07360,2.48832,2.98598,3.58318,4.29982,5.15978,6.19174};  
  758.   int width, height, min_bb_side;  
  759.   //Rect bbox;  
  760.   BoundingBox bbox;  
  761.   Size scale;  
  762.   int sc=0;  
  763.     
  764.   for (int s=0; s < 21; s++){  
  765.     width = round(box.width*SCALES[s]);  
  766.     height = round(box.height*SCALES[s]);  
  767.     min_bb_side = min(height,width);  //bounding box最短的边  
  768.     //由于图像片（min_win 为15x15像素）是在bounding box中采样得到的，所以box必须比min_win要大  
  769.     //另外，输入的图像肯定得比 bounding box 要大了  
  770.     if (min_bb_side < min_win || width > img.cols || height > img.rows)  
  771.       continue;  
  772.     scale.width = width;  
  773.     scale.height = height;  
  774.     //push_back在vector类中作用为在vector尾部加入一个数据  
  775.     //scales在类TLD中定义：std::vector<cv::Size> scales;  
  776.     scales.push_back(scale);  //把该尺度的窗口存入scales容器，避免在扫描时计算，加快检测速度  
  777.     for (int y=1; y<img.rows-height; y+=round(SHIFT*min_bb_side)){  //按步长移动窗口  
  778.       for (int x=1; x<img.cols-width; x+=round(SHIFT*min_bb_side)){  
  779.         bbox.x = x;  
  780.         bbox.y = y;  
  781.         bbox.width = width;  
  782.         bbox.height = height;  
  783.         //判断传入的bounding box（目标边界框）与 传入图像中的此时窗口的 重叠度，  
  784.         //以此来确定该图像窗口是否含有目标  
  785.         bbox.overlap = bbOverlap(bbox, BoundingBox(box));  
  786.         bbox.sidx = sc;  //属于第几个尺度  
  787.         //grid在类TLD中定义：std::vector<BoundingBox> grid;  
  788.         //把本位置和本尺度的扫描窗口存入grid容器  
  789.         grid.push_back(bbox);  
  790.       }  
  791.     }  
  792.     sc++;  
  793.   }  
  794. }  
  795.   
  796. //此函数计算两个bounding box 的重叠度  
  797. //重叠度定义为 两个box的交集 与 它们的并集 的比  
  798. float TLD::bbOverlap(const BoundingBox& box1, const BoundingBox& box2){  
  799.   //先判断坐标，假如它们都没有重叠的地方，就直接返回0  
  800.   if (box1.x > box2.x + box2.width) { return 0.0; }  
  801.   if (box1.y > box2.y + box2.height) { return 0.0; }  
  802.   if (box1.x + box1.width < box2.x) { return 0.0; }  
  803.   if (box1.y + box1.height < box2.y) { return 0.0; }  
  804.   
  805.   float colInt =  min(box1.x + box1.width, box2.x + box2.width) - max(box1.x, box2.x);  
  806.   float rowInt =  min(box1.y + box1.height, box2.y + box2.height) - max(box1.y, box2.y);  
  807.   
  808.   float intersection = colInt * rowInt;  
  809.   float area1 = box1.width * box1.height;  
  810.   float area2 = box2.width * box2.height;  
  811.   return intersection / (area1 + area2 - intersection);  
  812. }  
  813.   
  814. //此函数根据传入的box1（目标边界框），在整帧图像中的全部窗口中寻找与该box1距离最小（即最相似，  
  815. //重叠度最大）的num_closest个窗口，然后把这些窗口 归入good_boxes容器（只是把网格数组的索引存入）  
  816. //同时，把重叠度小于0.2的，归入 bad_boxes 容器  
  817. void TLD::getOverlappingBoxes(const cv::Rect& box1,int num_closest){  
  818.   float max_overlap = 0;  
  819.   for (int i=0;i<grid.size();i++){  
  820.       if (grid[i].overlap > max_overlap) {  //找出重叠度最大的box  
  821.           max_overlap = grid[i].overlap;  
  822.           best_box = grid[i];         
  823.       }  
  824.       if (grid[i].overlap > 0.6){   //重叠度大于0.6的，归入 good_boxes  
  825.           good_boxes.push_back(i);  
  826.       }  
  827.       else if (grid[i].overlap < bad_overlap){  //重叠度小于0.2的，归入 bad_boxes  
  828.           bad_boxes.push_back(i);  
  829.       }  
  830.   }  
  831.   //Get the best num_closest (10) boxes and puts them in good_boxes  
  832.   if (good_boxes.size()>num_closest){  
  833.   //STL中的nth_element()方法找出一个数列中排名第n（下面为第num_closest）的那个数。这个函数运行后  
  834.   //在good_boxes[num_closest]前面num_closest个数都比他大，也就是找到最好的num_closest个box了  
  835.     std::nth_element(good_boxes.begin(), good_boxes.begin() + num_closest, good_boxes.end(), OComparator(grid));  
  836.     //重新压缩good_boxes为num_closest大小  
  837.     good_boxes.resize(num_closest);  
  838.   }  
  839.   //获取good_boxes 的 Hull壳，也就是窗口的边框  
  840.   getBBHull();  
  841. }  
  842.   
  843. //此函数获取good_boxes 的 Hull壳，也就是窗口（图像）的边框 bounding box  
  844. void TLD::getBBHull(){  
  845.   int x1=INT_MAX, x2=0;  //INT_MAX 最大的整形数  
  846.   int y1=INT_MAX, y2=0;  
  847.   int idx;  
  848.   for (int i=0;i<good_boxes.size();i++){  
  849.       idx= good_boxes[i];  
  850.       x1=min(grid[idx].x,x1);   //防止出现负数？？  
  851.       y1=min(grid[idx].y,y1);  
  852.       x2=max(grid[idx].x + grid[idx].width,x2);  
  853.       y2=max(grid[idx].y + grid[idx].height,y2);  
  854.   }  
  855.   bbhull.x = x1;  
  856.   bbhull.y = y1;  
  857.   bbhull.width = x2-x1;  
  858.   bbhull.height = y2 -y1;  
  859. }  
  860.   
  861. //如果两个box的重叠度小于0.5，返回false，否则返回true  
  862. bool bbcomp(const BoundingBox& b1,const BoundingBox& b2){  
  863.   TLD t;  
  864.     if (t.bbOverlap(b1,b2)<0.5)  
  865.       return false;  
  866.     else  
  867.       return true;  
  868. }  
  869.   
  870. int TLD::clusterBB(const vector<BoundingBox>& dbb,vector<int>& indexes){  
  871.   //FIXME: Conditional jump or move depends on uninitialised value(s)  
  872.   const int c = dbb.size();  
  873.   //1. Build proximity matrix  
  874.   Mat D(c,c,CV_32F);  
  875.   float d;  
  876.   for (int i=0;i<c;i++){  
  877.       for (int j=i+1;j<c;j++){  
  878.         d = 1-bbOverlap(dbb[i],dbb[j]);  
  879.         D.at<float>(i,j) = d;  
  880.         D.at<float>(j,i) = d;  
  881.       }  
  882.   }  
  883.   //2. Initialize disjoint clustering  
  884.  float L[c-1]; //Level  
  885.  int nodes[c-1][2];  
  886.  int belongs[c];  
  887.  int m=c;  
  888.  for (int i=0;i<c;i++){  
  889.     belongs[i]=i;  
  890.  }  
  891.  for (int it=0;it<c-1;it++){  
  892.  //3. Find nearest neighbor  
  893.      float min_d = 1;  
  894.      int node_a, node_b;  
  895.      for (int i=0;i<D.rows;i++){  
  896.          for (int j=i+1;j<D.cols;j++){  
  897.              if (D.at<float>(i,j)<min_d && belongs[i]!=belongs[j]){  
  898.                  min_d = D.at<float>(i,j);  
  899.                  node_a = i;  
  900.                  node_b = j;  
  901.              }  
  902.          }  
  903.      }  
  904.      if (min_d>0.5){  
  905.          int max_idx =0;  
  906.          bool visited;  
  907.          for (int j=0;j<c;j++){  
  908.              visited = false;  
  909.              for(int i=0;i<2*c-1;i++){  
  910.                  if (belongs[j]==i){  
  911.                      indexes[j]=max_idx;  
  912.                      visited = true;  
  913.                  }  
  914.              }  
  915.              if (visited)  
  916.                max_idx++;  
  917.          }  
  918.          return max_idx;  
  919.      }  
  920.   
  921.  //4. Merge clusters and assign level  
  922.      L[m]=min_d;  
  923.      nodes[it][0] = belongs[node_a];  
  924.      nodes[it][1] = belongs[node_b];  
  925.      for (int k=0;k<c;k++){  
  926.          if (belongs[k]==belongs[node_a] || belongs[k]==belongs[node_b])  
  927.            belongs[k]=m;  
  928.      }  
  929.      m++;  
  930.  }  
  931.  return 1;  
  932.   
  933. }  
  934.   
  935. //对检测器检测到的目标bounding box进行聚类  
  936. //聚类（Cluster）分析是由若干模式（Pattern）组成的，通常，模式是一个度量（Measurement）的向量，或者是多维空间中的  
  937. //一个点。聚类分析以相似性为基础，在一个聚类中的模式之间比不在同一聚类中的模式之间具有更多的相似性。  
  938. void TLD::clusterConf(const vector<BoundingBox>& dbb,const vector<float>& dconf,vector<BoundingBox>& cbb,vector<float>& cconf){  
  939.   int numbb =dbb.size();  
  940.   vector<int> T;  
  941.   float space_thr = 0.5;  
  942.   int c=1;    //记录 聚类的类个数  
  943.   switch (numbb){  //检测到的含有目标的bounding box个数  
  944.   case 1:  
  945.     cbb=vector<BoundingBox>(1,dbb[0]);  //如果只检测到一个，那么这个就是检测器检测到的目标  
  946.     cconf=vector<float>(1,dconf[0]);  
  947.     return;  
  948.     break;  
  949.   case 2:  
  950.     T =vector<int>(2,0);  
  951.     //此函数计算两个bounding box 的重叠度  
  952.     if (1 - bbOverlap(dbb[0],dbb[1]) > space_thr){  //如果只检测到两个box，但他们的重叠度小于0.5  
  953.       T[1]=1;  
  954.       c=2;  //重叠度小于0.5的box，属于不同的类  
  955.     }  
  956.     break;  
  957.   default:  //检测到的box数目大于2个，则筛选出重叠度大于0.5的  
  958.     T = vector<int>(numbb, 0);  
  959.     //stable_partition()重新排列元素，使得满足指定条件的元素排在不满足条件的元素前面。它维持着两组元素的顺序关系。  
  960.     //STL partition就是把一个区间中的元素按照某个条件分成两类。返回第二类子集的起点  
  961.     //bbcomp()函数判断两个box的重叠度小于0.5，返回false，否则返回true （分界点是重叠度：0.5）  
  962.     //partition() 将dbb划分为两个子集，将满足两个box的重叠度小于0.5的元素移动到序列的前面，为一个子集，重叠度大于0.5的，  
  963.     //放在序列后面，为第二个子集，但两个子集的大小不知道，返回第二类子集的起点  
  964.     c = partition(dbb, T, (*bbcomp));   //重叠度小于0.5的box，属于不同的类，所以c是不同的类别个数  
  965.     //c = clusterBB(dbb,T);  
  966.     break;  
  967.   }  
  968.     
  969.   cconf=vector<float>(c);   
  970.   cbb=vector<BoundingBox>(c);  
  971.   printf("Cluster indexes: ");  
  972.   BoundingBox bx;  
  973.   for (int i=0;i<c;i++){   //类别个数  
  974.       float cnf=0;  
  975.       int N=0,mx=0,my=0,mw=0,mh=0;  
  976.       for (int j=0;j<T.size();j++){  //检测到的bounding box个数  
  977.           if (T[j]==i){   //将聚类为同一个类别的box的坐标和大小进行累加  
  978.               printf("%d ",i);  
  979.               cnf=cnf+dconf[j];  
  980.               mx=mx+dbb[j].x;  
  981.               my=my+dbb[j].y;  
  982.               mw=mw+dbb[j].width;  
  983.               mh=mh+dbb[j].height;  
  984.               N++;  
  985.           }  
  986.       }  
  987.       if (N>0){   //然后求该类的box的坐标和大小的平均值，将平均值作为该类的box的代表  
  988.           cconf[i]=cnf/N;  
  989.           bx.x=cvRound(mx/N);  
  990.           bx.y=cvRound(my/N);  
  991.           bx.width=cvRound(mw/N);  
  992.           bx.height=cvRound(mh/N);  
  993.           cbb[i]=bx;  //返回的是聚类，每一个类都有一个代表的bounding box  
  994.       }  
  995.   }  
  996.   printf("\n");  
  997. }  
淘宝 军品 淘宝 军品
原创粉丝点击
热门IT博客
人工智能小说人工智能小说
员工生日提醒软件员工生日提醒软件
nexus 配置阿里云仓库
linux vi 搜索 下一个
java输出金字塔
ubuntu 14.04
windows微信聊天记录
网络销售香烟
单片机电子钟原理图
java中定义二维数组
薪酬数据分析报告
Mac可以装精简版w10
sql语句与语法
水仙花数java
sql中except的用法
cad图纸合并软件
pdf创建软件
sap数据分析
淘宝秒杀神器
玩具车遥控器软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 真人108做法 佗锂片 japanesepussyvideo jjjzzzx 兽人共夫np 特大号湃集 单位52岁会计 第章公交破萝莉 70福利 男主他活大器好疯甜的小肉酱 柠檬永久导航 cockyboy官网 二姑趴下了吃我的巨龙 91体检区1分钟 爸在开车 我在和妈全文阅读 男裸男无遮盖 91 最懂男人的利区 你轻一点儿 顶得太深了 好胀 h视动漫 japanhd日本母亲 www.6699xoxo.com 丝服制袜第一页在线 今晚姐随你弄视频 短集900合 www.caoj88.com 俄罗斯大姑娘大白b 视频 国内精品路线视频 cockyboys比较猛 杨幂解衣喂奶 安全看黄不付费 app香蕉 www.xj1.app香蕉下载 20阴的种类 动态dj动态 六年级女孩一步步脱给你看 japanwifexxxtube 194章-196章 奶奶怀孕 第1268章 再侵韩雪 www.8xea.com 2828电影电影网 日本人与黑人系列 www.tubemodel.com iapahesehurses小学生

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里