cozyclay 1.9.0 → 2.0.0

package/tools/track/py/test_masks.py

@@ -0,0 +1,229 @@
+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

@@ -0,0 +1,288 @@
+"""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"