| """Validate active scene-local rendering, trajectory and physics dependencies. |
| |
| Historical provenance paths are not runtime dependencies. This checks all active |
| paths, matrix consistency, hashes, and collision file readability. Mesh-readability |
| is NOT Isaac cooking, cavity quality, contact or dynamics validation. |
| """ |
| import argparse |
| import json |
| from pathlib import Path |
| import time |
|
|
| import numpy as np |
| from PIL import Image |
| import trimesh |
| import yaml |
|
|
| from package_trajectories import digest, write_json |
|
|
|
|
| def local(scene, value): |
| path = Path(value) |
| assert not path.is_absolute(), f'Absolute active path: {value}' |
| path = (scene / path).resolve() |
| assert path.is_relative_to(scene.resolve()), f'Escapes scene: {value}' |
| assert 'backup' not in path.relative_to(scene.resolve()).parts, f'Active dependency on backup: {value}' |
| assert path.is_file(), f'Missing active file: {value}' |
| return path |
|
|
|
|
| def check(scene, mesh_check): |
| start = time.monotonic() |
| c = json.loads((scene / 'render/scene.json').read_text()) |
| fg, bg, image = [local(scene, c[k]) for k in ('foreground', 'background', 'target_image')] |
| sha = digest(fg) |
| assert sha == c['canonical_foreground_sha256'], 'Render contract foreground hash changed' |
| assert list(Image.open(image).size) == c['image_size_wh'] |
| wf, wb, g = [np.asarray(c[k]) for k in ('world_to_camera_foreground', 'world_to_camera_background', 'transform_foreground_from_background')] |
| assert all(x.shape == (4, 4) and np.isfinite(x).all() for x in (wf, wb, g)) |
| assert np.allclose(wf @ g, wb, atol=1e-6), 'Not the same camera across layers' |
| assert c['same_camera'] and c['compositing_policy'] == 'foreground_alpha_priority_over_real_gs' |
| assert c['background_renderer'] in ('world', 'camera_gauge_sh0') |
| |
| with open(bg, 'rb') as f: |
| lines = [] |
| for _ in range(256): |
| line = f.readline() |
| lines.append(line) |
| if line.strip() == b'end_header': |
| break |
| header = b''.join(lines) |
| assert all(x in header for x in (b'opacity', b'scale_0', b'rot_0', b'f_dc_0')), 'Not a Gaussian PLY' |
| trajectory = json.loads((scene / 'trajectory/manifest.json').read_text()) |
| for name, expected in trajectory['sha256'].items(): |
| assert digest(local(scene, 'trajectory/' + name)) == expected, f'Trajectory hash mismatch: {name}' |
| cal = json.loads(local(scene, 'trajectory/camera.json').read_text()) |
| assert np.allclose(np.array(cal['transform_camera_from_robot_base']) @ np.array(cal['transform_robot_base_from_camera']), np.eye(4), atol=1e-8) |
| parameters = yaml.safe_load((scene / 'parameters.yaml').read_text()) |
| assert parameters['foreground_sha256'] == sha |
| mesh_scene = trimesh.load(fg, force='scene', process=False) |
| assert set(mesh_scene.graph.nodes_geometry) == {o['node'] for o in parameters['objects']} |
| parts, readable, unmatched = 0, 0, [] |
| issues = [] |
| for obj in parameters['objects']: |
| collision = obj['collision'] |
| node_transform = np.asarray(mesh_scene.graph[obj['node']][0]) |
| assert np.allclose(node_transform, obj['visual']['transform_world_from_node'], atol=1e-8) |
| matrix = collision['transform_world_from_collision'] |
| if matrix is None: |
| unmatched.append(obj['node']) |
| else: |
| assert np.isfinite(matrix).all() and np.asarray(matrix).shape == (4, 4) |
| assert abs(np.linalg.det(np.asarray(matrix)[:3, :3])) > 1e-12 |
| assert collision['parts'], 'Registered collision has no parts' |
| if collision['input_mesh']: |
| local(scene, collision['input_mesh']) |
| for path in collision['parts']: |
| part = local(scene, path) |
| parts += 1 |
| if mesh_check: |
| try: |
| loaded = trimesh.load(part, force='scene', process=False) |
| assert len(loaded.geometry) > 0 |
| for mesh in loaded.geometry.values(): |
| assert len(mesh.vertices) >= 4 and len(mesh.faces) >= 4 |
| assert np.isfinite(mesh.vertices).all() |
| assert mesh.faces.min() >= 0 and mesh.faces.max() < len(mesh.vertices) |
| readable += 1 |
| except Exception as error: |
| issues.append(dict(path=path, error=str(error))) |
| return dict(scene=scene.name, status='valid' if not issues else 'collision_read_errors', |
| active_paths_scene_local=True, backup_runtime_dependencies=0, |
| same_camera_matrix_identity_verified=True, gaussian_background=True, |
| trajectory_hashes_verified=True, foreground_sha256=sha, |
| final_nodes=len(parameters['objects']), collision_parts=parts, |
| collision_parts_readable=readable if mesh_check else None, |
| collision_read_errors=issues, unregistered_collision_nodes=unmatched, |
| physics_validated=False, elapsed_seconds=round(time.monotonic()-start, 3)) |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument('--dataset', type=Path, required=True) |
| p.add_argument('--report', type=Path, required=True) |
| p.add_argument('--mesh-check', action='store_true') |
| a = p.parse_args() |
| rows = [] |
| for scene in sorted(a.dataset.iterdir()): |
| if not scene.is_dir() or not scene.name[:4].isdigit(): |
| continue |
| try: |
| row = check(scene, a.mesh_check) |
| except Exception as error: |
| row = dict(scene=scene.name, status='failed', error=str(error)) |
| rows.append(row) |
| print(json.dumps(row), flush=True) |
| write_json(a.report, dict(total=len(rows), valid=sum(r['status'] == 'valid' for r in rows), scenes=rows)) |
| if any(r['status'] != 'valid' for r in rows): |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
