| """Recover explicit portable cameras from retained render evidence, without deleting it. |
| |
| Only adds render/scene.json. Missing or ambiguous evidence is reported, not guessed. |
| """ |
| import argparse |
| import json |
| from pathlib import Path |
| import subprocess |
|
|
| import numpy as np |
| from PIL import Image |
|
|
| from package_trajectories import digest, write_json |
| from render_kernels import load_camera, load_foreground_intrinsics |
|
|
|
|
| def read(path): |
| try: |
| return json.loads(path.read_text()) |
| except (ValueError, OSError): |
| return {} |
|
|
|
|
| def walk(value): |
| yield value |
| if isinstance(value, dict): |
| for x in value.values(): |
| yield from walk(x) |
| elif isinstance(value, list): |
| for x in value: |
| yield from walk(x) |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument('--dataset', type=Path, default=Path(__file__).resolve().parents[2] / 'batch_1st_scene') |
| p.add_argument('--search-roots', type=Path, nargs='*', default=[]) |
| p.add_argument('--report', type=Path, required=True) |
| p.add_argument('--scenes', type=int, nargs='*') |
| a = p.parse_args() |
| indexed = [] |
| if a.search_roots: |
| result = subprocess.run(['rg', '--files', '-uuu', '-g', '*gravity*.json', *map(str, a.search_roots)], |
| text=True, capture_output=True, check=False) |
| if result.returncode not in (0, 1): |
| raise RuntimeError(result.stderr) |
| indexed = [Path(line) for line in result.stdout.splitlines()] |
| rows = [] |
| for scene in sorted(a.dataset.iterdir()): |
| if not scene.is_dir() or not scene.name[:4].isdigit(): |
| continue |
| if a.scenes and int(scene.name[:4]) not in a.scenes: |
| continue |
| row = dict(scene=scene.name) |
| try: |
| backups = list((scene / 'backup').glob('layered_render_repro_*')) |
| if len(backups) > 1: |
| accepted_hash = digest(scene / 'layered_composite.png') |
| backups = [b for b in backups if (b / 'layered_composite.png').exists() |
| and digest(b / 'layered_composite.png') == accepted_hash] |
| assert len(backups) == 1, f'Expected one accepted render package, found {len(backups)}' |
| backup = backups[0] |
| documents = {p.name: read(p) for p in backup.glob('*.json')} |
| request = documents.get('foreground_request.json', {}) |
| render_request = documents.get('render_request.json', {}) |
| manifest = documents.get('shadow_layered_manifest.json', {}) |
| width, height = Image.open(scene / 'image.png').size |
| cam_path = scene / 'background/aligned_target_vggt/cameras_target_vggt.npz' |
| ply = scene / 'background/aligned_target_vggt/background_aligned_target_vggt.ply' |
| if not cam_path.exists() or not ply.exists(): |
| raise ValueError('No canonical GS alignment; retained background source: ' + str(manifest.get('background_source'))) |
| wb, kb, _, _, frame, _ = load_camera(cam_path, 0, width, height) |
| fg_camera_path = scene / 'reconstruction/vggt/camera.json' |
| local_inputs = render_request.get('inputs_relative_to_scene_root', {}) |
| if local_inputs.get('foreground_camera_json'): |
| fg_camera_path = scene / local_inputs['foreground_camera_json'] |
| kf, _ = load_foreground_intrinsics(fg_camera_path, width, height) |
| fg_npz = backup / 'foreground_layer.npz' |
| if not fg_npz.is_file(): |
| source_run = documents.get('layered_repro_package_manifest.json', {}).get('source_layered_run') |
| if source_run: |
| source_run = Path(source_run) |
| |
| |
| source_npz = source_run / 'foreground_layer.npz' |
| if source_npz.is_file() and all( |
| (source_run / f).is_file() and (backup / f).is_file() |
| and digest(source_run / f) == digest(backup / f) |
| for f in ('foreground_render.png', 'layered_composite.png') |
| ): |
| fg_npz = source_npz |
| gravity_path = None |
| gravity = None |
| legacy_same_frame = bool(local_inputs.get('gravity_json') and (backup / 'render_layered_scene.py').exists()) |
| if fg_npz.is_file(): |
| with np.load(fg_npz, allow_pickle=False) as f: |
| wf = f['w2c'].astype(np.float64) |
| kf = f['intrinsics'].astype(np.float64) |
| camera_source = str(fg_npz) |
| gravity = np.linalg.inv(wf) @ wb |
| else: |
| declared = request.get('gravity_transform') or render_request.get('gravity_transform') |
| if local_inputs.get('gravity_json'): |
| declared = str(scene / local_inputs['gravity_json']) |
| if declared and not Path(declared).is_file() and scene.name + '/' in declared: |
| relocated = scene / declared.split(scene.name + '/', 1)[1] |
| if relocated.is_file(): |
| declared = str(relocated) |
| expected_hashes = set() |
| for value in walk(documents): |
| if isinstance(value, dict) and isinstance(value.get('path'), str) and 'gravity' in Path(value['path']).name: |
| if value.get('sha256'): |
| expected_hashes.add(value['sha256']) |
| candidates = ([Path(declared)] if declared else []) + list(scene.rglob('*gravity*.json')) |
| candidates += [p for p in indexed if scene.name in str(p)] |
| candidates = list(dict.fromkeys(p for p in candidates if p.is_file())) |
| usable = [] |
| for candidate in candidates: |
| d = read(candidate) |
| if 'transform_gravity_from_background' not in d: |
| continue |
| g = np.asarray(d['transform_gravity_from_background'], dtype=np.float64) |
| if g.shape != (4, 4) or not np.isfinite(g).all(): |
| continue |
| usable.append((candidate, g, digest(candidate))) |
| matched = [x for x in usable if x[2] in expected_hashes] |
| if not matched and declared: |
| matched = [x for x in usable if x[0] == Path(declared)] |
| if not matched: |
| raise ValueError(f'Cannot identify authoritative gravity; {len(usable)} candidates, {len(expected_hashes)} reference hashes') |
| gravity_path, gravity, _ = matched[0] |
| assert all(np.allclose(x[1], gravity, atol=1e-8) for x in matched), 'Conflicting authoritative gravity transforms' |
| wf = wb @ np.linalg.inv(gravity) |
| camera_source = str(gravity_path) |
| if request.get('foreground_camera_override_json'): |
| raise ValueError('Foreground camera override needs explicit migration') |
| if legacy_same_frame: |
| |
| |
| code = (backup / 'render_layered_scene.py').read_text() |
| if 'gaussians,\n w2c_gravity,' not in code: |
| raise ValueError('Legacy renderer background frame requires inspection') |
| wb = wf.copy() |
| gravity = np.eye(4) |
| if not np.allclose(kf, kb, atol=1e-4, rtol=1e-5): |
| raise ValueError('Foreground and background intrinsics differ; cannot claim one camera') |
| assert np.isfinite(wf).all() and np.allclose(wf[3], [0, 0, 0, 1]) |
| bg_request = documents.get('background_request.json', {}) |
| gauge = bg_request.get('render_gauge_world_units_per_normalized_unit') |
| if gauge is None: |
| with np.load(cam_path, allow_pickle=False) as f: |
| if 'render_gauge_world_units_per_normalized_unit' in f: |
| gauge = float(f['render_gauge_world_units_per_normalized_unit']) |
| |
| mode = 'world' if legacy_same_frame else 'camera_gauge_sh0' |
| if mode != 'world' and (gauge is None or float(gauge) <= 0): |
| raise ValueError('Missing numerical Gaussian gauge') |
| contract = dict(format='droid_sim_render_v1', foreground='fully_refined_foreground.glb', |
| background=str(ply.relative_to(scene)), target_image='image.png', |
| image_size_wh=[width, height], frame_index=frame, |
| intrinsic=kf.tolist(), world_to_camera_foreground=wf.tolist(), |
| world_to_camera_background=wb.tolist(), |
| transform_foreground_from_background=gravity.tolist(), |
| background_renderer=mode, background_gauge=gauge, |
| compositing_policy='foreground_alpha_priority_over_real_gs', |
| background_color=[0.96, 0.96, 0.96], |
| same_camera=True, metric_scale_verified=False, |
| canonical_foreground_sha256=digest(scene / 'fully_refined_foreground.glb'), |
| accepted_composite_sha256=digest(scene / 'layered_composite.png'), |
| migration=dict(camera_source=camera_source, validated_by_rerender=False)) |
| (scene / 'render').mkdir(exist_ok=True) |
| write_json(scene / 'render/scene.json', contract) |
| row.update(status='contract_recovered_pending_render_test', camera_source=camera_source, background_renderer=mode) |
| except Exception as e: |
| row.update(status='needs_recovery', error=f'{type(e).__name__}: {e}') |
| rows.append(row) |
| print(scene.name[:4], row['status'], row.get('error', ''), flush=True) |
| a.report.parent.mkdir(parents=True, exist_ok=True) |
| write_json(a.report, dict(total=len(rows), recovered=sum(x['status'].startswith('contract_') for x in rows), scenes=rows)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
