30秒教会你利用Python换脸

PREDICTOR_PATH = "/home/matt/dlib-18.16/shape_predictor_68_face_landmarks.dat"

detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(PREDICTOR_PATH)
def get_landmarks(im):

    rects = detector(im, 1)    
    if len(rects) > 1:        
        raise TooManyFaces    
    if len(rects) == 0:        
        raise NoFaces    
    return numpy.matrix([[p.x, p.y] for p in predictor(im, rects[0]).parts()])

def transformation_from_points(points1, points2):

    points1 = points1.astype(numpy.float64)
    points2 = points2.astype(numpy.float64)

    c1 = numpy.mean(points1, axis=0)
    c2 = numpy.mean(points2, axis=0)

    points1 -= c1
    points2 -= c2

    s1 = numpy.std(points1)
    s2 = numpy.std(points2)

    points1 /= s1
    points2 /= s2

    U, S, Vt = numpy.linalg.svd(points1.T * points2)
    R = (U * Vt).T    
    return numpy.vstack([numpy.hstack(((s2 / s1) * 
        R,c2.T - (s2 / s1) * R * c1.T)),
        numpy.matrix([0., 0., 1.])])

代码实现了这几步：

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

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

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

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

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

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

def warp_im(im, M, dshape):

    output_im = numpy.zeros(dshape, dtype=im.dtype)
    cv2.warpAffine(im,
               M[:2],
               (dshape[1], dshape[0]),
               dst=output_im,
               borderMode=cv2.BORDER_TRANSPARENT,
               flags=cv2.WARP_INVERSE_MAP)    
    return output_im

COLOUR_CORRECT_BLUR_FRAC = 0.6LEFT_EYE_POINTS = list(range(42, 48))
RIGHT_EYE_POINTS = list(range(36, 42))def correct_colours(im1, im2, landmarks1):
    blur_amount = COLOUR_CORRECT_BLUR_FRAC * numpy.linalg.norm(
      numpy.mean(landmarks1[LEFT_EYE_POINTS], axis=0) -
      numpy.mean(landmarks1[RIGHT_EYE_POINTS], axis=0))

    blur_amount = int(blur_amount)    if blur_amount % 2 == 0:
        blur_amount += 1

    im1_blur = cv2.GaussianBlur(im1, (blur_amount, blur_amount), 0)
    im2_blur = cv2.GaussianBlur(im2, (blur_amount, blur_amount), 0)    # Avoid divide-by-zero errors.
    im2_blur += 128 * (im2_blur <= 1.0)    
    return (im2.astype(numpy.float64) * im1_blur.astype(numpy.float64) /
            im2_blur.astype(numpy.float64))

LEFT_EYE_POINTS = list(range(42, 48))
RIGHT_EYE_POINTS = list(range(36, 42))
LEFT_BROW_POINTS = list(range(22, 27))
RIGHT_BROW_POINTS = list(range(17, 22))
NOSE_POINTS = list(range(27, 35))
MOUTH_POINTS = list(range(48, 61))
OVERLAY_POINTS = [
    LEFT_EYE_POINTS + RIGHT_EYE_POINTS + LEFT_BROW_POINTS + RIGHT_BROW_POINTS,
    NOSE_POINTS + MOUTH_POINTS,
]
FEATHER_AMOUNT = 11def draw_convex_hull(im, points, color):
    points = cv2.convexHull(points)
    cv2.fillConvexPoly(im, points, color=color)def get_face_mask(im, landmarks):
    im = numpy.zeros(im.shape[:2], dtype=numpy.float64)    for group in OVERLAY_POINTS:
        draw_convex_hull(im,
             landmarks[group],
             color=1)

    im = numpy.array([im, im, im]).transpose((1, 2, 0))
    im = (cv2.GaussianBlur(im, (FEATHER_AMOUNT, FEATHER_AMOUNT), 0) > 0) * 1.0
    im = cv2.GaussianBlur(im, (FEATHER_AMOUNT, FEATHER_AMOUNT), 0)    return im

mask = get_face_mask(im2, landmarks2)
warped_mask = warp_im(mask, M, im1.shape)
combined_mask = numpy.max([get_face_mask(im1, landmarks1), warped_mask],
    axis=0)

我们把上述过程分解：

get_face_mask()的定义是为一张图像和一个标记矩阵生成一个遮罩，它画出了两个白色的凸多边形：一个是眼睛周围的区域，一个是鼻子和嘴部周围的区域。

之后它由11个像素向遮罩的边缘外部羽化扩展，可以帮助隐藏任何不连续的区域。

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

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

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

output_im = im1 * (1.0 - combined_mask) + warped_corrected_im2 * combined_mask