深度学习AI美颜系列----AI人像美妆算法初识

2019年3月1日 270次阅读 来源: 算法小白

人像美妆是近几年来深受广大女孩儿群体喜欢的修图功能之一，目前市面中做的比较好的有美妆相机、玩美彩妆、天天P图等APP，当然还有一些PC专用的秀图软件，本文将给大家做个算法初识；

什么是人像美妆？通俗的看个样例图：

《深度学习AI美颜系列----AI人像美妆算法初识》

这个图中，由左边的原图，到右边的化妆效果图，就叫做人像美妆。

本人对AI美妆的一些看法如下：

1.妆容自然，逼真；

2.鲁棒性高，不受五官遮挡影响；

3.速度越快越好；

4.完全智能化，可以针对不同人像照片智能匹配最优妆容；

目前传统美妆的优缺点：

优点：

1.妆容种类丰富，可自由搭配，用户自主选择；

美妆相机和玩美彩妆两款App均提供了数十种不同的妆容效果，供用户自由选择；

2.上妆速度快，可以实时处理；

玩美彩妆、美妆相机、天天P图、无他相机、FaceU等APP均已支持实时上妆效果；

缺点：

1.妆容鲁棒性不高，被光线，五官遮挡影响较大；

2.逼真度不高；

3.无法完全智能化；

目前市面基于传统算法的美妆类APP均无法达到上述3点；

传统人像美妆算法流程：

1.妆容模版制作(Photoshop等编辑软件制作，由设计完成)

2.人脸检测，特征点识别；

这一步骤主要通过人脸检测+人脸对齐来获得N个特征点，目前开源的有Dlib，OpenCV等，商用版有商汤科技、旷世科技、虹软科技等，以及腾讯、美图等；

这里给出一个开源的人脸检测+对齐(68点位)的资源链接：github.com/XiuSdk/cnn-…

《深度学习AI美颜系列----AI人像美妆算法初识》

3.基于人脸特征点，将模版变形，对齐到人脸五官区域；

变形算法有很多，仿射变换，IDW变换，MLS变换，RMLS变换等；

相关代码连接：

IDW

RMLS

MLS(MLS代码在博客内容中)

如果大家懒得看博客，这里给出MLS变形代码：


  
  
     
   
  1. static void setSrcPoints(const vector<PointD> &qsrc, vector<PointD> &newDotL, int* nPoint) {
    2.  
   
  2.  *nPoint = qsrc.size();
    3.  
   
  3.  newDotL.clear();
    4.  
   
  4.  newDotL.reserve(*nPoint);
    5.  
   
  5.  for (size_t i = 0; i < qsrc.size(); i++) 
    6.  
   
  6.  newDotL.push_back(qsrc[i]);
    7.  
   
  7. }
    8.  
   
  8.  
    9.  
   
  9. static void setDstPoints(const vector<PointD> &qdst,vector<PointD> &oldDotL, int* nPoint) {
    10.  
   
  10.  *nPoint = qdst.size();
    11.  
   
  11.  oldDotL.clear();
    12.  
   
  12.  oldDotL.reserve(*nPoint);
    13.  
   
  13.  
    14.  
   
  14.  for (size_t i = 0; i < qdst.size(); i++) oldDotL.push_back(qdst[i]);
    15.  
   
  15. }
    16.  
   
  16. static double bilinear_interp(double x, double y, double v11, double v12,
    17.  
   
  17.  double v21, double v22) {
    18.  
   
  18.  return (v11 * (1 - y) + v12 * y) * (1 - x) + (v21 * (1 - y) + v22 * y) * x;
    19.  
   
  19. }
    20.  
   
  20.  
    21.  
   
  21. static double calcArea(const vector<PointD> &V) {
    22.  
   
  22.  PointD lt, rb;
    23.  
   
  23.  lt.x = lt.y = 1e10;
    24.  
   
  24.  rb.x = rb.y = -1e10;
    25.  
   
  25.  for (vector<PointD >::const_iterator i = V.begin(); i != V.end();
    26.  
   
  26.  i++) {
    27.  
   
  27.  if (i->x < lt.x) lt.x = i->x;
    28.  
   
  28.  if (i->x > rb.x) rb.x = i->x;
    29.  
   
  29.  if (i->y < lt.y) lt.y = i->y;
    30.  
   
  30.  if (i->y > rb.y) rb.y = i->y;
    31.  
   
  31.  }
    32.  
   
  32.  return (rb.x - lt.x) * (rb.y - lt.y);
    33.  
   
  33. }
    34.  
   
  34. static void calcDelta_rigid(int srcW, int srcH, int tarW, int tarH, double alpha, int gridSize, int nPoint, int preScale, double *rDx, double *rDy, vector<PointD> &oldDotL, vector<PointD> &newDotL)
    35.  
   
  35. {
    36.  
   
  36.  int i, j, k;
    37.  
   
  37.  PointD swq, qstar, newP, tmpP;
    38.  
   
  38.  double sw;
    39.  
   
  39.  
    40.  
   
  40.  double ratio;
    41.  
   
  41.  
    42.  
   
  42.  if (preScale) {
    43.  
   
  43.  ratio = sqrt(calcArea(newDotL) / calcArea(oldDotL));
    44.  
   
  44.  for (i = 0; i < nPoint; i++) {
    45.  
   
  45.  newDotL[i].x *= 1 / ratio;
    46.  
   
  46.  newDotL[i].y *= 1 / ratio;
    47.  
   
  47.  }
    48.  
   
  48.  }
    49.  
   
  49.  double *w = new double[nPoint];
    50.  
   
  50.  
    51.  
   
  51.  if (nPoint < 2) {
    52.  
   
  52.  //rDx.setTo(0);
    53.  
   
  53.  //rDy.setTo(0);
    54.  
   
  54.  return;
    55.  
   
  55.  }
    56.  
   
  56.  PointD swp, pstar, curV, curVJ, Pi, PiJ, Qi;
    57.  
   
  57.  double miu_r;
    58.  
   
  58.  
    59.  
   
  59.  for (i = 0;; i += gridSize) {
    60.  
   
  60.  if (i >= tarW && i < tarW + gridSize - 1)
    61.  
   
  61.  i = tarW - 1;
    62.  
   
  62.  else if (i >= tarW)
    63.  
   
  63.  break;
    64.  
   
  64.  for (j = 0;; j += gridSize) {
    65.  
   
  65.  if (j >= tarH && j < tarH + gridSize - 1)
    66.  
   
  66.  j = tarH - 1;
    67.  
   
  67.  else if (j >= tarH)
    68.  
   
  68.  break;
    69.  
   
  69.  sw = 0;
    70.  
   
  70.  swp.x = swp.y = 0;
    71.  
   
  71.  swq.x = swq.y = 0;
    72.  
   
  72.  newP.x = newP.y = 0;
    73.  
   
  73.  curV.x = i;
    74.  
   
  74.  curV.y = j;
    75.  
   
  75.  for (k = 0; k < nPoint; k++) {
    76.  
   
  76.  if ((i == oldDotL[k].x) && j == oldDotL[k].y) break;
    77.  
   
  77.  if (alpha == 1)
    78.  
   
  78.  w[k] = 1 / ((i - oldDotL[k].x) * (i - oldDotL[k].x) +
    79.  
   
  79.  (j - oldDotL[k].y) * (j - oldDotL[k].y));
    80.  
   
  80.  else
    81.  
   
  81.  w[k] = pow((i - oldDotL[k].x) * (i - oldDotL[k].x) +
    82.  
   
  82.  (j - oldDotL[k].y) * (j - oldDotL[k].y),
    83.  
   
  83.  -alpha);
    84.  
   
  84.  sw = sw + w[k];
    85.  
   
  85.  swp.x = swp.x + w[k] * oldDotL[k].x;
    86.  
   
  86.  swp.y = swp.y + w[k] * oldDotL[k].y;
    87.  
   
  87.  swq.x = swq.x + w[k] * newDotL[k].x;
    88.  
   
  88.  swq.y = swq.y + w[k] * newDotL[k].y;
    89.  
   
  89.  }
    90.  
   
  90.  if (k == nPoint) {
    91.  
   
  91.  pstar.x = (1 / sw) * swp.x;
    92.  
   
  92.  pstar.y = (1 / sw) * swp.y;
    93.  
   
  93.  qstar.x = 1 / sw * swq.x;
    94.  
   
  94.  qstar.y = 1 / sw * swq.y;
    95.  
   
  95.  // Calc miu_r
    96.  
   
  96.  double s1 = 0, s2 = 0;
    97.  
   
  97.  for (k = 0; k < nPoint; k++) {
    98.  
   
  98.  if (i == oldDotL[k].x && j == oldDotL[k].y) continue;
    99.  
   
  99.  Pi.x = oldDotL[k].x - pstar.x;
    100.  
   
  100.  Pi.y = oldDotL[k].y - pstar.y;
    101.  
   
  101.  PiJ.x = -Pi.y, PiJ.y = Pi.x;
    102.  
   
  102.  Qi.x = newDotL[k].x - qstar.x;
    103.  
   
  103.  Qi.y = newDotL[k].y - qstar.y;
    104.  
   
  104.  s1 += w[k] * (Qi.x*Pi.x+Qi.y*Pi.y);
    105.  
   
  105.  s2 += w[k] * (Qi.x*PiJ.x+Qi.y*PiJ.y);
    106.  
   
  106.  }
    107.  
   
  107.  miu_r = sqrt(s1 * s1 + s2 * s2);
    108.  
   
  108.  curV.x -= pstar.x;
    109.  
   
  109.  curV.y -= pstar.y;
    110.  
   
  110.  
    111.  
   
  111.  curVJ.x = -curV.y, curVJ.y = curV.x;
    112.  
   
  112.  
    113.  
   
  113.  for (k = 0; k < nPoint; k++) {
    114.  
   
  114.  if (i == oldDotL[k].x && j == oldDotL[k].y) continue;
    115.  
   
  115.  Pi.x = oldDotL[k].x - pstar.x;
    116.  
   
  116.  Pi.y = oldDotL[k].y - pstar.y;
    117.  
   
  117.  PiJ.x = -Pi.y, PiJ.y = Pi.x;
    118.  
   
  118.  tmpP.x = (Pi.x*curV.x+Pi.y*curV.y)* newDotL[k].x -
    119.  
   
  119.  (PiJ.x*curV.x+PiJ.y*curV.y)* newDotL[k].y;
    120.  
   
  120.  tmpP.y = -(Pi.x*curVJ.x+Pi.y*curVJ.y) * newDotL[k].x +
    121.  
   
  121.  (PiJ.x*curVJ.x+PiJ.y*curVJ.y) * newDotL[k].y;
    122.  
   
  122.  tmpP.x *= w[k] / miu_r;
    123.  
   
  123.  tmpP.y *= w[k] / miu_r;
    124.  
   
  124.  newP.x += tmpP.x;
    125.  
   
  125.  newP.y += tmpP.y;
    126.  
   
  126.  }
    127.  
   
  127.  newP.x += qstar.x;
    128.  
   
  128.  newP.y += qstar.y;
    129.  
   
  129.  } else {
    130.  
   
  130.  newP = newDotL[k];
    131.  
   
  131.  }
    132.  
   
  132.  
    133.  
   
  133.  if (preScale) {
    134.  
   
  134.  rDx[j * tarW + i] = newP.x * ratio - i;
    135.  
   
  135.  rDy[j * tarW + i] = newP.y * ratio - j;
    136.  
   
  136.  } else {
    137.  
   
  137.  rDx[j * tarW + i] = newP.x - i;
    138.  
   
  138.  rDy[j * tarW + i] = newP.y - j;
    139.  
   
  139.  }
    140.  
   
  140.  }
    141.  
   
  141.  }
    142.  
   
  142.  delete[] w;
    143.  
   
  143.  
    144.  
   
  144.  if (preScale!=0) {
    145.  
   
  145.  for (i = 0; i < nPoint; i++){
    146.  
   
  146.  newDotL[i].x *= ratio;
    147.  
   
  147.  newDotL[i].y *= ratio;
    148.  
   
  148.  }
    149.  
   
  149.  }
    150.  
   
  150. }
    151.  
   
  151. static void calcDelta_Similarity(int srcW, int srcH, int tarW, int tarH, double alpha, int gridSize, int nPoint, int preScale, double *rDx, double *rDy, vector<PointD> &oldDotL, vector<PointD> &newDotL)
    152.  
   
  152. {
    153.  
   
  153.  int i, j, k;
    154.  
   
  154.  
    155.  
   
  155.  PointD swq, qstar, newP, tmpP;
    156.  
   
  156.  double sw;
    157.  
   
  157.  
    158.  
   
  158.  double ratio;
    159.  
   
  159.  
    160.  
   
  160.  if (preScale) {
    161.  
   
  161.  ratio = sqrt(calcArea(newDotL) / calcArea(oldDotL));
    162.  
   
  162.  for (i = 0; i < nPoint; i++) {
    163.  
   
  163.  newDotL[i].x *= 1 / ratio;
    164.  
   
  164.  newDotL[i].y *= 1 / ratio;
    165.  
   
  165.  }
    166.  
   
  166.  }
    167.  
   
  167.  double *w = new double[nPoint];
    168.  
   
  168.  
    169.  
   
  169.  if (nPoint < 2) {
    170.  
   
  170.  return;
    171.  
   
  171.  }
    172.  
   
  172.  
    173.  
   
  173.  PointD swp, pstar, curV, curVJ, Pi, PiJ;
    174.  
   
  174.  double miu_s;
    175.  
   
  175.  
    176.  
   
  176.  for (i = 0;; i += gridSize) {
    177.  
   
  177.  if (i >= tarW && i < tarW + gridSize - 1)
    178.  
   
  178.  i = tarW - 1;
    179.  
   
  179.  else if (i >= tarW)
    180.  
   
  180.  break;
    181.  
   
  181.  for (j = 0;; j += gridSize) {
    182.  
   
  182.  if (j >= tarH && j < tarH + gridSize - 1)
    183.  
   
  183.  j = tarH - 1;
    184.  
   
  184.  else if (j >= tarH)
    185.  
   
  185.  break;
    186.  
   
  186.  sw = 0;
    187.  
   
  187.  swp.x = swp.y = 0;
    188.  
   
  188.  swq.x = swq.y = 0;
    189.  
   
  189.  newP.x = newP.y = 0;
    190.  
   
  190.  curV.x = i;
    191.  
   
  191.  curV.y = j;
    192.  
   
  192.  for (k = 0; k < nPoint; k++) {
    193.  
   
  193.  if ((i == oldDotL[k].x) && j == oldDotL[k].y) break;
    194.  
   
  194.  w[k] = 1 / ((i - oldDotL[k].x) * (i - oldDotL[k].x) +
    195.  
   
  195.  (j - oldDotL[k].y) * (j - oldDotL[k].y));
    196.  
   
  196.  sw = sw + w[k];
    197.  
   
  197.  swp.x = swp.x + w[k] * oldDotL[k].x;
    198.  
   
  198.  swp.y = swp.y + w[k] * oldDotL[k].y;
    199.  
   
  199.  swq.x = swq.x + w[k] * newDotL[k].x;
    200.  
   
  200.  swq.y = swq.y + w[k] * newDotL[k].y;
    201.  
   
  201.  }
    202.  
   
  202.  if (k == nPoint) {
    203.  
   
  203.  pstar.x = (1 / sw) * swp.x;
    204.  
   
  204.  pstar.y = (1 / sw) * swp.y;
    205.  
   
  205.  qstar.x = 1 / sw * swq.x;
    206.  
   
  206.  qstar.y = 1 / sw * swq.y;
    207.  
   
  207.  // Calc miu_s
    208.  
   
  208.  miu_s = 0;
    209.  
   
  209.  for (k = 0; k < nPoint; k++) {
    210.  
   
  210.  if (i == oldDotL[k].x && j == oldDotL[k].y) continue;
    211.  
   
  211.  
    212.  
   
  212.  Pi.x = oldDotL[k].x - pstar.x;
    213.  
   
  213.  Pi.y = oldDotL[k].y - pstar.y;
    214.  
   
  214.  miu_s += w[k] * (Pi.x*Pi.x+Pi.y*Pi.y);
    215.  
   
  215.  }
    216.  
   
  216.  
    217.  
   
  217.  curV.x -= pstar.x;
    218.  
   
  218.  curV.y -= pstar.y;
    219.  
   
  219.  curVJ.x = -curV.y, curVJ.y = curV.x;
    220.  
   
  220.  
    221.  
   
  221.  for (k = 0; k < nPoint; k++) {
    222.  
   
  222.  if (i == oldDotL[k].x && j == oldDotL[k].y) continue;
    223.  
   
  223.  
    224.  
   
  224.  Pi.x = oldDotL[k].x - pstar.x;
    225.  
   
  225.  Pi.y = oldDotL[k].y - pstar.y;
    226.  
   
  226.  PiJ.x = -Pi.y, PiJ.y = Pi.x;
    227.  
   
  227.  
    228.  
   
  228.  tmpP.x = (Pi.x*curV.x+Pi.y*curV.y) * newDotL[k].x -
    229.  
   
  229.  (PiJ.x*curV.x+PiJ.y*curV.y) * newDotL[k].y;
    230.  
   
  230.  tmpP.y = -(Pi.x*curVJ.x+Pi.y*curVJ.y) * newDotL[k].x +
    231.  
   
  231.  (PiJ.x*curVJ.x+PiJ.y*curVJ.y) * newDotL[k].y;
    232.  
   
  232.  tmpP.x *= w[k] / miu_s;
    233.  
   
  233.  tmpP.y *= w[k] / miu_s;
    234.  
   
  234.  newP.x += tmpP.x;
    235.  
   
  235.  newP.y += tmpP.y;
    236.  
   
  236.  }
    237.  
   
  237.  newP.x += qstar.x;
    238.  
   
  238.  newP.y += qstar.y;
    239.  
   
  239.  } else {
    240.  
   
  240.  newP = newDotL[k];
    241.  
   
  241.  }
    242.  
   
  242.  
    243.  
   
  243.  rDx[j * tarW + i] = newP.x - i; 
    244.  
   
  244.  rDy[j * tarW + i] = newP.y - j;
    245.  
   
  245.  }
    246.  
   
  246.  }
    247.  
   
  247.  
    248.  
   
  248.  delete[] w;
    249.  
   
  249.  if (preScale!=0) {
    250.  
   
  250.  for (i = 0; i < nPoint; i++){
    251.  
   
  251.  newDotL[i].x *= ratio;
    252.  
   
  252.  newDotL[i].y *= ratio;
    253.  
   
  253.  }
    254.  
   
  254.  }
    255.  
   
  255. }
    256.  
   
  256. static int GetNewImg(unsigned char* oriImg, int width, int height, int stride, unsigned char* tarImg, int tarW, int tarH, int tarStride, int gridSize, double* rDx, double* rDy, double transRatio)
    257.  
   
  257. {
    258.  
   
  258.  int i, j;
    259.  
   
  259.  double di, dj;
    260.  
   
  260.  double nx, ny;
    261.  
   
  261.  int nxi, nyi, nxi1, nyi1;
    262.  
   
  262.  double deltaX, deltaY;
    263.  
   
  263.  double w, h;
    264.  
   
  264.  int ni, nj;
    265.  
   
  265.  int pos, posa, posb, posc, posd;
    266.  
   
  266.  for (i = 0; i < tarH; i += gridSize)
    267.  
   
  267.  for (j = 0; j < tarW; j += gridSize) {
    268.  
   
  268.  ni = i + gridSize, nj = j + gridSize;
    269.  
   
  269.  w = h = gridSize;
    270.  
   
  270.  if (ni >= tarH) ni = tarH - 1, h = ni - i + 1;
    271.  
   
  271.  if (nj >= tarW) nj = tarW - 1, w = nj - j + 1;
    272.  
   
  272.  for (di = 0; di < h; di++)
    273.  
   
  273.  for (dj = 0; dj < w; dj++) {
    274.  
   
  274.  deltaX =
    275.  
   
  275.  bilinear_interp(di / h, dj / w, rDx[i * tarW + j], rDx[i * tarW + nj],
    276.  
   
  276.  rDx[ni * tarW + j], rDx[ni * tarW + nj]);
    277.  
   
  277.  deltaY =
    278.  
   
  278.  bilinear_interp(di / h, dj / w, rDy[i * tarW + j], rDy[i * tarW + nj],
    279.  
   
  279.  rDy[ni * tarW + j], rDy[ni * tarW + nj]);
    280.  
   
  280.  nx = j + dj + deltaX * transRatio;
    281.  
   
  281.  ny = i + di + deltaY * transRatio;
    282.  
   
  282.  if (nx > width - 1) nx = width - 1;
    283.  
   
  283.  if (ny > height - 1) ny = height - 1;
    284.  
   
  284.  if (nx < 0) nx = 0;
    285.  
   
  285.  if (ny < 0) ny = 0;
    286.  
   
  286.  nxi = int(nx);
    287.  
   
  287.  nyi = int(ny);
    288.  
   
  288.  nxi1 = ceil(nx);
    289.  
   
  289.  nyi1 = ceil(ny);
    290.  
   
  290.  pos = (int)(i + di) * tarStride + ((int)(j + dj) << 2);
    291.  
   
  291.  posa = nyi * stride + (nxi << 2);
    292.  
   
  292.  posb = nyi * stride + (nxi1 << 2);
    293.  
   
  293.  posc = nyi1 * stride + (nxi << 2);
    294.  
   
  294.  posd = nyi1 * stride + (nxi1 << 2);
    295.  
   
  295.  tarImg[pos] = (unsigned char)bilinear_interp(ny - nyi, nx - nxi, oriImg[posa], oriImg[posb], oriImg[posc], oriImg[posd]);
    296.  
   
  296.  tarImg[pos + 1] = (unsigned char)bilinear_interp(ny - nyi, nx - nxi, oriImg[posa + 1],oriImg[posb + 1], oriImg[posc + 1], oriImg[posd + 1]);
    297.  
   
  297.  tarImg[pos + 2] = (unsigned char)bilinear_interp(ny - nyi, nx - nxi, oriImg[posa + 2],oriImg[posb + 2], oriImg[posc + 2], oriImg[posd + 2]);
    298.  
   
  298.  tarImg[pos + 3] = (unsigned char)bilinear_interp(ny - nyi, nx - nxi, oriImg[posa + 3],oriImg[posb + 3], oriImg[posc + 3], oriImg[posd + 3]);
    299.  
   
  299.  }
    300.  
   
  300.  }
    301.  
   
  301.  return 0;
    302.  
   
  302. };
    303.  
   
  303.  
    304.  
   
  304. static void MLSImageWrapping(unsigned char* oriImg,int width, int height, int stride,const vector<PointD > &qsrc, const vector<PointD > &qdst, unsigned char* tarImg, int outW, int outH, int outStride, double transRatio, int preScale, int gridSize, int method)
    305.  
   
  305. {
    306.  
   
  306.  int srcW = width;
    307.  
   
  307.  int srcH = height;
    308.  
   
  308.  int tarW = outW;
    309.  
   
  309.  int tarH = outH;
    310.  
   
  310.  double alpha = 1;
    311.  
   
  311.  int nPoint;
    312.  
   
  312.  int len = tarH * tarW;
    313.  
   
  313.  vector<PointD> oldDotL, newDotL;
    314.  
   
  314.  double *rDx = NULL,*rDy = NULL;
    315.  
   
  315.  setSrcPoints(qsrc,newDotL,&nPoint);
    316.  
   
  316.  setDstPoints(qdst,oldDotL,&nPoint);
    317.  
   
  317.  rDx = (double*)malloc(sizeof(double) * len);
    318.  
   
  318.  rDy = (double*)malloc(sizeof(double) * len);
    319.  
   
  319.  memset(rDx, 0, sizeof(double) * len);
    320.  
   
  320.  memset(rDy, 0, sizeof(double) * len);
    321.  
   
  321.  if(method!=0)
    322.  
   
  322.  calcDelta_Similarity(srcW, srcH, tarW, tarH, alpha, gridSize, nPoint, preScale, rDx, rDy, oldDotL, newDotL);
    323.  
   
  323.  else
    324.  
   
  324.  calcDelta_rigid(srcW, srcH, tarW, tarH, alpha, gridSize, nPoint, preScale, rDx, rDy, oldDotL, newDotL);
    325.  
   
  325.  GetNewImg(oriImg, srcW, srcH, stride, tarImg, tarW, tarH, outStride, gridSize, rDx, rDy, transRatio);
    326.  
   
  326.  if(rDx != NULL)
    327.  
   
  327.  free(rDx);
    328.  
   
  328.  if(rDy != NULL)
    329.  
   
  329.  free(rDy);
    330.  
   
  330. };
    331.  
   
  331. int f_TMLSImagewarpping(unsigned char* srcData, int width ,int height, int stride, unsigned char* dstData, int outW, int outH, int outStride, int srcPoint[], int dragPoint[], int pointNum, double intensity, int preScale, int gridSize, int method)
    332.  
   
  332. {
    333.  
   
  333.  int res = 0;
    334.  
   
  334.  vector<PointD> qDst;
    335.  
   
  335.  vector<PointD> qSrc;
    336.  
   
  336.  PointD point = {0};
    337.  
   
  337.  int len = 0;
    338.  
   
  338.  for(int i = 0; i < pointNum; i++)
    339.  
   
  339.  {
    340.  
   
  340.  len = (i << 1);
    341.  
   
  341.  point.x = srcPoint[len];
    342.  
   
  342.  point.y = srcPoint[len + 1];
    343.  
   
  343.  qSrc.push_back(point);
    344.  
   
  344.  point.x = dragPoint[len];
    345.  
   
  345.  point.y = dragPoint[len + 1];
    346.  
   
  346.  qDst.push_back(point);
    347.  
   
  347.  }
    348.  
   
  348.  MLSImageWrapping(srcData, width, height, stride, qSrc, qDst, dstData, outW, outH, outStride, intensity, preScale,gridSize, method);
    349.  
   
  349.  return res;
    350.  
   
  350. };
    351.

4.将模版与人脸五官图像进行融合；

融合算法主要有alpha融合，Photoshop图层混合，泊松融合等；

alpha融合： S * alpha + D*(1-alpha)

图层混合公式如下：

《深度学习AI美颜系列----AI人像美妆算法初识》

泊松融合：算法详解

上述过程即传统算法流程，其中对美妆效果起决定性的是人脸特征点识别，如果没有准确的特征点，再好的妆容模版，上妆效果也出不来；

比如下面的例子：

《深度学习AI美颜系列----AI人像美妆算法初识》

《深度学习AI美颜系列----AI人像美妆算法初识》

《深度学习AI美颜系列----AI人像美妆算法初识》

图1中，由于眼睛特征点位置不准确，睫毛妆容已经偏离了眼睛区域；

图2中，由于拍照光线较暗，腮红明显，逼真度过低；

图3中，由于人眼和眉毛被部分遮挡，因此，传统算法的睫毛和眉毛效果悬浮在了头发之上；

目前传统算法相关的论文资料如下：

Rule-Based Facial Makeup Recommendation System.

Example-Based Cosmetic Transfer.

Region-based Face Makeup using example face images.

Simulating Makeup through Physics-based Manipulation of Intrinsic Image Layers.

A Visual Representation for editing face images.

Digital Face Makeup By Example.

在传统算法中，有一种妆容迁移算法，该算法可以直接将一张妆容效果图中的妆容特征，迁移到任意一张人像照片中去，实际上也是与人脸特征点密不可分，具体连接可参考：blog.csdn.net/trent1985/a…

目前AI美妆相关的论文资料如下：

Makeup Like a Superstar Deep Localized Makeup Transfer Network.

Examples-Rules Guided Deep Neural Network for Makeup Recommendation.

上述两篇基于深度学习的美妆算法论文主要思想有两个：

1，对于第一篇论文主要是对人像进行五官分析，获取肤色，眉毛颜色，唇色等等信息，然后进行不同妆容的最佳匹配，最后上妆；

框架如下：

《深度学习AI美颜系列----AI人像美妆算法初识》

2，对五官进行分别提取分类成不同的style，依据样例数据的特征style，进行最优匹配并上妆；

框架如下：

《深度学习AI美颜系列----AI人像美妆算法初识》

上述两篇算法论文，依旧是建立在人脸特征点的基础上研究的。

本人针对传统美妆算法，结合深度学习，做了如下改进：

1.只需要人脸检测框，不依赖于人脸特征点；

2.不受五官遮挡和光线影响；

3.妆容效果逼真度提高；

本人算法框架：

1.人脸检测，得到正方形人脸框，包含五官区域；

2.基于全卷积网络，以人脸框图像作为输入，上妆之后的人脸五官效果图作为输出，进行学习训练；

妆容模版使用如下模版：

《深度学习AI美颜系列----AI人像美妆算法初识》

在Fig.4模板妆容中，分别进行了眉毛处理，眼影、睫毛和唇彩的上妆，整体肤色以及其他内容均无调整；

训练中迭代10次，训练集和验证集准确率均达到了94%-95%，本人训练样本选取了500张，数据比较少，这里仅仅探讨可行性与方法分析；

3.使用2中的训练模型，对测试图进行上妆；

效果图如下：

《深度学习AI美颜系列----AI人像美妆算法初识》

《深度学习AI美颜系列----AI人像美妆算法初识》

上述效果图中我们可以看到，基于深度学习的美妆效果，避免了五官遮挡的影响，同时上妆效果更加自然，对环境光的鲁棒性也较高，本文这里未给出具体的网络模型与参数，不过思路大家已经可以借鉴！目前算法处于研究测试阶段，后续本人将公布完整的DEMO！

本人QQ：1358009172

    原文作者：算法小白
    原文地址: https://juejin.im/entry/5b580f85f265da0fab4020d0
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞