| """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() |
|
|
