(学习笔记)第六章 非刚性人脸跟踪——annotation(标记)_非刚性人脸追踪

一、工具

非刚性人脸跟踪，也就是所谓的asm(active shape model)。

准备的材料，搜先到网站上下载标记用的图片和工具：

http://code.google.com/p/muct/downloads/list

1、下载图像数据文件即： muct-a-jpg-v1.tar.gz到 muct-e-jpg-v1.tar.gz即a,b,c,d,e五个压缩文件。例如直接在D盘根目录下解压会生成一个新的文件夹jpg，5个均解压后共3755张图片。

2、下载muct-landmarks-v1.tar.gz文件，将其加压到和图片同样的目录，这里采用解压到D盘的根目录。

3、下载Mastering OpenCV的随书代码（资料源内有)，第六章，Chapter6_NonRigidFaceTracking。

4、新建OpenCV工程，将annotate.cpp做为主程序，并将其用到的头文件和源文件引入到工程。在调试——命令行参数输入格式如下：

./annotate -m $mdir -d $odir 这里的$mdir是存储图像数据所在目录的文件的目录，$odir是要输出的 annotations.yaml文档的路径，该文档包含的数据是以ft_data对象存储的。

例如我输入的命令行参数为：./annotate -m D:/  -d D:/result_landmarks

二、知识普及：.

ASM是基于点分布的模型。点分布模型（Point Distribution Model,PDM)

ASM模型的建立的第一步就是标记图像的特征.

为建立表情完备的模型，训练集中的图像数目应为一百幅以上，且包含不同变化类型的人脸图像:

1)不同性别、年龄、长相尽可能具有代表性。

2)不同表情的图像

3)不同姿态的图像

为了得到最好的效果，图像集应当详细说明环境的类型（即身份，光照，到相机的距离，捕捉设备以及其他）

收集关于形状变化的信息，需要图像中相应的点的位置等信息，在脸部轮廓，以及眉毛，眼睛，鼻子，嘴巴的轮廓和瞳孔等位置的选取一定数目分布均匀的特征点，这样一来，每个形状都可以通过一组标定点来描述。特征点的选取奔着如下的选取原则：

1)一是关键特征点的选取就是那些肉眼直接分辨出的特征点。

2)二是这些特征点之间尽可能的均匀的分布一些特征点。

3)三是特征点的密度要适当使其能够表现形状的全貌和细节。

对于训练集的每幅图像，我们通过目测确定出每个点在形状中的位置，这个过程就叫做训练集的标定。能够准确的指定标定点的位置对于下面的整个过程是非常重要的。在形状标定上，每一幅图像的相应标定点的位置次序必须严格一致。比如，第一幅图像是逆时针顺序标定的，后面的所有图像必须按照一致的顺序进行，绝不能出现顺时针标定，并且每个点在人脸的相对位置也要始终保存一致，否则，也会影响模型的精确性。

幸运地是，对于MUCT数据库，我们不需要对每个图像进行特征点的标定，因为它已经给出了对外使用的接口，即特征点的坐标位置；

在muct-landmarks文件夹下存在四个文件：

1)muct76.shape       shape文件(www.milbo.users.sonic.net/stasm)

2)muct76.rda         R数据文件(www.r-project.org/)

3)muct76.csv       逗号分割值

4)muct76-opencv.csv 逗号分割值,针对opencv的坐标系即原点在左上方。

注意：这些文件的坐标系统和stasm使用的一样.(即(0,0)点在图像的中心，向左移动x增加，向上移动y增加。而一个例外是muct76-opencv.csv，这里的格式是opencv中的格式，即原点在左上方，向左移动x增加，向下移动y增加)

无效的点用坐标（0，0）标记，"无效的点”是那些被其他面部特征遮挡的点，这指得是鼻子后面或者脸侧面，这些特征点的位置不容易估计。相反的，头发或者眼镜后的特征点位置是通过标记者估计的。

因此任何坐标为(0,0)的点应当被忽视。无效的点只会出现在相机画面b和c上。除非你的程序知道如何处理这些无效的点，否者你应当只使用相机画面a,d,和e

Note that subjects 247 and 248 are identical twins. 注意:247和248是孪生双胞胎。

三、程序

运行程序效果如下：

为了方便下面的理解，我们将76个点的相对位置标记处理，由于点比较靠近，标记的效果不是太好，当然也可以通过人脸检测，人眼检测然后找到人眼矩形区域，然后在计算相对位置，接着放大图像，进行标记，这里为了简单，不再进行上述步骤：

下面我们分析一下代码以及实现:

1、ft_data.cpp

我们数据的导入，输出，以及简单处理和画出都是通过ft_data类来完成的，该类有如下的数据成员，用来存储操作的数据。（这里ft_data是face tracking data)

  vector<int> symmetry;                    //indices of symmetric points//对称点的索引,即vector<int>存储的是对称点的索引
  vector<Vec2i> connections;               //indices of connected points //存储的为联通点索引
  vector<string> imnames;                  //images//图像的名字
  vector<vector<Point2f> > points;         //points//图像中的点集

从左到右，第一个是原始图像，第二个是面部特征标记(76个点),第三个为用彩色标记出两边对称的点（symmery)，第四个是镜像图像(flip)，第五个是面部特征的连通性(connections)

1、symmetry；这里的vector<int> symmery;成员是存储的点值所在的索引，即0，1，2，3，.....75。例如，假如点p1在点序列（76个）中的位置为3，与之相对称的点p2(关于面部对称，类似与左眼和由于是对称的）在序列中的位置为15，那么symmery[2]存储是15，symmery[14]存储的为3.这需要我们在程序运行的时候，手动的点击图像上的点形成对称点。

2、connections；存储连通性，Vec2i类型为Vec<int, 2>存储两个整数对的容器。例如我们将一个正数对(23,15)存储到vector<Vec2i> connections中，利用Vec2i的构造函数构造一个Vec2i类型的对象  Vec2i     v2(23,15);然后利用connectons.pushback(v2);访问采用connections[0]获取Vec2i对象，然后connections[0][0]得到23,connections[0][1]得到15.

3、imnames；是存储的图像名字，（假设图像前几个图像不存在无效点）则：

imnames[0]==i000qa-fn

imnames[1]==i000qb-fn

imnames[2]==i000qc-fn......

4、points；是存储的点集，例如通过points[0]可以访问第一个图像的点集序列，点集中的顺序（容器中的位置顺序）是由加载的muct-landmarks文件夹下的 muct76-opencv.csv中的点的顺序决定的，这个顺序并不影响我们的使用。即一个图像有76个特征点，每个图像的特征点均是按照同样的相对位置进行排序的，例如我们看muct-landmarks文件夹下的muct76-opencv.csv，我们程序读取的时候就是对每个图像的76个点相对应的顺序读取的，如表格中第图像的i000qa-fn的第一个坐标为(x00,y00)=(201,348),然后我们可以通过points访问到该点，首先它是第一个图片（如果想上面提到的，它不存在无效的点，即被存储到了points中,如果为无效的点，则不会被存储到points中),通过points[0]访问到这个图像的点集序列,通过points[0][0]，访问到这个(x00,y00)，points[0][1]=(x01,y01)等等。

2、ft_data数据的生成

我们要理解ft_data数据成员的含义，最好的方法就是看看这些数据成员的数据是通过什么样的方式生成的。数据生成是通过annotations.cpp来实现的，该类在实现时，直接后跟着示例化了一个annotation对象。

annotation类的数据成员：

  int idx;                       //index of image to annotate//用来标记的图像索引
  int pidx;                      //index of point to manipulate//用来操作的点的索引，用来操作对称性
  Mat image;                     //current image to display //用来显示的当前图像
  Mat image_clean;               //clean image to display//用来显示的清新图像,原图像的副本
  ft_data data;                  //annotation data//标记数据
  const char* wname;             //display window name//显示的窗口名字
  vector<string> instructions;   //annotation instructions//操作说明，窗口左上角的提示

首先从annotation的主函数入手，即看一下ft_data类四个数据成员：symmetry ,connections,imnames,points 的数据形成过程：

1、部分main函数，完成的功能是读入csv文件中的数据，包括图像的名字和这些图像的特征点的位置，也即points点数据和imnames数据的形成的函数

  //parse cmd line options
  if(parse_help(argc,argv)){//检测命令行参数中是否输入了-h和-help即帮组指令
    cout << "usage: ./annotate [-v video] [-m muct_dir] [-d output_dir]" 
     << endl; return 0;
  }
  string odir = parse_odir(argc,argv);
  string ifile; int type = parse_ifile(argc,argv,ifile);//type==2表示输入的为MUCT数据，type==1表示输入的为视频文件
  string fname = odir + "annotations.yaml"; //file to save annotation data to//保存标记数据的文件
 
  //get data
  namedWindow(annotation.wname); //annotation这个为类定义时实例化了一个对象
  if(type == 2){ //MUCT data
    string lmfile = ifile + "muct-landmarks/muct76-opencv.csv";//ifile是muct-landmarks文件夹所在的根目录
    ifstream file(lmfile.c_str()); //lmfile表示landmarks文件
    if(!file.is_open()){
      cerr << "Failed opening " << lmfile << " for reading!" << endl; return 0;
    }
	//从csv文件中读取图片名和标记的坐标
    string str; getline(file,str);//获取文件流到string对象，获取csv文件中的第一行，不用抛弃
    while(!file.eof()){  //如果没有遇到文件结束符
      getline(file,str); if(str.length() == 0)break; //获取csv中的数据行，没有则break
      muct_data d(str,ifile); if(d.name.length() == 0)continue;
      annotation.data.imnames.push_back(d.name);//存储图像的名字
      annotation.data.points.push_back(d.points);//存储图像上特征点的坐标
    }
    file.close();
    annotation.data.rm_incomplete_samples();//去除不完整的样本
  }

说明：rm_imcomplete_sampes()函数用来去除下列条件的点：

1)图像中点的数目没有达到所有图像的中最多点的数目的图像。这里的用途就是去除点的数目小于76的图像的特征数据（或者说图像）

2)“无效的点”,即x和y至少有一个小于等于0的点。从相机b,c采集来的图像才存在这样的无效点，我们的程序可以处理这样的无效点。

该函数定义在ft_data.cpp文件夹下，是ft_data的成员函数。

//==============================================================================
void
ft_data::
rm_incomplete_samples()//去掉不完整的样本
{
  int n = points[0].size(),N = points.size();
  for(int i = 1; i < N; i++)n = max(n,int(points[i].size()));//从所有图像中找出最大点集数量，以此为参照
  for(int i = 0; i < int(points.size()); i++){
    if(int(points[i].size()) != n){//如果大小小于最大的，则移除掉
      points.erase(points.begin()+i); imnames.erase(imnames.begin()+i); i--;
    }else{//否则，相当于分类，在进行第二次过滤，将点集中坐标（x,y)两个有其一小于等于0的点的，即所谓的“无效点”
      int j = 0;
      for(; j < n; j++){
    if((points[i][j].x <= 0) || (points[i][j].y <= 0))break;
      }
      if(j < n){//移除“无效点”所在的点集和图片的路径
    points.erase(points.begin()+i); imnames.erase(imnames.begin()+i); i--;
      }
    }
  }
}
//==============================================================================

2、main函数中部分代码，connections数据的形成

 //annotate connectivity //标记连通性
  setMouseCallback(annotation.wname,pc_MouseCallback,0);//设置鼠标回调函数
  annotation.set_connectivity_instructions();
  annotation.set_current_image(0);
  annotation.draw_instructions();
  annotation.idx = 0;
  while(1){ annotation.draw_connections(); 
    imshow(annotation.wname,annotation.image); if(waitKey(0) == 'q')break;
  }
  save_ft(fname.c_str(),annotation.data); 

connections数据的形成主要是通过我们手动添加的。这里通过一个交互的方式来实现，即通过鼠标回调函数，该函数定义如下：

void pc_MouseCallback(int event, int x, int y, int /*flags*/, void* /*param*/)//pc 表示point connections点的连通
{ //这里Vec2i(first,second),first是指当前的点，second是其后的点。
  if(event == CV_EVENT_LBUTTONDOWN){//鼠标左键事件
    int imin = annotation.find_closest_point(Point2f(x,y));//鼠标点击位置最邻近的点，返回的是该点在点序列中的位置
    if(imin >= 0){ //add connection//增加连通
      int m = annotation.data.connections.size();//获取 vector<Vec2i> connections的大小
      if(m == 0)annotation.data.connections.push_back(Vec2i(imin,-1));//如果是第一个数据，压入两个点的序号，即第一个点与-1关联
      else{
    if(annotation.data.connections[m-1][1] < 0)//1st connecting point chosen,//选择最后一个连通点
      annotation.data.connections[m-1][1] = imin;//如果有一个关联到了,则修改(imin,-1)中的-1为现在的-1
    else annotation.data.connections.push_back(Vec2i(imin,-1));//没有关联则还是压入，imin，
      }
      annotation.draw_connections(); //画出连通性
      imshow(annotation.wname,annotation.image); //展示图像
    }
  }
}

说明:

1)该回调函数的理解，即也就是ft_data数据成员connection的形成过程，可以通过运行工程，手工操作亲自体验，不然不好理解。

2)find_closest_point(Point2f(x,y))是找到鼠标点击位置最临近的特征点，当然这个函数也有阈值约束的当如果发现对临近的距离小于10像素（为默认，当然你可以修改），则表示没有选中。

3)连通性的增加都是获取connections容器的最后一个来处理的。

if   (如果存在与鼠标所点位置匹配的特征点)
则  {
            获取所存连通性容器的最后一个连通关系；
           if(如果是第一次增加连通性)
           { 
               将当前该特征点和一个-1进行匹配——并将其存储到连通性容器中。
           }
           else  //不是第一次
           {
                if(如果最后容器中存储的最后一个点,匹配的是-1)
                 {
                     将容器中存储的最后一个特征点和当前该特征点匹配;//至少修改
                 }
                else//如果最后一个有了匹配
                {
                     将该当前特征点和-1匹配——并且将器存储到连通性容器中
                 }
 
                   画出连通性;
                   展示图像；
          }//end_else 
        
}//end_if

4)存在如下的情况：

1、第一次鼠标点击图像中的一个特征点，则也是第一次存储两个点的连通性，则存储一个<当前特征点,-1>的对象;

2、当第二次鼠标点击图像中的另外一个特征点时，算法找到先前的最后一个特征点，发现他没有匹配的，则修改为<上一次的特征点,当前特征点>

3、我们在想：1)连通性在connection容器中的创建没有先后顺序，即连通性对在容器中的位置没有约束。

                          2)如果我们上一次点击的特征点和这一次点击的特征点是同一个特征点如何处理？这里好像没有处理的（现在我还没发现)，其实没有相应的处理也是可以理解的,假如我们要连通两个点，即两个点之间有连线，如果还有一个点离着这两个点很近，如果我们不小心本应该连接a点和b点，结果连接成了a点和c点，因此程序无法判别我们的意图，所有在进行手工标记连通性时要格外的细心，如果不小心标错了，则重新运行程序标定。

我们可能会想对于:<特征点，-1>这样的连通性，它是怎么画出的呢？即我们看一下上面annotation.draw_connections()函数的实现：

  void
  draw_connections(){
    int m = data.connections.size();
    if(m == 0)this->draw_points();//如果没有连通性，则调用ft_data的draw_points只画出那些特征点
    else{
      if(data.connections[m-1][1] < 0){//如果该点没有下一个点
    int i = data.connections[m-1][0];//获取第一个点的位置。
    data.connections[m-1][1] = i;//将第一个点赋给第一个点，即本身，为了直接调用下面的画图函数
    data.draw_connect(image,idx); this->draw_points();
    circle(image,data.points[idx][i],1,CV_RGB(0,255,0),2,CV_AA);//用绿色标识最后一个点，
    data.connections[m-1][1] = -1;//画完后，在修改到起始数据，
      }else{data.draw_connect(image,idx); this->draw_points();}
    }
  }

说明:

其一,从上面的代码我们可以看出，将出现<特征点,-1>的情况时，它做了如下的处理即转换为<特征点,特征点(同样的)>即要画线的两个点是同一个点。

其二，该函数实际只是简单的处理一下输入的数据，相当于打包一下，实际的画图还是调用ft_data类的draw_conncect函数来完成。下面我们看一下ft_data::draw_connect函数：

void
ft_data::
draw_connect(Mat &im,//im画布
         const int idx,//图像的索引，也就是图像点集的索引
         const bool flipped,//我们在标记annotation.cpp初始化数据时，这里采用默认值，false
         const Scalar color,//默认值Scalar(255,0,0)
         const vector<int> &con)//默认值vector<int>()一个空对象
{
  if((idx < 0) || (idx >= (int)imnames.size()))return;
  int n = connections.size();//连通的大小
  if(con.size() == 0){    //我们调用时采用的为默认的参数的函数，con.size()==0
    for(int i = 0; i < n; i++){
      int j = connections[i][0],k = connections[i][1];//获取要连接的两个的位置
      if(!flipped)line(im,points[idx][j],points[idx][k],color,1);//如果不翻转，则直接画出，采用默认蓝色
      else{
    Point2f p(im.cols - 1 - points[idx][symmetry[j]].x,
          points[idx][symmetry[j]].y);
    Point2f q(im.cols - 1 - points[idx][symmetry[k]].x,
          points[idx][symmetry[k]].y);
    line(im,p,q,color,1);//如果翻转，则计算翻转后的点在画出
      }
	}
  }else{
    int m = con.size();
    for(int j = 0; j < m; j++){
      int i = con[j]; if((i < 0) || (i >= n))continue;
      int k = connections[i][0],l = connections[i][1];
      if(!flipped)line(im,points[idx][k],points[idx][l],color,1);
      else{
    Point2f p(im.cols - 1 - points[idx][symmetry[k]].x,
          points[idx][symmetry[k]].y);
    Point2f q(im.cols - 1 - points[idx][symmetry[l]].x,
          points[idx][symmetry[l]].y);
    line(im,p,q,color,1);
      }
    }
  }
}

说明:

我们在annotation.cpp中使用的是带有默认参数的draw_connect函数，即此时的con对象是一个空的，即我们只关心满足if(con.size()==0)的条件内的语句，即上面带有注释的语句。

3、main函数中symmetry 数据的生成

同样的symmetry数据的生成也是通过交互式界面，我们手动标记两个点的的对称型的，我们首先看一下在main函数中的代码:

//annotate symmetry//标记对称性
  setMouseCallback(annotation.wname,ps_MouseCallback,0);
  annotation.initialise_symmetry(0);
  annotation.set_symmetry_instructions();
  annotation.set_current_image(0);
  annotation.draw_instructions();
  annotation.idx = 0; annotation.pidx = -1;
  while(1){ annotation.draw_symmetry(); 
    imshow(annotation.wname,annotation.image); if(waitKey(0) == 'q')break;
  }
  save_ft(fname.c_str(),annotation.data); 

上述鼠标回调函数调用ps_MouseCallback()函数，该函数定义如下：

void ps_MouseCallback(int event, int x, int y, int /*flags*/, void* /*param*/)//ps 表示point symmetry点的对称
{ 
  if(event == CV_EVENT_LBUTTONDOWN){//监听左键事件
    int imin = annotation.find_closest_point(Point2f(x,y));//找到鼠标点击位置临近的点
    if(imin >= 0){//如果找到了
      if(annotation.pidx < 0)annotation.pidx = imin;//如果标记点的索引小于0，则把当前点的给标记点
      else{
    annotation.data.symmetry[annotation.pidx] = imin;//否则把当前点作为标记点的对称点
    annotation.data.symmetry[imin] = annotation.pidx;//并且将当前点的对称点设置为上一次标记的点
    annotation.pidx = -1;//完成一次点的匹配，回复到初始状态
      }      
      annotation.draw_symmetry(); 
      imshow(annotation.wname,annotation.image); 
	}//if
  }//if
}

说明：

上面程序完成的功能是存储与之对称的点的位置。例如vector<int> symmetry中，symmetry[0]的值是一点在序列中的相对位置，这里假设值为5，则(0,5)即为一对对称点，0和5是点在序列，或者说是容器中以0开始的相对位置。那么，symmetry[5]的结果自然就是0了。

附函数annotation.cpp中代码，带有部分注释:

/*****************************************************************************
*   Non-Rigid Face Tracking
******************************************************************************
*   by Jason Saragih, 5th Dec 2012
*   http://jsaragih.org/
******************************************************************************
*   Ch6 of the book "Mastering OpenCV with Practical Computer Vision Projects"
*   Copyright Packt Publishing 2012.
*   http://www.packtpub.com/cool-projects-with-opencv/book
*****************************************************************************/
/*
  annotate: annotation tool
  Jason Saragih (2012)
*/
#include "opencv_hotshots/ft/ft.hpp"
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
#include <fstream>
//==============================================================================
class annotate{
public:
  int idx;                       //index of image to annotate//用来标记的图像索引
  int pidx;                      //index of point to manipulate//用来操作的点的索引，用来操作对称性
  Mat image;                     //current image to display //用来显示的当前图像
  Mat image_clean;               //clean image to display//用来显示的清新图像,原图像的副本
  ft_data data;                  //annotation data//标记数据
  const char* wname;             //display window name//显示的窗口名字
  vector<string> instructions;   //annotation instructions//操作说明，窗口左上角的提示
  
  annotate(){wname = "Annotate"; idx = 0; pidx = -1;}//默认构造函数
 
  int
  set_current_image(const int idx = 0){
    if((idx < 0) || (idx > int(data.imnames.size())))return 0;
    image = data.get_image(idx,2); return 1;
  }
  void
  set_clean_image(){
    image_clean = image.clone();
  }
  void
  copy_clean_image(){
    image_clean.copyTo(image);
  }
  void
  draw_instructions(){
    if(image.empty())return;
    this->draw_strings(image,instructions);
  }
  void
  draw_points(){
    data.draw_points(image,idx);
  }
  void
  draw_chosen_point(){
    if(pidx >= 0)circle(image,data.points[idx][pidx],1,CV_RGB(0,255,0),2,CV_AA);
  }
  void
  draw_connections(){
    int m = data.connections.size();
    if(m == 0)this->draw_points();//如果没有连通性，则调用ft_data的draw_points只画出那些特征点
    else{
      if(data.connections[m-1][1] < 0){//如果该点没有下一个点
    int i = data.connections[m-1][0];//获取第一个点的位置。
    data.connections[m-1][1] = i;//将第一个点赋给第一个点，即本身，为了直接调用下面的画图函数
    data.draw_connect(image,idx); this->draw_points();
    circle(image,data.points[idx][i],1,CV_RGB(0,255,0),2,CV_AA);//用绿色标识最后一个点，
    data.connections[m-1][1] = -1;//画完后，在修改到起始数据，
      }else{data.draw_connect(image,idx); this->draw_points();}
    }
  }
  void
  draw_symmetry(){
    this->draw_points(); this->draw_connections();
    for(int i = 0; i < int(data.symmetry.size()); i++){
      int j = data.symmetry[i];
      if(j != i){
    circle(image,data.points[idx][i],1,CV_RGB(255,255,0),2,CV_AA);
    circle(image,data.points[idx][j],1,CV_RGB(255,255,0),2,CV_AA);
      }
    }
    if(pidx >= 0)circle(image,data.points[idx][pidx],1,CV_RGB(0,255,0),2,CV_AA);
  }
  void
  set_capture_instructions(){
    instructions.clear();
    instructions.push_back(string("Select expressive frames."));
    instructions.push_back(string("s - use this frame"));
    instructions.push_back(string("q - done"));
  }
  void
  set_pick_points_instructions(){
    instructions.clear();
    instructions.push_back(string("Pick Points"));
    instructions.push_back(string("q - done"));
  }
  void
  set_connectivity_instructions(){
    instructions.clear();
    instructions.push_back(string("Pick Connections"));
    instructions.push_back(string("q - done"));
  }
  void
  set_symmetry_instructions(){
    instructions.clear();
    instructions.push_back(string("Pick Symmetric Points"));
    instructions.push_back(string("q - done"));
  }
  void
  set_move_points_instructions(){
    instructions.clear();
    instructions.push_back(string("Move Points"));
    instructions.push_back(string("p - next image"));
    instructions.push_back(string("o - previous image"));
    instructions.push_back(string("q - done"));
  }
  void
  initialise_symmetry(const int index){
    int n = data.points[index].size(); data.symmetry.resize(n);
    for(int i = 0; i < n; i++)data.symmetry[i] = i;
  }
  void
  replicate_annotations(const int index){
    if((index < 0) || (index >= int(data.points.size())))return;
    for(int i = 0; i < int(data.points.size()); i++){
      if(i == index)continue;
      data.points[i] = data.points[index];
    }
  }
  int
  find_closest_point(const Point2f p,
             const double thresh = 10.0){
    int n = data.points[idx].size(),imin = -1; double dmin = -1;
    for(int i = 0; i < n; i++){
      double d = norm(p-data.points[idx][i]);
      if((imin < 0) || (d < dmin)){imin = i; dmin = d;}
    }
    if((dmin >= 0) && (dmin < thresh))return imin; else return -1;
  }
protected:
  void
  draw_strings(Mat img,
           const vector<string> &text){
    for(int i = 0; i < int(text.size()); i++)this->draw_string(img,text[i],i+1);
  }
  void
  draw_string(Mat img, 
          const string text,
          const int level)
  {
    Size size = getTextSize(text,FONT_HERSHEY_COMPLEX,0.6f,1,NULL);
    putText(img,text,Point(0,level*size.height),FONT_HERSHEY_COMPLEX,0.6f,
        Scalar::all(0),1,CV_AA);
    putText(img,text,Point(1,level*size.height+1),FONT_HERSHEY_COMPLEX,0.6f,
        Scalar::all(255),1,CV_AA);
  }
}annotation;
//==============================================================================
void pp_MouseCallback(int event, int x, int y, int /*flags*/, void* /*param*/)
{ 
  if(event == CV_EVENT_LBUTTONDOWN){
    annotation.data.points[0].push_back(Point2f(x,y));
    annotation.draw_points(); imshow(annotation.wname,annotation.image); 
  }
}
//==============================================================================
void pc_MouseCallback(int event, int x, int y, int /*flags*/, void* /*param*/)//pc 表示point connections点的连通
{ //这里Vec2i(first,second),first是指当前的点，second是其后的点。
  if(event == CV_EVENT_LBUTTONDOWN){//鼠标左键事件
    int imin = annotation.find_closest_point(Point2f(x,y));//找到点击的最临近的点在
    if(imin >= 0){ //add connection
      int m = annotation.data.connections.size();//获取 vector<Vec2i> connections的大小
      if(m == 0)annotation.data.connections.push_back(Vec2i(imin,-1));//如果是第一个数据，压入两个点的序号，即第一个点与-1关联
      else{
    if(annotation.data.connections[m-1][1] < 0)//1st connecting point chosen,//选择最后一个连通点
      annotation.data.connections[m-1][1] = imin;//如果有一个关联到了,则修改(imin,-1)中的-1为现在的-1
    else annotation.data.connections.push_back(Vec2i(imin,-1));//没有关联则还是压入，imin，
      }
      annotation.draw_connections(); //画出连通性
      imshow(annotation.wname,annotation.image); //展示图像
    }
  }
}
//==============================================================================
void ps_MouseCallback(int event, int x, int y, int /*flags*/, void* /*param*/)//ps 表示point symmetry点的对称
{ 
  if(event == CV_EVENT_LBUTTONDOWN){//监听左键事件
    int imin = annotation.find_closest_point(Point2f(x,y));//找到鼠标点击位置临近的点
    if(imin >= 0){//如果找到了
      if(annotation.pidx < 0)annotation.pidx = imin;//如果标记点的索引小于0，则把当前点的给标记点
      else{
    annotation.data.symmetry[annotation.pidx] = imin;//否则把当前点作为标记点的对称点
    annotation.data.symmetry[imin] = annotation.pidx;//并且将当前点的对称点设置为上一次标记的点
    annotation.pidx = -1;//完成一次点的匹配，回复到初始状态
      }      
      annotation.draw_symmetry(); 
      imshow(annotation.wname,annotation.image); 
	}//if
  }//if
}
//==============================================================================
void mv_MouseCallback(int event, int x, int y, int /*flags*/, void* /*param*/)
{ 
  if(event == CV_EVENT_LBUTTONDOWN){
    if(annotation.pidx < 0){
      annotation.pidx = annotation.find_closest_point(Point2f(x,y));
    }else annotation.pidx = -1;
    annotation.copy_clean_image();
    annotation.draw_connections();
    annotation.draw_chosen_point();
    imshow(annotation.wname,annotation.image); 
  }else if(event == CV_EVENT_MOUSEMOVE){
    if(annotation.pidx >= 0){
      annotation.data.points[annotation.idx][annotation.pidx] = Point2f(x,y);
      annotation.copy_clean_image();
      annotation.draw_connections();
      annotation.draw_chosen_point();
      imshow(annotation.wname,annotation.image); 
    }
  }
}
//==============================================================================
class muct_data{   //从来读取csv中数据的类，存储图片名字和索引，以及图片对应的点集
public:
  string name;              //图片的名字
  string index;            //图片的索引
  vector<Point2f> points;   //图片中特征点的坐标
 
  muct_data(string str,//str存储的为从流中读取的每一行
        string muct_dir){   //构造函数，这里muct_dir传入的是muct-landmarks文件夹所在的根目录，我这里为"D:/"
    size_t p1 = 0,p2;
    
    //set image directory//设置图像路径
    string idir = muct_dir; if(idir[idir.length()-1] != '/')idir += "/";//如果输入的路径后面没有"/",则加上"/"
    idir += "jpg/";//即这就是为什么要求注释工具文件夹muct-landmarks和jpg文件夹在同一目录。
 
    //get image name//获取图像的名字
    p2 = str.find(",");//寻找逗号的位置
    if(p2 == string::npos){cerr << "Invalid MUCT file" << endl; exit(0);}//如果没有找到则输出无效 muct file
    name = str.substr(p1,p2-p1);//从起始位置开始的到逗号之前的str的部分，即从0到','
  
    if((strcmp(name.c_str(),"i434xe-fn") == 0) || //corrupted data//损坏的数据
       (name[1] == 'r'))name = "";                //ignore flipped images//忽略翻转的图像
    else{
      name = idir + str.substr(p1,p2-p1) + ".jpg"; p1 = p2+1;//获取图像路径，并且获取图像名字的下一个位置
      
      //get index
      p2 = str.find(",",p1);//找到从p1开始的下一个逗号
      if(p2 == string::npos){cerr << "Invalid MUCT file" << endl; exit(0);}//如果没有找到，则说明是无效的数据，即没有坐标信息
      index = str.substr(p1,p2-p1); p1 = p2+1;
      
      //get points//获取点的坐标信息
      for(int i = 0; i < 75; i++){//0-74共75个
    p2 = str.find(",",p1);//p2用来存储','逗号的位置，p1用来存储逗号的下一个位置
    if(p2 == string::npos){cerr << "Invalid MUCT file" << endl; exit(0);}
    string x = str.substr(p1,p2-p1); p1 = p2+1;//获取x坐标
    p2 = str.find(",",p1);
    if(p2 == string::npos){cerr << "Invalid MUCT file" << endl; exit(0);}
    string y = str.substr(p1,p2-p1); p1 = p2+1;//获取y坐标
    points.push_back(Point2f(atoi(x.c_str()),atoi(y.c_str())));
      }
      p2 = str.find(",",p1);//最后一个单独处理
      if(p2 == string::npos){cerr << "Invalid MUCT file" << endl; exit(0);}
      string x = str.substr(p1,p2-p1); p1 = p2+1;
      string y = str.substr(p1,str.length()-p1);//最后一个不需要find逗号,
      points.push_back(Point2f(atoi(x.c_str()),atoi(y.c_str())));
    }
  }
};
//==============================================================================
bool
parse_help(int argc,char** argv)//检测是否输入了-h和-help指令
{
  for(int i = 1; i < argc; i++){
    string str = argv[i];
    if(str.length() == 2){if(strcmp(str.c_str(),"-h") == 0)return true;}
    if(str.length() == 6){if(strcmp(str.c_str(),"--help") == 0)return true;}
  }return false;
}
//==============================================================================
string 
parse_odir(int argc,char** argv)//parse从语法上分析，函数功能是找到命令行输入目的输出目录
{
  string odir = "data/";
  for(int i = 1; i < argc; i++){
    string str = argv[i];
    if(str.length() != 2)continue;
    if(strcmp(str.c_str(),"-d") == 0){
      if(argc > i+1){odir = argv[i+1]; break;}//寻找目的目录
    }
  }
  if(odir[odir.length()-1] != '/')odir += "/";//如果你输入的参数目录中的最后没有'/'则我们在后面追加一个，更安全
  return odir;
}
//==============================================================================
int 
parse_ifile(int argc,//从参数中寻找输入的文件名
        char** argv,
        string& ifile)
{
  for(int i = 1; i < argc; i++){
    string str = argv[i];
    if(str.length() != 2)continue;
    if(strcmp(str.c_str(),"-m") == 0){ //MUCT data//寻找明命令行中的-m，进而寻找到输入的命令行参数中要输入的muct数据的地址
      if(argc > i+1){ifile = argv[i+1]; return 2;}//找到了返回结束
    }
    if(strcmp(str.c_str(),"-v") == 0){ //video file 这里我们不用视频文件，所以略去
      if(argc > i+1){ifile = argv[i+1]; return 1;}
    }
  }
  ifile = ""; return 0;
}
//==============================================================================
int main(int argc,char** argv)
{
  //parse cmd line options
  if(parse_help(argc,argv)){//检测命令行参数中是否输入了-h和-help即帮组指令
    cout << "usage: ./annotate [-v video] [-m muct_dir] [-d output_dir]" 
     << endl; return 0;
  }
  string odir = parse_odir(argc,argv);
  string ifile; int type = parse_ifile(argc,argv,ifile);//type==2表示输入的为MUCT数据，type==1表示输入的为视频文件
  string fname = odir + "annotations.yaml"; //file to save annotation data to//保存标记数据的文件
 
  //get data
  namedWindow(annotation.wname); //annotation这个为类定义时实例化了一个对象
  if(type == 2){ //MUCT data
    string lmfile = ifile + "muct-landmarks/muct76-opencv.csv";//ifile是muct-landmarks文件夹所在的根目录
    ifstream file(lmfile.c_str()); //lmfile表示landmarks文件
    if(!file.is_open()){
      cerr << "Failed opening " << lmfile << " for reading!" << endl; return 0;
    }
	//从csv文件中读取图片名和标记的坐标
    string str; getline(file,str);//获取文件流到string对象，获取csv文件中的第一行，不用抛弃
    while(!file.eof()){  //如果没有遇到文件结束符
      getline(file,str); if(str.length() == 0)break; //获取csv中的数据行，没有则break
      muct_data d(str,ifile); if(d.name.length() == 0)continue;
      annotation.data.imnames.push_back(d.name);//存储图像的名字
      annotation.data.points.push_back(d.points);//存储图像上特征点的坐标
    }
    file.close();
    annotation.data.rm_incomplete_samples();//去除不完整的样本
  }else{
    //open video stream//我们的type==2，是处理的图片库不是视频文件，故这里略过
    VideoCapture cam; 
    if(type == 1)cam.open(ifile); else cam.open(0);
    if(!cam.isOpened()){
      cout << "Failed opening video file." << endl
       << "usage: ./annotate [-v video] [-m muct_dir] [-d output_dir]" 
       << endl; return 0;
    }
    //get images to annotate//获取图像用来标记
    annotation.set_capture_instructions();//初始化标记的instructions对象
    while(cam.get(CV_CAP_PROP_POS_AVI_RATIO) < 0.999999){
      Mat im,img; cam >> im; annotation.image = im.clone(); 
      annotation.draw_instructions();
      imshow(annotation.wname,annotation.image); int c = waitKey(10);
      if(c == 'q')break;
      else if(c == 's'){
    int idx = annotation.data.imnames.size(); char str[1024]; 
    if     (idx < 10)sprintf(str,"%s00%d.png",odir.c_str(),idx);
    else if(idx < 100)sprintf(str,"%s0%d.png",odir.c_str(),idx);
    else               sprintf(str,"%s%d.png",odir.c_str(),idx);
    imwrite(str,im); annotation.data.imnames.push_back(str);
    im = Scalar::all(255); imshow(annotation.wname,im); waitKey(10);
      }
	}
    if(annotation.data.imnames.size() == 0)return 0;
    annotation.data.points.resize(annotation.data.imnames.size());
 
    //annotate first image
    setMouseCallback(annotation.wname,pp_MouseCallback,0);
    annotation.set_pick_points_instructions();
    annotation.set_current_image(0);
    annotation.draw_instructions();
    annotation.idx = 0;
    while(1){ annotation.draw_points();
      imshow(annotation.wname,annotation.image); if(waitKey(0) == 'q')break;
    }
    if(annotation.data.points[0].size() == 0)return 0;
    annotation.replicate_annotations(0);
  }
 
 
  //从这里开始，上面的属于处理视频图像的
  save_ft(fname.c_str(),annotation.data);
  
  //annotate connectivity //标记连通性
  setMouseCallback(annotation.wname,pc_MouseCallback,0);//设置鼠标回调函数
  annotation.set_connectivity_instructions();
  annotation.set_current_image(0);
  annotation.draw_instructions();
  annotation.idx = 0;
  while(1){ annotation.draw_connections(); 
    imshow(annotation.wname,annotation.image); if(waitKey(0) == 'q')break;
  }
  save_ft(fname.c_str(),annotation.data); 
 
  //annotate symmetry//标记连通性
  setMouseCallback(annotation.wname,ps_MouseCallback,0);
  annotation.initialise_symmetry(0);
  annotation.set_symmetry_instructions();
  annotation.set_current_image(0);
  annotation.draw_instructions();
  annotation.idx = 0; annotation.pidx = -1;
  while(1){ annotation.draw_symmetry(); 
    imshow(annotation.wname,annotation.image); if(waitKey(0) == 'q')break;
  }
  save_ft(fname.c_str(),annotation.data); 
 
  //annotate the rest
  if(type != 2){
    setMouseCallback(annotation.wname,mv_MouseCallback,0);
    annotation.set_move_points_instructions();
    annotation.idx = 1; annotation.pidx = -1;
    while(1){
      annotation.set_current_image(annotation.idx);
      annotation.draw_instructions();
      annotation.set_clean_image();
      annotation.draw_connections();
      imshow(annotation.wname,annotation.image); 
      int c = waitKey(0);
      if     (c == 'q')break;
      else if(c == 'p'){annotation.idx++; annotation.pidx = -1;}
      else if(c == 'o'){annotation.idx--; annotation.pidx = -1;}
      if(annotation.idx < 0)annotation.idx = 0;
      if(annotation.idx >= int(annotation.data.imnames.size()))
    annotation.idx = annotation.data.imnames.size()-1;
    }
  }
  save_ft(fname.c_str(),annotation.data); destroyWindow("Annotate"); return 0;
}
//==============================================================================