File size: 5,946 Bytes
85c3bfc | 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 133 134 135 136 137 138 139 | # Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
#
import torch
import numpy as np
import json
from glob import glob
import os.path as osp
import smplx
import cv2
import os
import random
from plyfile import PlyData, PlyElement
from pytorch3d.structures import Meshes
from pytorch3d.renderer import (
PointLights,
DirectionalLights,
PerspectiveCameras,
Materials,
SoftPhongShader,
RasterizationSettings,
MeshRenderer,
MeshRendererWithFragments,
MeshRasterizer,
TexturesVertex)
def load_ply(file_name):
plydata = PlyData.read(file_name)
x = plydata['vertex']['x']
y = plydata['vertex']['y']
z = plydata['vertex']['z']
v = np.stack((x,y,z),1)
return v
def render_mesh(mesh, face, cam_param, render_shape, hand_type):
mesh = torch.bmm(cam_param['R'], mesh.permute(0,2,1)).permute(0,2,1) + cam_param['t'].view(-1,1,3)
batch_size, vertex_num = mesh.shape[:2]
textures = TexturesVertex(verts_features=torch.ones((batch_size,vertex_num,3)).float().cuda())
mesh = torch.stack((-mesh[:,:,0], -mesh[:,:,1], mesh[:,:,2]),2) # reverse x- and y-axis following PyTorch3D axis direction
mesh = Meshes(mesh, face, textures)
cameras = PerspectiveCameras(focal_length=cam_param['focal'],
principal_point=cam_param['princpt'],
device='cuda',
in_ndc=False,
image_size=torch.LongTensor(render_shape).cuda().view(1,2))
raster_settings = RasterizationSettings(image_size=render_shape, blur_radius=0.0, faces_per_pixel=1, perspective_correct=True)
rasterizer = MeshRasterizer(cameras=cameras, raster_settings=raster_settings).cuda()
lights = PointLights(device='cuda')
shader = SoftPhongShader(device='cuda', cameras=cameras, lights=lights)
if hand_type == 'right':
color = ((1.0, 0.0, 0.0),)
else:
color = ((0.0, 1.0, 0.0),)
materials = Materials(
device='cuda',
specular_color=color,
shininess=0
)
# render
with torch.no_grad():
renderer = MeshRendererWithFragments(rasterizer=rasterizer, shader=shader)
images, fragments = renderer(mesh, materials=materials)
image = images[:,:,:,:3] * 255
depthmap = fragments.zbuf.float()
mask = depthmap > 0
return image, depthmap, mask
data_root_path = ''
mano_root_path = ''
capture_id = 'm--20210701--1058--0000000--pilot--relightablehandsy--participant0--two-hands'
envmap_mode = 'envmap_per_frame' # envmap_per_frame, envmap_per_segment
mano_layer = {'right': smplx.create(mano_root_path, 'mano', is_rhand=True, use_pca=False, flat_hand_mean=False).cuda(), 'left': smplx.create(mano_root_path, 'mano', is_rhand=False, use_pca=False, flat_hand_mean=False).cuda()}
# fix MANO shapedirs of the left hand bug (https://github.com/vchoutas/smplx/issues/48)
if torch.sum(torch.abs(mano_layer['left'].shapedirs[:,0,:] - mano_layer['right'].shapedirs[:,0,:])) < 1:
print('Fix shapedirs bug of MANO')
mano_layer['left'].shapedirs[:,0,:] *= -1
with open(osp.join(data_root_path, capture_id, 'Mugsy_cameras', 'cam_params.json')) as f:
cam_params = json.load(f)
cam_path_list = glob(osp.join(data_root_path, capture_id, 'Mugsy_cameras', envmap_mode, 'images', '*'))
for cam_path in cam_path_list:
cam_name = cam_path.split('/')[-1]
cam_param = cam_params[cam_name]
R, t = torch.FloatTensor(cam_param['R']).view(1,3,3).cuda(), torch.FloatTensor(cam_param['t']).view(1,3).cuda() / 1000 # millimeter to meter
focal, princpt = torch.FloatTensor(cam_param['focal']).view(1,2).cuda(), torch.FloatTensor(cam_param['princpt']).view(1,2).cuda()
img_path_list = glob(osp.join(cam_path, '*.png'))
for img_path in img_path_list:
frame_idx = int(img_path.split('/')[-1][:-4])
img = cv2.imread(img_path)
img_height, img_width = img.shape[:2]
prev_depth = None
for h in ('right', 'left'):
# option 1: get mesh from parameters
with open(osp.join(data_root_path, capture_id, 'mano_fits', 'params', str(frame_idx) + '_' + h + '.json')) as f:
mano_param = json.load(f)
pose = torch.FloatTensor(mano_param['pose']).view(1,-1).cuda()
shape = torch.FloatTensor(mano_param['shape']).view(1,-1).cuda()
trans = torch.FloatTensor(mano_param['trans']).view(1,-1).cuda()
with torch.no_grad():
output = mano_layer[h](global_orient=pose[:,:3], hand_pose=pose[:,3:], betas=shape, transl=trans)
mesh = output.vertices
# option 2: load mesh
#mesh = load_ply(osp.join(data_root_path, capture_id, 'mano_fits', 'meshes', str(frame_idx) + '_' + h + '.ply'))
#mesh = mesh / 1000 # millimeter to meter
#mesh = torch.from_numpy(mesh).float().cuda()[None,:,:]
# render
face = torch.LongTensor(mano_layer[h].faces.astype(np.int32))[None,:,:].cuda()
rgb, depth, valid_mask = render_mesh(mesh, face, {'R': R, 't': t, 'focal': focal, 'princpt': princpt}, (img_height, img_width), h)
rgb, depth, valid_mask = rgb.cpu().numpy()[0], depth.cpu().numpy()[0], valid_mask.cpu().numpy()[0]
if prev_depth is None:
render_mask = valid_mask
img = rgb * render_mask + img * (1 - render_mask)
prev_depth = depth
else:
render_mask = valid_mask * np.logical_or(depth < prev_depth, prev_depth<=0)
img = rgb * render_mask + img * (1 - render_mask)
prev_depth = depth * render_mask + prev_depth * (1 - render_mask)
cv2.imwrite(capture_id + '_' + cam_name + '_' + str(frame_idx) + '.jpg', img)
print('saved')
|