| |
| import argparse |
| import json |
| from datetime import date |
| from pathlib import Path |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
|
|
| def parse_simple_yaml(path: Path): |
| data = {} |
| current_key = None |
| for raw in path.read_text().splitlines(): |
| if not raw.strip() or raw.lstrip().startswith("#"): |
| continue |
| if raw.startswith(" - ") and current_key: |
| data.setdefault(current_key, []).append(raw.strip()[2:].strip()) |
| continue |
| if ":" in raw and not raw.startswith(" "): |
| key, value = raw.split(":", 1) |
| key = key.strip() |
| value = value.strip() |
| current_key = key |
| if value == "": |
| data[key] = [] |
| else: |
| data[key] = value.strip('"').strip("'") |
| return data |
|
|
|
|
| def yaml_scalar(value): |
| if isinstance(value, bool): |
| return "true" if value else "false" |
| if value is None: |
| return "null" |
| if isinstance(value, (int, float)): |
| return str(value) |
| text = str(value) |
| if text == "": |
| return '""' |
| if any(ch in text for ch in [":", "#", "{", "}", "[", "]", ",", "\"", "'", "\n"]) or text.startswith(" ") or text.endswith(" "): |
| return json.dumps(text, ensure_ascii=False) |
| return text |
|
|
|
|
| def dump_yaml(mapping, indent=0): |
| lines = [] |
| pad = " " * indent |
| for key, value in mapping.items(): |
| if isinstance(value, dict): |
| lines.append(f"{pad}{key}:") |
| lines.extend(dump_yaml(value, indent + 2)) |
| elif isinstance(value, list): |
| if not value: |
| lines.append(f"{pad}{key}: []") |
| else: |
| lines.append(f"{pad}{key}:") |
| for item in value: |
| if isinstance(item, dict): |
| lines.append(f"{pad} -") |
| lines.extend(dump_yaml(item, indent + 4)) |
| else: |
| lines.append(f"{pad} - {yaml_scalar(item)}") |
| else: |
| lines.append(f"{pad}{key}: {yaml_scalar(value)}") |
| return lines |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="Scaffold a derived convex decomposition asset directory.") |
| parser.add_argument("raw_asset_dir", help="Path to a raw asset directory under assets/<source>/raw/...") |
| parser.add_argument("--variant", default="vhacd_v1", help="Derived asset variant suffix.") |
| parser.add_argument("--tool", default="vhacd", help="Convex decomposition tool name.") |
| parser.add_argument("--tool-version", default="TBD", help="Convex decomposition tool version.") |
| args = parser.parse_args() |
|
|
| raw_asset_dir = Path(args.raw_asset_dir).resolve() |
| raw_rel = raw_asset_dir.relative_to(ROOT / "assets") |
| parts = raw_rel.parts |
| if len(parts) < 5 or parts[1] != "raw": |
| raise SystemExit("raw_asset_dir must be under assets/<source>/raw/<asset_type>/<category>/<asset_id>") |
|
|
| source = parts[0] |
| asset_type = parts[2] |
| category = parts[3] |
| asset_id = parts[4] |
|
|
| raw_meta_path = raw_asset_dir / "metadata.yaml" |
| raw_meta = parse_simple_yaml(raw_meta_path) if raw_meta_path.exists() else {} |
| license_name = raw_meta.get("license", "unknown") |
| origin_url = raw_meta.get("origin_url", "") |
| source_commit = raw_meta.get("source_commit") |
|
|
| derived_asset_id = f"{asset_id}_{args.variant}" |
| derived_dir = ROOT / "assets" / source / "derived" / "convex_decompositions" / category / derived_asset_id |
| if derived_dir.exists(): |
| raise SystemExit(f"destination already exists: {derived_dir}") |
|
|
| (derived_dir / "meshes").mkdir(parents=True, exist_ok=False) |
| (derived_dir / "mjcf").mkdir(parents=True, exist_ok=False) |
| (derived_dir / "logs").mkdir(parents=True, exist_ok=False) |
|
|
| metadata = { |
| "asset_id": f"{source}.convex_decompositions.{category}.{derived_asset_id}", |
| "source": source, |
| "source_asset_id": asset_id, |
| "asset_type": "convex_decompositions", |
| "category": category, |
| "format": "obj_mjcf_include", |
| "entry_file": "mjcf/convex_collision_include.xml", |
| "license": license_name, |
| "origin_url": origin_url, |
| "path": derived_dir.relative_to(ROOT).as_posix(), |
| "storage_mode": "derived", |
| "derived_from": [raw_asset_dir.relative_to(ROOT).as_posix()], |
| "derivation_method": "convex_decomposition", |
| "decomposition_tool": args.tool, |
| "decomposition_version": args.tool_version, |
| "decomposition_params_file": "logs/decomposition.json", |
| "validation_status": "scaffolded", |
| "tags": [source, "convex_decomposition", "collision"], |
| } |
| if source_commit: |
| metadata["source_commit"] = source_commit |
|
|
| if "readiness_level" in raw_meta: |
| metadata["readiness_level"] = raw_meta["readiness_level"] |
|
|
| (derived_dir / "metadata.yaml").write_text("\n".join(dump_yaml(metadata)) + "\n") |
|
|
| source_refs = { |
| "raw_asset": raw_asset_dir.relative_to(ROOT).as_posix(), |
| "raw_entry_file": (raw_asset_dir / raw_meta.get("entry_file", "model.xml")).relative_to(ROOT).as_posix(), |
| } |
| (derived_dir / "source_refs.yaml").write_text("\n".join(dump_yaml(source_refs)) + "\n") |
|
|
| include_xml = f"""<!-- Scaffolded convex collision include for {raw_asset_dir.relative_to(ROOT).as_posix()} --> |
| <mujocoinclude> |
| <!-- Replace with convex collision geoms generated by {args.tool} --> |
| </mujocoinclude> |
| """ |
| (derived_dir / "mjcf" / "convex_collision_include.xml").write_text(include_xml) |
|
|
| logs = { |
| "tool": args.tool, |
| "tool_version": args.tool_version, |
| "created_at": str(date.today()), |
| "raw_asset": raw_asset_dir.relative_to(ROOT).as_posix(), |
| "derived_asset": derived_dir.relative_to(ROOT).as_posix(), |
| "params": {}, |
| "inputs": [], |
| "outputs": [], |
| } |
| (derived_dir / "logs" / "decomposition.json").write_text(json.dumps(logs, indent=2, ensure_ascii=False) + "\n") |
|
|
| readme = f"""# Convex decomposition scaffold |
| |
| Raw asset: |
| |
| ```text |
| {raw_asset_dir.relative_to(ROOT).as_posix()} |
| ``` |
| |
| Derived asset: |
| |
| ```text |
| {derived_dir.relative_to(ROOT).as_posix()} |
| ``` |
| |
| This directory is a scaffold only. Populate `meshes/` and replace the include file with real convex collision geometry before registering it in the manifest. |
| """ |
| (derived_dir / "README.md").write_text(readme) |
|
|
| print(derived_dir.relative_to(ROOT).as_posix()) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
