yianW/goal_gen_cases

Cases Demo

Self-contained snapshot of the 8 manipulation cases used in the goal-image pipeline. Bundles the scene-rendering and physics-refinement code with all the meshes, textures, and per-case parameters needed to reproduce the renders and the physics validation step.

What's in here

cases_demo/
├── cases.json                 # per-case config (paths + params); see "_doc" inside
├── run_case.py                # thin runner that dispatches to scripts/
├── scripts/
│   ├── place_scene.py         # Stage 1: Genesis RayTracer scene render
│   ├── refine_pose_physics.py # Stage 6: parallel physics validation of a pose
│   ├── verify_pose.py         # Render the scene with the estimated pose
│   └── genesis_patch.py       # runtime monkey-patch (see "Genesis patch" below)
├── assets/
│   ├── scene/                 # shared assets
│   │   ├── table.glb
│   │   ├── wall-basecolor.jpg
│   │   └── env.hdr            # HDR environment for the RayTracer
│   └── cases/                 # per-case meshes (target, container, collision)
│       ├── mug_0.glb / metal_mug_holder/...
│       ├── dish_rack_*  dish_rack_2_*
│       ├── tube_rack_*  scissor_rack_*
│       ├── wine_rack_*  wine_rack_2_*
│       └── hanger_hooks_*
│
├── mug_escape_v1/             # +4 mug-on-mug-tree cases (with escape paths)
├── mug_escape_v3/             # +3 mug-on-mug-tree-v3 cases (refined poses only)
└── cloth_hanger_hook/         # +12 cloth-hanger × wall-hook cases (refined + escape)

The 8 headline cases are configured via cases.json and runnable through run_case.py. The three appended bundles are self-contained snapshots that each carry their own meshes, manifest, and (for two of them) a small code/ directory with the original escape-search scripts. See their per-folder README / manifest for layouts.

Shared scene assets

assets/scene/ (table.glb, wall-basecolor.jpg, env.hdr) is the only copy of the table mesh, wall texture, and HDR environment in this dataset — the appended bundles reference it via relative ../assets/scene/table.glb paths in their manifests rather than carrying duplicates.

All bundles use the same world frame:

• Table: table_pos=(0, 0, 0.485403), table_euler=(90, 0, 90), table top at z=0.7451.
• 8 headline cases also add a background wall mesh at x=-0.345 (uses the shared wall-basecolor.jpg).
• cloth_hanger_hook: wall-mounted; wall plane at x=-0.45, wall_height=1.2, container snapped to wall (the refined-pose data doesn't depend on the table; MPC uses the headline robot at [0.15, -0.2, 0.6451]).

Per-case poses for mug_escape_v1 / v3 use the goal_pos_old / goal_quat fields — those match the waypoints in each case's escape/object_path.json. The legacy goal_pos_new field is a robot-relative offset (= goal_pos_old + (0.3, -0.2, -0.7451)) from an earlier search pass and is NOT the frame the trajectories use — ignore it.

Saved camera poses

case_renders/<case>/cam_pose_reset.npy is the exact 4×4 Genesis camera transform from the upstream render. All 8 cases share the same intrinsics (res=(1200, 896), fov=50°); only the per-case transform varies. Load it back with:

T = np.load("case_renders/<case>/cam_pose_reset.npy")
cam.set_pose(transform=T)   # transform takes priority over pos/lookat/up

find_best_camera() is otherwise deterministic given the meshes, so a fresh render normally picks the same camera. The one exception is hanger_hooks (we shipped the smaller *_container.glb variant) — see case_renders/README.md.

Object placement (table cases)

place_scene.py derives the initial container/target placement from the mesh bounds + the rotations in cases.json — the (x, y, z) positions are NOT stored explicitly anywhere, by design:

• Container: pos = (0, 0, 0.7451 − mesh_min_z) (auto-rests on the table top). Euler = (90, 0, container_z_rot).
• Target: pos = (0, +y_offset, 0.7451 − mesh_min_z) where y_offset = (container_y_extent + target_y_extent) / 2 + 0.02 (sits beside the container along +Y with a 2 cm margin). Euler = (90, 0, target_z_rot).
• Camera: auto_camera=True → find_best_camera() fits the union AABB of both entities into a 1200×896 frame at 50° FOV with 85 % fill.
• container_pos override (in cases.json for dish_rack, dish_rack_2, tube_rack, scissor_rack, wine_rack, wine_rack_2): only used by refine_pose_physics.py / verify_pose.py because the bundled pre-decomposed convex collision OBJs have different bounds than the visual GLB. The render itself still uses the visual-mesh auto-z.

Object placement (wall cases)

For hanger_hooks and the cloth_hanger_hook bundle, the container is snapped to the wall plane:

• Container: pos = (wall_x − container_min_x, 0, wall_height).
• Target: in the demo render the hanger sits in the same auto-y-offset spot used for table cases; for the refined poses it ends up where physics validation found a stable hang.
• Wall plane defaults: wall_x=-0.5, wall_height=1.2 for hanger_hooks; wall_x=-0.45, wall_height per-case for cloth_hanger_hook.

Genesis patch (runtime)

refine_pose_physics.py calls RigidEntity.detect_collision_parallel(...), which is not in upstream Genesis. Both methods it depends on are pure Python — they only read fields already exposed by the upstream collider — so instead of forking Genesis we monkey-patch the classes at import time.

scripts/genesis_patch.py adds:

• RigidEntity.detect_collision_parallel(with_entity=, exclude_self_contact=, envs_idx=, *, unsafe=) — GPU-parallel per-env collision flag against the current contact buffers.
• RigidLink.detect_collision(env_idx=0) — single-env real-time collision query for one link (used by motion-planning state samplers).

refine_pose_physics.py already calls genesis_patch.apply() right after gs.init(). If you write your own scripts that need these methods, do the same:

import genesis as gs
import genesis_patch
gs.init(...)
genesis_patch.apply()

apply() must be called after gs.init() — importing genesis.engine.entities.rigid_entity.rigid_entity before init raises Genesis hasn't been initialized. from genesis.utils.array_class, so the patch defers all genesis-internal imports until apply(). No changes to your Genesis install required — the runtime patch sits on top of any upstream Genesis that exposes solver.collider._collider_state.{n_contacts, contact_data.{geom_a, geom_b}}.

What's NOT in here

• Stages 2–5 (Gemini edit, SAM3 segmentation, Depth Pro depth, DINOv3 pose estimation) — they need external API keys and large pretrained checkpoints.
• Motion planning / MPC (Stage 7 + the MPC insertion pipeline) — they depend on cuRobo, the benchgen solver_agent package, and xarm7 URDFs.
• The original outputs/<case>/ directories (videos, masks, candidate poses) from the upstream repo — only re-runnable scripts and configs are bundled.

Cases

Case	Category	Container_pos	Container_euler	object_scale	Notes
mug_tree_goal	table	auto	(90, 0, 0)	1.0	OBJ container w/ Metal surface
dish_rack	table	(0, 0, 1.1879)	(90, 0, 0)	1.0	dish_rack_collision_convex.obj
dish_rack_2	table	(0, 0, 1.0839)	(90, 0, 90)	1.0	uses pre-scaled 0.9× plate GLB
tube_rack	table	auto	(90, 0, 90)	1.0	tube_rack_collision_convex.obj
scissor_rack	table	(0, 0, 0.9775)	(90, 0, 90)	1.0	separate target+container UIDs
wine_rack	table	(0, 0, 0.8473)	(90, 0, 90)	1.0	wine_rack_collision_convex.obj
wine_rack_2	table	(0, 0, 1.0851)	(90, 0, 0)	1.0	wine_rack2_collision_convex.obj
hanger_hooks	wall	auto (wall-mount)	(-180, 0, 90)	1.0	wall_x=-0.5, wall_height=1.2

auto ⇒ container_z = 0.7451 - mesh.bounds[0][2] (table top minus mesh min-z) at runtime. The explicit container_pos overrides come from the visual mesh when a different collision mesh is also loaded — see the container_pos field for each case in cases.json.

The dish_rack_2 plate is bundled both as the original GLB and a pre-scaled 0.9× variant (dish_rack_2_target_0.9.glb); the config uses the 0.9× one because the full-size plate doesn't fit between the rails (100 % collision in physics refinement).

Running

# 1. Activate the same conda env used by the upstream pipeline
conda activate genesis_latest

# 2. Render the initial scene with the RayTracer (Stage 1)
python run_case.py --case dish_rack --stage render
python run_case.py --case all       --stage render        # all 8 cases

# 3. Physics-refine an existing estimated pose (Stage 6)
#    Requires outputs/<case>/pose_estimation/best_pose.json — you'd produce
#    that with the upstream estimate_goal_pose.py (DINOv3) outside this folder.
python run_case.py --case dish_rack --stage refine

# 4. Render the scene with the (refined or estimated) pose for visual check
python run_case.py --case dish_rack --stage verify

Outputs land in cases_demo/outputs/<case>/:

• image.png, depth.npy, seg.npy, mask_*.npy, cam_pose.npy, intrinsic_K.npy — from place_scene.py
• physics_refinement/refined_poses.json — from refine_pose_physics.py
• pose_verification/rendered_at_estimated_pose.png — from verify_pose.py

Calling the scripts directly (without run_case.py)

run_case.py only resolves paths from cases.json and shells out to the underlying scripts; everything is also runnable by hand. Example for dish_rack_2:

python scripts/place_scene.py \
    --table_path assets/scene/table.glb \
    --target_object_path assets/cases/dish_rack_2_target_0.9.glb \
    --container_path     assets/cases/dish_rack_2_container.glb \
    --container_z_rot 90 --target_z_rot 90 \
    --save_dir outputs --save_name dish_rack_2

python scripts/refine_pose_physics.py \
    --output_dir outputs/dish_rack_2 \
    --object_mesh_path    assets/cases/dish_rack_2_target_0.9.glb \
    --container_mesh_path assets/cases/dish_rack_2_collision_convex.obj \
    --table_path          assets/scene/table.glb \
    --container_euler 90 0 90 --container_pos 0 0 1.0839 \
    --num_samples 1024 --num_rounds 3 \
    --xyz_jitter 0.02 0.02 0.01 --rot_jitter 5 5 15

The HDR/wall paths are wired up via the DEMO_HDR_PATH and DEMO_WALL_TEXTURE env vars (set automatically by run_case.py), with a fallback to the original ../video_gen_assets/... paths from the upstream repo. Set them yourself when calling the scripts directly:

DEMO_HDR_PATH=$PWD/assets/scene/env.hdr \
DEMO_WALL_TEXTURE=$PWD/assets/scene/wall-basecolor.jpg \
python scripts/place_scene.py ...

Dependencies

• genesis (the physics simulator — import genesis as gs)
• trimesh, numpy, imageio, scipy, torch

The collision OBJs are pre-decomposed (per-part convex hulls grouped under o markers); Genesis loads them with convexify=True, merge_submeshes_for_collision=False, group_by_material=False — the loader flags are already set in refine_pose_physics.py.

Provenance

Conventions match the upstream repo:

• Quaternions are WXYZ throughout.
• Table sits at pos=(0, 0, 0.485403), euler=(90, 0, 90) — table top at z = 0.7451.
• Render resolution 1200×896, FOV 50°, 1024 spp, with the camera auto-positioned by find_best_camera() to fit both target and container.
• Wall-mounted scenes (hanger_hooks) replace the table with a textured wall at x = -0.5 and snap the container's min-x to the wall plane.