| """Detectors for unusable frames, and the clean-span complement. |
| |
| Three failure modes are flagged per episode: |
| |
| ``intensity_spikes`` a GelSight reading far above anything contact produces — |
| usually the sensor being knocked or re-seated |
| ``pose_teleports_*`` OptiTrack solving to the wrong marker set, which moves |
| the sensor implausibly far *and* rotates it implausibly |
| fast in a single frame |
| ``ot_loss_*`` the tracker dropping out, which shows up as a run of |
| bit-identical poses rather than as missing samples |
| |
| Thresholds are the ones validated against the published motherboard |
| ``bad_frames.json`` (25/27 episodes bit-identical). |
| |
| Previously split across ``detect_bad_intervals.py`` and ``build_segments.py`` |
| in ``twm/scripts/``; the latter has since been archived, so this module is now |
| the only live copy of ``find_clean_segments``. |
| """ |
| from __future__ import annotations |
|
|
| import numpy as np |
|
|
| from .config import FPS |
|
|
| TAU_INTENSITY = 30.0 |
| TAU_VELOCITY_MPS = 5.0 |
| TAU_ANGULAR_RAD_PS = 15.0 |
| FREEZE_THRESHOLD_S = 0.25 |
| BUFFER_FRAMES = 3 |
| EPS_POSE_BIT = 1e-7 |
|
|
|
|
| def merge_intervals(events, gap: int = 1) -> list[list[int]]: |
| """Merge inclusive ``(a, b)`` intervals that touch or overlap.""" |
| if not events: |
| return [] |
| ordered = sorted((int(a), int(b)) for a, b in events) |
| merged = [list(ordered[0])] |
| for a, b in ordered[1:]: |
| if a <= merged[-1][1] + gap: |
| merged[-1][1] = max(merged[-1][1], b) |
| else: |
| merged.append([a, b]) |
| return merged |
|
|
|
|
| def pad_and_merge(events, T: int, buffer: int) -> list[list[int]]: |
| """Pad each interval by ``±buffer``, clip to ``[0, T-1]``, then merge.""" |
| if not events: |
| return [] |
| return merge_intervals([(max(0, a - buffer), min(T - 1, b + buffer)) |
| for a, b in events]) |
|
|
|
|
| def detect_intensity_spikes(intens_l: np.ndarray, intens_r: np.ndarray, |
| T: int) -> list[list[int]]: |
| """Frames where either sensor reads above ``TAU_INTENSITY``.""" |
| above = (intens_l > TAU_INTENSITY) | (intens_r > TAU_INTENSITY) |
| return pad_and_merge([(int(i), int(i)) for i in np.where(above)[0]], |
| T, BUFFER_FRAMES) |
|
|
|
|
| def detect_pose_teleports(pose: np.ndarray, T: int) -> list[list[int]]: |
| """Frames whose pose jump is implausible in translation *and* rotation. |
| |
| The conjunction matters: ordinary fast motion trips the translational |
| threshold on its own, so requiring both is what separates a tracking error |
| from a quick reach. |
| """ |
| if T < 2: |
| return [] |
| xyz, quat = pose[:, :3], pose[:, 3:] |
| qn = quat / np.maximum(np.linalg.norm(quat, axis=1, keepdims=True), 1e-12) |
| trans_vel = np.linalg.norm(np.diff(xyz, axis=0), axis=1) * FPS |
| dot = np.abs((qn[:-1] * qn[1:]).sum(axis=1)).clip(-1.0, 1.0) |
| ang_vel = 2.0 * np.arccos(dot) * FPS |
| flag = (trans_vel > TAU_VELOCITY_MPS) & (ang_vel > TAU_ANGULAR_RAD_PS) |
| return pad_and_merge([(int(i), int(i + 1)) for i in np.where(flag)[0]], |
| T, BUFFER_FRAMES) |
|
|
|
|
| def detect_pose_freezes(pose: np.ndarray, T: int) -> list[list[int]]: |
| """Runs of bit-identical pose lasting at least ``FREEZE_THRESHOLD_S``. |
| |
| OptiTrack repeats its last solution when it loses the marker set, so a |
| frozen pose is track loss rather than genuine stillness — a real hold still |
| jitters in the last decimal places. |
| |
| Reported unpadded, matching the published ``bad_frames.json``. |
| """ |
| if T < 2: |
| return [] |
| same = np.zeros(T, dtype=bool) |
| same[1:] = np.all(np.abs(np.diff(pose, axis=0)) < EPS_POSE_BIT, axis=1) |
| min_frames = int(round(FREEZE_THRESHOLD_S * FPS)) |
|
|
| events, i = [], 1 |
| while i < T: |
| if not same[i]: |
| i += 1 |
| continue |
| j = i |
| while j < T and same[j]: |
| j += 1 |
| |
| run_a, run_b = i - 1, j - 1 |
| if (run_b - run_a + 1) >= min_frames: |
| events.append((run_a, run_b)) |
| i = j |
| return pad_and_merge(events, T, 0) |
|
|
|
|
| def find_clean_segments(T: int, bad_intervals) -> list[tuple[int, int]]: |
| """Complement of the bad intervals: inclusive ``[a, b]`` clean spans.""" |
| segments, prev_end = [], -1 |
| for a, b in merge_intervals(bad_intervals): |
| if a > prev_end + 1: |
| segments.append((prev_end + 1, a - 1)) |
| prev_end = max(prev_end, b) |
| if prev_end < T - 1: |
| segments.append((prev_end + 1, T - 1)) |
| return segments |
|
|
|
|
| def thresholds() -> dict: |
| """The detector settings, for recording alongside the results.""" |
| return { |
| "tau_intensity": TAU_INTENSITY, |
| "tau_velocity_mps": TAU_VELOCITY_MPS, |
| "tau_angular_rad_per_s": TAU_ANGULAR_RAD_PS, |
| "freeze_threshold_s": FREEZE_THRESHOLD_S, |
| "buffer_frames": BUFFER_FRAMES, |
| } |
|
|
