backup 03_4dcodebench 2026-11-08 10:10:50

4dcodebench/cases/B_03/B_03.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:abe0e90a40311406bdf4d7a5baab9ffe5f35c64c0397313134f2c65e107ed2a7
+size 18410240

4dcodebench/cases/B_03/B_03.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae3731942295ca4c0ba702cede9c0f0f1d3d2fc05faf0650427a872409ca08ef
+size 491165

4dcodebench/cases/B_07/B_07.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:273b75b492022c2516816c59817cdbe996b3fc54248508e1340622b4cf57f935
+size 32970785

4dcodebench/cases/B_07/B_07.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c5477fc58fda612906937c0db6a1c93a5fc7d1ceedb2fdf1f223cae0421f8c2
+size 978302

4dcodebench/cases/B_24/B_24.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:961f81e5e7e7fa6903c83b37546def9b8ed15fea60ebec441051d26e5aef888a
+size 53149265

4dcodebench/cases/B_24/B_24.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d3f6c92c94f8ba1c7f3671ad3f7857aaf2c75a574ce4d24896e43d00c63adfb
+size 443899

4dcodebench/cases/G_12/G_12.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7dadf7bbf03308f7200314a188475c4327165dd86ea9e5a449ab8e78d50edad7
+size 5569309

4dcodebench/cases/G_12/G_12.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62a0aba416e9f441bb0aca0dbf0e6409bb1b4a116e787187bd32714992392fe2
+size 953363

4dcodebench/resim/agent_card.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+"""Agent prior card (ablation factor A): what a coding agent can infer about
+the cloth parameter card from the reference video alone, without any fitting.
+
+This emulates the "coding agent writes a world + parameters" arm of the
+ablation. The agent sees: reference.mp4 (and nothing else). Its priors:
+
+  1. Material: it looks like standard polyester/cotton fabric -> areal density
+     ~0.2-0.4 kg/m^2 -> card density 0.35 (anchored working point).
+  2. Stiffness: folds look soft, drapes over the table edge smoothly ->
+     flimsy -> bending 0.02 (rag-like).
+  3. Air drag: the drop in the video falls fast, no parachute behavior ->
+     air_damp 1.0 (Blender default).
+
+So the agent card IS the default card here, which is the honest baseline:
+"agent guesses from priors, no measurement". The NeuIDO arm (B1) instead
+*measures* the parameters from the truth trajectories by closed-loop fitting.
+
+We write the card to JSON so the 2x2 ablation runner picks it up.
+
+Usage:
+  python agent_card.py --world work/B_07/world --out work/B_07/agent_card.json
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--world", required=True)
+    ap.add_argument("--out", required=True)
+    args = ap.parse_args()
+
+    world = Path(args.world)
+    spec = json.loads((world / "spec.json").read_text())
+    z = np.load(world / "dyn" / "Cloth.npz")
+    pos = z["pos"]
+    faces = z["faces"]
+
+    # cloth area at frame 0 (agent could estimate this from the video geometry)
+    v = pos[0].astype(np.float64)[faces.astype(np.int64)]
+    a = v[:, 1] - v[:, 0]
+    b = v[:, 2] - v[:, 0]
+    area = float(0.5 * np.linalg.norm(np.cross(a, b), axis=1).sum())
+
+    # drop speed visible in the first frames (agent could read this from video)
+    dt = 1.0 / float(spec["video"]["fps"])
+    speed = float(np.linalg.norm((pos[6] - pos[0]) / (6 * dt), axis=1).mean())
+
+    # agent priors -> card (fabric recognition + free-fall check vs 9.81)
+    card = {
+        "density": 0.35,        # "standard fabric" prior, kg/m^2 anchor
+        "bending": 0.02,        # "soft drape" prior
+        "air_damp": 1.0,        # "falls like normal cloth" prior
+        "tensile": 15.0,
+        "compress": 15.0,
+        "shear": 8.0,
+        "method": "agent_prior",
+        "notes": {
+            "cloth_area_m2": round(area, 3),
+            "early_drop_speed_ms": round(speed, 3),
+            "gravity_freefall_check": round(speed / (6 * dt) / 9.81, 3),
+        },
+    }
+    Path(args.out).write_text(json.dumps(card, indent=1))
+    print(json.dumps(card, indent=1))
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/resim/compose_video.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+"""Compose truth | sim... side-by-side comparison video with labels.
+
+Usage:
+  python compose_video.py --world work/B_03/world \
+      --sims work/B_03/out_p1 work/B_03/out_p2 \
+      --labels "mu=0.5 e=0.05" "mu=0.02 e=0.9" \
+      --out work/B_03/compare_B_03.mp4
+"""
+import argparse
+import json
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+
+def read_frames(path):
+    cap = cv2.VideoCapture(str(path))
+    frames = []
+    while True:
+        ok, f = cap.read()
+        if not ok:
+            break
+        frames.append(f)
+    cap.release()
+    return frames
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--world", required=True)
+    ap.add_argument("--sims", nargs="+", required=True)
+    ap.add_argument("--labels", nargs="+", required=True)
+    ap.add_argument("--truth-label", default="truth (reference)")
+    ap.add_argument("--out", required=True)
+    args = ap.parse_args()
+    assert len(args.labels) == len(args.sims)
+
+    spec = json.loads((Path(args.world) / "spec.json").read_text())
+    W, H = spec["video"]["width"], spec["video"]["height"]
+    fps = spec["video"]["fps"] or 24.0
+
+    panels = [(args.truth_label, read_frames(Path(args.world) / "render.mp4"))]
+    for sim, lab in zip(args.sims, args.labels):
+        panels.append((lab, read_frames(Path(sim) / "sim.mp4")))
+
+    n = min(len(f) for _, f in panels)
+    canvas_w, canvas_h = W * len(panels), H
+    writer = cv2.VideoWriter(str(args.out), cv2.VideoWriter_fourcc(*"mp4v"),
+                             fps, (canvas_w, canvas_h))
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    for i in range(n):
+        row = []
+        for k, (lab, frames) in enumerate(panels):
+            f = frames[i]
+            if f.shape[:2] != (H, W):
+                f = cv2.resize(f, (W, H))
+            tag = f"{lab}  [{i+1}/{n}]"
+            cv2.rectangle(f, (0, 0), (W, 34), (0, 0, 0), -1)
+            cv2.putText(f, tag, (10, 24), font, 0.62, (255, 255, 255), 2, cv2.LINE_AA)
+            if k:
+                cv2.line(f, (0, 0), (0, H), (255, 255, 255), 2)
+            row.append(f)
+        writer.write(np.hstack(row))
+    writer.release()
+    print(f"wrote {args.out} ({n} frames, {canvas_w}x{canvas_h})")
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/resim/debug_scene.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python
+"""Debug: rebuild the B_03 scene, dump object boxes + camera projections, render 1 frame (Workbench).
+  blender --background --python debug_scene.py -- --world work/B_03/world --out work/B_03/dbg
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import bpy
+import numpy as np
+from mathutils import Matrix, Vector
+import bpy_extras
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--world", required=True)
+    ap.add_argument("--out", required=True)
+    return ap.parse_args(sys.argv[sys.argv.index("--") + 1:])
+
+
+def add_mesh(name, verts, faces):
+    me = bpy.data.meshes.new(name)
+    me.from_pydata([tuple(float(x) for x in v) for v in verts], [],
+                   [tuple(int(x) for x in f) for f in faces])
+    me.update()
+    ob = bpy.data.objects.new(name, me)
+    bpy.context.scene.collection.objects.link(ob)
+    return ob
+
+
+def main():
+    args = parse_args()
+    world = Path(args.world)
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+
+    spec = json.loads((world / "spec.json").read_text())
+    cam = json.loads((world / "camera.json").read_text())
+    K = np.array(cam["intrinsics"], float)
+    E = np.array(cam["extrinsic"], float)
+    W, H = spec["video"]["width"], spec["video"]["height"]
+    scene = bpy.context.scene
+    for ob in list(bpy.data.objects):
+        bpy.data.objects.remove(ob, do_unlink=True)
+
+    for mid, v in spec["meshes"].items():
+        z = np.load(world / "mesh" / f"{mid}.npz")
+        add_mesh(f"mesh_{mid}", z["vertices"][0], z["faces"][0])
+
+    cam_data = bpy.data.cameras.new("cam")
+    cam_data.sensor_fit = "HORIZONTAL"
+    cam_data.sensor_width = 36.0
+    cam_data.lens = float(K[0, 0]) * 36.0 / W
+    cam_ob = bpy.data.objects.new("cam", cam_data)
+    bpy.context.scene.collection.objects.link(cam_ob)
+    D = Matrix.Diagonal((1.0, -1.0, -1.0, 1.0))
+    cam_ob.matrix_world = Matrix(E) @ D
+    scene.camera = cam_ob
+    scene.render.resolution_x = W
+    scene.render.resolution_y = H
+
+    sun = bpy.data.lights.new("sun", type="SUN")
+    sun.energy = 3.0
+    sun_ob = bpy.data.objects.new("sun", sun)
+    bpy.context.scene.collection.objects.link(sun_ob)
+    sun_ob.rotation_euler = (0.9, 0, 0.5)
+    w = bpy.data.worlds.new("w")
+    w.use_nodes = True
+    w.node_tree.nodes["Background"].inputs["Color"].default_value = (0.8, 0.8, 0.8, 1)
+    scene.world = w
+
+    print("=== object bounding boxes (world) ===")
+    dg = bpy.context.evaluated_depsgraph_get()
+    for ob in bpy.data.objects:
+        if ob.type != "MESH":
+            continue
+        corners = [ob.matrix_world @ Vector(c) for c in ob.bound_box]
+        xs = [c.x for c in corners]; ys = [c.y for c in corners]; zs = [c.z for c in corners]
+        print(f"{ob.name:12s} x[{min(xs):7.2f},{max(xs):7.2f}] y[{min(ys):7.2f},{max(ys):7.2f}] z[{min(zs):7.2f},{max(zs):7.2f}]")
+
+    print("=== camera projection of pin COMs (should be in-frame) ===")
+    bpy.context.view_layer.update()
+    for name in ["Pin00", "Pin05", "Pin09"]:
+        pos = np.load(world / "dyn" / f"{name}.npz")["pos"]
+        p = Vector(pos[0].mean(0))
+        uv = bpy_extras.object_utils.world_to_camera_view(scene, cam_ob, p)
+        print(f"{name}: blender uv=({uv.x:.3f},{uv.y:.3f}) depth={uv.z:.2f}")
+    ball = np.load(world / "dyn" / "Ball.npz")["pos"]
+    p = Vector(ball[0].mean(0))
+    uv = bpy_extras.object_utils.world_to_camera_view(scene, cam_ob, p)
+    print(f"Ball f0: blender uv=({uv.x:.3f},{uv.y:.3f}) depth={uv.z:.2f}")
+    p30 = Vector(ball[30].mean(0))
+    uv = bpy_extras.object_utils.world_to_camera_view(scene, cam_ob, p30)
+    print(f"Ball f30: blender uv=({uv.x:.3f},{uv.y:.3f}) depth={uv.z:.2f}")
+
+    scene.render.engine = "BLENDER_WORKBENCH"
+    scene.display.render_aa = "5"
+    scene.render.filepath = str(out / "dbg_f1.png")
+    scene.frame_set(1)
+    bpy.ops.render.render(write_still=True)
+    print("wrote", out / "dbg_f1.png")
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/resim/fit_params_neuido.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python
+"""Fit cloth parameter card (density, bending, air_damp) to ground-truth cloth
+trajectories, NeuIDO-style: differentiable-proxy fitting loop that re-simulates
+in Blender with candidate parameters and minimizes trajectory distance.
+
+This is the "with NeuIDO method" arm of the ablation. The "without" arm just
+uses fixed default parameters (no fitting).
+
+Method (mirror of NeuIDO's few-shot adaptation, Eq. 8, but with a classical
+optimizer instead of a learned latent):
+    z_hat = argmin_z  L_sim(R(z), u)
+where R(z) = Blender cloth rollout under parameter card z, and L measures
+per-frame vertex-cloud distance (chamfer) + bbox/COM matching vs the observed
+cloth positions u = dyn/Cloth.npz.
+
+Coordinate notes:
+  * dyn/Cloth.npz pos is in world coordinates already (verified vs bbox of
+    static table mesh), same as Blender world space after to_mesh().
+  * The truth cloth starts exactly at frame-0 pose in every rollout, so the
+    fit identifies the card (density/bending/air) from the drop dynamics.
+
+Usage (H100, after unpack_world.py):
+  python fit_params_neuido.py --world work/B_07/world --out work/B_07/fit \
+      --trials 24 --parallel 3
+Output: <out>/best_card.json, <out>/trials.csv, <out>/fit_log.txt
+"""
+import argparse
+import csv
+import itertools
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+
+BLENDER = os.path.expanduser("~/jiayin/blender/blender")
+SCRIPT = os.path.expanduser("~/jiayin/4dcodebench/resim/resim_cloth_blender.py")
+
+
+def chamfer(a, b, n=2000, seed=0):
+    rng = np.random.default_rng(seed)
+    ai = rng.choice(len(a), min(n, len(a)), replace=False)
+    bi = rng.choice(len(b), min(n, len(b)), replace=False)
+    A, B = a[ai].astype(np.float64), b[bi].astype(np.float64)
+    d = ((A[:, None, :] - B[None, :, :]) ** 2).sum(-1)
+    d1 = np.sqrt(d.min(1))
+    d2 = np.sqrt(((B[:, None, :] - A[None, :, :]) ** 2).sum(-1)).min(1)
+    return 0.5 * (d1.mean() + d2.mean())
+
+
+def rollout_loss(world_dir, traj_dir, gt, frame_stride=3, n_samples=1500):
+    """Loss between a rollout's clothtraj.npz and gt (F,N,3)."""
+    f = Path(traj_dir) / "clothtraj.npz"
+    if not f.exists():
+        return None
+    try:
+        sim = np.load(f)["pos"].astype(np.float32)
+    except Exception:
+        return None
+    if not np.isfinite(sim).all() or sim.shape != gt.shape:
+        return None
+    # NaN/instability guard: cloth flew away
+    if np.abs(sim).max() > 50:
+        return 10.0
+    frames = list(range(0, gt.shape[0], frame_stride))
+    if frames[-1] != gt.shape[0] - 1:
+        frames.append(gt.shape[0] - 1)
+    losses = [chamfer(sim[i], gt[i], n=n_samples, seed=i) for i in frames]
+    return float(np.mean(losses))
+
+
+def run_rollout(world_dir, out_dir, card, gpu, timeout=600):
+    """Run one Blender cloth rollout with a parameter card. Returns bool.
+
+    Fitting rollouts use --no_render: sim + trajectory export take ~4 min,
+    rendering would add ~12 min for pixels we never look at during fitting.
+    """
+    cmd = [
+        BLENDER, "--background", "--python", SCRIPT, "--",
+        "--world", str(world_dir), "--out", str(out_dir),
+        "--density", str(card["density"]),
+        "--bending", str(card["bending"]),
+        "--air_damp", str(card["air_damp"]),
+        "--no_render",
+        "--quality", "8",            # faster solver for fitting
+    ]
+    logf = open(Path(out_dir) / "blender.log", "w")
+    env = dict(os.environ, CUDA_VISIBLE_DEVICES=str(gpu))
+    try:
+        subprocess.run(cmd, env=env, stdout=logf, stderr=subprocess.STDOUT,
+                       timeout=timeout, check=False)
+    except subprocess.TimeoutExpired:
+        logf.close()
+        return False
+    logf.close()
+    return (Path(out_dir) / "clothtraj.npz").exists()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--world", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--trials", type=int, default=24)
+    ap.add_argument("--parallel", type=int, default=3, help="concurrent rollouts")
+    ap.add_argument("--gpus", default="4,5,6", help="GPUs to rotate for rollouts")
+    ap.add_argument("--seed", type=int, default=7)
+    ap.add_argument("--center", default=None,
+                    help="JSON file with a card; when given, sample locally "
+                         "around it (gaussian, --sigma) instead of global uniform")
+    ap.add_argument("--sigma", default="0.15,0.4,0.3",
+                    help="gaussian std for density,bending,air_damp local sampling")
+    args = ap.parse_args()
+
+    world = Path(args.world).resolve()
+    out = Path(args.out).resolve()
+    out.mkdir(parents=True, exist_ok=True)
+    gpus = [int(g) for g in args.gpus.split(",")]
+
+    gt = np.load(world / "dyn" / "Cloth.npz")["pos"].astype(np.float32)
+    F = gt.shape[0]
+
+    rng = np.random.default_rng(args.seed)
+    trials = []
+    if args.center:
+        # local refinement (NeuIDO few-shot adaptation analogue): start from a
+        # predicted card and explore its neighborhood
+        c = json.loads(Path(args.center).read_text())
+        s_d, s_b, s_a = (float(x) for x in args.sigma.split(","))
+        for i in range(args.trials):
+            if i == 0:
+                trials.append({"density": c["density"], "bending": c["bending"],
+                               "air_damp": c["air_damp"], "tag": "center"})
+            else:
+                trials.append({
+                    "density": float(np.clip(rng.normal(c["density"], s_d), 0.03, 3.0)),
+                    "bending": float(np.clip(rng.normal(c["bending"], s_b), 0.0, 6.0)),
+                    "air_damp": float(np.clip(rng.normal(c["air_damp"], s_a), 0.1, 6.0)),
+                    "tag": f"loc{i}",
+                })
+    else:
+        # global search: first point = default card, rest uniform in the box
+        dens_lo, dens_hi = 0.08, 1.6
+        bend_lo, bend_hi = 0.0, 4.0
+        air_lo, air_hi = 0.3, 4.0
+        trials.append({
+            "density": 0.35, "bending": 0.02, "air_damp": 1.0, "tag": "default"
+        })
+        while len(trials) < args.trials:
+            trials.append({
+                "density": float(rng.uniform(dens_lo, dens_hi)),
+                "bending": float(rng.uniform(bend_lo, bend_hi)),
+                "air_damp": float(rng.uniform(air_lo, air_hi)),
+                "tag": f"rand{len(trials)}",
+            })
+
+    log = open(out / "fit_log.txt", "a")
+    rows = []
+
+    def work(item, gpu):
+        tag = item["tag"]
+        tdir = out / f"trial_{tag}"
+        tdir.mkdir(exist_ok=True)
+        ok = run_rollout(world, tdir, item, gpu)
+        loss = None
+        if ok:
+            try:
+                loss = rollout_loss(world, tdir, gt)
+            except Exception as e:
+                print(f"[fit] {tag} loss error: {e}", flush=True)
+                loss = None
+        row = dict(item, loss=loss)
+        print(f"[fit] {tag} card={item} loss={loss}", flush=True)
+        print(f"[fit] {tag} card={item} loss={loss}", file=log, flush=True)
+        return row
+
+    results = []
+    from concurrent.futures import ThreadPoolExecutor
+    gpu_cycle = itertools.cycle(gpus)
+    queue = list(trials)
+    with ThreadPoolExecutor(max_workers=args.parallel) as ex:
+        futs = []
+        for item in queue:
+            gpu = next(gpu_cycle)
+            futs.append(ex.submit(work, item, gpu))
+        for f in futs:
+            results.append(f.result())
+
+    ok = [r for r in results if r["loss"] is not None]
+    ok.sort(key=lambda r: r["loss"])
+    best = ok[0]
+    print(f"[fit] BEST: {best}", flush=True)
+    print(f"[fit] BEST: {best}", file=log, flush=True)
+
+    with open(out / "trials.csv", "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=["tag", "density", "bending", "air_damp", "loss"])
+        w.writeheader()
+        for r in sorted(results, key=lambda r: (r["loss"] is None, r["loss"] or 9e9)):
+            w.writerow(r)
+
+    best_card = {
+        "density": best["density"],
+        "bending": best["bending"],
+        "air_damp": best["air_damp"],
+        "tensile": 15.0,
+        "compress": 15.0,
+        "shear": 8.0,
+        "method": "neuido_style_fit",
+        "loss": best["loss"],
+    }
+    (out / "best_card.json").write_text(json.dumps(best_card, indent=1))
+    print(f"[fit] wrote {out/'best_card.json'}")
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/resim/resim_blender.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python
+"""Re-simulate a 4DCodeBench rigid-body world in Blender with a chosen parameter card.
+
+Run inside Blender (background):
+  blender --background --python resim_blender.py -- \
+      --world work/B_03/world --out work/B_03/out_p1 --kinematic Ball \
+      --friction 0.5 --restitution 0.05 --mass 1.5 --samples 32
+
+Split (verified on B_03):
+  * static meshes          -> passive rigid bodies, exact geometry, collision as-is
+  * the --kinematic group  -> passive+kinematic body replaying the baked trajectory
+                              (the driver; identical impact conditions in every preset)
+  * every other dynamics group -> active rigid body spawned at its frame-0 pose with
+                              the parameter card (this is what we sweep)
+
+Output: <out>/sim.mp4, <out>/simtraj.npz (per-object mean-vertex positions, (F,3))
+"""
+import argparse
+import json
+import sys
+from math import radians
+from pathlib import Path
+
+import bpy
+import numpy as np
+from mathutils import Matrix, Vector
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--world", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--preset", default="p")
+    ap.add_argument("--kinematic", default=None, help="dynamics group name to replay as driver")
+    ap.add_argument("--friction", type=float, default=0.5)
+    ap.add_argument("--restitution", type=float, default=0.05)
+    ap.add_argument("--mass", type=float, default=1.5)
+    ap.add_argument("--lin_damp", type=float, default=0.04)
+    ap.add_argument("--ang_damp", type=float, default=0.04)
+    ap.add_argument("--samples", type=int, default=32)
+    ap.add_argument("--substeps", type=int, default=20)
+    ap.add_argument("--iters", type=int, default=20)
+    ap.add_argument("--device", default="gpu", choices=["gpu", "cpu"])
+    return ap.parse_args(sys.argv[sys.argv.index("--") + 1:])
+
+
+def rigid_tf(A, B):
+    """Least-squares rigid transform mapping A -> B (both (N,3))."""
+    ca, cb = A.mean(0), B.mean(0)
+    H = (A - ca).T @ (B - cb)
+    U, _, Vt = np.linalg.svd(H)
+    D = np.diag([1.0, 1.0, float(np.sign(np.linalg.det(Vt.T @ U.T)))])
+    R = Vt.T @ D @ U.T
+    return R, cb - R @ ca
+
+
+def add_mesh(name, verts, faces, mat=None):
+    me = bpy.data.meshes.new(name)
+    me.from_pydata([tuple(float(x) for x in v) for v in verts], [],
+                   [tuple(int(x) for x in f) for f in faces])
+    me.update()
+    ob = bpy.data.objects.new(name, me)
+    bpy.context.scene.collection.objects.link(ob)
+    if mat is not None:
+        ob.data.materials.append(mat)
+    return ob
+
+
+def add_rb(ob, rbtype, shape, mass=1.0, friction=0.5, restitution=0.5,
+           lin_damp=0.04, ang_damp=0.04, kinematic=False, margin=0.001):
+    # deselect everything first: the operator acts on ALL selected objects
+    for other in bpy.context.selected_objects:
+        other.select_set(False)
+    bpy.context.view_layer.objects.active = ob
+    ob.select_set(True)
+    try:
+        bpy.ops.rigidbody.objects_add(type=rbtype)
+    except RuntimeError:
+        with bpy.context.temp_override(active_object=ob, object=ob,
+                                       selected_objects=[ob],
+                                       selected_editable_objects=[ob]):
+            bpy.ops.rigidbody.objects_add(type=rbtype)
+    rb = ob.rigid_body
+    rb.collision_shape = shape
+    rb.mass = mass
+    rb.friction = friction
+    rb.restitution = restitution
+    rb.linear_damping = lin_damp
+    rb.angular_damping = ang_damp
+    rb.use_margin = True
+    rb.collision_margin = margin
+    rb.kinematic = kinematic
+    return rb
+
+
+def mat_simple(name, rgb):
+    m = bpy.data.materials.new(name)
+    m.use_nodes = True
+    bsdf = m.node_tree.nodes["Principled BSDF"]
+    bsdf.inputs["Base Color"].default_value = (*rgb, 1.0)
+    bsdf.inputs["Roughness"].default_value = 0.6
+    return m
+
+
+def setup_cycles(scene, samples, use_gpu):
+    scene.render.engine = "CYCLES"
+    if use_gpu:
+        prefs = bpy.context.preferences.addons["cycles"].preferences
+        for ctype in ("OPTIX", "CUDA"):
+            try:
+                prefs.compute_device_type = ctype
+                prefs.get_devices()
+                devs = [d for d in prefs.devices if d.type == ctype]
+                if devs:
+                    for d in prefs.devices:
+                        d.use = d.type == ctype
+                    scene.cycles.device = "GPU"
+                    print(f"[cycles] using {ctype}: {[d.name for d in devs]}")
+                    return
+            except Exception as e:
+                print(f"[cycles] {ctype} failed: {e}")
+        print("[cycles] no GPU backend, falling back to CPU")
+    scene.cycles.device = "CPU"
+
+
+def main():
+    args = parse_args()
+    world = Path(args.world)
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+
+    spec = json.loads((world / "spec.json").read_text())
+    cam = json.loads((world / "camera.json").read_text())
+    K = np.array(cam["intrinsics"], float)
+    E = np.array(cam["extrinsic"], float)
+    F = int(spec["F"])
+    W, H = spec["video"]["width"], spec["video"]["height"]
+    fps = float(spec["video"]["fps"])
+
+    # ---------- clean scene ----------
+    scene = bpy.context.scene
+    for ob in list(bpy.data.objects):
+        bpy.data.objects.remove(ob, do_unlink=True)
+
+    mats = {"ball": mat_simple("m_ball", (0.10, 0.25, 0.75)),
+            "pin": mat_simple("m_pin", (0.92, 0.92, 0.90)),
+            "deck": mat_simple("m_deck", (0.25, 0.15, 0.10)),
+            "static": mat_simple("m_static", (0.55, 0.55, 0.58))}
+
+    # ---------- rigid body world ----------
+    if scene.rigidbody_world is None:
+        bpy.ops.rigidbody.world_add()
+    rbw = scene.rigidbody_world
+    rbw.substeps_per_frame = args.substeps
+    rbw.solver_iterations = args.iters
+    rbw.point_cache.frame_start = 1
+    rbw.point_cache.frame_end = F
+    scene.gravity = (0.0, 0.0, -9.81)
+
+    dyn = {}
+    for name in spec["dynamics"]:
+        z = np.load(world / "dyn" / f"{name}.npz")
+        dyn[name] = {"pos": z["pos"], "ids": z["ids"].tolist()}
+
+    kin_name = args.kinematic or next(iter(dyn))
+    active_names = [n for n in dyn if n != kin_name]
+    static_ids = [int(m) for m, v in spec["meshes"].items() if v["static"]]
+
+    # ---------- static geometry ----------
+    for mid in static_ids:
+        z = np.load(world / "mesh" / f"{mid}.npz")
+        mat = mats["deck"] if z["vertices"].shape[1] <= 4 else mats["static"]
+        ob = add_mesh(f"static_{mid}", z["vertices"][0], z["faces"][0], mat)
+        add_rb(ob, "PASSIVE", "MESH", margin=0.001)
+
+    # ---------- kinematic driver (replay baked trajectory) ----------
+    driver_pos = dyn[kin_name]["pos"]  # (F,N,3)
+    drv_ids = dyn[kin_name]["ids"]
+    z = np.load(world / "mesh" / f"{drv_ids[0]}.npz")
+    drv_ob = add_mesh(kin_name, z["vertices"][0], z["faces"][0], mats["ball"])
+    drv_verts0 = z["vertices"][0].astype(np.float64)
+    for t in range(F):
+        R, tt = rigid_tf(driver_pos[0].astype(np.float64), driver_pos[t].astype(np.float64))
+        drv_ob.location = Vector(tt)
+        drv_ob.rotation_euler = Matrix(R).to_euler()
+        drv_ob.keyframe_insert("location", frame=t + 1)
+        drv_ob.keyframe_insert("rotation_euler", frame=t + 1)
+    for fc in drv_ob.animation_data.action.fcurves:
+        for kp in fc.keyframe_points:
+            kp.interpolation = "LINEAR"
+    add_rb(drv_ob, "PASSIVE", "CONVEX_HULL", kinematic=True, margin=0.002)
+
+    # ---------- active bodies (parameter card) ----------
+    actives = {}
+    for name in active_names:
+        ids = dyn[name]["ids"]
+        z = np.load(world / "mesh" / f"{ids[0]}.npz")
+        ob = add_mesh(name, z["vertices"][0], z["faces"][0], mats["pin"])
+        add_rb(ob, "ACTIVE", "CONVEX_HULL", mass=args.mass, friction=args.friction,
+               restitution=args.restitution, lin_damp=args.lin_damp,
+               ang_damp=args.ang_damp, margin=0.001)
+        actives[name] = (ob, z["vertices"][0].astype(np.float64))
+
+    # ---------- camera ----------
+    print("[rb-check] " + ", ".join(
+        f"{o.name}:{o.rigid_body.type}{'/K' if o.rigid_body.kinematic else ''}"
+        for o in bpy.data.objects if o.rigid_body))
+    cam_data = bpy.data.cameras.new("cam")
+    cam_data.sensor_fit = "HORIZONTAL"
+    cam_data.sensor_width = 36.0
+    cam_data.lens = float(K[0, 0]) * 36.0 / W
+    cam_ob = bpy.data.objects.new("cam", cam_data)
+    bpy.context.scene.collection.objects.link(cam_ob)
+    D = Matrix.Diagonal((1.0, -1.0, -1.0, 1.0))  # cam axes (x right, y down, z fwd) -> Blender (-Z fwd)
+    cam_ob.matrix_world = Matrix(E) @ D
+    scene.camera = cam_ob
+
+    # camera sanity: project driver COM at frame 0 both ways
+    p0 = Vector(driver_pos[0].mean(0))
+    import bpy_extras
+    uv = bpy_extras.object_utils.world_to_camera_view(scene, cam_ob, p0)
+    pc = E[:3, :3].T @ (np.asarray(p0) - E[:3, 3])
+    proj = K @ pc
+    u_px, v_px = float(proj[0]) / float(pc[2]), float(proj[1]) / float(pc[2])
+    print(f"[cam-check] blender uv=({uv.x:.3f},{uv.y:.3f})  numpy px=({u_px:.1f},{v_px:.1f})/"
+          f"({W},{H})  expect uv≈({u_px/W:.3f},{1-v_px/H:.3f})")
+
+    # ---------- lights ----------
+    world = bpy.data.worlds.new("w")
+    world.use_nodes = True
+    world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.85, 0.85, 0.85, 1)
+    world.node_tree.nodes["Background"].inputs["Strength"].default_value = 1.1
+    scene.world = world
+    sun = bpy.data.lights.new("sun", type="SUN")
+    sun.energy = 3.0
+    sun_ob = bpy.data.objects.new("sun", sun)
+    bpy.context.scene.collection.objects.link(sun_ob)
+    sun_ob.rotation_euler = (radians(50), 0, radians(30))
+
+    # ---------- bake ----------
+    scene.frame_start = 1
+    scene.frame_end = F
+    scene.frame_set(1)
+    bpy.ops.ptcache.free_bake_all()
+    bpy.ops.ptcache.bake_all(bake=True)
+    print("[bake] done")
+
+    # ---------- record trajectories ----------
+    traj = {kin_name: np.zeros((F, 3), np.float32)}
+    for name, (ob, v0) in actives.items():
+        traj[name] = np.zeros((F, 3), np.float32)
+    for t in range(1, F + 1):
+        scene.frame_set(t)
+        bpy.context.view_layer.update()
+        M = np.array(drv_ob.matrix_world)
+        traj[kin_name][t - 1] = (M[:3, :3] @ drv_verts0.T).T.mean(0)
+        for name, (ob, v0) in actives.items():
+            M = np.array(ob.matrix_world)
+            traj[name][t - 1] = (M[:3, :3] @ v0.T).T.mean(0)
+    np.savez_compressed(out / "simtraj.npz", **traj)
+    print(f"[traj] saved {list(traj)}")
+
+    # ---------- render ----------
+    scene.render.resolution_x = W
+    scene.render.resolution_y = H
+    scene.render.fps = int(round(fps))
+    scene.render.fps_base = 1.0
+    scene.cycles.samples = args.samples
+    scene.cycles.use_denoising = True
+    scene.cycles.max_bounces = 4
+    setup_cycles(scene, args.samples, args.device == "gpu")
+    scene.render.image_settings.file_format = "FFMPEG"
+    scene.render.ffmpeg.format = "MPEG4"
+    scene.render.ffmpeg.codec = "H264"
+    scene.render.ffmpeg.constant_rate_factor = "HIGH"
+    scene.render.ffmpeg.audio_codec = "NONE"
+    scene.render.filepath = str(out / "sim.mp4")
+    bpy.ops.render.render(animation=True)
+    print(f"[render] wrote {out/'sim.mp4'}")
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/resim/resim_cloth_blender.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python
+"""Cloth re-simulation of a 4DCodeBench world (B_07: cloth drop over table+props)
+with a parameter card, inside Blender (background).
+
+Run:
+  blender --background --python resim_cloth_blender.py -- \
+      --world work/B_07/world --out work/B_07/out_a0b0 \
+      --density 0.35 --tensile 15 --bending 0.02 --air_damp 1.0 --samples 32
+
+World layout (from unpack_world.py):
+  world/spec.json      F, video specs, dynamics/meshes split
+  world/camera.json    K (3x3 intrinsics px), E (4x4 cam-to-world)
+  world/render.mp4     reference render (ground truth video)
+  world/mesh/<id>.npz  vertices (F,V,3) f32, faces (F,T,3) i32
+  world/dyn/<name>.npz pos (F,N,3) f32, ids (M,) u16, faces (T,3) i32
+
+Split:
+  * every dynamics group  -> active CLOTH body spawned at its frame-0 pose with
+    the parameter card (this is what we sweep)
+  * static meshes         -> passive collision bodies (exact geometry)
+
+Parameter card (what the ablation sweeps):
+  --density    cloth areal density (kg/m^2). Real cloth ~0.15-0.5.
+  --tensile    tensile stiffness (structural springs, Blender scale).
+  --bending    bending stiffness (0 = flimsy rag, high = paper-stiff folds).
+  --air_damp   air drag multiplier (higher = falls/slide slower, heavier look).
+  --mass       override total mass (kg); else per-vertex mass from density.
+
+Output: <out>/sim.mp4, <out>/clothtraj.npz (cloth vertex positions (F,N,3) f16),
+        <out>/params.json (the card actually used)
+"""
+import argparse
+import json
+import sys
+from math import radians
+from pathlib import Path
+
+import bpy
+import numpy as np
+from mathutils import Matrix, Vector
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--world", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--density", type=float, default=0.35, help="kg/m^2")
+    ap.add_argument("--tensile", type=float, default=15.0)
+    ap.add_argument("--compress", type=float, default=15.0)
+    ap.add_argument("--shear", type=float, default=8.0)
+    ap.add_argument("--bending", type=float, default=0.02)
+    ap.add_argument("--air_damp", type=float, default=1.0)
+    ap.add_argument("--mass", type=float, default=None, help="total mass override (kg)")
+    ap.add_argument("--quality", type=int, default=10)
+    ap.add_argument("--coll_quality", type=int, default=4)
+    ap.add_argument("--samples", type=int, default=32)
+    ap.add_argument("--no_render", action="store_true", help="skip render (fitting)")
+    ap.add_argument("--device", default="gpu", choices=["gpu", "cpu"])
+    return ap.parse_args(sys.argv[sys.argv.index("--") + 1:])
+
+
+def add_mesh(name, verts, faces, mat=None):
+    me = bpy.data.meshes.new(name)
+    me.from_pydata([tuple(float(x) for x in v) for v in verts], [],
+                   [tuple(int(x) for x in f) for f in faces])
+    me.update()
+    ob = bpy.data.objects.new(name, me)
+    bpy.context.scene.collection.objects.link(ob)
+    if mat is not None:
+        ob.data.materials.append(mat)
+    return ob
+
+
+def add_collision(ob, friction=0.5, damping=0.05, thickness=0.004):
+    mod = ob.modifiers.new("Coll", "COLLISION")
+    c = mod.settings
+    c.absorption = 0
+    c.cloth_friction = friction   # friction as seen by cloth sim
+    c.damping = damping           # velocity damping factor
+    c.thickness_outer = thickness
+    c.thickness_inner = thickness
+    return mod
+
+
+def mat_simple(name, rgb, rough=0.6):
+    m = bpy.data.materials.new(name)
+    m.use_nodes = True
+    bsdf = m.node_tree.nodes["Principled BSDF"]
+    bsdf.inputs["Base Color"].default_value = (*rgb, 1.0)
+    bsdf.inputs["Roughness"].default_value = rough
+    return m
+
+
+def setup_cycles(scene, samples, use_gpu):
+    scene.render.engine = "CYCLES"
+    if use_gpu:
+        prefs = bpy.context.preferences.addons["cycles"].preferences
+        for ctype in ("OPTIX", "CUDA"):
+            try:
+                prefs.compute_device_type = ctype
+                prefs.get_devices()
+                devs = [d for d in prefs.devices if d.type == ctype]
+                if devs:
+                    for d in prefs.devices:
+                        d.use = d.type == ctype
+                    scene.cycles.device = "GPU"
+                    print(f"[cycles] using {ctype}: {[d.name for d in devs]}")
+                    return
+            except Exception as e:
+                print(f"[cycles] {ctype} failed: {e}")
+        print("[cycles] no GPU backend, falling back to CPU")
+    scene.cycles.device = "CPU"
+
+
+def build_cloth(mod, args, F, area_m2, verts_n):
+    """Configure cloth physics on an already-created CLOTH modifier.
+
+    Mass working point: Blender's cloth solver expects per-vertex mass in the
+    ~0.05-0.5 kg range (default 0.15). Real cloth areal density (0.1-1.2
+    kg/m^2) maps to tiny per-vertex masses that make gravity negligible vs
+    spring/air forces -> the cloth floats. So we anchor density=0.35 kg/m^2 at
+    the default 0.15 kg/vertex working point and scale linearly: the ablation
+    still sweeps real relative density (inertia vs drag/collision), while the
+    solver stays in its valid regime.
+    """
+    s = mod.settings
+    total_mass = args.mass if args.mass is not None else 0.15 * verts_n * (args.density / 0.35)
+    s.mass = total_mass / verts_n  # per-vertex mass
+    # structural springs
+    s.tension_stiffness = max(1.0, args.tensile)
+    s.compression_stiffness = max(1.0, args.compress)
+    s.shear_stiffness = max(1.0, args.shear)
+    s.tension_damping = 5.0
+    s.compression_damping = 5.0
+    s.shear_damping = 5.0
+    # bending (the flexibility knob)
+    s.bending_stiffness = max(0.0, args.bending)
+    s.bending_damping = 0.5
+    s.bending_model = 'ANGULAR'
+    # air (the density look knob: more drag = floats down slowly)
+    s.air_damping = max(0.0, args.air_damp)
+    # solver
+    s.quality = args.quality
+    s.time_scale = 1.0
+    # collisions
+    cs = mod.collision_settings
+    cs.use_collision = True
+    cs.distance_min = 0.0025
+    cs.friction = 0.5
+    cs.damping = 0.1
+    cs.collision_quality = args.coll_quality
+    cs.use_self_collision = True
+    cs.self_distance_min = 0.0025
+    cs.self_friction = 0.3
+    # cache
+    pc = mod.point_cache
+    pc.frame_start = 1
+    pc.frame_end = F
+    return mod
+
+
+def mesh_area(verts, faces):
+    """Sum of triangle areas for (N,3) verts and (T,3) tri indices."""
+    v = verts[faces]
+    a = v[:, 1] - v[:, 0]
+    b = v[:, 2] - v[:, 0]
+    return float(0.5 * np.linalg.norm(np.cross(a, b), axis=1).sum())
+
+
+def main():
+    args = parse_args()
+    world = Path(args.world)
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+
+    spec = json.loads((world / "spec.json").read_text())
+    cam = json.loads((world / "camera.json").read_text())
+    K = np.array(cam["intrinsics"], float)
+    E = np.array(cam["extrinsic"], float)
+    F = int(spec["F"])
+    W, H = spec["video"]["width"], spec["video"]["height"]
+    fps = float(spec["video"]["fps"])
+
+    scene = bpy.context.scene
+    for ob in list(bpy.data.objects):
+        bpy.data.objects.remove(ob, do_unlink=True)
+
+    mats = {"cloth": mat_simple("m_cloth", (0.78, 0.10, 0.08), rough=0.45),
+            "wood": mat_simple("m_wood", (0.35, 0.20, 0.11), rough=0.5),
+            "ball": mat_simple("m_ball", (0.90, 0.88, 0.82), rough=0.35)}
+
+    # ---------- static geometry (collision only) ----------
+    dyn_ids = set()
+    for name, v in spec["dynamics"].items():
+        dyn_ids.update(int(i) for i in v["ids"])
+    for mid, mv in spec["meshes"].items():
+        if not mv["static"]:
+            continue
+        z = np.load(world / "mesh" / f"{mid}.npz")
+        v0 = z["vertices"][0]
+        bb = v0.max(0) - v0.min(0)
+        if max(bb) < 0.3 and bb[2] > 0.03:
+            m = mats["ball"]
+        else:
+            m = mats["wood"]
+        ob = add_mesh(f"static_{mid}", v0, z["faces"][0], m)
+        add_collision(ob)
+
+    # ---------- cloth body ----------
+    card = {
+        "density_kg_m2": args.density,
+        "tensile": args.tensile,
+        "compress": args.compress,
+        "shear": args.shear,
+        "bending": args.bending,
+        "air_damp": args.air_damp,
+        "mass_total_kg": args.mass,
+        "quality": args.quality,
+    }
+    (out / "params.json").write_text(json.dumps(card, indent=1))
+
+    cloth_name = next(iter(spec["dynamics"]))
+    z = np.load(world / "dyn" / f"{cloth_name}.npz")
+    pos = z["pos"]          # (F,N,3) ground truth; we spawn at frame-0 pose
+    faces = z["faces"]
+    p0 = pos[0]
+    area = mesh_area(p0.astype(np.float64), faces.astype(np.int64))
+    print(f"[cloth] V={len(p0)} T={len(faces)} area={area:.3f} m^2")
+
+    ob = add_mesh(cloth_name, p0, faces, mats["cloth"])
+    bpy.context.view_layer.objects.active = ob
+    try:
+        bpy.ops.object.shade_smooth()
+    except Exception:
+        pass
+    mod = ob.modifiers.new("Cloth", "CLOTH")
+    build_cloth(mod, args, F, area, len(p0))
+    print(f"[cloth] mass_total={args.density * area:.3f} kg (density {args.density})")
+
+    # ---------- camera ----------
+    cam_data = bpy.data.cameras.new("cam")
+    cam_data.sensor_fit = "HORIZONTAL"
+    cam_data.sensor_width = 36.0
+    cam_data.lens = float(K[0, 0]) * 36.0 / W
+    cam_ob = bpy.data.objects.new("cam", cam_data)
+    bpy.context.scene.collection.objects.link(cam_ob)
+    D = Matrix.Diagonal((1.0, -1.0, -1.0, 1.0))
+    cam_ob.matrix_world = Matrix(E) @ D
+    scene.camera = cam_ob
+
+    # ---------- lights ----------
+    w = bpy.data.worlds.new("w")
+    w.use_nodes = True
+    w.node_tree.nodes["Background"].inputs["Color"].default_value = (0.85, 0.85, 0.85, 1)
+    w.node_tree.nodes["Background"].inputs["Strength"].default_value = 1.1
+    scene.world = w
+    sun = bpy.data.lights.new("sun", type="SUN")
+    sun.energy = 3.0
+    sun_ob = bpy.data.objects.new("sun", sun)
+    bpy.context.scene.collection.objects.link(sun_ob)
+    sun_ob.rotation_euler = (radians(50), 0, radians(30))
+    area_l = bpy.data.lights.new("fill", type="AREA")
+    area_l.energy = 300.0
+    area_l.size = 2.0
+    area_ob = bpy.data.objects.new("fill", area_l)
+    bpy.context.scene.collection.objects.link(area_ob)
+    area_ob.location = (0.0, -2.0, 2.5)
+    area_ob.rotation_euler = (radians(35), 0, 0)
+
+    # ---------- bake cloth ----------
+    scene.frame_start = 1
+    scene.frame_end = F
+    scene.frame_set(1)
+    mod.point_cache.frame_start = 1
+    mod.point_cache.frame_end = F
+    bpy.ops.ptcache.free_bake_all()
+    bpy.ops.ptcache.bake_all(bake=True)
+    print("[bake] done")
+
+    # ---------- record cloth trajectories ----------
+    deps = bpy.context.evaluated_depsgraph_get()
+    traj = np.zeros((F, pos.shape[1], 3), np.float16)
+    for t in range(1, F + 1):
+        scene.frame_set(t)
+        bpy.context.view_layer.update()
+        ob_eval = ob.evaluated_get(deps)
+        me = ob_eval.to_mesh()
+        verts = np.empty(len(me.vertices) * 3, np.float32)
+        me.vertices.foreach_get("co", verts)
+        traj[t - 1] = verts.reshape(-1, 3).astype(np.float16)
+        ob_eval.to_mesh_clear()
+    np.savez_compressed(out / "clothtraj.npz", pos=traj)
+    print(f"[traj] saved clothtraj ({traj.shape})")
+
+    if args.no_render:
+        print("[render] skipped (--no_render)")
+        return
+
+    # ---------- render ----------
+    scene.render.resolution_x = W
+    scene.render.resolution_y = H
+    scene.render.fps = int(round(fps))
+    scene.render.fps_base = 1.0
+    scene.cycles.samples = args.samples
+    scene.cycles.use_denoising = True
+    scene.cycles.max_bounces = 4
+    setup_cycles(scene, args.samples, args.device == "gpu")
+    scene.render.image_settings.file_format = "FFMPEG"
+    scene.render.ffmpeg.format = "MPEG4"
+    scene.render.ffmpeg.codec = "H264"
+    scene.render.ffmpeg.constant_rate_factor = "HIGH"
+    scene.render.ffmpeg.audio_codec = "NONE"
+    scene.render.filepath = str(out / "sim.mp4")
+    bpy.ops.render.render(animation=True)
+    print(f"[render] wrote {out/'sim.mp4'}")
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/resim/run_ablation_b07.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+# 2x2 ablation on B_07 (4DCodeBench cloth case): agent prior (A) x NeuIDO fit (B)
+#   A0B0: default card (no agent reasoning, no fitting)     -> baseline
+#   A1B0: agent prior card (material/fall reasoning, no fit)
+#   A0B1: NeuIDO-style closed-loop fit from neutral start (default center)
+#   A1B1: NeuIDO-style fit seeded by the agent prior card (interaction)
+# Full render (32 samples) for every arm. GPUs 4-7 only.
+set -e
+export LANG=en_US.UTF-8 PYTHONUTF8=1
+cd ~/jiayin/4dcodebench
+PY=~/miniconda3/envs/ovow-motion/bin/python
+BL=~/jiayin/blender/blender
+W=work/B_07/world
+BASE=work/B_07/ablation
+mkdir -p $BASE
+
+echo "=== [0/6] cards ==="
+$PY resim/agent_card.py --world $W --out work/B_07/agent_card.json
+test -f work/B_07/fit/best_card.json || { echo "global fit missing"; exit 1; }
+
+render () {  # render <outdir> <density> <bending> <air_damp>
+  local OUT=$1 D=$2 BE=$3 AI=$4
+  if [ -f "$OUT/sim.mp4" ] && [ $(stat -c %s "$OUT/sim.mp4") -gt 100000 ]; then
+    echo "--- $OUT already done, skip"; return 0
+  fi
+  rm -rf "$OUT"
+  mkdir -p "$OUT"
+  echo "--- rendering $OUT (d=$D b=$BE a=$AI)"
+  CUDA_VISIBLE_DEVICES=$GPU $BL --background --python resim/resim_cloth_blender.py -- \
+    --world $W --out "$OUT" --density $D --bending $BE --air_damp $AI --samples 32 \
+    > "$OUT/blender.log" 2>&1
+  test -f "$OUT/sim.mp4" && [ $(stat -c %s "$OUT/sim.mp4") -gt 100000 ]
+}
+
+# ---------- A0B0: default ----------
+GPU=4
+echo "=== [1/6] A0B0 default ==="
+render $BASE/a0b0 0.35 0.02 1.0
+
+# ---------- A1B0: agent prior ----------
+echo "=== [2/6] A1B0 agent prior ==="
+GPU=5 render $BASE/a1b0 0.35 0.02 1.0   # same card, produced by agent reasoning
+cp work/B_07/agent_card.json $BASE/a1b0/params_src.json || true
+
+# ---------- A0B1: NeuIDO fit from neutral start (already fitted globally) ----------
+echo "=== [3/6] A0B1 neuido fit (neutral) ==="
+read D BE AI <<< $($PY -c "import json;c=json.load(open('work/B_07/fit/best_card.json'));print(c['density'],c['bending'],c['air_damp'])")
+GPU=6 render $BASE/a0b1 $D $BE $AI
+cp work/B_07/fit/best_card.json $BASE/a0b1/params_src.json
+
+# ---------- A1B1: local refit seeded by agent prior ----------
+echo "=== [4/6] A1B1 local refit around agent card ==="
+if [ ! -f work/B_07/fit_agent/best_card.json ]; then
+  $PY resim/fit_params_neuido.py --world $W --out work/B_07/fit_agent \
+    --trials 10 --parallel 3 --gpus 4,5,6 \
+    --center work/B_07/agent_card.json --sigma 0.12,0.35,0.25 \
+    > work/B_07/fit_agent_main.log 2>&1
+fi
+read D BE AI <<< $($PY -c "import json;c=json.load(open('work/B_07/fit_agent/best_card.json'));print(c['density'],c['bending'],c['air_damp'])")
+GPU=7 render $BASE/a1b1 $D $BE $AI
+cp work/B_07/fit_agent/best_card.json $BASE/a1b1/params_src.json
+
+echo "=== ALL ABLATION ROLLOUTS DONE ==="

4dcodebench/resim/run_b03.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# B_03 bowling re-simulation: two parameter presets -> DTW -> comparison video
+set -e
+cd ~/jiayin/4dcodebench
+PY=~/miniconda3/envs/ovow-motion/bin/python
+BL=~/jiayin/blender/blender
+CASE=B_03
+W=work/$CASE/world
+
+echo "=== [1/4] unpack ==="
+$PY resim/unpack_world.py cases/$CASE/$CASE.h5 $W
+
+mkdir -p work/$CASE
+echo "=== [2/4] preset 1: mu=0.5, e=0.05 (sticky) ==="
+CUDA_VISIBLE_DEVICES=4 $BL --background --python resim/resim_blender.py -- \
+  --world $W --out work/$CASE/out_p1 --preset p1 --kinematic Ball \
+  --friction 0.5 --restitution 0.05 --mass 1.5 --samples 32
+test -f work/$CASE/out_p1/sim.mp4 || { echo "preset 1 FAILED (no sim.mp4)"; exit 1; }
+
+echo "=== [3/4] preset 2: mu=0.02, e=0.9 (icy+bouncy) ==="
+CUDA_VISIBLE_DEVICES=4 $BL --background --python resim/resim_blender.py -- \
+  --world $W --out work/$CASE/out_p2 --preset p2 --kinematic Ball \
+  --friction 0.02 --restitution 0.9 --mass 1.5 --samples 32
+test -f work/$CASE/out_p2/sim.mp4 || { echo "preset 2 FAILED (no sim.mp4)"; exit 1; }
+
+echo "=== [4/4] score + compose ==="
+$PY resim/score_dtw.py --world $W --sims work/$CASE/out_p1 work/$CASE/out_p2 \
+  --out work/$CASE/dtw.json
+$PY resim/compose_video.py --world $W --sims work/$CASE/out_p1 work/$CASE/out_p2 \
+  --labels "sim mu=0.50 e=0.05" "sim mu=0.02 e=0.90" \
+  --out work/$CASE/compare_$CASE.mp4
+echo "=== ALL DONE ==="

4dcodebench/resim/score_ablation.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+"""Score the 2x2 ablation arms for the B_07 cloth case, 4DCodeBench-style.
+
+Metrics (all computed against the baked ground-truth cloth trajectory):
+  chamfer_t    mean per-frame symmetric chamfer between sim and GT cloth point
+               clouds, subsampled, averaged over frames (meters, lower better)
+  dtw_com      DTW between the cloth center-of-mass trajectories (meters)
+  bbox_iou_t   mean 3D IoU of the axis-aligned cloth bounding box per frame
+  final_cham   chamfer at the last frame (did it end in the same place?)
+
+Usage:
+  python score_ablation.py --world work/B_07/world --runs work/B_07/ablation \
+      --out work/B_07/ablation/metrics.json [--csv work/B_07/ablation/metrics.csv]
+"""
+import argparse
+import csv
+import json
+from pathlib import Path
+
+import numpy as np
+
+
+def chamfer(a, b, n=2000, seed=0):
+    rng = np.random.default_rng(seed)
+    ai = rng.choice(len(a), min(n, len(a)), replace=False)
+    bi = rng.choice(len(b), min(n, len(b)), replace=False)
+    A, B = a[ai].astype(np.float64), b[bi].astype(np.float64)
+    d_ab = ((A[:, None, :] - B[None, :, :]) ** 2).sum(-1)
+    d1 = np.sqrt(d_ab.min(1))
+    d2 = np.sqrt(((B[:, None, :] - A[None, :, :]) ** 2).sum(-1)).min(1)
+    return float(0.5 * (d1.mean() + d2.mean()))
+
+
+def dtw(a, b):
+    n, m = len(a), len(b)
+    D = np.full((n + 1, m + 1), np.inf)
+    D[0, 0] = 0.0
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            c = float(np.linalg.norm(a[i - 1] - b[j - 1]))
+            D[i, j] = c + min(D[i - 1, j - 1], D[i, j - 1], D[i - 1, j])
+    return float(D[n, m] / (n + m))
+
+
+def bbox_iou(a, b):
+    amin, amax = a.min(0), a.max(0)
+    bmin, bmax = b.min(0), b.max(0)
+    inter_min = np.maximum(amin, bmin)
+    inter_max = np.minimum(amax, bmax)
+    inter = np.clip(inter_max - inter_min, 0, None).prod()
+    va = (amax - amin).prod()
+    vb = (bmax - bmin).prod()
+    union = va + vb - inter
+    return float(inter / union) if union > 0 else 0.0
+
+
+def score(world_dir, traj_dir, frame_stride=3):
+    gt = np.load(Path(world_dir) / "dyn" / "Cloth.npz")["pos"].astype(np.float32)
+    sim = np.load(Path(traj_dir) / "clothtraj.npz")["pos"].astype(np.float32)
+    assert sim.shape == gt.shape, f"shape mismatch {sim.shape} vs {gt.shape}"
+    F = gt.shape[0]
+    frames = list(range(0, F, frame_stride))
+    if frames[-1] != F - 1:
+        frames.append(F - 1)
+    ch = [chamfer(sim[i], gt[i], seed=i) for i in frames]
+    gt_com = gt.mean(1)
+    sim_com = sim.mean(1)
+    iou = [bbox_iou(sim[i], gt[i]) for i in frames]
+    return {
+        "chamfer_t_m": round(float(np.mean(ch)), 4),
+        "final_chamfer_m": round(ch[-1], 4),
+        "dtw_com_m": round(dtw(sim_com, gt_com), 4),
+        "bbox_iou_t": round(float(np.mean(iou)), 4),
+    }
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--world", required=True)
+    ap.add_argument("--runs", required=True, nargs="+")
+    ap.add_argument("--names", required=True, nargs="+")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--csv", default=None)
+    args = ap.parse_args()
+
+    report = {}
+    for name, run in zip(args.names, args.runs):
+        try:
+            report[name] = score(args.world, run)
+        except Exception as e:
+            report[name] = {"error": str(e)}
+        print(name, json.dumps(report[name]))
+
+    Path(args.out).write_text(json.dumps(report, indent=1))
+    print(f"wrote {args.out}")
+
+    if args.csv:
+        keys = ["chamfer_t_m", "final_chamfer_m", "dtw_com_m", "bbox_iou_t"]
+        with open(args.csv, "w", newline="") as f:
+            w = csv.writer(f)
+            w.writerow(["arm"] + keys)
+            for name in args.names:
+                r = report[name]
+                w.writerow([name] + [r.get(k, "") for k in keys])
+        print(f"wrote {args.csv}")
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/resim/score_dtw.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+"""DTW score: re-simulated trajectories vs baked ground truth, per active object.
+
+Usage:
+  python score_dtw.py --world work/B_03/world --sims work/B_03/out_p1 work/B_03/out_p2
+"""
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+
+
+def dtw(a, b):
+    """Mean-per-step DTW cost between two (F,3) trajectories."""
+    n, m = len(a), len(b)
+    D = np.full((n + 1, m + 1), np.inf)
+    D[0, 0] = 0.0
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            c = float(np.linalg.norm(a[i - 1] - b[j - 1]))
+            D[i, j] = c + min(D[i - 1, j - 1], D[i, j - 1], D[i - 1, j])
+    return D[n, m] / (n + m)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--world", required=True)
+    ap.add_argument("--sims", nargs="+", required=True)
+    ap.add_argument("--out", default=None, help="write JSON here too")
+    args = ap.parse_args()
+
+    world = Path(args.world)
+    names = [p.stem for p in (world / "dyn").glob("*.npz")]
+    report = {}
+    for sim in args.sims:
+        traj = np.load(Path(sim) / "simtraj.npz")
+        sim_names = [k for k in traj.files if k in names and k != "Ball"]  # Ball = kinematic replay == truth
+        per = {}
+        for n in sorted(sim_names):
+            truth = np.load(world / "dyn" / f"{n}.npz")["pos"].astype(np.float64).mean(axis=1)
+            sim_t = traj[n].astype(np.float64)
+            per[n] = round(dtw(truth, sim_t), 5)
+        report[sim] = {
+            "per_object": per,
+            "mean": round(float(np.mean(list(per.values()))) if per else None, 5),
+        }
+        print(json.dumps({sim: report[sim]}, indent=1))
+
+    if args.out:
+        Path(args.out).write_text(json.dumps(report, indent=1))
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/resim/unpack_world.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+"""Unpack a 4DCodeBench synthetic world h5 into a plain directory + spec.json.
+
+Usage:
+  python unpack_world.py <case.h5> <outdir>
+
+Output (our own simplified layout, plain numpy npz):
+  <outdir>/camera.json     verbatim from the h5 (intrinsics K 3x3 px, extrinsic E 4x4 cam-to-world)
+  <outdir>/render.mp4      verbatim from the h5 (the reference render)
+  <outdir>/mesh/<id>.npz   vertices (F,V,3) f32, faces (F,T,3) i32, nverts/nfaces per frame
+  <outdir>/dyn/<name>.npz  pos (F,N,3) f32, ids (M,) u16, faces (T,3) i32
+  <outdir>/spec.json       F, video specs, per-object summary, static/dynamic split
+"""
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+import h5py
+import hdf5plugin  # noqa: F401  (registers the Zstd filter)
+
+
+def read_series(group):
+    """Per-frame series stored as (frames + stack) or (frames + flat + lengths)."""
+    frames = group["frames"][()]
+    if "stack" in group:
+        parts = list(group["stack"][()])
+    else:
+        flat = group["flat"][()]
+        lengths = group["lengths"][()]
+        edges = np.concatenate([[0], np.cumsum(lengths)])
+        parts = [flat[edges[i]:edges[i + 1]] for i in range(len(frames))]
+    return frames, parts
+
+
+def probe_video(path):
+    try:
+        import cv2
+        cap = cv2.VideoCapture(str(path))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        n = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        cap.release()
+        if fps and fps > 0 and w > 0:
+            return {"fps": round(float(fps), 6), "width": w, "height": h, "frames": n}
+    except Exception:
+        pass
+    return None
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("h5")
+    ap.add_argument("out")
+    args = ap.parse_args()
+
+    out = Path(args.out)
+    (out / "mesh").mkdir(parents=True, exist_ok=True)
+    (out / "dyn").mkdir(parents=True, exist_ok=True)
+
+    spec = {"source": str(args.h5)}
+    with h5py.File(args.h5, "r") as h:
+        (out / "camera.json").write_bytes(bytes(h["camera.json"][()]))
+        (out / "render.mp4").write_bytes(bytes(h["render.mp4"][()]))
+        vid = probe_video(out / "render.mp4") or {"fps": 24.0, "width": 1280, "height": 720, "frames": None}
+        spec["video"] = vid
+
+        F = int(h[f"dynamics/{next(iter(h['dynamics']))}/pos"].shape[0]) if len(h["dynamics"]) \
+            else int(h[f"meshes/{next(iter(h['meshes']))}/vertices/frames"].shape[0])
+        spec["F"] = F
+
+        dyn = {}
+        for name in h["dynamics"]:
+            g = h[f"dynamics/{name}"]
+            np.savez_compressed(out / "dyn" / f"{name}.npz",
+                                pos=g["pos"][()].astype(np.float32),
+                                ids=g["ids"][()].astype(np.uint16),
+                                faces=g["faces"][()].astype(np.int32))
+            dyn[name] = {"ids": [int(i) for i in g["ids"][()]], "N": int(g["pos"].shape[1])}
+        spec["dynamics"] = dyn
+
+        dyn_ids = {i for v in dyn.values() for i in v["ids"]}
+        meshes = {}
+        for mid in h["meshes"]:
+            vf, vp = read_series(h[f"meshes/{mid}/vertices"])
+            ff, fp = read_series(h[f"meshes/{mid}/faces"])
+            V = max(len(p) for p in vp)
+            T = max(len(p) for p in fp)
+            vert = np.zeros((len(vp), V, 3), np.float32)
+            face = np.zeros((len(fp), T, 3), np.int32)
+            for i, (pv, pf) in enumerate(zip(vp, fp)):
+                vert[i, :len(pv)] = pv
+                face[i, :len(pf)] = pf
+            np.savez_compressed(out / "mesh" / f"{int(mid)}.npz", vertices=vert, faces=face,
+                                frames=np.asarray(vf, np.int32),
+                                nverts=np.array([len(p) for p in vp], np.int32),
+                                nfaces=np.array([len(p) for p in fp], np.int32))
+            meshes[int(mid)] = {"nverts": int(len(vp[0])), "nfaces": int(len(fp[0])),
+                                "static": int(mid) not in dyn_ids}
+        spec["meshes"] = {str(k): v for k, v in sorted(meshes.items())}
+
+        cam = json.loads((out / "camera.json").read_text())
+        K = np.array(cam["intrinsics"], float)
+        spec["camera"] = {"K": K.tolist(), "E": np.array(cam["extrinsic"], float).tolist()}
+
+    (out / "spec.json").write_text(json.dumps(spec, indent=1))
+    print(f"unpacked to {out} | F={spec['F']} | video={vid}")
+
+
+if __name__ == "__main__":
+    main()

4dcodebench/work/B_03/compare_B_03.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:041cd650d81fc82129c3de321d106127384f9127da94c11d4314224935b380c7
+size 2785712

4dcodebench/work/B_03/dtw.json

@@ -0,0 +1,32 @@
+{
+ "work/B_03/out_p1": {
+  "per_object": {
+   "Pin00": 0.56827,
+   "Pin01": 0.42597,
+   "Pin02": 0.71006,
+   "Pin03": 0.6415,
+   "Pin04": 0.70023,
+   "Pin05": 0.63049,
+   "Pin06": 0.60231,
+   "Pin07": 0.80838,
+   "Pin08": 0.76187,
+   "Pin09": 0.81381
+  },
+  "mean": 0.66629
+ },
+ "work/B_03/out_p2": {
+  "per_object": {
+   "Pin00": 0.57008,
+   "Pin01": 0.48433,
+   "Pin02": 0.65053,
+   "Pin03": 0.55086,
+   "Pin04": 0.72888,
+   "Pin05": 0.67485,
+   "Pin06": 0.51459,
+   "Pin07": 0.78546,
+   "Pin08": 0.81593,
+   "Pin09": 0.80364
+  },
+  "mean": 0.65791
+ }
+}

4dcodebench/work/B_03/out_p1/sim.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52201869fe0772f416fd03345b69331131884795dd5c822541699bfb1369ade3
+size 570094

4dcodebench/work/B_03/out_p1/simtraj.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e0b0e4fae069fc6da5923e7d39403638d748c09018528fd1ae7c8d2963c84e4
+size 18231

4dcodebench/work/B_03/out_p2/sim.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8fb0bb81b38445ec07f0bcc5e750eb67d2e7b9325155db6ed75ca5306e5dc97
+size 619049

4dcodebench/work/B_03/out_p2/simtraj.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e06a3979431619b447c8182f4ff8b6e7dc36a54a8966d40e9aff5d4bbac19b2d
+size 18286

4dcodebench/work/B_03/world/camera.json

@@ -0,0 +1 @@
+{"intrinsics": [[2204.4444444444443, 0.0, 640.0], [0.0, 2204.4444444444443, 360.0], [0.0, 0.0, 1.0]], "extrinsic": [[0.5174191726573811, -0.24477246018742208, 0.8199779524477159, -3.8001997470855713], [-0.8557320841049176, -0.14800179780998798, 0.4958004317045986, -2.5872905254364014], [-8.030350601151426e-08, -0.9582180913439324, -0.2860386152623192, 1.6765010356903076], [0.0, 0.0, 0.0, 1.0]]}

4dcodebench/work/B_03/world/dyn/Ball.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4482e42f3514b1a7de83c49bb72f4b951125baf39972a261163be18ad4475b19
+size 6125504

4dcodebench/work/B_03/world/dyn/Pin00.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1906732cbe85ca621e56386fc02d557c217ba9d16170337433dd79d435cbc156
+size 660805

4dcodebench/work/B_03/world/dyn/Pin01.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e311e58b9f268d5630a979dea3fd757513a421379f6fa457beab6c55fbd31cc
+size 705252

4dcodebench/work/B_03/world/dyn/Pin02.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b73599876b08b16008648da600810d41f770294a17220204ee942de9d471e8e
+size 704848

4dcodebench/work/B_03/world/dyn/Pin03.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59d8bb0d19c32745506849fb150770102eab7b28633e36ecf08bf0a44562d7fa
+size 695912

4dcodebench/work/B_03/world/dyn/Pin04.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae6da1587c193e8f6524a63682253a2f3f03333da9fcd2459ffb1c74fb4d484c
+size 647843

4dcodebench/work/B_03/world/dyn/Pin05.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:791ab07f3372b979ca4f8375e83dcdfdcd8631697883bf6b7b0ff97d42c832a5
+size 693786

4dcodebench/work/B_03/world/dyn/Pin06.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a5e7dd5a79c56ebc676c1431be940aaddf4badc15a77dfebeb3c73e77728ab4
+size 589148

4dcodebench/work/B_03/world/dyn/Pin07.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5cb0acd4b62890b0ad4ae0ac03ab951fdacd762d865088a4401805b684364f6
+size 646749

4dcodebench/work/B_03/world/dyn/Pin08.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4610cca9cfdc5cb48d1b761ba4a62e8f7017243f394de0e8c3d0490741a91c91
+size 697896

4dcodebench/work/B_03/world/dyn/Pin09.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0514ee43ca447ed2af4a801c3824eb425ddfdfe2617e0dd07d05212a6bfa17a8
+size 695769

4dcodebench/work/B_03/world/mesh/1.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:629b9fe4c01f4386152507e5fdcf34e07e990dfcf8853e547dc6a0802eeed96d
+size 10902995

4dcodebench/work/B_03/world/mesh/10.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8342e5872e25dce8551bb091d254afadd018bb632acebb5f661076de7c3b3b98
+size 660508

4dcodebench/work/B_03/world/mesh/11.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68ce643726c1d056fd407ab29ff23e150253861393eaea24dce790ef67d6928a
+size 706451

4dcodebench/work/B_03/world/mesh/12.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33f6e1fcf1b5e8901fcbdd2d72db4526cf3984fcd16ce519ad886ddfe7a7a00e
+size 601813

4dcodebench/work/B_03/world/mesh/13.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e2a46392db579a9dac80b7956002fcb3679750eb917a618efdfdf165fb87ec4
+size 659414

4dcodebench/work/B_03/world/mesh/14.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7893118ace03e5b9e40b1731219c16d969e6e7ccc0811a9ec92275ff443ba63
+size 710561

4dcodebench/work/B_03/world/mesh/15.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d00fa4c61736bbfaae1cffb2eb91edce2ac00661bcaa8e8c9de2b2c740f8027d
+size 708434

4dcodebench/work/B_03/world/mesh/16.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7682afc2c5b14511820fd340f08923191105c85d02b5b6a6a26932239726ef9d
+size 1464

4dcodebench/work/B_03/world/mesh/17.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19ba3e91c35d0cfc1828556505049ee4d46a6868b5282aa93b6626e27607162e
+size 1463

4dcodebench/work/B_03/world/mesh/18.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4cec6face6af2df04a0f7fe5934ab5a7ff7fee52d873b4564120da244a188ec7
+size 1465

4dcodebench/work/B_03/world/mesh/19.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c86c307de2410e0032485b099f237f3737ed2d1e8126d201f38e7a6a699c9c15
+size 1464