| |
| """Render demo assets for every exported scene with DragMesh trajectories. |
| |
| Runs on the server host (dragmesh_env, mujoco EGL offscreen): |
| python render_all.py [scene-substring-filter] |
| Outputs to outputs/demo/<scene>/... (grid pngs + per-scene mp4 + report) |
| """ |
| import json |
| import os |
| import sys |
| from pathlib import Path |
|
|
| import imageio.v2 as imageio |
| import mujoco |
| import numpy as np |
|
|
| FRAMES = (0, 4, 8, 12, 15) |
| W, H = 400, 300 |
| FPS = 8 |
| ANIM_FRAMES = 16 |
| OUT_ROOT = Path("/home/zhanghao/scene/scenesmith_full/outputs/demo") |
| TRAJ_ROOT = Path("/home/zhanghao/scene/trajectories") |
|
|
|
|
| def qpos_addr(model, name): |
| jid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_JOINT, name) |
| if jid < 0: |
| return None |
| return model.jnt_qposadr[jid] |
|
|
|
|
| def children_map(model): |
| ch = {} |
| for b in range(model.nbody): |
| ch.setdefault(model.body_parentid[b], []).append(b) |
| return ch |
|
|
|
|
| def body_bbox(model, data, bid, children): |
| mins, maxs = [], [] |
| stack = [bid] |
| while stack: |
| b = stack.pop() |
| for g in range(model.ngeom): |
| if model.geom_bodyid[g] == b and model.geom(g).type == mujoco.mjtGeom.mjGEOM_MESH: |
| gname = model.geom(g).name or "" |
| if "_visual_visual_mesh" not in gname and "visual_mesh" not in gname: |
| continue |
| mesh = model.mesh(model.geom_dataid[g]) |
| verts = mesh.vert.reshape(-1, 3) |
| world = data.xpos[b] + verts @ data.xmat[b].reshape(3, 3).T |
| mins.append(world.min(0)) |
| maxs.append(world.max(0)) |
| stack.extend(children.get(b, [])) |
| if not mins: |
| return None |
| return np.min(mins, 0), np.max(maxs, 0) |
|
|
|
|
| def make_camera(model, data, bname, children): |
| bid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_BODY, bname) |
| bbox = body_bbox(model, data, bid, children) |
| if bbox is None: |
| pos = data.body(bid).xpos |
| bbox = (pos - 0.5, pos + 0.5) |
| lo, hi = bbox |
| center = (lo + hi) / 2 |
| size = max((hi - lo).max(), 0.4) |
| cam = mujoco.MjvCamera() |
| cam.lookat = center |
| cam.distance = size * 2.0 |
| cam.azimuth = 0.0 |
| cam.elevation = -25.0 |
| return cam, size |
|
|
|
|
| def render_frames(model, data, rend, cam, addr, traj, lo, hi, frames): |
| imgs = [] |
| for f in frames: |
| v = float(np.clip(traj[f], lo, hi)) |
| data.qpos[addr] = v |
| mujoco.mj_forward(model, data) |
| rend.update_scene(data, camera=cam) |
| imgs.append(rend.render()) |
| return imgs |
|
|
|
|
| def collect_joints(traj_json): |
| out = [] |
| for jname, entry in traj_json.get("joints", {}).items(): |
| t = entry.get("traj_abs") |
| if not t: |
| continue |
| t = np.asarray(t, float) |
| if float(np.abs(t).max()) < 1e-9: |
| continue |
| out.append((jname, entry, t)) |
| return out |
|
|
|
|
| def main(): |
| filt = sys.argv[1] if len(sys.argv) > 1 else None |
| base = Path("/home/zhanghao/scene/scenesmith_full/outputs") |
| scenes = sorted(base.glob("mujoco_scene_home_*")) |
| if not scenes: |
| scenes = sorted(base.glob("mujoco_scene_*")) |
| if filt: |
| scenes = [s for s in scenes if filt in s.name] |
| print(f"{len(scenes)} scenes: {[s.name for s in scenes]}") |
| OUT_ROOT.mkdir(parents=True, exist_ok=True) |
| report = [] |
|
|
| for sc in scenes: |
| sname = sc.name.replace("mujoco_scene_", "") |
| traj_dir = TRAJ_ROOT / sname / "scene_trajectories.json" |
| if not traj_dir.exists(): |
| print(f"[{sname}] no trajectories, skip") |
| continue |
| with open(traj_dir) as f: |
| traj_json = json.load(f) |
| joints = collect_joints(traj_json) |
| if not joints: |
| print(f"[{sname}] no moving joints") |
| continue |
| model = mujoco.MjModel.from_xml_path(str(sc / "scene.xml")) |
| data = mujoco.MjData(model) |
| mujoco.mj_forward(model, data) |
| children = children_map(model) |
|
|
| s_out = OUT_ROOT / sname |
| s_out.mkdir(parents=True, exist_ok=True) |
|
|
| |
| canvas_w = W * 5 |
| model.vis.global_.offwidth = canvas_w |
| model.vis.global_.offheight = H |
| rend = mujoco.Renderer(model, H, canvas_w) |
|
|
| joint_meta = [] |
| for idx, (jname, entry, t) in enumerate(joints[:6]): |
| addr = qpos_addr(model, jname) |
| if addr is None: |
| continue |
| jid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_JOINT, jname) |
| bname = model.body(model.jnt_bodyid[jid]).name |
| cam, size = make_camera(model, data, bname, children) |
| lo, hi = entry.get("range", [-size * 2, size * 2]) |
| imgs = render_frames(model, data, rend, cam, addr, t, lo, hi, FRAMES) |
| row = np.concatenate(imgs, axis=1) |
| imageio.imwrite(str(s_out / f"joint_{idx:02d}.png"), row) |
| joint_meta.append({ |
| "joint": jname, "body": bname, |
| "range": [float(lo), float(hi)], |
| "max_abs": float(np.abs(t).max()), |
| "type": entry.get("joint_type", entry.get("type", "?")), |
| }) |
| |
| frames = list(range(ANIM_FRAMES)) |
| vid_imgs = [] |
| cam0, size0 = make_camera(model, data, model.body(model.jnt_bodyid[ |
| mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_JOINT, joints[0][0])]).name, children) |
| base_az = cam0.azimuth |
| for f in frames: |
| cam = mujoco.MjvCamera() |
| cam.lookat = cam0.lookat |
| cam.distance = cam0.distance |
| cam.azimuth = base_az + (f / (ANIM_FRAMES - 1)) * 60.0 |
| cam.elevation = cam0.elevation |
| addr = qpos_addr(model, joints[0][0]) |
| lo, hi = joints[0][1].get("range", [-size0 * 2, size0 * 2]) |
| imgs = render_frames(model, data, rend, cam, addr, joints[0][2], lo, hi, [f]) |
| vid_imgs.append(imgs[0]) |
| mp4 = str(s_out / f"{sname}.mp4") |
| imageio.mimsave(mp4, vid_imgs, fps=FPS) |
| rend.close() |
|
|
| report.append({ |
| "scene": sname, |
| "n_joints": len(joint_meta), |
| "joints": joint_meta, |
| "mp4": f"demo/{sname}/{sname}.mp4", |
| "stills": [f"demo/{sname}/joint_{i:02d}.png" for i in range(len(joint_meta))], |
| }) |
| print(f"[{sname}] {len(joint_meta)} joints, mp4 done") |
|
|
| with open(OUT_ROOT / "report.json", "w") as f: |
| json.dump(report, f, indent=2) |
| print("ALL_RENDER_DONE", len(report)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
