File size: 8,017 Bytes
dffbc1f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | """F0 onset-timing analysis: event detection, onset finding, end to end on crafted signals."""
import csv
import json
import numpy as np
from conftest import REPO, SKELETON_JOINTS, write_csv
from pulse.data import modalities as M
from pulse.data.availability import build_availability
from pulse.paths import DataRoot
from pulse.tasks import f0
T = 1500
ONSETS = (400, 800, 1200)
def test_detect_onsets_hysteresis_and_gap():
p = np.zeros(1000)
p[100:300] = 20.0
p[303:400] = 20.0 # 3-frame dip: no release, same contact
p[600:603] = 20.0 # too short to persist
p[800:820] = 20.0
p[840:900] = 20.0 # released, but re-contact within min_gap: not a new onset
on = f0.detect_onsets(p, 5.0, 10, 50, 0.7, 5, 0.3)
assert on == [100, 800]
def test_signal_onset_finds_rise():
s = np.zeros(400)
s[250:] = 1.0 # rises 50 frames before ref=300
assert f0.signal_onset(s, 300, 200, 0.3, 0.3, 25) == -50
assert f0.signal_onset(np.zeros(400), 300, 200, 0.3, 0.3, 25) is None
def _craft(rng, shift_emg=60, shift_motion=80, gap_at=None):
pres = np.zeros((T, 50))
emg = rng.normal(0, 0.05, (T, 8))
pos = np.zeros((T, 3))
x = 100.0 # a real hand is never at the lab origin
moving = np.zeros(T, bool)
for on in ONSETS:
pres[on:on + 150, :25] = 2.0 # right hand only
emg[on - shift_emg:on + 100] += rng.normal(0, 1.0, (shift_emg + 100, 8))
moving[on - shift_motion:on] = True
for i in range(T):
x += 5.0 if moving[i] else 0.0
pos[i] = (x, 0.0, 0.0)
if gap_at is not None:
pos[gap_at] = 0.0 # untracked frame (Qualisys writes 0, 0, 0)
return pres, emg, pos
def _write_recording(d, rid, rng, **kw):
pres, emg, pos = _craft(rng, **kw)
write_csv(d / "aligned_pressure_100hz.csv", M.PRESSURE_COLS, pres.tolist())
write_csv(d / "aligned_emg_100hz.csv", M.EMG_COLS, emg.tolist())
cols = ["Frame", "Time"]
for j in SKELETON_JOINTS:
cols += [f"{j}_X", f"{j}_Y", f"{j}_Z", f"{j}_QX", f"{j}_QY", f"{j}_QZ", f"{j}_QW"]
tsv = d / "raw" / f"aligned_{rid}_s_Q.tsv"
for p in (d / f"aligned_{rid}_s_Q.tsv", tsv):
if p.exists():
p.unlink()
tsv.parent.mkdir(parents=True, exist_ok=True)
with open(tsv, "w", encoding="utf-8") as f:
f.write("\t".join(cols) + "\n")
for i in range(T):
row = [str(i), f"{i / 100:.2f}"]
for j in SKELETON_JOINTS:
xyz = pos[i] if j == "RightHand" else (500.0, 500.0, 500.0)
row += [f"{v:.3f}" for v in xyz] + ["0.1", "0.2", "0.3", "0.9"]
f.write("\t".join(row) + "\n")
# other streams must keep the same length
for name in ("aligned_imu_100hz.csv", "aligned_eyetrack_100hz.csv", "aligned_myo_quat_100hz.csv",
"aligned_mocap_100hz.csv"):
p = d / name
if p.exists():
p.unlink()
meta = json.loads((d / "alignment_metadata.json").read_text(encoding="utf-8"))
meta.update(n_samples=T, aligned_modalities=["emg", "pressure", "mocap_sq"])
(d / "alignment_metadata.json").write_text(json.dumps(meta), encoding="utf-8")
def test_f0_end_to_end(mini_root, tmp_path):
rng = np.random.default_rng(3)
for rid, gap in (("v6s1", None), ("v6s2", 700)): # v6s2: one untracked frame before contact 800
_write_recording(mini_root / "data" / "v6" / rid[2:], rid, rng, gap_at=gap)
rows = list(csv.DictReader(open(mini_root / "metadata" / "recordings.csv", encoding="utf-8")))
for r in rows:
if r["recording_id"] in ("v6s1", "v6s2"):
r.update(n_samples_100hz=T, aligned_modalities="pressure|emg")
with open(mini_root / "metadata" / "recordings.csv", "w", newline="", encoding="utf-8") as f:
w = csv.DictWriter(f, fieldnames=list(rows[0]))
w.writeheader()
w.writerows(rows)
av = tmp_path / "av.json"
av.write_text(json.dumps(build_availability(DataRoot.from_arg(mini_root))), encoding="utf-8")
out = tmp_path / "f0"
rc = f0.main(["--root", str(mini_root), "--availability", str(av), "--out", str(out),
"--workers", "1", "--set", "volunteers=[v6]", "--set", "n_bootstrap=200"])
assert rc == 0
r = json.loads((out / "f0_timing.json").read_text(encoding="utf-8"))
assert r["provenance"]["loaded_recordings"] == ["v6s1", "v6s2"]
assert r["counts"]["onsets"] == 6 and r["counts"]["used"] == 5 and r["counts"]["mocap_gap"] == 1
assert r["per_recording_counts"]["v6s2"]["mocap_gap"] == 1
st = r["stats"]
assert -800 <= st["emg_delay_ms"]["median"] <= -400 # burst starts 600 ms before contact
assert -900 <= st["motion_delay_ms"]["median"] <= -700 # motion starts 800 ms before
ev = st["paired_motion_minus_emg"]["event_level"]
assert ev["mean_diff_ms"] < 0 and ev["motion_first_fraction"] == 1.0
assert st["paired_motion_minus_emg"]["volunteer_level"]["n_volunteers"] == 1
z = np.load(out / "f0_traces.npz")
assert z["traces"].shape == (5, 3, 250) and z["time_ms"][0] == -2000
assert str(mini_root) not in (out / "f0_timing.json").read_text(encoding="utf-8")
# figures + numbers
import subprocess
import sys
res = subprocess.run([sys.executable, str(REPO / "figures" / "f0" / "plot_f0.py"), "--in", str(out),
"--out", str(tmp_path / "fig"), "--tables", str(tmp_path / "tables")],
capture_output=True, text=True)
assert res.returncode == 0, res.stderr
assert (tmp_path / "fig" / "f0_grasp_phase_timing.pdf").is_file()
assert (tmp_path / "fig" / "f0_delay_distributions.pdf").is_file()
nums = (tmp_path / "tables" / "numbers_f0.tex").read_text(encoding="utf-8")
assert r"\csname pulse@f0/events\endcsname{5}" in nums
def test_edge_filled_parsing():
w = {"warnings": ["mocap edge-filled to preserve original duration (front=4.092s, back=6.408s)",
"something else"]}
assert f0.edge_filled(w) == {"mocap": (4.092, 6.408)}
def test_place_on_alignment_timeline():
from pulse.errors import DataQualityError
span = {"start": 3, "n": 5, "n_total": 12, "offsets": {"emg": 2, "mocap": 0},
"lengths": {"emg": 9, "mocap": 12}}
emg = np.arange(9) # re-trimmed stream: timeline frames 2..10
mocap = np.arange(12) # full timeline
assert f0.place(emg, "emg", span, "v0s1").tolist() == [1, 2, 3, 4, 5] # timeline 3..7
assert f0.place(mocap, "mocap", span, "v0s1").tolist() == [3, 4, 5, 6, 7]
try:
f0.place(np.arange(8), "emg", span, "v0s1")
except DataQualityError:
pass
else:
raise AssertionError("a stream with an unexpected length must raise")
def test_volunteer_bootstrap_ci_matches_its_estimate():
rng = np.random.default_rng(0)
vols, emg, mot = [], [], []
for i, shift in enumerate((-120, -100, -90, -80, -60, -40, 10, 30)):
n = 5 + 10 * (i % 2) # unequal event counts: pooled median != median of medians
e = rng.normal(-600, 50, n)
vols += [f"v{i + 1}"] * n
emg += list(e)
mot += list(e + shift + rng.normal(0, 5, n))
st = f0.paired_stats(np.array(emg), np.array(mot), vols, 500, 0)["volunteer_level"]
lo, hi = st["bootstrap_median_of_volunteer_medians_ci95_ms"]
assert lo <= st["median_of_volunteer_median_diffs_ms"] <= hi
lo, hi = st["cluster_bootstrap_pooled_median_diff_ci95_ms"]
assert lo <= st["pooled_median_diff_ms"] <= hi
def test_fill_gaps_interpolates_untracked_frames():
pos = np.array([[1.0, 2.0, 3.0], [0.0, 0.0, 0.0], [np.nan, np.nan, np.nan], [4.0, 5.0, 6.0]])
gap = ~np.isfinite(pos).all(axis=1) | (pos == 0).all(axis=1)
assert gap.tolist() == [False, True, True, False]
out = f0.fill_gaps(pos, gap)
assert np.allclose(out[1], [2.0, 3.0, 4.0]) and np.allclose(out[2], [3.0, 4.0, 5.0])
|