Spaces:
Sleeping
Sleeping
| # -*- coding: utf-8 -*- | |
| # Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is | |
| # holder of all proprietary rights on this computer program. | |
| # You can only use this computer program if you have closed | |
| # a license agreement with MPG or you get the right to use the computer | |
| # program from someone who is authorized to grant you that right. | |
| # Any use of the computer program without a valid license is prohibited and | |
| # liable to prosecution. | |
| # | |
| # Copyright©2019 Max-Planck-Gesellschaft zur Förderung | |
| # der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute | |
| # for Intelligent Systems. All rights reserved. | |
| # | |
| # Contact: ps-license@tuebingen.mpg.de | |
| import os | |
| from lib.renderer.mesh import load_scan, compute_tangent | |
| from lib.renderer.camera import Camera | |
| import cv2 | |
| import math | |
| import random | |
| import numpy as np | |
| def render_result(rndr, shader_id, path, mask=False): | |
| cam_render = rndr.get_color(shader_id) | |
| cam_render = cv2.cvtColor(cam_render, cv2.COLOR_RGBA2BGRA) | |
| os.makedirs(os.path.dirname(path), exist_ok=True) | |
| if shader_id != 2: | |
| cv2.imwrite(path, np.uint8(255.0 * cam_render)) | |
| else: | |
| cam_render[:, :, -1] -= 0.5 | |
| cam_render[:, :, -1] *= 2.0 | |
| if not mask: | |
| cv2.imwrite(path, np.uint8(255.0 / 2.0 * (cam_render + 1.0))) | |
| else: | |
| cv2.imwrite(path, np.uint8(-1.0 * cam_render[:, :, [3]])) | |
| def make_rotate(rx, ry, rz): | |
| sinX = np.sin(rx) | |
| sinY = np.sin(ry) | |
| sinZ = np.sin(rz) | |
| cosX = np.cos(rx) | |
| cosY = np.cos(ry) | |
| cosZ = np.cos(rz) | |
| Rx = np.zeros((3, 3)) | |
| Rx[0, 0] = 1.0 | |
| Rx[1, 1] = cosX | |
| Rx[1, 2] = -sinX | |
| Rx[2, 1] = sinX | |
| Rx[2, 2] = cosX | |
| Ry = np.zeros((3, 3)) | |
| Ry[0, 0] = cosY | |
| Ry[0, 2] = sinY | |
| Ry[1, 1] = 1.0 | |
| Ry[2, 0] = -sinY | |
| Ry[2, 2] = cosY | |
| Rz = np.zeros((3, 3)) | |
| Rz[0, 0] = cosZ | |
| Rz[0, 1] = -sinZ | |
| Rz[1, 0] = sinZ | |
| Rz[1, 1] = cosZ | |
| Rz[2, 2] = 1.0 | |
| R = np.matmul(np.matmul(Rz, Ry), Rx) | |
| return R | |
| def rotateSH(SH, R): | |
| SHn = SH | |
| # 1st order | |
| SHn[1] = R[1, 1] * SH[1] - R[1, 2] * SH[2] + R[1, 0] * SH[3] | |
| SHn[2] = -R[2, 1] * SH[1] + R[2, 2] * SH[2] - R[2, 0] * SH[3] | |
| SHn[3] = R[0, 1] * SH[1] - R[0, 2] * SH[2] + R[0, 0] * SH[3] | |
| # 2nd order | |
| SHn[4:, 0] = rotateBand2(SH[4:, 0], R) | |
| SHn[4:, 1] = rotateBand2(SH[4:, 1], R) | |
| SHn[4:, 2] = rotateBand2(SH[4:, 2], R) | |
| return SHn | |
| def rotateBand2(x, R): | |
| s_c3 = 0.94617469575 | |
| s_c4 = -0.31539156525 | |
| s_c5 = 0.54627421529 | |
| s_c_scale = 1.0 / 0.91529123286551084 | |
| s_c_scale_inv = 0.91529123286551084 | |
| s_rc2 = 1.5853309190550713 * s_c_scale | |
| s_c4_div_c3 = s_c4 / s_c3 | |
| s_c4_div_c3_x2 = (s_c4 / s_c3) * 2.0 | |
| s_scale_dst2 = s_c3 * s_c_scale_inv | |
| s_scale_dst4 = s_c5 * s_c_scale_inv | |
| sh0 = x[3] + x[4] + x[4] - x[1] | |
| sh1 = x[0] + s_rc2 * x[2] + x[3] + x[4] | |
| sh2 = x[0] | |
| sh3 = -x[3] | |
| sh4 = -x[1] | |
| r2x = R[0][0] + R[0][1] | |
| r2y = R[1][0] + R[1][1] | |
| r2z = R[2][0] + R[2][1] | |
| r3x = R[0][0] + R[0][2] | |
| r3y = R[1][0] + R[1][2] | |
| r3z = R[2][0] + R[2][2] | |
| r4x = R[0][1] + R[0][2] | |
| r4y = R[1][1] + R[1][2] | |
| r4z = R[2][1] + R[2][2] | |
| sh0_x = sh0 * R[0][0] | |
| sh0_y = sh0 * R[1][0] | |
| d0 = sh0_x * R[1][0] | |
| d1 = sh0_y * R[2][0] | |
| d2 = sh0 * (R[2][0] * R[2][0] + s_c4_div_c3) | |
| d3 = sh0_x * R[2][0] | |
| d4 = sh0_x * R[0][0] - sh0_y * R[1][0] | |
| sh1_x = sh1 * R[0][2] | |
| sh1_y = sh1 * R[1][2] | |
| d0 += sh1_x * R[1][2] | |
| d1 += sh1_y * R[2][2] | |
| d2 += sh1 * (R[2][2] * R[2][2] + s_c4_div_c3) | |
| d3 += sh1_x * R[2][2] | |
| d4 += sh1_x * R[0][2] - sh1_y * R[1][2] | |
| sh2_x = sh2 * r2x | |
| sh2_y = sh2 * r2y | |
| d0 += sh2_x * r2y | |
| d1 += sh2_y * r2z | |
| d2 += sh2 * (r2z * r2z + s_c4_div_c3_x2) | |
| d3 += sh2_x * r2z | |
| d4 += sh2_x * r2x - sh2_y * r2y | |
| sh3_x = sh3 * r3x | |
| sh3_y = sh3 * r3y | |
| d0 += sh3_x * r3y | |
| d1 += sh3_y * r3z | |
| d2 += sh3 * (r3z * r3z + s_c4_div_c3_x2) | |
| d3 += sh3_x * r3z | |
| d4 += sh3_x * r3x - sh3_y * r3y | |
| sh4_x = sh4 * r4x | |
| sh4_y = sh4 * r4y | |
| d0 += sh4_x * r4y | |
| d1 += sh4_y * r4z | |
| d2 += sh4 * (r4z * r4z + s_c4_div_c3_x2) | |
| d3 += sh4_x * r4z | |
| d4 += sh4_x * r4x - sh4_y * r4y | |
| dst = x | |
| dst[0] = d0 | |
| dst[1] = -d1 | |
| dst[2] = d2 * s_scale_dst2 | |
| dst[3] = -d3 | |
| dst[4] = d4 * s_scale_dst4 | |
| return dst | |
| def load_calib(param, render_size=512): | |
| # pixel unit / world unit | |
| ortho_ratio = param['ortho_ratio'] | |
| # world unit / model unit | |
| scale = param['scale'] | |
| # camera center world coordinate | |
| center = param['center'] | |
| # model rotation | |
| R = param['R'] | |
| translate = -np.matmul(R, center).reshape(3, 1) | |
| extrinsic = np.concatenate([R, translate], axis=1) | |
| extrinsic = np.concatenate( | |
| [extrinsic, np.array([0, 0, 0, 1]).reshape(1, 4)], 0) | |
| # Match camera space to image pixel space | |
| scale_intrinsic = np.identity(4) | |
| scale_intrinsic[0, 0] = scale / ortho_ratio | |
| scale_intrinsic[1, 1] = -scale / ortho_ratio | |
| scale_intrinsic[2, 2] = scale / ortho_ratio | |
| # Match image pixel space to image uv space | |
| uv_intrinsic = np.identity(4) | |
| uv_intrinsic[0, 0] = 1.0 / float(render_size // 2) | |
| uv_intrinsic[1, 1] = 1.0 / float(render_size // 2) | |
| uv_intrinsic[2, 2] = 1.0 / float(render_size // 2) | |
| intrinsic = np.matmul(uv_intrinsic, scale_intrinsic) | |
| calib = np.concatenate([extrinsic, intrinsic], axis=0) | |
| return calib | |
| def render_prt_ortho(out_path, | |
| folder_name, | |
| subject_name, | |
| shs, | |
| rndr, | |
| rndr_uv, | |
| im_size, | |
| angl_step=4, | |
| n_light=1, | |
| pitch=[0]): | |
| cam = Camera(width=im_size, height=im_size) | |
| cam.ortho_ratio = 0.4 * (512 / im_size) | |
| cam.near = -100 | |
| cam.far = 100 | |
| cam.sanity_check() | |
| # set path for obj, prt | |
| mesh_file = os.path.join(folder_name, subject_name + '_100k.obj') | |
| if not os.path.exists(mesh_file): | |
| print('ERROR: obj file does not exist!!', mesh_file) | |
| return | |
| prt_file = os.path.join(folder_name, 'bounce', 'bounce0.txt') | |
| if not os.path.exists(prt_file): | |
| print('ERROR: prt file does not exist!!!', prt_file) | |
| return | |
| face_prt_file = os.path.join(folder_name, 'bounce', 'face.npy') | |
| if not os.path.exists(face_prt_file): | |
| print('ERROR: face prt file does not exist!!!', prt_file) | |
| return | |
| text_file = os.path.join(folder_name, 'tex', subject_name + '_dif_2k.jpg') | |
| if not os.path.exists(text_file): | |
| print('ERROR: dif file does not exist!!', text_file) | |
| return | |
| texture_image = cv2.imread(text_file) | |
| texture_image = cv2.cvtColor(texture_image, cv2.COLOR_BGR2RGB) | |
| vertices, faces, normals, faces_normals, textures, face_textures = load_scan( | |
| mesh_file, with_normal=True, with_texture=True) | |
| vmin = vertices.min(0) | |
| vmax = vertices.max(0) | |
| up_axis = 1 if (vmax - vmin).argmax() == 1 else 2 | |
| vmed = np.median(vertices, 0) | |
| vmed[up_axis] = 0.5 * (vmax[up_axis] + vmin[up_axis]) | |
| y_scale = 180 / (vmax[up_axis] - vmin[up_axis]) | |
| rndr.set_norm_mat(y_scale, vmed) | |
| rndr_uv.set_norm_mat(y_scale, vmed) | |
| tan, bitan = compute_tangent(vertices, faces, normals, textures, | |
| face_textures) | |
| prt = np.loadtxt(prt_file) | |
| face_prt = np.load(face_prt_file) | |
| rndr.set_mesh(vertices, faces, normals, faces_normals, textures, | |
| face_textures, prt, face_prt, tan, bitan) | |
| rndr.set_albedo(texture_image) | |
| rndr_uv.set_mesh(vertices, faces, normals, faces_normals, textures, | |
| face_textures, prt, face_prt, tan, bitan) | |
| rndr_uv.set_albedo(texture_image) | |
| os.makedirs(os.path.join(out_path, 'GEO', 'OBJ', subject_name), | |
| exist_ok=True) | |
| os.makedirs(os.path.join(out_path, 'PARAM', subject_name), exist_ok=True) | |
| os.makedirs(os.path.join(out_path, 'RENDER', subject_name), exist_ok=True) | |
| os.makedirs(os.path.join(out_path, 'MASK', subject_name), exist_ok=True) | |
| os.makedirs(os.path.join(out_path, 'UV_RENDER', subject_name), | |
| exist_ok=True) | |
| os.makedirs(os.path.join(out_path, 'UV_MASK', subject_name), exist_ok=True) | |
| os.makedirs(os.path.join(out_path, 'UV_POS', subject_name), exist_ok=True) | |
| os.makedirs(os.path.join(out_path, 'UV_NORMAL', subject_name), | |
| exist_ok=True) | |
| if not os.path.exists(os.path.join(out_path, 'val.txt')): | |
| f = open(os.path.join(out_path, 'val.txt'), 'w') | |
| f.close() | |
| # copy obj file | |
| cmd = 'cp %s %s' % (mesh_file, | |
| os.path.join(out_path, 'GEO', 'OBJ', subject_name)) | |
| print(cmd) | |
| os.system(cmd) | |
| for p in pitch: | |
| for y in tqdm(range(0, 360, angl_step)): | |
| R = np.matmul(make_rotate(math.radians(p), 0, 0), | |
| make_rotate(0, math.radians(y), 0)) | |
| if up_axis == 2: | |
| R = np.matmul(R, make_rotate(math.radians(90), 0, 0)) | |
| rndr.rot_matrix = R | |
| rndr_uv.rot_matrix = R | |
| rndr.set_camera(cam) | |
| rndr_uv.set_camera(cam) | |
| for j in range(n_light): | |
| sh_id = random.randint(0, shs.shape[0] - 1) | |
| sh = shs[sh_id] | |
| sh_angle = 0.2 * np.pi * (random.random() - 0.5) | |
| sh = rotateSH(sh, make_rotate(0, sh_angle, 0).T) | |
| dic = { | |
| 'sh': sh, | |
| 'ortho_ratio': cam.ortho_ratio, | |
| 'scale': y_scale, | |
| 'center': vmed, | |
| 'R': R | |
| } | |
| rndr.set_sh(sh) | |
| rndr.analytic = False | |
| rndr.use_inverse_depth = False | |
| rndr.display() | |
| out_all_f = rndr.get_color(0) | |
| out_mask = out_all_f[:, :, 3] | |
| out_all_f = cv2.cvtColor(out_all_f, cv2.COLOR_RGBA2BGR) | |
| np.save( | |
| os.path.join(out_path, 'PARAM', subject_name, | |
| '%d_%d_%02d.npy' % (y, p, j)), dic) | |
| cv2.imwrite( | |
| os.path.join(out_path, 'RENDER', subject_name, | |
| '%d_%d_%02d.jpg' % (y, p, j)), | |
| 255.0 * out_all_f) | |
| cv2.imwrite( | |
| os.path.join(out_path, 'MASK', subject_name, | |
| '%d_%d_%02d.png' % (y, p, j)), | |
| 255.0 * out_mask) | |
| rndr_uv.set_sh(sh) | |
| rndr_uv.analytic = False | |
| rndr_uv.use_inverse_depth = False | |
| rndr_uv.display() | |
| uv_color = rndr_uv.get_color(0) | |
| uv_color = cv2.cvtColor(uv_color, cv2.COLOR_RGBA2BGR) | |
| cv2.imwrite( | |
| os.path.join(out_path, 'UV_RENDER', subject_name, | |
| '%d_%d_%02d.jpg' % (y, p, j)), | |
| 255.0 * uv_color) | |
| if y == 0 and j == 0 and p == pitch[0]: | |
| uv_pos = rndr_uv.get_color(1) | |
| uv_mask = uv_pos[:, :, 3] | |
| cv2.imwrite( | |
| os.path.join(out_path, 'UV_MASK', subject_name, | |
| '00.png'), 255.0 * uv_mask) | |
| data = { | |
| 'default': uv_pos[:, :, :3] | |
| } # default is a reserved name | |
| pyexr.write( | |
| os.path.join(out_path, 'UV_POS', subject_name, | |
| '00.exr'), data) | |
| uv_nml = rndr_uv.get_color(2) | |
| uv_nml = cv2.cvtColor(uv_nml, cv2.COLOR_RGBA2BGR) | |
| cv2.imwrite( | |
| os.path.join(out_path, 'UV_NORMAL', subject_name, | |
| '00.png'), 255.0 * uv_nml) | |