C++实现人脸渐变算法

立即下载用AI写一个

发布时间：2018-11-06

14人 | 浏览：7174次 | 收藏 |

技术：C++，CImg，dlib

概述

输入两张人脸图像，根据Image Morphing的方法完成中间 11 帧的差值，得到一张人脸渐变的动图。

详细

#### 项目要求
输入图像是两张人脸图像, 根据 Image Morphing 的方法完成中间 11 帧的差值, 得到一个人脸渐变的动图。
##### 输入
两张人脸图片
<image src="/contentImages/image/20180721/1ZCRSzWNCf9YbqAxbFu.jpg"></image><image src="/contentImages/image/20180721/gzlF9L8kG5Z5ubckbOG.jpg"></image>

##### 输出
人脸渐变的gif
![](/contentImages/image/20181106/LlV6BqWAYUadpYs0bWO.gif)

#### 项目结构
项目使用了`CImg`进行图像处理，使用`dlib`进行人脸训练，得到人脸的68个特征点，项目完整的目录结构如下：
```
Morphing
├── bin        // 编译过程中的obj文件
├── CImg库参考手册.pdf
├── dlib      // dlib 库
├── dlib下载地址.txt      // dlib库较大，里面有百度云链接
├── Image       // 输入和输出
│   ├── a.bmp
│   ├── b.bmp
│   └── result.gif
├── Makefile
├── Morphing    // 可执行文件
├── shape_predictor_68_face_landmarks.dat  // 人脸训练数据集
└── src  // 源码
    ├── CImg.h
    ├── delaunay.cpp
    ├── delaunay.h
    ├── edge.h
    ├── main.cpp
    ├── morphing.cpp
    ├── morphing.h
    ├── point.h
    ├── triangle.cpp
    └── triangle.h
```

#### 程序运行
推荐在Linux下运行，WIndows下需要依赖VS，过程繁琐。Linux下依赖X11，如果编译提示找不到`X11/Xlib.h`，需要先安装`libx11-dev`。Ubuntu下安装命令为`sudo apt-get install libx11-dev`，其他发行版软件名不一定是这个，可自行百度报错的原因安装对应的X11。

1. 下载dlib，解压到项目文件夹下，按照上面的目录结构放置；
2. 如果缺少X11，先安装
3. 编译，`make -j8`，生成可执行文件`Morphing`，项目较大，编译过程请耐心等待
4. 运行 `./Morphing`
5. 运行过程会显示中间过程的图片，如果不想显示，可以注释`src/morphing.cpp`文件中的含有`display()`的语句。
6. 输入图片为a.bmp和b.bmp，运行后会生成10张中间过程的图片和渐变的gif。

#### 实验方法
- 分别对原图像和目标图像进行人脸特征点标记（使用dlib库）
- 使用 F = α A + (1- α) B 求出中间过渡图像的特征点对应的坐标
- 对中间过渡图像的特征点进行三角剖分（Bowyer Watson算法）
- 根据剖分后的三角形，求出它在原图像和目标图像中对应的三角形（记录三角形顶点对应的下标）
- 分别计算中间过渡图像的每个三角形到原图像和目标图像的变换矩阵
- 对于中间图像中的每个点，求出它所在的三角形，使用对应的变换函数，将坐标变换到原图像中，插值得到像素值，最终得到一张变换后的图像a
- 同理使用中间图像到目标图像的变换矩阵进行变换，得到变换后的图像b。
- 使用 F = α A + (1 - α)B 对图像a、b的像素值进行加权，求出中间一帧的图像。
- 从0到1增大 α 的值，重复以上步骤
- 将原图像、目标图像和中间10帧的图像保存为gif

#### 实验实现
 主要部分代码实现如下：
 
- 使用dlib库对68个人脸特征点标记

```c++
void getFeaturePoints(const char* filename, std::vector<Point>& points) {
  CImg<float> src(filename);

frontal_face_detector detector = get_frontal_face_detector(); // 人脸探测器
  array2d<rgb_pixel> img;
  load_image(img, filename);
  std::vector<rectangle> faces = detector(img);  // 返回探测到的所有人脸
  shape_predictor sp;
  deserialize("shape_predictor_68_face_landmarks.dat") >> sp;
  full_object_detection shape = sp(img, faces[0]);
  
  // 显示人脸特征点
  float red[] = {255, 0, 0};
  for (int i = 0; i < shape.num_parts(); ++i) {
    point p = shape.part(i);
    src.draw_circle(p.x(), p.y(), 2, red);
    points.push_back(Point(p.x(), p.y()));
  }
  src.display();
}
```
- 三角剖分

```c++
// 三角剖分
// Bowyer-Watson算法(推荐)
// 算法的基本步骤是：
// 1、构造一个超级三角形，包含所有散点，放入三角形链表。
// 2、将点集中的散点依次插入，在三角形链表中找出外接圆包含插入点的三角形(称为该点的影响三角形)
//    删除影响三角形的公共边，将插入点同影响三角形的全部顶点连接起来，
//    完成一个点在Delaunay三角形链表中的插入。
// 3、根据优化准则对局部新形成的三角形优化。将形成的三角形放入Delaunay三角形链表。
// 4、循环执行上述第2步，直到所有散点插入完毕。
void Delaunay::triangulate(vector<Point> &points) {
  // 求超级三角形
  float minX = points[0].x;
  float minY = points[0].y;
  float maxX = minX;
  float maxY = minY;

for (Point p : points) {
    if (p.x < minX) minX = p.x;
    if (p.y < minY) minY = p.y;
    if (p.x > maxX) maxX = p.x;
    if (p.y > maxY) maxY = p.y;
  }
  
  float dx = maxX - minX, dy = maxY - minY;
  float deltaMax = max(dx, dy);
  float midx = (minX + maxX) / 2, midy = (minY + maxY) / 2;

Point p1(midx - 20 * deltaMax, midy - deltaMax);
  Point p2(midx, midy + 20 * deltaMax);
  Point p3(midx + 20 * deltaMax, midy - deltaMax);

// 将超级三角形加入三角形列表
  _triangles.push_back(Triangle(p1, p2, p3));

for(Point p : points) {
    vector<Triangle> badTriangles;
    vector<Edge> polygon;

for(Triangle t : _triangles) {
      if(t.circumCircleContains(p)) {
        badTriangles.push_back(t);
        polygon.push_back(t.e1);
        polygon.push_back(t.e2);
        polygon.push_back(t.e3);
      }
    }

_triangles.erase(remove_if(begin(_triangles), end(_triangles),
                    [badTriangles](Triangle &t) {
      for(Triangle bt : badTriangles) { 
        if (bt == t) return true;   
      }
      return false;
    }), end(_triangles));

vector<Edge> badEdges;
    int size = polygon.size();
    for(int i = 0; i < size; ++i) {
      for(int j = i + 1; j < size; ++j) {
        if (polygon[i] == polygon[j]) {
          badEdges.push_back(polygon[i]); 
          badEdges.push_back(polygon[j]); 
        }
      }
    }

polygon.erase(remove_if(begin(polygon), end(polygon), 
                  [badEdges](Edge &e){
      for(Edge be : badEdges) {
        if (be == e) return true;
      }
      return false;
    }), end(polygon));

for(Edge e : polygon)
      _triangles.push_back(Triangle(e.p1, e.p2, p));
  }

_triangles.erase(remove_if(begin(_triangles), end(_triangles), 
                  [p1, p2, p3](Triangle &t){
    return t.containsVertex(p1) 
          || t.containsVertex(p2)
          || t.containsVertex(p3);
  }), end(_triangles));
}
```
- 求出中间过渡特征点的坐标，需要注意的一点，α 是从0到1，原图像的权重应该是从1到0减小，后面两幅图像像素点进行加权也是如此

```c++
// 坐标变换
inline Point F(const Point& p1, const Point& p2, float alpha) {
  float x = (1 - alpha) * p1.x + alpha * p2.x;
  float y = (1 - alpha) * p1.y + alpha * p2.y;
  return Point(x, y);
}
```
- 计算两个三角形的变换矩阵，若 TA = B，则 T = B / A，可直接调用CImg的矩阵除法，这里需要使用两个三角形的顶点坐标构造矩阵AB
![](/contentImages/image/20180722/MIS3bpgTTKervXLsV20.png)
需要注意的是，CImg里面声明的3x3的矩阵，下标是先y后x

```c++
// 获取变换矩阵
// !!! CImg 下标是先y后x !!!
CImg<float> getTransformMatrix(const Triangle& t1, const Triangle& t2) {
  CImg<float> m1(3, 3);
  m1(0, 0) = t1.p1.x;
  m1(1, 0) = t1.p2.x;
  m1(2, 0) = t1.p3.x;
  m1(0, 1) = t1.p1.y;
  m1(1, 1) = t1.p2.y;
  m1(2, 1) = t1.p3.y;
  m1(0, 2) = m1(1, 2) = m1(2, 2) = 1;

CImg<float> m2(3, 3);
  m2(0, 0) = t2.p1.x;
  m2(1, 0) = t2.p2.x;
  m2(2, 0) = t2.p3.x;
  m2(0, 1) = t2.p1.y;
  m2(1, 1) = t2.p2.y;
  m2(2, 1) = t2.p3.y;
  m2(0, 2) = m2(1, 2) = m2(2, 2) = 1;

return m2 / m1;
}
```

- 对原图像进行三角变换

```c++
//对原图像进行三角变换
CImg<float> target1 = src1;
cimg_forXY(target1, x, y) {
  bool flag = false;
  Point p(x, y);
  int size = triangles.size();
  for (int i = 0; i < size; ++i) {
    if (triangles[i].isPointInTriangle(p)) {
      // 计算中间图像对应于原图像的坐标
      // CImg 坐标先y后x
      float tx = x * mat1[i](0, 0) + y * mat1[i](1, 0) + mat1[i](2, 0);
      float ty = x * mat1[i](0, 1) + y * mat1[i](1, 1) + mat1[i](2, 1);
      int _x = (int)(tx), _y = (int)(ty);

if (_x >= 0 && _x < width && _y >= 0 && _y < height) {
        cimg_forC(src1, c)
          target1(x, y, c) = src1.linear_atXY(_x, _y, c);
      }
      flag = true; 
      break;
    }
  }
  if (!flag) {
    cimg_forC(src1, c)
      target1(x, y, c) = src1.linear_atXY(x, y, c);
  }
}
```
- 对生成的两幅图像像素值进行加权

```c++
// 像素加权
CImg<float> result = src1;
cimg_forXYC(result, x, y, c)
  result(x, y, c) = alpha * target2(x, y, c) + (1 - alpha) * target1(x, y, c);

(target1, target2, result).display();
```

完整实现请看源代码。

#### 实验结果：
人脸特征点
![](/contentImages/image/20180723/c9e0N8NY1vvc7BZeevh.png)

第3帧的三角剖分
![](/contentImages/image/20180723/gnpM4A4DDIVHS8JWWgr.png)

第3帧的图像(右边)，由左边和中间加权得到
![](/contentImages/image/20180723/gM5MS4YnX8qvDWiEfz6.png)

####参考文章：
- [人脸特征点检测](http://blog.csdn.net/xiamentingtao/article/details/50908190)
- [求三角形外接圆](http://blog.csdn.net/xiaogugood/article/details/28238349)
- [判断点是否在三角形内](http://blog.csdn.net/dracularking/archive/2008/03/25/2217180.aspx)
- [Bowyer-Watson算法](https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm)

本实例支付的费用只是购买源码的费用，如有疑问欢迎在文末留言交流，如需作者在线代码指导、定制等，在作者开启付费服务后，可以点击“购买服务”进行实时联系，请知悉，谢谢

感谢

手机上随时阅读、收藏该文章？请扫下方二维码

C++实现人脸渐变算法

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子