小200行Python代码做了一个换脸程序

简介

在这篇文章中我将介绍如何写一个简短（200行）的 Python 脚本，来自动地将一幅图片的脸替换为另一幅图片的脸。

创新互联公司凭借专业的设计团队扎实的技术支持、优质高效的服务意识和丰厚的资源优势，提供专业的网站策划、网站设计、成都网站制作、网站优化、软件开发、网站改版等服务，在成都十多年的网站建设设计经验，为成都上千中小型企业策划设计了网站。

这个过程分四步：

  • 检测脸部标记。

  • 旋转、缩放、平移和第二张图片，以配合***步。

  • 调整第二张图片的色彩平衡，以适配***张图片。

  • 把第二张图像的特性混合在***张图像中。

1.使用 dlib 提取面部标记

该脚本使用 dlib 的 Python 绑定来提取面部标记：

Dlib 实现了 Vahid Kazemi 和 Josephine Sullivan 的《使用回归树一毫秒脸部对准》论文中的算法。算法本身非常复杂，但dlib接口使用起来非常简单：

 
 
 
 
    
  
  
  
  
  1. PREDICTOR_PATH = "/home/matt/dlib-18.16/shape_predictor_68_face_landmarks.dat"  
    2. 
  
  
  
  
  2. detector = dlib.get_frontal_face_detector() 
    3. 
  
  
  
  
  3. predictor = dlib.shape_predictor(PREDICTOR_PATH)  
    4. 
  
  
  
  
  4. def get_landmarks(im): 
    5. 
  
  
  
  
  5.     rects = detector(im, 1) 
    6. 
  
  
  
  
  6.     if len(rects) > 1: 
    7. 
  
  
  
  
  7.         raise TooManyFaces 
    8. 
  
  
  
  
  8.     if len(rects) == 0: 
    9. 
  
  
  
  
  9.         raise NoFaces 
    10. 
  
  
  
  
  10.     return numpy.matrix([[p.x, p.y] for p in predictor(im, rects[0]).parts()])  
    11.

get_landmarks()函数将一个图像转化成numpy数组，并返回一个68×2元素矩阵，输入图像的每个特征点对应每行的一个x，y坐标。

特征提取器（predictor）需要一个粗糙的边界框作为算法输入，由一个传统的能返回一个矩形列表的人脸检测器（detector）提供，其每个矩形列表在图像中对应一个脸。

2.用 Procrustes 分析调整脸部

现在我们已经有了两个标记矩阵，每行有一组坐标对应一个特定的面部特征（如第30行的坐标对应于鼻头）。我们现在要解决如何旋转、翻译和缩放***个向量，使它们尽可能适配第二个向量的点。一个想法是可以用相同的变换在***个图像上覆盖第二个图像。

将这个问题数学化，寻找T，s 和 R，使得下面这个表达式：

结果最小，其中R是个2×2正交矩阵，s是标量，T是二维向量，pi和qi是上面标记矩阵的行。

事实证明，这类问题可以用“常规 Procrustes 分析法”解决：

 
 
 
 
    
  
  
  
  
  1. def transformation_from_points(points1, points2): 
    2. 
  
  
  
  
  2.     points1 = points1.astype(numpy.float64) 
    3. 
  
  
  
  
  3.     points2 = points2.astype(numpy.float64)  
    4. 
  
  
  
  
  4. 
  
  
  
  
  5.     c1 = numpy.mean(points1, axis=0) 
    6. 
  
  
  
  
  6.     c2 = numpy.mean(points2, axis=0) 
    7. 
  
  
  
  
  7.     points1 -= c1 
    8. 
  
  
  
  
  8.     points2 -= c2  
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.     s1 = numpy.std(points1) 
    11. 
  
  
  
  
  11.     s2 = numpy.std(points2) 
    12. 
  
  
  
  
  12.     points1 /= s1 
    13. 
  
  
  
  
  13.     points2 /= s2  
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     U, S, Vt = numpy.linalg.svd(points1.T * points2) 
    16. 
  
  
  
  
  16.     R = (U * Vt).T  
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.     return numpy.vstack([numpy.hstack(((s2 / s1) * R, 
    19. 
  
  
  
  
  19.                                        c2.T - (s2 / s1) * R * c1.T)), 
    20. 
  
  
  
  
  20.                          numpy.matrix([0., 0., 1.])]) 
    21.

代码实现了这几步：

1.将输入矩阵转换为浮点数。这是后续操作的基础。

2.每一个点集减去它的矩心。一旦为点集找到了一个***的缩放和旋转方法，这两个矩心 c1 和 c2 就可以用来找到完整的解决方案。

3.同样，每一个点集除以它的标准偏差。这会消除组件缩放偏差的问题。

4.使用奇异值分解计算旋转部分。可以在维基百科上看到关于解决正交 Procrustes 问题的细节。

5.利用仿射变换矩阵返回完整的转化。

其结果可以插入 OpenCV 的 cv2.warpAffine 函数，将图像二映射到图像一：

 
 
 
 
    
  
  
  
  
  1. def warp_im(im, M, dshape): 
    2. 
  
  
  
  
  2.     output_im = numpy.zeros(dshape, dtype=im.dtype) 
    3. 
  
  
  
  
  3.     cv2.warpAffine(im, 
    4. 
  
  
  
  
  4.                    M[:2], 
    5. 
  
  
  
  
  5.                    (dshape[1], dshape[0]), 
    6. 
  
  
  
  
  6.                    dst=output_im, 
    7. 
  
  
  
  
  7.                    borderMode=cv2.BORDER_TRANSPARENT, 
    8. 
  
  
  
  
  8.                    flags=cv2.WARP_INVERSE_MAP) 
    9. 
  
  
  
  
  9.     return output_im 
    10.

对齐结果如下：

3.校正第二张图像的颜色

如果我们试图直接覆盖面部特征，很快会看到这个问题：

这个问题是两幅图像之间不同的肤色和光线造成了覆盖区域的边缘不连续。我们试着修正：

 
 
 
 
    
  
  
  
  
  1. COLOUR_CORRECT_BLUR_FRAC = 0.6 
    2. 
  
  
  
  
  2. LEFT_EYE_POINTS = list(range(42, 48)) 
    3. 
  
  
  
  
  3. RIGHT_EYE_POINTS = list(range(36, 42))  
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. def correct_colours(im1, im2, landmarks1): 
    6. 
  
  
  
  
  6.     blur_amount = COLOUR_CORRECT_BLUR_FRAC * numpy.linalg.norm( 
    7. 
  
  
  
  
  7.                               numpy.mean(landmarks1[LEFT_EYE_POINTS], axis=0) - 
    8. 
  
  
  
  
  8.                               numpy.mean(landmarks1[RIGHT_EYE_POINTS], axis=0)) 
    9. 
  
  
  
  
  9.     blur_amount = int(blur_amount) 
    10. 
  
  
  
  
  10.     if blur_amount % 2 == 0: 
    11. 
  
  
  
  
  11.         blur_amount += 1 
    12. 
  
  
  
  
  12.     im1_blur = cv2.GaussianBlur(im1, (blur_amount, blur_amount), 0) 
    13. 
  
  
  
  
  13.     im2_blur = cv2.GaussianBlur(im2, (blur_amount, blur_amount), 0)  
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     # Avoid divide-by-zero errors. 
    16. 
  
  
  
  
  16.     im2_blur += 128 * (im2_blur <= 1.0)  
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.     return (im2.astype(numpy.float64) * im1_blur.astype(numpy.float64) /
    19. 
  
  
  
  
  19. 
  
  
  
  
  20.                                                 im2_blur.astype(numpy.float64)) 
    21.

结果如下：

此函数试图改变 im2 的颜色来适配 im1。它通过用 im2 除以 im2 的高斯模糊值，然后乘以im1的高斯模糊值。这里的想法是用RGB缩放校色，但并不是用所有图像的整体常数比例因子，每个像素都有自己的局部比例因子。

用这种方法两图像之间光线的差异只能在某种程度上被修正。例如，如果图像1是从一侧照亮，但图像2是被均匀照亮的，色彩校正后图像2也会出现未照亮一侧暗一些的问题。

也就是说，这是一个相当简陋的办法，而且解决问题的关键是一个适当的高斯核函数大小。如果太小，***个图像的面部特征将显示在第二个图像中。过大，内核之外区域像素被覆盖，并发生变色。这里的内核用了一个0.6 *的瞳孔距离。

4.把第二张图像的特征混合在***张图像中

用一个遮罩来选择图像2和图像1的哪些部分应该是最终显示的图像：

值为1(显示为白色)的地方为图像2应该显示出的区域，值为0(显示为黑色)的地方为图像1应该显示出的区域。值在0和1之间为图像1和图像2的混合区域。

这是生成上图的代码:

 
 
 
 
    
  
  
  
  
  1. LEFT_EYE_POINTS = list(range(42, 48)) 
    2. 
  
  
  
  
  2. RIGHT_EYE_POINTS = list(range(36, 42)) 
    3. 
  
  
  
  
  3. LEFT_BROW_POINTS = list(range(22, 27)) 
    4. 
  
  
  
  
  4. RIGHT_BROW_POINTS = list(range(17, 22)) 
    5. 
  
  
  
  
  5. NOSE_POINTS = list(range(27, 35)) 
    6. 
  
  
  
  
  6. MOUTH_POINTS = list(range(48, 61)) 
    7. 
  
  
  
  
  7. OVERLAY_POINTS = [ 
    8. 
  
  
  
  
  8.     LEFT_EYE_POINTS + RIGHT_EYE_POINTS + LEFT_BROW_POINTS + RIGHT_BROW_POINTS, 
    9. 
  
  
  
  
  9.     NOSE_POINTS + MOUTH_POINTS, 
    10. 
  
  
  
  
  10. ] 
    11. 
  
  
  
  
  11. FEATHER_AMOUNT = 11 
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. def draw_convex_hull(im, points, color): 
    14. 
  
  
  
  
  14.     points = cv2.convexHull(points)
    15. 
  
  
  
  
  15.     cv2.fillConvexPoly(im, points, color=color)  
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. def get_face_mask(im, landmarks): 
    18. 
  
  
  
  
  18.     im = numpy.zeros(im.shape[:2], dtype=numpy.float64)  
    19. 
  
  
  
  
  19. 
  
  
  
  
  20.     for group in OVERLAY_POINTS: 
    21. 
  
  
  
  
  21.         draw_convex_hull(im, 
    22. 
  
  
  
  
  22.                          landmarks[group], 
    23. 
  
  
  
  
  23.                          color=1)  
    24. 
  
  
  
  
  24. 
  
  
  
  
  25.     im = numpy.array([im, im, im]).transpose((1, 2, 0))  
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.     im = (cv2.GaussianBlur(im, (FEATHER_AMOUNT, FEATHER_AMOUNT), 0) > 0) * 1.0 
    28. 
  
  
  
  
  28.     im = cv2.GaussianBlur(im, (FEATHER_AMOUNT, FEATHER_AMOUNT), 0)  
    29. 
  
  
  
  
  29. 
  
  
  
  
  30.     return im  
    31. 
  
  
  
  
  31. 
  
  
  
  
  32. mask = get_face_mask(im2, landmarks2) 
    33. 
  
  
  
  
  33. warped_mask = warp_im(mask, M, im1.shape) 
    34. 
  
  
  
  
  34. combined_mask = numpy.max([get_face_mask(im1, landmarks1), warped_mask], axis=0)  
    35.

我们把上述过程分解：

  • get_face_mask()的定义是为一张图像和一个标记矩阵生成一个遮罩，它画出了两个白色的凸多边形：一个是眼睛周围的区域，一个是鼻子和嘴部周围的区域。之后它由11个像素向遮罩的边缘外部羽化扩展，可以帮助隐藏任何不连续的区域。

  • 这样一个遮罩同时为这两个图像生成，使用与步骤2中相同的转换，可以使图像2的遮罩转化为图像1的坐标空间。

  • 之后，通过一个element-wise***值，这两个遮罩结合成一个。结合这两个遮罩是为了确保图像1被掩盖，而显现出图像2的特性。

***，使用遮罩得到最终的图像：

 
 
 
 
    
  
  
  
  
  1. output_im = im1 * (1.0 - combined_mask) + warped_corrected_im2 * combined_mask  
    2.

完整代码（link）：

 
 
 
 
    
  
  
  
  
  1. import cv2
    2. 
  
  
  
  
  2. import dlib
    3. 
  
  
  
  
  3. import numpy
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. import sys
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. PREDICTOR_PATH = "/home/matt/dlib-18.16/shape_predictor_68_face_landmarks.dat"
    8. 
  
  
  
  
  8. SCALE_FACTOR = 1
    9. 
  
  
  
  
  9. FEATHER_AMOUNT = 11
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. FACE_POINTS = list(range(17, 68))
    12. 
  
  
  
  
  12. MOUTH_POINTS = list(range(48, 61))
    13. 
  
  
  
  
  13. RIGHT_BROW_POINTS = list(range(17, 22))
    14. 
  
  
  
  
  14. LEFT_BROW_POINTS = list(range(22, 27))
    15. 
  
  
  
  
  15. RIGHT_EYE_POINTS = list(range(36, 42))
    16. 
  
  
  
  
  16. LEFT_EYE_POINTS = list(range(42, 48))
    17. 
  
  
  
  
  17. NOSE_POINTS = list(range(27, 35))
    18. 
  
  
  
  
  18. JAW_POINTS = list(range(0, 17))
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20. # Points used to line up the images.
    21. 
  
  
  
  
  21. ALIGN_POINTS = (LEFT_BROW_POINTS + RIGHT_EYE_POINTS + LEFT_EYE_POINTS +
    22. 
  
  
  
  
  22.                                RIGHT_BROW_POINTS + NOSE_POINTS + MOUTH_POINTS)
    23. 
  
  
  
  
  23.  
    24. 
  
  
  
  
  24. # Points from the second image to overlay on the first. The convex hull of each
    25. 
  
  
  
  
  25. # element will be overlaid.
    26. 
  
  
  
  
  26. OVERLAY_POINTS = [
    27. 
  
  
  
  
  27.     LEFT_EYE_POINTS + RIGHT_EYE_POINTS + LEFT_BROW_POINTS + RIGHT_BROW_POINTS,
    28. 
  
  
  
  
  28.     NOSE_POINTS + MOUTH_POINTS,
    29. 
  
  
  
  
  29. ]
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31. # Amount of blur to use during colour correction, as a fraction of the
    32. 
  
  
  
  
  32. # pupillary distance.
    33. 
  
  
  
  
  33. COLOUR_CORRECT_BLUR_FRAC = 0.6
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35. detector = dlib.get_frontal_face_detector()
    36. 
  
  
  
  
  36. predictor = dlib.shape_predictor(PREDICTOR_PATH)
    37. 
  
  
  
  
  37.  
    38. 
  
  
  
  
  38. class TooManyFaces(Exception):
    39. 
  
  
  
  
  39.     pass
    40. 
  
  
  
  
  40.  
    41. 
  
  
  
  
  41. class NoFaces(Exception):
    42. 
  
  
  
  
  42.     pass
    43. 
  
  
  
  
  43.  
    44. 
  
  
  
  
  44. def get_landmarks(im):
    45. 
  
  
  
  
  45.     rects = detector(im, 1)
    46. 
  
  
  
  
  46.  
    47. 
  
  
  
  
  47.     if len(rects) > 1:
    48. 
  
  
  
  
  48.         raise TooManyFaces
    49. 
  
  
  
  
  49.     if len(rects) == 0:
    50. 
  
  
  
  
  50.         raise NoFaces
    51. 
  
  
  
  
  51.  
    52. 
  
  
  
  
  52.     return numpy.matrix([[p.x, p.y] for p in predictor(im, rects[0]).parts()])
    53. 
  
  
  
  
  53.  
    54. 
  
  
  
  
  54. def annotate_landmarks(im, landmarks):
    55. 
  
  
  
  
  55.     im = im.copy()
    56. 
  
  
  
  
  56.     for idx, point in enumerate(landmarks):
    57. 
  
  
  
  
  57.         pos = (point[0, 0], point[0, 1])
    58. 
  
  
  
  
  58.         cv2.putText(im, str(idx), pos,
    59. 
  
  
  
  
  59.                     fontFace=cv2.FONT_HERSHEY_SCRIPT_SIMPLEX,
    60. 
  
  
  
  
  60.                     fontScale=0.4,
    61. 
  
  
  
  
  61.                     color=(0, 0, 255))
    62. 
  
  
  
  
  62.         cv2.circle(im, pos, 3, color=(0, 255, 255))
    63. 
  
  
  
  
  63.     return im
    64. 
  
  
  
  
  64.  
    65. 
  
  
  
  
  65. def draw_convex_hull(im, points, color):
    66. 
  
  
  
  
  66.     points = cv2.convexHull(points)
    67. 
  
  
  
  
  67.     cv2.fillConvexPoly(im, points, color=color)
    68. 
  
  
  
  
  68.  
    69. 
  
  
  
  
  69. def get_face_mask(im, landmarks):
    70. 
  
  
  
  
  70.     im = numpy.zeros(im.shape[:2], dtype=numpy.float64)
    71. 
  
  
  
  
  71.  
    72. 
  
  
  
  
  72.     for group in OVERLAY_POINTS:
    73. 
  
  
  
  
  73.         draw_convex_hull(im,
    74. 
  
  
  
  
  74.                          landmarks[group],
    75. 
  
  
  
  
  75.                          color=1)
    76. 
  
  
  
  
  76.  
    77. 
  
  
  
  
  77.     im = numpy.array([im, im, im]).transpose((1, 2, 0))
    78. 
  
  
  
  
  78.  
    79. 
  
  
  
  
  79.     im = (cv2.GaussianBlur(im, (FEATHER_AMOUNT, FEATHER_AMOUNT), 0) > 0) * 1.0
    80. 
  
  
  
  
  80.     im = cv2.GaussianBlur(im, (FEATHER_AMOUNT, FEATHER_AMOUNT), 0)
    81. 
  
  
  
  
  81.  
    82. 
  
  
  
  
  82.     return im
    83. 
  
  
  
  
  83.  
    84. 
  
  
  
  
  84. def transformation_from_points(points1, points2):
    85. 
  
  
  
  
  85.     """
    86. 
  
  
  
  
  86.     Return an affine transformation [s * R | T] such that:
    87. 
  
  
  
  
  87.         sum ||s*R*p1,i + T - p2,i||^2
    88. 
  
  
  
  
  88.     is minimized.
    89. 
  
  
  
  
  89.     """
    90. 
  
  
  
  
  90.     # Solve the procrustes problem by subtracting centroids, scaling by the
    91. 
  
  
  
  
  91.     # standard deviation, and then using the SVD to calculate the rotation. See
    92. 
  
  
  
  
  92.     # the following for more details:
    93. 
  
  
  
  
  93.     #   https://en.wikipedia.org/wiki/Orthogonal_Procrustes_problem
    94. 
  
  
  
  
  94.  
    95. 
  
  
  
  
  95.     points1 = points1.astype(numpy.float64)
    96. 
  
  
  
  
  96.     points2 = points2.astype(numpy.float64)
    97. 
  
  
  
  
  97.  
    98. 
  
  
  
  
  98.     c1 = numpy.mean(points1, axis=0)
    99. 
  
  
  
  
  99.     c2 = numpy.mean(points2, axis=0)
    100. 
  
  
  
  
  100.     points1 -= c1
    101. 
  
  
  
  
  101.     points2 -= c2
    102. 
  
  
  
  
  102.  
    103. 
  
  
  
  
  103.     s1 = numpy.std(points1)
    104. 
  
  
  
  
  104.     s2 = numpy.std(points2)
    105. 
  
  
  
  
  105.     points1 /= s1
    106. 
  
  
  
  
  106.     points2 /= s2
    107. 
  
  
  
  
  107.  
    108. 
  
  
  
  
  108.     U, S, Vt = numpy.linalg.svd(points1.T * points2)
    109. 
  
  
  
  
  109.  
    110. 
  
  
  
  
  110.     # The R we seek is in fact the transpose of the one given by U * Vt. This
    111. 
  
  
  
  
  111.     # is because the above formulation assumes the matrix goes on the right
    112. 
  
  
  
  
  112.     # (with row vectors) where as our solution requires the matrix to be on the
    113. 
  
  
  
  
  113.     # left (with column vectors).
    114. 
  
  
  
  
  114.     R = (U * Vt).T
    115. 
  
  
  
  
  115.  
    116. 
  
  
  
  
  116.     return numpy.vstack([numpy.hstack(((s2 / s1) * R,
    117. 
  
  
  
  
  117.                                        c2.T - (s2 / s1) * R * c1.T)),
    118. 
  
  
  
  
  118.                          numpy.matrix([0., 0., 1.])])
    119. 
  
  
  
  
  119.  
    120. 
  
  
  
  
  120. def read_im_and_landmarks(fname):
    121. 
  
  
  
  
  121.     im = cv2.imread(fname, cv2.IMREAD_COLOR)
    122. 
  
  
  
  
  122.     im = cv2.resize(im, (im.shape[1] * SCALE_FACTOR,
    123. 
  
  
  
  
  123.                          im.shape[0] * SCALE_FACTOR))
    124. 
  
  
  
  
  124.     s = get_landmarks(im)
    125. 
  
  
  
  
  125.  
    126. 
  
  
  
  
  126.     return im, s
    127. 
  
  
  
  
  127.  
    128. 
  
  
  
  
  128. def warp_im(im, M, dshape):
    129. 
  
  
  
  
  129.     output_im = numpy.zeros(dshape, dtype=im.dtype)
    130. 
  
  
  
  
  130.     cv2.warpAffine(im,
    131. 
  
  
  
  
  131.                    M[:2],
    132. 
  
  
  
  
  132.                    (dshape[1], dshape[0]),
    133. 
  
  
  
  
  133.                    dst=output_im,
    134. 
  
  
  
  
  134.                    borderMode=cv2.BORDER_TRANSPARENT,
    135. 
  
  
  
  
  135.                    flags=cv2.WARP_INVERSE_MAP)
    136. 
  
  
  
  
  136.     return output_im
    137. 
  
  
  
  
  137.  
    138. 
  
  
  
  
  138. def correct_colours(im1, im2, landmarks1):
    139. 
  
  
  
  
  139.     blur_amount = COLOUR_CORRECT_BLUR_FRAC * numpy.linalg.norm(
    140. 
  
  
  
  
  140.                               numpy.mean(landmarks1[LEFT_EYE_POINTS], axis=0) -
    141. 
  
  
  
  
  141.                               numpy.mean(landmarks1[RIGHT_EYE_POINTS], axis=0))
    142. 
  
  
  
  
  142.     blur_amount = int(blur_amount)
    143. 
  
  
  
  
  143.     if blur_amount % 2 == 0:
    144. 
  
  
  
  
  144.         blur_amount += 1
    145. 
  
  
  
  
  145.     im1_blur = cv2.GaussianBlur(im1, (blur_amount, blur_amount), 0)
    146. 
  
  
  
  
  146.     im2_blur = cv2.GaussianBlur(im2, (blur_amount, blur_amount), 0)
    147. 
  
  
  
  
  147.  
    148. 
  
  
  
  
  148.     # Avoid divide-by-zero errors.
    149. 
  
  
  
  
  149.     im2_blur += 128 * (im2_blur <= 1.0)
    150. 
  
  
  
  
  150.  
    151. 
  
  
  
  
  151.     return (im2.astype(numpy.float64) * im1_blur.astype(numpy.float64) /
    152. 
  
  
  
  
  152.                                                 im2_blur.astype(numpy.float64))
    153. 
  
  
  
  
  153.  
    154. 
  
  
  
  
  154. im1, landmarks1 = read_im_and_landmarks(sys.argv[1])
    155. 
  
  
  
  
  155. im2, landmarks2 = read_im_and_landmarks(sys.argv[2])
    156. 
  
  
  
  
  156.  
    157. 
  
  
  
  
  157. M = transformation_from_points(landmarks1[ALIGN_POINTS],
    158. 
  
  
  
  
  158.                                landmarks2[ALIGN_POINTS])
    159. 
  
  
  
  
  159.  
    160. 
  
  
  
  
  160. mask = get_face_mask(im2, landmarks2)
    161. 
  
  
  
  
  161. warped_mask = warp_im(mask, M, im1.shape)
    162. 
  
  
  
  
  162. combined_mask = numpy.max([get_face_mask(im1, landmarks1), warped_mask],
    163. 
  
  
  
  
  163.                           axis=0)
    164. 
  
  
  
  
  164.  
    165. 
  
  
  
  
  165. warped_im2 = warp_im(im2, M, im1.shape)
    166. 
  
  
  
  
  166. warped_corrected_im2 = correct_colours(im1, warped_im2, landmarks1)
    167. 
  
  
  
  
  167.  
    168. 
  
  
  
  
  168. output_im = im1 * (1.0 - combined_mask) + warped_corrected_im2 * combined_mask
    169. 
  
  
  
  
  169.  
    170. 
  
  
  
  
  170. cv2.imwrite('output.jpg', output_im) 
    171.

分享标题：小200行Python代码做了一个换脸程序
本文网址：http://www.shufengxianlan.com/qtweb/news2/285902.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站建设知识

分类信息网

成都门窗定制　　 　云服务器　　 　自适应网站　　 　seo网络营销推广　　 　网站设计　　 　胜锦安防科技　　 　手机网站设计　　 　四川门窗　　 　建站公司　　 　温江做网站公司　　 　网站推广　　 　简阳做网站　　 　成都微信开发　　 　成都酒店服定制　　 　成都包装设计公司　　 　贵安服务器托管　　 　成都app开发公司　　 　网站制作公司　　 　百度推广公司　　 　泽君科技