Datasets:

shu4dev
/

dishsim-assets

License:

Dataset card Files Files and versions

xet

Community

dishsim-assets / bosch800 /source /cache_dump.py

shu4dev

Six flat asset folders with their generators (code repo refactor, section 1) (part 7)

41aebeb verified 20 days ago

Raw History Blame Contribute Delete

9.14 kB

# Copyright (c) 2026, dishsim project.
#
# SPDX-License-Identifier: BSD-3-Clause

"""Kit-side extraction of the collision-world cache (``dump_cache``).
Verbatim from ``code/src/dishsim/geometry.py`` (moved here on 2026-10-21; the cache format and its readers stay in
the code repo's ``dishsim.geometry``). Only ``extract_geometry.py`` imports it, after Kit has booted.
"""

import json
import os

import numpy as np

from dishsim import config
from dishsim.geometry import MANIFEST, MESH_DIR, config_hash
from dishsim.quats import wxyz_to_xyzw

#: dishwasher rigid bodies to extract (body-frame meshes + world poses); machines with a
#: third rack extend this via :func:`dishwasher_bodies`
DISHWASHER_BODIES = ["E_body_5", "E_door_4", "E_shelf_03", "E_shelf_1_04"]


def dishwasher_bodies() -> list[str]:
    """The active machine's extractable rigid bodies (adds the third rack when present)."""
    return DISHWASHER_BODIES + (["E_shelf_third"] if config.HAS_THIRD_RACK else [])


# ---------------------------------------------------------------------------------------------
# Kit-side extraction
# ---------------------------------------------------------------------------------------------


#: Geom prim types the extractor understands (Isaac Lab 2.1 ships no ``utils.mesh`` — the
#: 3.0 helpers this replaces returned exactly these plus ``Mesh``).
_GEOM_TYPES = ("Cube", "Sphere", "Cylinder", "Capsule", "Cone")


def _mesh_prims_under(prim):
    import isaaclab.sim as sim_utils  # noqa: PLC0415

    return sim_utils.get_all_matching_child_prims(
        prim.GetPath(), lambda p: p.GetTypeName() in _GEOM_TYPES + ("Mesh",)
    )


def _trimesh_from_geom_prim(mesh_prim) -> "object":
    """A ``trimesh.Trimesh`` of one Mesh/primitive geom prim, in the prim's LOCAL frame."""
    import numpy as _np  # noqa: PLC0415
    import trimesh  # noqa: PLC0415
    from pxr import UsdGeom  # noqa: PLC0415

    t = mesh_prim.GetTypeName()
    if t == "Mesh":
        geom = UsdGeom.Mesh(mesh_prim)
        pts = _np.asarray(geom.GetPointsAttr().Get() or [], dtype=float)
        counts = _np.asarray(geom.GetFaceVertexCountsAttr().Get() or [], dtype=int)
        idx = _np.asarray(geom.GetFaceVertexIndicesAttr().Get() or [], dtype=int)
        if len(pts) == 0 or len(counts) == 0:
            return None
        faces, o = [], 0
        for c in counts:  # fan-triangulate n-gons
            for k in range(1, c - 1):
                faces.append((idx[o], idx[o + k], idx[o + k + 1]))
            o += c
        return trimesh.Trimesh(vertices=pts, faces=_np.asarray(faces, dtype=int), process=False)
    if t == "Cube":
        size = float(UsdGeom.Cube(mesh_prim).GetSizeAttr().Get())
        return trimesh.creation.box(extents=(size, size, size))
    axis_rot = {"X": [0.0, 1.0, 0.0, 90.0], "Y": [1.0, 0.0, 0.0, -90.0], "Z": None}
    if t == "Sphere":
        return trimesh.creation.icosphere(radius=float(UsdGeom.Sphere(mesh_prim).GetRadiusAttr().Get()))
    if t in ("Cylinder", "Capsule", "Cone"):
        geom = {"Cylinder": UsdGeom.Cylinder, "Capsule": UsdGeom.Capsule, "Cone": UsdGeom.Cone}[t](mesh_prim)
        r, h = float(geom.GetRadiusAttr().Get()), float(geom.GetHeightAttr().Get())
        if t == "Cylinder":
            m = trimesh.creation.cylinder(radius=r, height=h)
        elif t == "Capsule":
            m = trimesh.creation.capsule(radius=r, height=h)
        else:
            m = trimesh.creation.cone(radius=r, height=h)
            m.apply_translation((0.0, 0.0, -h / 2.0))  # USD cones are center-origin
        rot = axis_rot[str(geom.GetAxisAttr().Get() or "Z")]
        if rot is not None:
            m.apply_transform(trimesh.transformations.rotation_matrix(
                _np.radians(rot[3]), rot[:3]))
        return m
    return None


def extract_prim_mesh(body_prim, stage) -> "object":
    """Concatenate all meshes under a rigid-body prim into one trimesh in the BODY frame.
    Returns:
        A ``trimesh.Trimesh`` (body-frame vertices [m]) or None if no meshes found.
    """
    import trimesh  # noqa: PLC0415
    from pxr import Usd, UsdGeom  # noqa: PLC0415

    cache = UsdGeom.XformCache(Usd.TimeCode.Default())
    inv_body = cache.GetLocalToWorldTransform(body_prim).GetInverse()
    parts = []
    for mesh_prim in _mesh_prims_under(body_prim):
        mesh = _trimesh_from_geom_prim(mesh_prim)
        if mesh is None or len(mesh.vertices) == 0:
            continue
        # full mesh->body transform (scale included); Gf matrices are row-vector, transpose
        # to the column convention trimesh/make_T use
        rel = cache.GetLocalToWorldTransform(mesh_prim) * inv_body
        mesh.apply_transform(np.array(rel, dtype=float).T)
        parts.append(mesh)
    if not parts:
        return None
    return trimesh.util.concatenate(parts) if len(parts) > 1 else parts[0]


def dump_cache(scene, sim, cache_dir: str = config.CACHE_DIR) -> str:
    """Dump body-frame meshes + the scene_state.json manifest from the LIVE settled scene.
    Must run with ``use_fabric=False`` (stale-transform trap) after the scene has settled at
    the static state.
    Returns:
        Path to the manifest.
    """
    import trimesh  # noqa: PLC0415

    from dishsim.transforms import T_inv, make_T  # noqa: PLC0415

    stage = scene.stage
    mesh_dir = os.path.join(cache_dir, MESH_DIR)
    os.makedirs(mesh_dir, exist_ok=True)

    T_w_base = make_T(config.ROBOT_BASE_POS_W, config.ROBOT_BASE_QUAT_W)
    T_base_w = T_inv(T_w_base)
    manifest: dict = {
        "frame_convention": config.FRAME_CONVENTION,
        "config_hash": config_hash(),
        "object_name": config.OBJECT_NAME,
        "statics": {},
    }

    def body_pose_w(articulation, body_name):
        ids, _ = articulation.find_bodies(body_name)
        pos = articulation.data.body_link_pos_w[0, ids[0]].cpu().numpy()
        quat = wxyz_to_xyzw(articulation.data.body_link_quat_w[0, ids[0]].cpu().numpy())
        return make_T(pos, quat)

    def save_mesh(name, mesh):
        path = os.path.join(mesh_dir, f"{name}.obj")
        mesh.export(path)
        return f"{MESH_DIR}/{name}.obj"

    # -- dishwasher bodies (static in v0) ------------------------------------------------------
    dw = scene["dishwasher"]
    env_path = "/World/envs/env_0"
    for body in dishwasher_bodies():
        prim = None
        for cand in stage.Traverse():
            if cand.GetName() == body and str(cand.GetPath()).startswith(f"{env_path}/Dishwasher"):
                prim = cand
                break
        assert prim is not None, f"dishwasher body prim {body} not found"
        mesh = extract_prim_mesh(prim, stage)
        assert mesh is not None, f"no meshes under {body}"
        if body in config.RACK_GEN:
            # earliest Kit-stage guard against a scale/pre-compensation bug: the extracted
            # (USD-round-tripped) rack must match the generator's design-space geometry
            import rack_gen  # noqa: PLC0415  (this folder)

            ref = rack_gen.merged_mesh(rack_gen.build(config.RACK_GEN[body]))
            dev = np.abs(np.asarray(mesh.bounds) - np.asarray(ref.bounds)).max()
            assert dev < 2e-3, f"{body}: extracted bounds deviate {dev * 1e3:.2f} mm from rack_gen"
        T_base_body = T_base_w @ body_pose_w(dw, body)
        manifest["statics"][body] = {
            "mesh": save_mesh(body, mesh),
            "T_base_body": T_base_body.tolist(),
            "coacd": True,
        }

    # -- pedestal + ground (procedural boxes; base frame poses from config) -------------------
    ped = trimesh.creation.box(extents=config.PEDESTAL_SIZE)
    T_base_ped = T_base_w @ make_T(config.PEDESTAL_POS_W, (0, 0, 0, 1))
    manifest["statics"]["pedestal"] = {
        "mesh": save_mesh("pedestal", ped),
        "T_base_body": T_base_ped.tolist(),
        "coacd": False,
    }
    ground = trimesh.creation.box(extents=(4.0, 4.0, 0.02))
    T_base_ground = T_base_w @ make_T((0.4, 0.0, -0.01), (0, 0, 0, 1))
    manifest["statics"]["ground"] = {
        "mesh": save_mesh("ground", ground),
        "T_base_body": T_base_ground.tolist(),
        "coacd": False,
    }

    # -- object mesh (body frame, Kit-free source) ---------------------------------------------
    # every class ships a body-frame OBJ beside its physics USD (the same file
    # planning stack collides) — no live extraction needed for a free object
    obj_mesh = trimesh.load(
        os.path.join(config.ASSETS_DIR, "bosch_props", "meshes", f"{config.ACTIVE_OBJECT}.obj"),
        force="mesh")
    manifest["object"] = {
        "mesh": save_mesh("object", obj_mesh),
        "coacd": True,
    }

    # -- static machine state + scenario (recorded for review; not part of config_hash) -------
    from dishsim import scene as _s  # noqa: PLC0415

    manifest["statics_state"] = _s.statics_report(scene)
    manifest["scenario"] = config.SCENARIO_NAME

    path = os.path.join(cache_dir, MANIFEST)
    with open(path, "w") as f:
        json.dump(manifest, f, indent=2)
    print(f"[INFO] cache manifest written to {path} (hash {manifest['config_hash']})")
    return path

	# Copyright (c) 2026, dishsim project.
	#
	# SPDX-License-Identifier: BSD-3-Clause

	"""Kit-side extraction of the collision-world cache (``dump_cache``).

	Verbatim from ``code/src/dishsim/geometry.py`` (moved here on 2026-10-21; the cache format and its readers stay in
	the code repo's ``dishsim.geometry``). Only ``extract_geometry.py`` imports it, after Kit has booted.
	"""

	import json
	import os

	import numpy as np

	from dishsim import config
	from dishsim.geometry import MANIFEST, MESH_DIR, config_hash
	from dishsim.quats import wxyz_to_xyzw

	#: dishwasher rigid bodies to extract (body-frame meshes + world poses); machines with a
	#: third rack extend this via :func:`dishwasher_bodies`
	DISHWASHER_BODIES = ["E_body_5", "E_door_4", "E_shelf_03", "E_shelf_1_04"]


	def dishwasher_bodies() -> list[str]:
	"""The active machine's extractable rigid bodies (adds the third rack when present)."""
	return DISHWASHER_BODIES + (["E_shelf_third"] if config.HAS_THIRD_RACK else [])


	# ---------------------------------------------------------------------------------------------
	# Kit-side extraction
	# ---------------------------------------------------------------------------------------------


	#: Geom prim types the extractor understands (Isaac Lab 2.1 ships no ``utils.mesh`` — the
	#: 3.0 helpers this replaces returned exactly these plus ``Mesh``).
	_GEOM_TYPES = ("Cube", "Sphere", "Cylinder", "Capsule", "Cone")


	def _mesh_prims_under(prim):
	import isaaclab.sim as sim_utils # noqa: PLC0415

	return sim_utils.get_all_matching_child_prims(
	prim.GetPath(), lambda p: p.GetTypeName() in _GEOM_TYPES + ("Mesh",)
	)


	def _trimesh_from_geom_prim(mesh_prim) -> "object":
	"""A ``trimesh.Trimesh`` of one Mesh/primitive geom prim, in the prim's LOCAL frame."""
	import numpy as _np # noqa: PLC0415
	import trimesh # noqa: PLC0415
	from pxr import UsdGeom # noqa: PLC0415

	t = mesh_prim.GetTypeName()
	if t == "Mesh":
	geom = UsdGeom.Mesh(mesh_prim)
	pts = _np.asarray(geom.GetPointsAttr().Get() or [], dtype=float)
	counts = _np.asarray(geom.GetFaceVertexCountsAttr().Get() or [], dtype=int)
	idx = _np.asarray(geom.GetFaceVertexIndicesAttr().Get() or [], dtype=int)
	if len(pts) == 0 or len(counts) == 0:
	return None
	faces, o = [], 0
	for c in counts: # fan-triangulate n-gons
	for k in range(1, c - 1):
	faces.append((idx[o], idx[o + k], idx[o + k + 1]))
	o += c
	return trimesh.Trimesh(vertices=pts, faces=_np.asarray(faces, dtype=int), process=False)
	if t == "Cube":
	size = float(UsdGeom.Cube(mesh_prim).GetSizeAttr().Get())
	return trimesh.creation.box(extents=(size, size, size))
	axis_rot = {"X": [0.0, 1.0, 0.0, 90.0], "Y": [1.0, 0.0, 0.0, -90.0], "Z": None}
	if t == "Sphere":
	return trimesh.creation.icosphere(radius=float(UsdGeom.Sphere(mesh_prim).GetRadiusAttr().Get()))
	if t in ("Cylinder", "Capsule", "Cone"):
	geom = {"Cylinder": UsdGeom.Cylinder, "Capsule": UsdGeom.Capsule, "Cone": UsdGeom.Cone}[t](mesh_prim)
	r, h = float(geom.GetRadiusAttr().Get()), float(geom.GetHeightAttr().Get())
	if t == "Cylinder":
	m = trimesh.creation.cylinder(radius=r, height=h)
	elif t == "Capsule":
	m = trimesh.creation.capsule(radius=r, height=h)
	else:
	m = trimesh.creation.cone(radius=r, height=h)
	m.apply_translation((0.0, 0.0, -h / 2.0)) # USD cones are center-origin
	rot = axis_rot[str(geom.GetAxisAttr().Get() or "Z")]
	if rot is not None:
	m.apply_transform(trimesh.transformations.rotation_matrix(
	_np.radians(rot[3]), rot[:3]))
	return m
	return None


	def extract_prim_mesh(body_prim, stage) -> "object":
	"""Concatenate all meshes under a rigid-body prim into one trimesh in the BODY frame.

	Returns:
	A ``trimesh.Trimesh`` (body-frame vertices [m]) or None if no meshes found.
	"""
	import trimesh # noqa: PLC0415
	from pxr import Usd, UsdGeom # noqa: PLC0415

	cache = UsdGeom.XformCache(Usd.TimeCode.Default())
	inv_body = cache.GetLocalToWorldTransform(body_prim).GetInverse()
	parts = []
	for mesh_prim in _mesh_prims_under(body_prim):
	mesh = _trimesh_from_geom_prim(mesh_prim)
	if mesh is None or len(mesh.vertices) == 0:
	continue
	# full mesh->body transform (scale included); Gf matrices are row-vector, transpose
	# to the column convention trimesh/make_T use
	rel = cache.GetLocalToWorldTransform(mesh_prim) * inv_body
	mesh.apply_transform(np.array(rel, dtype=float).T)
	parts.append(mesh)
	if not parts:
	return None
	return trimesh.util.concatenate(parts) if len(parts) > 1 else parts[0]


	def dump_cache(scene, sim, cache_dir: str = config.CACHE_DIR) -> str:
	"""Dump body-frame meshes + the scene_state.json manifest from the LIVE settled scene.

	Must run with ``use_fabric=False`` (stale-transform trap) after the scene has settled at
	the static state.

	Returns:
	Path to the manifest.
	"""
	import trimesh # noqa: PLC0415

	from dishsim.transforms import T_inv, make_T # noqa: PLC0415

	stage = scene.stage
	mesh_dir = os.path.join(cache_dir, MESH_DIR)
	os.makedirs(mesh_dir, exist_ok=True)

	T_w_base = make_T(config.ROBOT_BASE_POS_W, config.ROBOT_BASE_QUAT_W)
	T_base_w = T_inv(T_w_base)
	manifest: dict = {
	"frame_convention": config.FRAME_CONVENTION,
	"config_hash": config_hash(),
	"object_name": config.OBJECT_NAME,
	"statics": {},
	}

	def body_pose_w(articulation, body_name):
	ids, _ = articulation.find_bodies(body_name)
	pos = articulation.data.body_link_pos_w[0, ids[0]].cpu().numpy()
	quat = wxyz_to_xyzw(articulation.data.body_link_quat_w[0, ids[0]].cpu().numpy())
	return make_T(pos, quat)

	def save_mesh(name, mesh):
	path = os.path.join(mesh_dir, f"{name}.obj")
	mesh.export(path)
	return f"{MESH_DIR}/{name}.obj"

	# -- dishwasher bodies (static in v0) ------------------------------------------------------
	dw = scene["dishwasher"]
	env_path = "/World/envs/env_0"
	for body in dishwasher_bodies():
	prim = None
	for cand in stage.Traverse():
	if cand.GetName() == body and str(cand.GetPath()).startswith(f"{env_path}/Dishwasher"):
	prim = cand
	break
	assert prim is not None, f"dishwasher body prim {body} not found"
	mesh = extract_prim_mesh(prim, stage)
	assert mesh is not None, f"no meshes under {body}"
	if body in config.RACK_GEN:
	# earliest Kit-stage guard against a scale/pre-compensation bug: the extracted
	# (USD-round-tripped) rack must match the generator's design-space geometry
	import rack_gen # noqa: PLC0415 (this folder)

	ref = rack_gen.merged_mesh(rack_gen.build(config.RACK_GEN[body]))
	dev = np.abs(np.asarray(mesh.bounds) - np.asarray(ref.bounds)).max()
	assert dev < 2e-3, f"{body}: extracted bounds deviate {dev * 1e3:.2f} mm from rack_gen"
	T_base_body = T_base_w @ body_pose_w(dw, body)
	manifest["statics"][body] = {
	"mesh": save_mesh(body, mesh),
	"T_base_body": T_base_body.tolist(),
	"coacd": True,
	}

	# -- pedestal + ground (procedural boxes; base frame poses from config) -------------------
	ped = trimesh.creation.box(extents=config.PEDESTAL_SIZE)
	T_base_ped = T_base_w @ make_T(config.PEDESTAL_POS_W, (0, 0, 0, 1))
	manifest["statics"]["pedestal"] = {
	"mesh": save_mesh("pedestal", ped),
	"T_base_body": T_base_ped.tolist(),
	"coacd": False,
	}
	ground = trimesh.creation.box(extents=(4.0, 4.0, 0.02))
	T_base_ground = T_base_w @ make_T((0.4, 0.0, -0.01), (0, 0, 0, 1))
	manifest["statics"]["ground"] = {
	"mesh": save_mesh("ground", ground),
	"T_base_body": T_base_ground.tolist(),
	"coacd": False,
	}

	# -- object mesh (body frame, Kit-free source) ---------------------------------------------
	# every class ships a body-frame OBJ beside its physics USD (the same file
	# planning stack collides) — no live extraction needed for a free object
	obj_mesh = trimesh.load(
	os.path.join(config.ASSETS_DIR, "bosch_props", "meshes", f"{config.ACTIVE_OBJECT}.obj"),
	force="mesh")
	manifest["object"] = {
	"mesh": save_mesh("object", obj_mesh),
	"coacd": True,
	}

	# -- static machine state + scenario (recorded for review; not part of config_hash) -------
	from dishsim import scene as _s # noqa: PLC0415

	manifest["statics_state"] = _s.statics_report(scene)
	manifest["scenario"] = config.SCENARIO_NAME

	path = os.path.join(cache_dir, MANIFEST)
	with open(path, "w") as f:
	json.dump(manifest, f, indent=2)
	print(f"[INFO] cache manifest written to {path} (hash {manifest['config_hash']})")
	return path