| """Render a slow shared-camera orbit, keeping mesh and real Gaussian assets loaded. |
| |
| The camera moves around the foreground bounds' center in the gravity XY plane. |
| No input/completed-background image is used for compositing. Output is isolated. |
| """ |
| import argparse |
| import json |
| from pathlib import Path |
| import time |
|
|
| import numpy as np |
| from PIL import Image |
|
|
| from package_trajectories import digest, write_json |
| import render_kernels as kernels |
| from render_scene import orbit_camera |
|
|
|
|
| def gaussian_tensors(vertices, device): |
| import torch |
| stack = lambda names: kernels.stack_fields(vertices, names) |
| to = lambda v: torch.from_numpy(np.ascontiguousarray(v)).to(device) |
| quats = stack(['rot_0', 'rot_1', 'rot_2', 'rot_3']) |
| quats /= np.linalg.norm(quats, axis=1, keepdims=True) |
| return dict(means=to(stack(['x', 'y', 'z'])), |
| scales=to(np.exp(stack(['scale_0', 'scale_1', 'scale_2']))), |
| quats=to(quats), opacities=to(1. / (1. + np.exp(-vertices['opacity'].astype(np.float32)))), |
| harmonics=to(stack(['f_dc_0', 'f_dc_1', 'f_dc_2'])[:, None, :])) |
|
|
|
|
| def render(scene, output, device='cuda:0', width=320, amplitude=10., frames=81, fps=10): |
| import pyrender |
| import trimesh |
| import torch |
| from plyfile import PlyData |
|
|
| started = time.monotonic() |
| contract_path = scene / 'render/scene.json' |
| contract = json.loads(contract_path.read_text()) |
| assert contract['same_camera'] and contract['compositing_policy'] == 'foreground_alpha_priority_over_real_gs' |
| fg_path, bg_path = scene / contract['foreground'], scene / contract['background'] |
| hashes = dict(camera_contract=digest(contract_path), foreground=digest(fg_path), background=digest(bg_path)) |
| source_w, source_h = contract['image_size_wh'] |
| height = round(width * source_h / source_w) |
| k = np.asarray(contract['intrinsic'], dtype=float) |
| k[0] *= width / source_w |
| k[1] *= height / source_h |
| mesh = trimesh.load(fg_path, force='scene', process=False) |
| pivot = np.asarray(mesh.bounds).mean(axis=0) |
| ps = pyrender.Scene.from_trimesh_scene(mesh, bg_color=np.zeros(4), ambient_light=np.ones(3) * .75) |
| camera = pyrender.IntrinsicsCamera(fx=k[0, 0], fy=k[1, 1], cx=k[0, 2], cy=k[1, 2], znear=.01, zfar=10000.) |
| cam_node = ps.add(camera) |
| light_node = ps.add(pyrender.DirectionalLight(color=np.ones(3), intensity=2.)) |
| wb0 = np.asarray(contract['world_to_camera_background']) |
| gauge = contract['background_gauge'] |
| proof = None |
| if contract['background_renderer'] == 'camera_gauge_sh0': |
| vertices = PlyData.read(str(bg_path))['vertex'].data |
| normalized, proof = kernels.normalize_reloaded_output_for_render(vertices, wb0, k, float(gauge)) |
| gaussians = gaussian_tensors(normalized, device) |
| del vertices, normalized |
| else: |
| assert contract['background_renderer'] == 'world' |
| gaussians = kernels.load_gaussians(bg_path, device) |
| output.mkdir(parents=True, exist_ok=True) |
| if proof: |
| write_json(output / 'normalization.json', proof) |
| |
| angles = np.interp(np.linspace(0, 1, frames), [0, .25, .75, 1], [0, amplitude, -amplitude, 0]) |
| renderer = pyrender.OffscreenRenderer(width, height) |
| rows = [] |
| images = [] |
| try: |
| for index, angle in enumerate(angles): |
| wf, wb = orbit_camera(contract, float(angle), pivot) |
| pose = np.linalg.inv(wf) @ np.diag([1., -1., -1., 1.]) |
| ps.set_pose(cam_node, pose) |
| ps.set_pose(light_node, pose) |
| rgba, depth = renderer.render(ps, flags=pyrender.RenderFlags.RGBA | pyrender.RenderFlags.SKIP_CULL_FACES) |
| bg_view = wb.copy() |
| if contract['background_renderer'] == 'camera_gauge_sh0': |
| bg_view = wb @ np.linalg.inv(wb0) |
| bg_view[:3, 3] /= float(gauge) |
| if angle == 0: |
| bg_view = np.eye(4) |
| with torch.inference_mode(): |
| bg, _, coverage = kernels.render_gaussians(gaussians, bg_view, k, width, height, contract['background_color']) |
| fg = rgba.astype(np.float32) / 255. |
| alpha = (fg[:, :, 3] * (depth > 0))[:, :, None] |
| rgb = np.rint(np.clip(fg[:, :, :3] * alpha + bg * (1 - alpha), 0, 1) * 255).astype(np.uint8) |
| im = Image.fromarray(rgb) |
| im.save(output / f'frame_{index:03d}.png') |
| images.append(im) |
| rows.append(dict(frame=index, angle_degrees=float(angle), foreground_coverage=float((depth > 0).mean()), |
| background_coverage=float((coverage > .02).mean()), world_to_camera_foreground=wf.tolist(), |
| world_to_camera_background=wb.tolist())) |
| assert digest(fg_path) == hashes['foreground'] and digest(contract_path) == hashes['camera_contract'], 'Input changed during rendering' |
| images[0].save(output / 'orbit.gif', save_all=True, append_images=images[1:], duration=round(1000 / fps), loop=0) |
| report = dict(scene=scene.name, status='rendered', hashes=hashes, frames=rows, fps=fps, |
| amplitude_degrees=amplitude, image_size_wh=[width, height], pivot_world=pivot.tolist(), |
| background_source='marble_gaussian_ply', same_camera=True, |
| compositing_policy=contract['compositing_policy'], |
| elapsed_seconds=round(time.monotonic() - started, 3)) |
| write_json(output / 'orbit.json', report) |
| print(json.dumps({k: v for k, v in report.items() if k != 'frames'}), flush=True) |
| finally: |
| renderer.delete() |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument('--scene', type=Path, required=True) |
| p.add_argument('--output-dir', type=Path, required=True) |
| p.add_argument('--device', default='cuda:0') |
| p.add_argument('--width', type=int, default=320) |
| p.add_argument('--amplitude', type=float, default=10) |
| p.add_argument('--frames', type=int, default=81) |
| p.add_argument('--fps', type=int, default=10) |
| a = p.parse_args() |
| assert a.frames >= 2 and a.fps > 0 and a.width > 0 |
| render(a.scene, a.output_dir, a.device, a.width, a.amplitude, a.frames, a.fps) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
