| """Render real Marble GS and mesh foreground through the release camera contract. |
| |
| Outputs only to --output-dir; never replaces accepted assets. The background |
| cache is invalidated by PLY, camera, renderer, resolution, or policy changes. |
| """ |
| import argparse |
| import hashlib |
| 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 |
|
|
|
|
| def orbit_camera(contract, angle_degrees, pivot): |
| from scipy.spatial.transform import Rotation |
| wf = np.asarray(contract['world_to_camera_foreground'], dtype=np.float64) |
| if angle_degrees == 0: |
| return wf, np.asarray(contract['world_to_camera_background'], dtype=np.float64) |
| transform = np.eye(4) |
| transform[:3, :3] = Rotation.from_euler('z', angle_degrees, degrees=True).as_matrix() |
| transform[:3, 3] = pivot - transform[:3, :3] @ pivot |
| new_wf = np.linalg.inv(transform @ np.linalg.inv(wf)) |
| new_wb = new_wf @ np.asarray(contract['transform_foreground_from_background']) |
| return new_wf, new_wb |
|
|
|
|
| def render(scene, output, device='cuda:0', width=None, angle=0.0, use_cache=True): |
| start = time.monotonic() |
| contract_path = scene / 'render/scene.json' |
| contract_hash = digest(contract_path) |
| contract = json.loads(contract_path.read_text()) |
| assert contract['format'] == 'droid_sim_render_v1' and contract['same_camera'] |
| assert contract['compositing_policy'] == 'foreground_alpha_priority_over_real_gs' |
| fg_path, bg_path = scene / contract['foreground'], scene / contract['background'] |
| fg_hash, bg_hash = digest(fg_path), digest(bg_path) |
| source_width, source_height = contract['image_size_wh'] |
| width = width or source_width |
| height = round(width * source_height / source_width) |
| k = np.asarray(contract['intrinsic'], dtype=np.float64) |
| k[0] *= width / source_width |
| k[1] *= height / source_height |
| if angle: |
| import trimesh |
| mesh_scene = trimesh.load(fg_path, force='scene', process=False) |
| pivot = np.asarray(mesh_scene.bounds).mean(axis=0) |
| else: |
| pivot = np.zeros(3) |
| wf, wb = orbit_camera(contract, angle, pivot) |
| output.mkdir(parents=True, exist_ok=True) |
| cache_key = dict(background_sha256=bg_hash, w2c=wb.tolist(), intrinsic=k.tolist(), |
| width=width, height=height, mode=contract['background_renderer'], |
| gauge=contract['background_gauge'], color=contract['background_color'], |
| kernel_sha256=digest(Path(kernels.__file__))) |
| key = hashlib.sha256(json.dumps(cache_key, sort_keys=True).encode()).hexdigest() |
| cache = output / 'background_cache.npz' |
| cached = False |
| if use_cache and cache.exists(): |
| with np.load(cache, allow_pickle=False) as f: |
| if str(f['cache_key']) == key: |
| bg, bg_depth, bg_alpha = f['rgb'], f['depth'], f['alpha'] |
| cached = True |
| if not cached: |
| if contract['background_renderer'] == 'camera_gauge_sh0': |
| from plyfile import PlyData |
| vertices = PlyData.read(str(bg_path))['vertex'].data |
| gauge = float(contract['background_gauge']) |
| normalized, proof = kernels.normalize_reloaded_output_for_render(vertices, wb, k, gauge) |
| bg, bg_depth, bg_alpha = kernels.render_gaussian_vertices(normalized, np.eye(4), k, width, height, device) |
| bg_depth *= gauge |
| write_json(output / 'normalization.json', proof) |
| elif contract['background_renderer'] == 'world': |
| gaussians = kernels.load_gaussians(bg_path, device) |
| bg, bg_depth, bg_alpha = kernels.render_gaussians(gaussians, wb, k, width, height, contract['background_color']) |
| else: |
| raise ValueError('Unknown background renderer') |
| assert np.isfinite(bg).all() and np.isfinite(bg_depth).all() |
| np.savez_compressed(cache, cache_key=np.asarray(key), rgb=bg, depth=bg_depth, alpha=bg_alpha) |
| foreground, fg_depth = kernels.render_mesh(fg_path, wf, k, width, height) |
| alpha = (foreground[:, :, 3] * (fg_depth > 0))[:, :, None] |
| rgb = np.rint(np.clip(foreground[:, :, :3] * alpha + bg * (1 - alpha), 0, 1) * 255).astype(np.uint8) |
| assert digest(fg_path) == fg_hash, 'GLB changed during rendering; output not published' |
| assert digest(contract_path) == contract_hash, 'Camera changed during rendering; output not published' |
| Image.fromarray(rgb).save(output / 'layered_composite.png') |
| Image.fromarray(np.rint(np.clip(bg, 0, 1) * 255).astype(np.uint8)).save(output / 'background_render.png') |
| Image.fromarray(np.rint(np.clip(foreground, 0, 1) * 255).astype(np.uint8)).save(output / 'foreground_render.png') |
| target = Image.open(scene / contract['target_image']).convert('RGB').resize((width, height), Image.Resampling.LANCZOS) |
| overlay = Image.blend(target, Image.fromarray(rgb), 0.5) |
| Image.fromarray(np.concatenate([np.asarray(target), rgb, np.asarray(overlay)], axis=1)).save(output / 'comparison.png') |
| metrics = dict(scene=scene.name, foreground_sha256=fg_hash, background_sha256=bg_hash, |
| camera_contract_sha256=digest(contract_path), background_cache_used=cached, |
| background_source='marble_gaussian_ply', image_size_wh=[width, height], |
| angle_degrees=angle, same_camera=True, |
| foreground_coverage=float((fg_depth > 0).mean()), |
| background_coverage=float((bg_alpha > .02).mean()), |
| compositing_policy=contract['compositing_policy'], |
| elapsed_seconds=round(time.monotonic() - start, 3)) |
| if not angle and width == source_width: |
| accepted = np.asarray(Image.open(scene / 'layered_composite.png').convert('RGB')) |
| error = np.abs(accepted.astype(float) - rgb.astype(float)) |
| metrics['accepted_composite_difference'] = dict(mae=float(error.mean()), max=float(error.max()), |
| different_pixel_fraction=float(np.any(error > 0, axis=-1).mean())) |
| write_json(output / 'render_status.json', metrics) |
| return metrics |
|
|
|
|
| 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) |
| p.add_argument('--orbit-deg', type=float, default=0.0) |
| p.add_argument('--no-cache', action='store_true') |
| a = p.parse_args() |
| print(json.dumps(render(a.scene, a.output_dir, a.device, a.width, a.orbit_deg, not a.no_cache), indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
