非刚性人脸跟踪 —— 人脸跟踪

　　人脸跟踪问题可认为是寻找一种高效和鲁棒性的方法，它能将各种面部特征的单独检测与这些特征的几何依赖性结合起来，已得到连续帧中每幅图像面部特征位置的精确估计。基于此，需仔细考虑几何依赖性的必要性。下图为用几何约束和不用几何约束所检测出来的面部特征。

　　　　

　　该结果清楚地说明利用空间上面部特征的相互依赖性非常有好处。两种方法的相对性能会因检测结果噪声过多而受影响，其原因在于对于每一个每一个面部特征的响应矩阵达到最大值时并不总是在正确的位置。但面部特征检测器要解决因图象噪声、光照变化、表情变化等带来的问题，仅有的方法是利用特征之间彼此共享的几何关系。

　　有一个特别简单，但非常有效的方法可将面部几何依赖加到跟踪过程中，该方法将人脸特征提取的结果投影到形状模型的线性子空间(shape model)，也就是最小化原始点集到其在人脸子空间最接近合理形状分布的投影点集的距离。（就是说，把通过模版匹配检测到的原始点集 A 投影到人脸子空间产生新的点集 B，再按照某种约束规则，通过对 A 迭代变化，使得 A’到 B 的距离最小）。

 

一、人脸跟踪实现

　　人脸跟踪算法的实现可以在 face_tracker 类中找到（见 face_tracker.cpp 和 face_tracker.hpp 文件）。下面这段代码来自其头文件，这展示了该类的主要功能：

class face_tracker{                        //face tracking class
public:
  bool tracking;                           //are we in tracking mode?
  fps_timer timer;                         // 用来保存帧速率的变化
  vector<Point2f> points;                  //current tracked points
  face_detector detector;                  //detector for initialisation
  shape_model smodel;                      //shape model
  patch_models pmodel;                     //feature detectors
  
  face_tracker(){tracking = false;}

  int                                      //0 = failure
  track(const Mat &im,                     //image containing face
    const face_tracker_params &p =     //fitting parameters 
    face_tracker_params());            //default tracking parameters

  void 
  reset(){                                 //reset tracker 
    tracking = false; timer.reset();
  }
  ....
protected:
  vector<Point2f>                          //points for fitted face in image
  fit(const Mat &image,                    //image containing face
      const vector<Point2f> &init,         //initial point estimates
      const Size ssize = Size(21,21),      //search region size
      const bool robust = false,           //use robust fitting?
      const int itol = 10,                 //maximum number of iterations to try
      const float ftol = 1e-3);            //convergence tolerance
};

 

 

 

　　face_tracker::track 函数，有两种功能。当 traking 标志位为 false 时，程序属于构建模型（detectmode）阶段，为第一帧或下一帧图像初始化的人脸特征，所用技术就是上面上一节所讲的；当 tracking 标志位为 true 时，则根据上一帧人脸特征点的位置估计下一帧的人脸特征，这个操作主要由 fit 函数完成。代码如下：

int
face_tracker::
track(const Mat &im,const face_tracker_params &p)
{
  //convert image to greyscale
  Mat gray; if(im.channels()==1)gray = im; else cvtColor(im,gray,CV_RGB2GRAY);

  //initialise，为第一帧或下一帧初始化人脸特征
  if(!tracking)
    points = detector.detect(gray,p.scaleFactor,p.minNeighbours,p.minSize);
  if((int)points.size() != smodel.npts())return 0;

  //fit，通过迭代缩小的搜索范围，估计当前帧中的人脸特征点
  for(int level = 0; level < int(p.ssize.size()); level++)
    points = this->fit(gray,points,p.ssize[level],p.robust,p.itol,p.ftol);

  //set tracking flag and increment timer
  tracking = true; timer.increment();  return 1;
}

 

　　face_tracker::fit 函数的主要功能：给定一帧图像及上一帧人脸特征点集，在当前图像上搜索该点集附近的人脸特征，并产生新的人脸特征点集。

vector<Point2f>
face_tracker::
fit(const Mat &image,                // 当前帧灰度图像
    const vector<Point2f> &init,    // 上一帧人脸特征点集（几何位置）
    const Size ssize,                // 搜索区域大小
    const bool robust,                // 标志位，决定是否采用 robustmodel fitting 流程，应对人脸特征的孤立点
    const int itol,                    // robustmodel fitting 迭代上限
    const float ftol)                // 迭代收敛判断阈值
{
  int n = smodel.npts();    // number of points int the shape model
  assert((int(init.size())==n) && (pmodel.n_patches()==n));
  smodel.calc_params(init); vector<Point2f> pts = smodel.calc_shape();

  //find facial features in image around current estimates
  vector<Point2f> peaks = pmodel.calc_peaks(image,pts,ssize);

  //optimise
  if(!robust){
    smodel.calc_params(peaks); //compute shape model parameters        
    pts = smodel.calc_shape(); //update shape
  }else{
    Mat weight(n,1,CV_32F),weight_sort(n,1,CV_32F);
    vector<Point2f> pts_old = pts;
    for(int iter = 0; iter < itol; iter++){
      //compute robust weight
      for(int i = 0; i < n; i++)weight.fl(i) = norm(pts[i] - peaks[i]);
      cv::sort(weight,weight_sort,CV_SORT_EVERY_COLUMN|CV_SORT_ASCENDING);
      double var = 1.4826*weight_sort.fl(n/2); if(var < 0.1)var = 0.1;
      pow(weight,2,weight); weight *= -0.5/(var*var); cv::exp(weight,weight); 

      //compute shape model parameters    
      smodel.calc_params(peaks,weight);
      
      //update shape
      pts = smodel.calc_shape();
      
      //check for convergence
      float v = 0; for(int i = 0; i < n; i++)v += norm(pts[i]-pts_old[i]);
      if(v < ftol)break; else pts_old = pts;
    }
  }return pts;
}

 

 

　　上面代码中，有两个函数：

• •  shape_model::calc_param，为了得到合理的人脸总空间投影，我们需要求参数向量 p，该函数通过人脸子空间投影坐标集合 pts 与人脸特征空间标准基 V，计算得到参数向量

    void 
    shape_model::
    calc_params(const vector<Point2f> &pts,const Mat weight,const float c_factor)
    {
      int n = pts.size(); assert(V.rows == 2*n);
      Mat s = Mat(pts).reshape(1,2*n); //point set to vector format
      if(weight.empty())p = V.t()*s;   //simple projection
      else{                            //scaled projection
        if(weight.rows != n){cout << "Invalid weighting matrix" << endl; abort();}
        int K = V.cols; Mat H = Mat::zeros(K,K,CV_32F),g = Mat::zeros(K,1,CV_32F);
        for(int i = 0; i < n; i++){
          Mat v = V(Rect(0,2*i,K,2)); float w = weight.fl(i);
          H += w*v.t()*v; g += w*v.t()*Mat(pts[i]);
        }
        solve(H,g,p,DECOMP_SVD);
      }this->clamp(c_factor);          //clamp resulting parameters
    }

     

  •  shape_model::calc_peaks，根据人脸子空间点集在当前图像内搜索人脸特征，并产生新的人脸特征位置估计

    vector<Point2f> 
    patch_models::
    calc_peaks(const Mat &im,                // 当前包含人脸的灰度图像
           const vector<Point2f> &points,    // 前一帧估计的人脸特征点集在人脸子空间投影坐标集合
           const Size ssize)                // 搜索区域大小
    {    
      int n = points.size(); assert(n == int(patches.size()));
      Mat pt = Mat(points).reshape(1,2*n);
      Mat S = this->calc_simil(pt);        // 计算当前点集到人脸参考模型的变化矩阵
      Mat Si = this->inv_simil(S);        // 对矩阵 S 求逆
      // 人脸子空间坐标经过仿射变换转成图像空间中的坐标
      vector<Point2f> pts = this->apply_simil(Si,points);
      for(int i = 0; i < n; i++){
        Size wsize = ssize + patches[i].patch_size(); Mat A(2,3,CV_32F);     
        A.fl(0,0) = S.fl(0,0); A.fl(0,1) = S.fl(0,1);
        A.fl(1,0) = S.fl(1,0); A.fl(1,1) = S.fl(1,1);
        A.fl(0,2) = pt.fl(2*i  ) - 
          (A.fl(0,0) * (wsize.width-1)/2 + A.fl(0,1)*(wsize.height-1)/2);
        A.fl(1,2) = pt.fl(2*i+1) - 
          (A.fl(1,0) * (wsize.width-1)/2 + A.fl(1,1)*(wsize.height-1)/2);
        Mat I; warpAffine(im,I,A,wsize,INTER_LINEAR+WARP_INVERSE_MAP);
        // 搜索人脸特征的匹配位置
        Mat R = patches[i].calc_response(I,false);
        Point maxLoc; minMaxLoc(R,0,0,0,&maxLoc);
        // 修正人脸特征估计点位置
        pts[i] = Point2f(pts[i].x + maxLoc.x - 0.5*ssize.width,
                 pts[i].y + maxLoc.y - 0.5*ssize.height);
      }
      // 再次将图像中的坐标投影到人脸特征子空间中，作为下一帧特征估计点位置
      return this->apply_simil(S,pts);
    }

     

 

　　在对每帧图像进行人脸跟踪时，track 函数都会通过 fit 函数迭代产生多个人脸子空间坐标集合，并且每次迭代的时候，搜索区域都在减小。在迭代过程中，可能会产生很多孤立的特征点（错误估计点）。为了得到更精确的人脸跟踪效果，如果存在孤立点时，仍采用简单投影，会严重影响跟踪效果。因此，在计算投影参数 calc_param 时引入了权重，搞了一套 robust model fitting 流程，特意去除孤立点。

 

 

二、训练与可视化

　　训练一个 face_tracker 对象不会涉及任何的学习过程。在 train_face_tracker.cpp 中简单实现了该功能，代码如下：

//create face tracker model
face_tracker tracker;
tracker.smodel = load_ft<shape_model>(argv[1]);        // 加载 shape_model 对象
tracker.pmodel = load_ft<patch_models>(argv[2]);        // 加载 patch_model 对象
tracker.detector = load_ft<face_detector>(argv[3]);    // 加载 face_detector 对象
  
//save face tracker
save_ft<face_tracker>(argv[4],tracker);                // 保存 face_tracker 对象

 

 

 

　　将 face_tracker 对象保存到 tracker_model.yaml 中，如下：

　　　　

 

　　在 visualize_face_tracker.cpp 文件中，可视化程序将 cv::VideoCapture 类从摄像机或视频文件的图像流作为输入，该程序有一个简单的循环，该循环在读到图像流最后或用户按 Q 键就会终止，否则就会跟踪出现的每一帧。用户随时可按 D 键来重置跟踪选项。主要代码如下：

while(cam.get(CV_CAP_PROP_POS_AVI_RATIO) < 0.999999){
Mat im; cam >> im; 
if(tracker.track(im,p))tracker.draw(im);
draw_string(im,"d - redetection");
tracker.timer.display_fps(im,Point(1,im.rows-1));
imshow("face tracker",im);
int c = waitKey(10);
if(c == 'q')break;
else if(c == 'd')tracker.reset();
}

 

 

　　运行效果如下：

　　　　　　

 

 

 

　　　Ending ！！！