File size: 5,802 Bytes
bfeeed7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | import numpy as np
from scipy.interpolate import griddata
import argparse
import os
def to_image(prokected_points, h, w):
'''
transform the center to (0,0)
'''
image_vertices = prokected_points.copy()
image_vertices[:,0] = image_vertices[:,0] + w/2
image_vertices[:,1] = image_vertices[:,1] + h/2
image_vertices[:,1] = h - image_vertices[:,1] - 1
return image_vertices
def orthogonal_transform(points3D, scale, R, t):
'''
orthogonal transform
'''
t3d = np.squeeze(np.array(t, dtype = np.float32))
transformed_vertices = scale * points3D.dot(R.T) + t3d[np.newaxis, :]
return transformed_vertices
def project_to_image(points3D, scale, R, t, h, w):
'''
project 3D points to 2d plane in orthogonal projection
'''
prokected_points = orthogonal_transform(points3D, scale, R, t)
prokected_points = to_image(prokected_points, h, w)
return prokected_points
def compute_projected_mesh_points(shape_para,exp_para,R,T,scale,image_size,model_3dmm):
'''
compute the projected mesh points from facial animation parameters
:param shape_para: the shape parameter of reference face
:param scale: the scale parameter in orthogonal projection
:param exp_para: the expression parameter in orthogonal projection
:param R: the head rotation in orthogonal projection
:param T: the head translation in orthogonal projection
:param image_size: the size of image
:param model_3dmm: 3dmm model
:return: projected_mesh_points
'''
shape_para = np.expand_dims(shape_para, 1)
exp_para = np.expand_dims(exp_para, 1)
R_matrix = R.reshape((3, 3))
## compute 3d mesh points in 3DMM
mesh_points_3D = model_3dmm.generate_vertices(shape_para, exp_para)
## project 3D points to 2D plane
projected_2Dpoints = project_to_image(mesh_points_3D, scale, R_matrix, T, image_size[0], image_size[1])
return projected_2Dpoints
def make_coordinate_grid(image_size):
h, w = image_size
x = np.arange(w)
y = np.arange(h)
x = (2 * (x / (w - 1)) - 1)
y = (2 * (y / (h - 1)) - 1)
xx = x.reshape(1, -1).repeat(h, axis=0)
yy = y.reshape(-1, 1).repeat(w, axis=1)
meshed = np.stack([xx, yy], 2)
return meshed
def construct_Fapp(reference_projected_mesh_points,
drive_projected_mesh_points,image_size):
'''
compute Fapp from projected mesh points
reference_projected_mesh_points: the projected mesh points of reference image
drive_projected_mesh_points: the driving projected mesh points
'''
## resize to -1 ~ 1
reference_projected_mesh_points = (reference_projected_mesh_points / image_size * 2) - 1
### compute the max heigh of face
face_max_h = np.max(drive_projected_mesh_points[:, 1]).astype(np.int)
## resize to -1 ~ 1
drive_projected_mesh_points = (drive_projected_mesh_points / image_size * 2) - 1
drive_projected_mesh_points_yx = drive_projected_mesh_points[:, [1, 0]]
## compute sparse dense flow
sparse_dense_flow = reference_projected_mesh_points - drive_projected_mesh_points
## compute average head motion
mean_dense_flow = np.mean(sparse_dense_flow, axis=0)
## compute the dense flow in head-related region
grid_nums = complex(str(image_size) + "j")
grid_y, grid_x = np.mgrid[-1:1:grid_nums, -1:1:grid_nums]
dense_foreground_flow_x = griddata(drive_projected_mesh_points_yx, sparse_dense_flow[:, 0], (grid_y, grid_x), method='nearest')
## compute dense flow in torso related region
dense_foreground_flow_x[face_max_h:, :] = mean_dense_flow[0]
dense_foreground_flow_y = griddata(drive_projected_mesh_points_yx, sparse_dense_flow[:, 1], (grid_y, grid_x), method='nearest')
dense_foreground_flow_y[face_max_h:, :] = mean_dense_flow[1]
Fapp = np.stack([dense_foreground_flow_x, dense_foreground_flow_y], 2)
## transform into grid data
grid_mesh = make_coordinate_grid((image_size,image_size))
Fapp = grid_mesh + Fapp
return Fapp
def parse_opts():
parser = argparse.ArgumentParser(description='construct Fapp')
parser.add_argument('--reference_projected_mesh_points_path', type=str,
default='./test_data/taile_source_points.npy',
help='the projected mesh points of reference image')
parser.add_argument('--drive_projected_mesh_points_path', type=str,
default='./test_data/taile_drive_points.npy',
help='the driving projected mesh points')
parser.add_argument('--image_size', type=int, default=512, help='the size of image')
parser.add_argument('--res_dir', type=str,default='./result',help='the dir of results')
args = parser.parse_args()
return args
if __name__ == "__main__":
'''
It is not allowed to share the 3DMM model, so we release the inference code
of constructing Fapp from projected mesh points.the function
"compute_projected_mesh_points" shows how to compute
projected mesh points from facial animation parameters.
'''
opt = parse_opts()
reference_projected_mesh_points = np.load(opt.reference_projected_mesh_points_path)
drive_projected_mesh_points = np.load(opt.drive_projected_mesh_points_path)
frame_num = drive_projected_mesh_points.shape[0]
res_Fapp = []
for i in range(frame_num):
print('construct {}/{} Fapp'.format(i,frame_num))
Fapp_i = construct_Fapp(reference_projected_mesh_points,
drive_projected_mesh_points[i,:,:],opt.image_size)
res_Fapp.append(Fapp_i)
res_Fapp = np.stack(res_Fapp,0)
res_Fapp_path = os.path.join(opt.res_dir,os.path.basename(opt.reference_projected_mesh_points_path).replace('_source_points','_Fapp'))
np.save(res_Fapp_path,res_Fapp)
|