"""Export final GLB transforms and provenance-aware physics inputs. Friction values are explicit language-model priors, not fitted measurements. Missing/unregistered colliders remain disabled; this script does not invent them. """ import argparse import json from pathlib import Path import re import numpy as np import trimesh import yaml from package_trajectories import digest, write_json def read(path): return json.loads(path.read_text()) if path.exists() else {} def friction_prior(name): text = name.lower() if any(w in text for w in ('cloth', 'towel', 'fabric', 'sponge', 'rubber')): return dict(static=0.8, dynamic=0.6, assumed_material='soft_or_rubber_like') if any(w in text for w in ('glass', 'metal', 'steel', 'pan', 'pot', 'spoon')): return dict(static=0.4, dynamic=0.3, assumed_material='smooth_rigid') return dict(static=0.6, dynamic=0.5, assumed_material='unspecified_rigid_surface') def world_geometry(scene, node): mat, geom = scene.graph[node] mesh = scene.geometry[geom] return mesh, trimesh.transform_points(mesh.vertices, mat), mat def fit_collision_frame(mesh_path, target): source = trimesh.load(mesh_path, force='scene', process=False) vertices = np.concatenate([world_geometry(source, n)[1] for n in source.graph.nodes_geometry]) if vertices.shape != target.shape: return None, 'vertex_count_mismatch' select = np.linspace(0, len(vertices) - 1, min(len(vertices), 10000), dtype=int) a = np.column_stack([vertices[select], np.ones(len(select))]) coeff, _, rank, _ = np.linalg.lstsq(a, target[select], rcond=None) if rank < 4: return None, 'rank_deficient_correspondence' matrix = np.eye(4) matrix[:3] = coeff.T error = float(np.linalg.norm(trimesh.transform_points(vertices, matrix) - target, axis=1).max()) if error > 2e-5: return None, f'vertex_correspondence_error_{error:.6g}' return matrix.tolist(), dict(max_vertex_error_scene_units=error, method='same_index_affine_fit_to_final_glb') def export(scene): glb = scene / 'fully_refined_foreground.glb' meshes = trimesh.load(glb, force='scene', process=False) metadata = {int(o['id']): o for o in read(scene / 'sam3d/object_metadata.json').get('objects', [])} recovered = read(scene / 'physics/colliders/manifest.json').get('objects', {}) objects = [] for node in meshes.graph.nodes_geometry: match = re.fullmatch(r'(?:obj|object)_(\d+)(?:_geometry_\d+)?', node) oid = int(match[1]) if match else None meta = metadata.get(oid, {}) name = meta.get('name', node) mesh, target, mat = world_geometry(meshes, node) obj_dir = scene / 'refinement/sf_real2sim/results' / f'obj_{oid}' parts = sorted((obj_dir / 'collision').glob('collision_part_*.glb')) mesh_path = obj_dir / 'mesh_scaled.glb' collision_transform, evidence = (None, 'no_retained_collision_input') if parts and mesh_path.is_file(): collision_transform, evidence = fit_collision_frame(mesh_path, target) retained_record = recovered.get(node) if retained_record: assert retained_record['foreground_sha256'] == digest(glb), 'Recovered collider refers to changed foreground' artifacts = retained_record['artifacts'] mesh_path = scene / artifacts['mesh_scaled.glb']['path'] parts = [scene / v['path'] for k, v in sorted(artifacts.items()) if k.startswith('collision_part_')] assert all(digest(scene / v['path']) == v['sha256'] for v in artifacts.values()), 'Retained collider checksum mismatch' collision_transform, evidence = fit_collision_frame(mesh_path, target) assert collision_transform is not None, 'Retained collider registration no longer valid' prior = friction_prior(name) prior.update(provenance='language_model_material_class_prior', measured=False, optimized=False, confidence='low', combination_rule='average', caveat='Pair-dependent coefficient; validate on contacts before dynamic tasks.') objects.append(dict(id=oid, name=name, node=node, visual=dict(path='fully_refined_foreground.glb', geometry=meshes.graph[node][1], transform_world_from_node=mat.tolist(), vertices=len(mesh.vertices), world_bounds=np.stack([target.min(axis=0), target.max(axis=0)]).tolist()), support_parent_id=meta.get('support_parent_id'), support_relation=meta.get('support_relation'), collision=dict(parts=[str(p.relative_to(scene)) for p in parts], input_mesh=str(mesh_path.relative_to(scene)) if mesh_path.is_file() else None, transform_world_from_collision=collision_transform, registration_evidence=evidence, load_validated=False, cavity_validated=False, enabled_for_replay=False), friction=prior, restitution=dict(value=0.0, provenance='conservative_replay_prior'), mass_kg=None, mass_provenance='not_measured', dynamic_enabled=False)) native = read(scene / 'refinement/status.json') physics = dict(format='droid_sim_physics_v1', scene=scene.name, geometry_authority='fully_refined_foreground.glb', foreground_sha256=digest(glb), units=dict(scene_length='reconstruction_units', meters_per_scene_unit=None, metric_scale_verified=False), gravity=dict(vector_si_m_s2=[0.0, 0.0, -9.81], frame='gravity_aligned_scene', provenance='earth_gravity_default_not_fitted', enabled=False, enable_condition='Establish metric scale and validate colliders before dynamic replay'), camera_contract='render/scene.json' if (scene / 'render/scene.json').exists() else None, trajectory_manifest='trajectory/manifest.json', validation=dict(visual_review='accepted_by_user', physics_revalidated=False, native_status=native), metadata_ids_not_in_final_glb=sorted(set(metadata) - {o['id'] for o in objects}), objects=objects) (scene / 'parameters.yaml').write_text(yaml.safe_dump(physics, sort_keys=False, allow_unicode=True)) return dict(scene=scene.name, final_objects=len(objects), collider_objects_retained=sum(bool(o['collision']['parts']) for o in objects), collider_objects_registered=sum(o['collision']['transform_world_from_collision'] is not None for o in objects), metadata_ids_not_in_final_glb=physics['metadata_ids_not_in_final_glb'], physics_validated=False) 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('--report', type=Path, required=True) args = p.parse_args() rows = [] for scene in sorted(args.dataset.iterdir()): if not scene.is_dir() or not scene.name[:4].isdigit(): continue try: row = export(scene) except Exception as e: row = dict(scene=scene.name, error=f'{type(e).__name__}: {e}') rows.append(row) print(json.dumps(row), flush=True) args.report.parent.mkdir(parents=True, exist_ok=True) write_json(args.report, dict(total=len(rows), scenes=rows)) if __name__ == '__main__': main()