cozyclay 2.1.0 → 3.0.0

package/tools/track/py/test_masks.py

@@ -1,229 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import os
-
-import numpy as np
-import pytest
-
-from masks import (
-    NoPersonPrompt,
-    box_from_xys,
-    choose_anchor,
-    main,
-    plan_chunks,
-    prompt_boxes,
-    prompt_points,
-    reprompt_frames,
-    segment,
-    should_reprompt,
-    track_clip,
-)
-
-
-def test_reprompt_rule_on_synthetic_area_sequence():
-    areas = [1000, 1100, 1200, 600, 620, 1000, 1000, 0, 0, 500, 700]
-    # 1200->600 (-50 %), 620->1000 (+61 %), 1000->0 (-100 %); 0->500 is a recovery, 500->700 is +40 % (not > 40 %).
-    assert reprompt_frames(areas) == [3, 5, 7]
-    assert reprompt_frames(areas, eligible=[True] * 5 + [False] * 6) == [3]
-    assert not should_reprompt(1000, 1400)
-    assert should_reprompt(1000, 1401)
-    assert not should_reprompt(0, 5000)
-
-
-def test_box_conversion_clips_and_rejects():
-    assert box_from_xys([100, 50, 40], 832, 480).tolist() == [80, 30, 120, 70]
-    assert box_from_xys([441.5, 49.0, 249.4], 832, 480)[1] == 0.0  # clipped at the top edge
-    assert box_from_xys([10, 10, 0], 832, 480) is None
-    assert box_from_xys([np.nan, 10, 50], 832, 480) is None
-    assert box_from_xys([-500, 10, 50], 832, 480) is None  # entirely outside the image
-
-
-def test_empty_bbx_raises_no_person_prompt():
-    for bbx in (None, np.zeros((0, 3), np.float32), np.zeros((5, 3), np.float32)):
-        with pytest.raises(NoPersonPrompt, match="no-person-prompt"):
-            prompt_boxes(bbx, 832, 480)
-
-
-def test_cli_empty_bbx_exits_3_without_output(tmp_path, capsys):
-    obs = tmp_path / "obs.npz"
-    np.savez(obs, bbx_xys=np.zeros((0, 3), np.float32), kp2d=np.zeros((0, 17, 3), np.float32))
-    out = tmp_path / "out"
-    assert main(["--video", str(tmp_path / "missing.mp4"), "--obs", str(obs), "--out", str(out)]) == 3
-    assert "no-person-prompt" in capsys.readouterr().err
-    assert not out.exists()
-
-
-def test_prompt_points_use_confident_joints_inside_the_box():
-    box = np.array([100, 100, 300, 400], np.float32)
-    kp = np.zeros((17, 3))
-    kp[:, :2] = 200
-    kp[:, 2] = 0.9
-    kp[5, :2], kp[6, :2] = (180, 150), (220, 150)  # shoulders -> midpoint (200, 150)
-    kp[0, :2], kp[0, 2] = (200, 120), 0.9  # nose
-    kp[9, 2] = 0.1  # unconfident wrist is dropped
-    kp[16, :2] = (500, 390)  # ankle outside the box is dropped
-    points = prompt_points("joints", box, kp)
-    assert [tuple(p) for p in points.tolist()] == [(200, 150), (200, 200), (200, 120), (200, 200), (200, 200)]
-    kp[15, 2] = 0.6  # an ankle needs ANKLE_TRUST (hidden feet behind props score 0.46-0.71)
-    assert len(prompt_points("joints", box, kp)) == 4
-    kp[9, 2] = 0.6  # a wrist at the same confidence is kept
-    assert len(prompt_points("joints", box, kp)) == 5
-    assert prompt_points("box", box, kp) is None
-    assert prompt_points("centre", box, kp).tolist() == [[200, 250]]
-    assert prompt_points("joints", box, np.zeros((17, 3))) is None  # nothing confident: box only
-    assert prompt_points("joints", None, kp) is None
-    with pytest.raises(ValueError):
-        prompt_points("palm", box, kp)
-
-
-def test_anchor_skips_untrusted_leading_frames():
-    boxes = [np.array([0, 0, 10, 10], np.float32)] * 6
-    assert choose_anchor(boxes, [0.02, 0.1, 0.6, 0.9, 0.9, 0.9]) == 2
-    assert choose_anchor(boxes, [0.02, 0.3, 0.1, 0.2, 0.4, 0.1]) == 4  # nothing trusted: most confident
-    assert choose_anchor([None, None] + boxes[:4], [0.9] * 6) == 2
-
-
-def test_chunk_plan_covers_every_frame_with_shared_boundaries():
-    assert plan_chunks(124, 0, 180) == [(1, 0, 123)]
-    assert plan_chunks(362, 0, 180) == [(1, 0, 179), (1, 179, 358), (1, 358, 361)]
-    assert plan_chunks(20, 5, 8) == [(1, 5, 12), (1, 12, 19), (-1, 0, 5)]
-    for frames, anchor, size in ((362, 0, 180), (20, 5, 8), (20, 19, 4), (1, 0, 2)):
-        chunks = plan_chunks(frames, anchor, size)
-        covered = set()
-        for _, start, end in chunks:
-            assert end - start + 1 <= size
-            covered.update(range(start, end + 1))
-        assert covered == set(range(frames))
-
-
-class FakePredictor:
-    """SAM2 video-predictor stand-in: frame t tracks to TRUE area, except in the
-    drift window where tracking alone shrinks the mask to 30 % until a box prompt
-    is placed inside the window. Mask seeds reproduce their own area."""
-
-    def __init__(self, count, drift, hw=(20, 50)):
-        self.count, self.drift, self.hw = count, drift, hw
-        self.true = 600
-        self.box_prompts = []
-        self.recomputed = []
-
-    def open_chunk(self, start, end):
-        @contextlib.contextmanager
-        def chunk():
-            yield {"start": start, "n": end - start + 1, "prompts": {},
-                   "output_dict_per_obj": {0: {"non_cond_frame_outputs": {}}}, "frames_tracked_per_obj": {0: {}}}
-        return chunk()
-
-    def logits(self, area):
-        import torch
-
-        flat = torch.full((self.hw[0] * self.hw[1],), -10.0)
-        flat[:area] = 10.0
-        return flat.reshape(1, 1, *self.hw)
-
-    def add_new_points_or_box(self, state, frame_idx, obj_id, box=None, points=None, labels=None):
-        assert frame_idx not in state["frames_tracked_per_obj"][0], "re-prompt must be a fresh conditioning frame"
-        state["prompts"][frame_idx] = ("box", self.true)
-        self.box_prompts.append(state["start"] + frame_idx)
-
-    def add_new_mask(self, state, frame_idx, obj_id, mask):
-        state["prompts"][frame_idx] = ("mask", int(mask.sum()))
-
-    def propagate_in_video(self, state, start_frame_idx, reverse=False):
-        order = range(start_frame_idx, -1, -1) if reverse else range(start_frame_idx, state["n"])
-        for local in order:
-            t = state["start"] + local
-            if local in state["prompts"]:
-                area = state["prompts"][local][1]
-            elif t in self.drift and not any(p in self.drift and (p <= t if not reverse else p >= t) for p in self.box_prompts):
-                area = int(self.true * 0.3)
-            else:
-                area = self.true
-            if local in state["output_dict_per_obj"][0]["non_cond_frame_outputs"]:
-                self.recomputed.append(t)
-            state["output_dict_per_obj"][0]["non_cond_frame_outputs"][local] = area
-            state["frames_tracked_per_obj"][0][local] = {"reverse": reverse}
-            yield local, [1], self.logits(area)
-
-
-def run_fake(count, anchor, size, drift, trusted):
-    fake = FakePredictor(count, set(drift))
-    boxes = [np.array([0, 0, 10, 10], np.float32)] * count
-    prob, area, reprompted = track_clip(fake, fake.open_chunk, count, (10, 25), boxes, np.array(trusted),
-                                        anchor, plan_chunks(count, anchor, size))
-    return fake, prob, area, reprompted
-
-
-def test_track_clip_reprompts_drift_once_and_resumes():
-    fake, prob, area, reprompted = run_fake(20, 5, 8, range(14, 18), [False] * 5 + [True] * 15)
-    assert reprompted == [14]
-    assert fake.box_prompts == [5, 14]
-    assert area.tolist() == [600] * 20
-    assert prob.dtype == np.float16 and prob.shape == (20, 10, 25)
-    assert float(prob.min()) >= 0.0 and float(prob.max()) <= 1.0
-    assert fake.recomputed == []  # no frame is tracked twice: the restart starts at the re-prompted frame
-
-
-def test_track_clip_never_reprompts_untrusted_frames():
-    fake, _, area, reprompted = run_fake(20, 5, 8, range(1, 3), [False] * 5 + [True] * 15)
-    assert reprompted == []
-    assert fake.box_prompts == [5]
-    assert area[1:3].tolist() == [180, 180] and area[0] == 600
-
-
-def draw_person(frame, cx, cy, scale):
-    import cv2
-
-    mask = np.zeros(frame.shape[:2], np.uint8)
-    cv2.circle(mask, (cx, cy - int(70 * scale)), int(14 * scale), 255, -1)
-    cv2.ellipse(mask, (cx, cy - int(25 * scale)), (int(18 * scale), int(34 * scale)), 0, 0, 360, 255, -1)
-    for dx in (-10, 10):
-        cv2.line(mask, (cx + dx, cy), (cx + dx * 2, cy + int(60 * scale)), 255, int(10 * scale))
-        cv2.line(mask, (cx + dx * 2, cy - int(50 * scale)), (cx + dx * 4, cy - int(10 * scale)), 255, int(8 * scale))
-    frame[mask > 0] = (60, 90, 200)
-    return mask > 0
-
-
-def test_sam2_synthetic_clip_backward_and_forward(tmp_path):
-    cv2 = pytest.importorskip("cv2")
-    count, width, height = 20, 832, 480
-    rng = np.random.default_rng(3)
-    background = np.full((height, width, 3), (200, 205, 210), np.uint8)
-    background[height // 2:] = (170, 180, 185)
-    for x in range(0, width, 64):
-        cv2.line(background, (x, height // 2), (x - 200, height), (150, 150, 150), 2)
-    background = np.clip(background.astype(int) + rng.integers(-4, 5, background.shape), 0, 255).astype(np.uint8)
-    video = str(tmp_path / "clip.avi")
-    writer = cv2.VideoWriter(video, cv2.VideoWriter_fourcc(*"MJPG"), 24, (width, height))
-    truth, bbx = [], []
-    for t in range(count):
-        frame = background.copy()
-        cx, cy = 250 + 12 * t, 300
-        mask = draw_person(frame, cx, cy, 1.4)
-        truth.append(mask)
-        ys, xs = np.nonzero(mask)
-        size = 1.2 * max(np.ptp(xs), np.ptp(ys))
-        bbx.append([(xs.min() + xs.max()) / 2, (ys.min() + ys.max()) / 2, size])
-        writer.write(frame)
-    writer.release()
-    bbx = np.array(bbx, np.float32)
-    bbx[:5] = [441.5, 49.0, 249.4]  # garbage leading boxes, as GVHMR emits before its first detection
-    kp2d = np.zeros((count, 17, 3), np.float32)
-    kp2d[:, :, 2] = 0.9
-    kp2d[:5, :, 2] = 0.02
-    obs = str(tmp_path / "obs.npz")
-    np.savez(obs, bbx_xys=bbx, kp2d=kp2d)
-
-    arrays, summary = segment(video, obs, chunk_frames=8)
-    assert summary["anchor"] == 5
-    assert summary["chunks"] == [[1, 5, 12], [1, 12, 19], [-1, 0, 5]]
-    assert arrays["prob"].shape == (count, height // 2, width // 2) and arrays["prob"].dtype == np.float16
-    assert summary["peakReservedMiB"] <= 5632
-    ious = []
-    for t in range(count):
-        prob = cv2.resize(arrays["prob"][t].astype(np.float32), (width, height), interpolation=cv2.INTER_LINEAR)
-        pred = prob > 0.5
-        ious.append((pred & truth[t]).sum() / max(1, (pred | truth[t]).sum()))
-    assert min(ious) >= 0.8, [round(v, 3) for v in ious]
-    assert int(np.median(ious) * 100) >= 90, [round(v, 3) for v in ious]

package/tools/track/py/test_rig.py

@@ -1,288 +0,0 @@
-"""Parity tests for rig.py (plan mocap-rearch todo 6, tests (a)-(e) + malformed input).
-
-Data (resolved in this order; a missing file FAILS, never skips):
-  - parity fixture: <repo>/test/fixtures/track-fk-parity.json
-    (node tools/track/fk-parity-fixture.mjs)
-  - rig npz: $COZYFIT_RIG, <repo>/node_modules/.cache/cozyfit/rig-y-bot-tpose.npz
-    (node tools/track/export-rig.mjs --model y-bot-tpose)
-  - truth motion: $COZYFIT_WALK, <repo>/../../evidence/prep/gt-motions/walk.npz
-On the box (tools/track/run-box-tests.mjs uploads only tools/track/py/*.py) the three
-files are read from ~/cclay-ingest/cozyfit/testdata/ - stage them with
-  scp test/fixtures/track-fk-parity.json node_modules/.cache/cozyfit/rig-y-bot-tpose.npz \
-      <evidence>/prep/gt-motions/walk.npz ubuntu-baremetal:cclay-ingest/cozyfit/testdata/
-
-Measured errors are printed as one `[rig-parity] {json}` line when pytest exits, so a
-passing log carries the numbers, not just dots.
-"""
-import atexit
-import json
-import os
-from pathlib import Path
-
-import numpy as np
-import pytest
-import torch
-
-import rig as rigmod
-from rig import RigError, State
-
-HERE = Path(__file__).resolve().parent
-# <repo>/tools/track/py locally; a flat /tmp/cozyfit-* upload dir on the box (no repo around it)
-REPO = HERE.parents[2] if len(HERE.parents) > 2 else HERE
-EVIDENCE = REPO.parents[1] / "evidence" if len(REPO.parents) > 1 else REPO / "evidence"
-BOX_DATA = Path.home() / "cclay-ingest" / "cozyfit" / "testdata"
-PARITY: dict = {}
-
-
-@atexit.register
-def _report():
-    if PARITY:
-        print("[rig-parity] " + json.dumps(PARITY, sort_keys=True))
-
-
-def _find(label, env, *candidates):
-    paths = ([Path(os.environ[env])] if env and os.environ.get(env) else []) + [Path(c) for c in candidates]
-    for p in paths:
-        if p.is_file():
-            return p
-    pytest.fail(f"missing {label}; looked in {[str(p) for p in paths]} (see test_rig.py docstring for staging)")
-
-
-@pytest.fixture(scope="module")
-def fixture():
-    path = _find("fk parity fixture", None, REPO / "test/fixtures/track-fk-parity.json", BOX_DATA / "track-fk-parity.json")
-    return json.loads(path.read_text())
-
-
-@pytest.fixture(scope="module")
-def rig_path():
-    return _find("rig npz", "COZYFIT_RIG", REPO / "node_modules/.cache/cozyfit/rig-y-bot-tpose.npz", BOX_DATA / "rig-y-bot-tpose.npz")
-
-
-@pytest.fixture(scope="module")
-def rig(rig_path, fixture):
-    torch.manual_seed(0)
-    r = rigmod.load_rig(rig_path)
-    source = (r.meta.get("source") or {}).get("sha256")
-    assert source == fixture["fbxSha256"], "rig npz and parity fixture come from different FBX files; regenerate one"
-    assert r.bone_names == fixture["bones"], "rig npz bone order differs from the fixture"
-    return r
-
-
-def _err(a, b):
-    return float(torch.linalg.norm(torch.as_tensor(a, dtype=torch.float64) - torch.as_tensor(b, dtype=torch.float64), dim=-1).max())
-
-
-# (a) ---------------------------------------------------------------------------------
-
-def test_a_identity_reproduces_neutral(rig, fixture):
-    canonical = torch.tensor(fixture["canonicalPosedJoints"])  # JS canonicalCskel27Reference().posed_joints
-    state = State.identity(1, root=(0.0, -rig.min_y, 0.0))
-    joints, globals_ = rigmod.cskel27_fk(state, None, rig)
-    err = _err(joints[0], canonical)
-    ones, _ = rigmod.cskel27_fk(state, np.ones(27, dtype=np.float32), rig)
-    PARITY["a_identity_max_m"] = err
-    assert err < 1e-5, f"identity pose vs neutral posedJoints: {err:.3e} m"
-    assert _err(ones, joints) < 1e-7
-    assert torch.allclose(globals_, torch.eye(3).expand_as(globals_))
-
-
-# (b) ---------------------------------------------------------------------------------
-
-def test_b_layer1_matches_truth_posed_joints(rig):
-    path = _find("truth motion walk.npz", "COZYFIT_WALK", EVIDENCE / "prep/gt-motions/walk.npz", BOX_DATA / "walk.npz")
-    with np.load(path) as z:
-        rot, root, posed = z["local_rot_mats"], z["root_positions"], z["posed_joints"]
-        bone_scale = z["bone_scale"] if "bone_scale" in z else None
-    state = State.from_motion(rot, root)
-    joints, _ = rigmod.cskel27_fk(state, bone_scale, rig)
-    per_frame = torch.linalg.norm(joints.double() - torch.as_tensor(posed, dtype=torch.float64), dim=-1).amax(dim=1)
-    PARITY["b_walk_frames"] = int(len(per_frame))
-    PARITY["b_walk_max_m"] = float(per_frame.max())
-    PARITY["b_walk_bone_scale"] = "npz" if bone_scale is not None else "none (canonical)"
-    assert len(per_frame) == len(posed) > 100
-    assert float(per_frame.max()) < 1e-4, f"worst frame {int(per_frame.argmax())}: {float(per_frame.max()):.3e} m"
-
-
-def test_b_layer1_matches_js_fk_with_bone_scale(rig, fixture):
-    worst = 0.0
-    for case in fixture["cases"]:
-        rot = np.asarray(case["rotMats"], dtype=np.float32).reshape(-1, 27, 3, 3)
-        root = np.asarray(case["rootPos"], dtype=np.float32).reshape(-1, 3)
-        posed = np.asarray(case["posedJoints"], dtype=np.float32).reshape(-1, 27, 3)
-        joints, _ = rigmod.cskel27_fk(State.from_motion(rot, root), case["boneScale"], rig)
-        worst = max(worst, _err(joints, posed))
-    PARITY["b_js_fk_max_m"] = worst
-    assert worst < 1e-4
-
-
-# (c) ---------------------------------------------------------------------------------
-
-def test_c_rot6d_round_trip():
-    g = torch.Generator().manual_seed(6)
-    q = torch.randn(4096, 4, generator=g)
-    R = rigmod.quat_to_matrix(q)
-    back = rigmod.rot6d_to_matrix(rigmod.matrix_to_rot6d(R))
-    err = float((back - R).abs().max())
-    # arbitrary (non-orthonormal) 6D vectors land on SO(3) and are a fixed point after one pass.
-    # The property is checked in float64; float32 Gram-Schmidt on near-parallel random column
-    # pairs loses ~1e-5 to cancellation (measured 1.02e-5 on the box), so its bound is looser.
-    a = torch.randn(4096, 6, generator=g, dtype=torch.float64)
-    Ra = rigmod.rot6d_to_matrix(a)
-    ortho = float((Ra.transpose(-1, -2) @ Ra - torch.eye(3, dtype=torch.float64)).abs().max())
-    det = float((torch.linalg.det(Ra) - 1).abs().max())
-    fixed = float((rigmod.rot6d_to_matrix(rigmod.matrix_to_rot6d(Ra)) - Ra).abs().max())
-    Ra32 = rigmod.rot6d_to_matrix(a.float())
-    ortho32 = float((Ra32.transpose(-1, -2) @ Ra32 - torch.eye(3)).abs().max())
-    PARITY["c_rot6d_round_trip_max"] = err
-    PARITY["c_rot6d_orthonormal_f64_max"] = ortho
-    PARITY["c_rot6d_orthonormal_f32_max"] = ortho32
-    assert err < 1e-5, f"6D round trip {err:.3e}"
-    assert ortho < 1e-12 and det < 1e-12 and fixed < 1e-12, (ortho, det, fixed)
-    assert ortho32 < 1e-4, f"float32 orthonormality {ortho32:.3e}"
-    eye = rigmod.rot6d_to_matrix(torch.tensor([1.0, 0, 0, 0, 1, 0]))
-    assert torch.equal(eye, torch.eye(3))
-
-
-# (d) ---------------------------------------------------------------------------------
-
-def test_d_gradients_finite(rig, fixture):
-    case = fixture["cases"][0]
-    rot = np.asarray(case["rotMats"], dtype=np.float32).reshape(-1, 27, 3, 3)
-    root = np.asarray(case["rootPos"], dtype=np.float32).reshape(-1, 3)
-    state = State.from_motion(rot, root)
-    g = torch.Generator().manual_seed(7)
-    for name in ("transl", "root6d", "local6d"):
-        t = getattr(state, name)
-        setattr(state, name, (t + 0.01 * torch.randn(t.shape, generator=g)).requires_grad_(True))
-    joints, globals_ = rigmod.cskel27_fk(state, case["boneScale"], rig)
-    _, verts = rigmod.studio_skin(globals_, joints, rig, bone_scale=case["boneScale"])
-    loss = joints.square().sum() + verts.square().mean()
-    loss.backward()
-    norms = {name: float(getattr(state, name).grad.norm()) for name in ("transl", "root6d", "local6d")}
-    PARITY["d_grad_norms"] = norms
-    for name in norms:
-        grad = getattr(state, name).grad
-        assert torch.isfinite(grad).all(), name
-        assert norms[name] > 0, name
-    # every limb rotation reaches the skinned surface (no detached joint)
-    driven = [j for j in range(1, 27) if rig.prep_bone[j] >= 0]
-    assert (state.local6d.grad[:, [j - 1 for j in driven]].abs().sum(dim=(0, 2)) > 0).all()
-
-
-# (e) ---------------------------------------------------------------------------------
-
-def test_e_layer2_matches_studio_playback(rig, fixture):
-    idx = fixture["vertexIndices"]
-    bone_err, rot_err, vert_err = 0.0, 0.0, 0.0
-    for case in fixture["cases"]:
-        rot = torch.tensor(case["rotMats"]).reshape(-1, 27, 3, 3)
-        posed = torch.tensor(case["posedJoints"]).reshape(-1, 27, 3)
-        f, a = case["frame"], case["anchorFrame"]
-        globals_ = rigmod.global_rotations(rot[f:f + 1], rig.parents)
-        anchor = posed[a, 0, [0, 2]]
-        W, verts = rigmod.studio_skin(globals_, posed[f:f + 1], rig, bone_scale=case["boneScale"],
-                                      anchor_xz=anchor, vertex_indices=idx)
-        ref_W = torch.tensor(case["boneWorld"]).reshape(-1, 4, 4)
-        ref_v = torch.tensor(case["vertices"]).reshape(-1, 3)
-        bone_err = max(bone_err, _err(W[0, :, :3, 3], ref_W[:, :3, 3]))
-        # linear part carries the 0.01 rig root scale; compare the rotation itself
-        rot_err = max(rot_err, float((W[0, :, :3, :3] - ref_W[:, :3, :3]).abs().max()) / rig.root_scale)
-        vert_err = max(vert_err, _err(verts[0], ref_v))
-    PARITY.update(e_cases=len(fixture["cases"]), e_bones=len(fixture["bones"]), e_vertices=len(idx),
-                  e_bone_pos_max_m=bone_err, e_bone_mat_max=rot_err, e_vertex_max_m=vert_err)
-    assert bone_err < 1e-4, f"bone world position {bone_err:.3e} m"
-    assert rot_err < 1e-4, f"bone world rotation entries {rot_err:.3e}"
-    assert vert_err < 1e-4, f"skinned vertex {vert_err:.3e} m"
-
-
-def test_e_parity_detects_a_wrong_mode(rig, fixture):
-    """Guard against a vacuous parity: dropping boneScale must move the arms by > 1 mm."""
-    case = fixture["cases"][0]
-    rot = torch.tensor(case["rotMats"]).reshape(-1, 27, 3, 3)
-    posed = torch.tensor(case["posedJoints"]).reshape(-1, 27, 3)
-    globals_ = rigmod.global_rotations(rot[1:2], rig.parents)
-    _, verts = rigmod.studio_skin(globals_, posed[1:2], rig, bone_scale=None, anchor_xz=posed[0, 0, [0, 2]],
-                                  vertex_indices=fixture["vertexIndices"])
-    wrong = _err(verts[0], torch.tensor(case["vertices"]).reshape(-1, 3))
-    PARITY["e_wrong_mode_vertex_max_m"] = wrong
-    assert wrong > 1e-3
-
-
-# decimated tracker mesh ----------------------------------------------------------------
-
-def test_decimated_mesh(rig):
-    faces, verts = rig.dec_faces, rig.dec_vertices
-    w = rig.dec_skin_weight.double()
-    PARITY.update(dec_faces=int(faces.shape[0]), dec_vertices=int(verts.shape[0]),
-                  full_vertices=int(rig.vertices.shape[0]))
-    assert 1000 < faces.shape[0] <= rigmod.MAX_FACES
-    assert int(faces.max()) < verts.shape[0] and int(faces.min()) >= 0
-    assert (w >= 0).all() and float((w.sum(dim=1) - 1).abs().max()) < 1e-6
-    assert torch.allclose(rig.dec_weights.sum(dim=1), torch.ones(len(verts)), atol=1e-6)
-    # weights come from the nearest original vertex: that vertex is close by
-    gap = torch.linalg.norm(verts - rig.vertices[torch.as_tensor(rig.dec_source)], dim=-1)
-    PARITY["dec_source_gap_max_m"] = float(gap.max())
-    assert float(gap.max()) < 0.05
-    # rest pose: identity-ish skinning leaves the rest mesh where it is
-    B = len(rig.bone_names)
-    rest_worlds = torch.linalg.inv(rig.bind_inverse).unsqueeze(0)
-    moved = rigmod.lbs(rest_worlds, rig, verts, rig.dec_weights)
-    assert rest_worlds.shape == (1, B, 4, 4)
-    assert float((moved[0] - verts).abs().max()) < 1e-4
-
-
-# malformed input -------------------------------------------------------------------------
-
-def _rewrite(rig_path, tmp_path, **changes):
-    with np.load(rig_path) as z:
-        members = {k: z[k] for k in z.files}
-    for key, value in changes.items():
-        if value is None:
-            members.pop(key)
-        else:
-            members[key] = value
-    out = tmp_path / "rig.npz"
-    np.savez(out, **members)
-    return out
-
-
-def test_bad_skin_weights_rejected(rig_path, tmp_path):
-    with np.load(rig_path) as z:
-        w = z["skin_weight"].copy()
-    w[123] *= 0.9
-    with pytest.raises(RigError) as err:
-        rigmod.load_rig(_rewrite(rig_path, tmp_path, skin_weight=w))
-    assert err.value.code == "bad-skin-weights" and "vertex 123" in str(err.value)
-    w = np.load(rig_path)["skin_weight"].copy()
-    w[7, 0], w[7, 1] = -0.25, w[7, 1] + 0.25 + w[7, 0]
-    with pytest.raises(RigError) as err:
-        rigmod.load_rig(_rewrite(rig_path, tmp_path, skin_weight=w))
-    assert err.value.code == "bad-skin-weights"
-
-
-def test_missing_and_malformed_members_rejected(rig_path, tmp_path):
-    with pytest.raises(RigError) as err:
-        rigmod.load_rig(_rewrite(rig_path, tmp_path, prep_chain_rel=None))
-    assert err.value.code == "bad-rig" and "prep_chain_rel" in str(err.value)
-    with pytest.raises(RigError) as err:
-        rigmod.load_rig(_rewrite(rig_path, tmp_path, prep_offsets=np.zeros((26, 3), np.float32)))
-    assert err.value.code == "bad-rig" and "prep_offsets" in str(err.value)
-    with pytest.raises(RigError) as err:
-        rigmod.load_rig(tmp_path / "no-such-rig.npz")
-    assert err.value.code == "bad-rig"
-
-
-def test_bad_bone_scale_and_motion_rejected(rig):
-    state = State.identity(2)
-    with pytest.raises(RigError) as err:
-        rigmod.cskel27_fk(state, np.ones(26), rig)
-    assert err.value.code == "bad-bone-scale"
-    bad = np.ones(27)
-    bad[3] = 0
-    with pytest.raises(RigError) as err:
-        rigmod.cskel27_fk(state, bad, rig)
-    assert err.value.code == "bad-bone-scale"
-    with pytest.raises(RigError) as err:
-        State.from_motion(np.zeros((4, 26, 3, 3)), np.zeros((4, 3)))
-    assert err.value.code == "bad-motion"