File size: 3,333 Bytes
e37c13d | 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 | """Contact metrics and reference-frame selection.
These reproduce the values shipped in the dataset parquet, and match
``react_toolbox.contact`` so producer and consumer agree by construction.
"""
from __future__ import annotations
import numpy as np
from .config import TAU
def l2_diff(frames: np.ndarray, reference: np.ndarray) -> np.ndarray:
"""Per-pixel L2 distance from a reference frame.
frames: (..., H, W, 3) uint8/float, reference: (H, W, 3). -> (..., H, W)
"""
d = frames.astype(np.float32) - reference.astype(np.float32)
return np.sqrt((d ** 2).sum(axis=-1))
def contact_metrics(frames: np.ndarray, reference: np.ndarray, tau: float = TAU):
"""(intensity, area, mixed) for a block of frames.
intensity = mean L2 distance, area = fraction above `tau`,
mixed = mean of the thresholded distance.
"""
d = l2_diff(frames, reference)
above = d > tau
axes = (-2, -1)
return (d.mean(axis=axes).astype(np.float32),
above.mean(axis=axes).astype(np.float32),
(d * above).mean(axis=axes).astype(np.float32))
def smooth(x: np.ndarray, win: int) -> np.ndarray:
w = max(1, min(win, len(x)))
return np.convolve(x, np.ones(w) / w, mode="same")
def pick_p01_reference(intensity: np.ndarray, win: int) -> int:
"""Index of the quietest (least-contact) frame — the no-contact reference.
Smoothing first avoids latching onto a single noisy frame.
"""
return int(smooth(intensity, win).argmin())
class NewFrameTracker:
"""Flags which frames are genuinely new tactile captures.
A GelSight frame repeated across consecutive rows means the sensor did not
update between those camera ticks — true of ~72 % of rows in legacy
recordings (tactile really ran at ~8 fps while rows were written at 30 Hz),
and of ~40 % in fixed recordings (18.75 fps sensor, 30 Hz rows).
Detection is an exact frame comparison, so it is correct for both the
legacy (duplicate pixels) and timestamped (repeated index) layouts.
"""
def __init__(self):
self._prev = None
def update(self, block: np.ndarray) -> np.ndarray:
"""block: (n, H, W, 3) uint8 -> (n,) bool, True where the frame changed."""
n = len(block)
out = np.empty(n, dtype=bool)
for i in range(n):
prev = block[i - 1] if i > 0 else self._prev
out[i] = True if prev is None else not np.array_equal(block[i], prev)
self._prev = block[-1].copy() if n else self._prev
return out
def duplication_stats(is_new: np.ndarray, fps: float = 30.0) -> dict:
"""Summarise how much of a tactile stream is duplicated."""
n = len(is_new)
if n == 0:
return {"n_frames": 0, "n_unique": 0, "duplicate_ratio": 0.0,
"effective_fps": 0.0, "max_repeat_run": 0}
n_unique = int(is_new.sum())
runs, cur = [], 0
for flag in is_new:
if flag:
if cur:
runs.append(cur)
cur = 1
else:
cur += 1
if cur:
runs.append(cur)
return {
"n_frames": n,
"n_unique": n_unique,
"duplicate_ratio": float(1.0 - n_unique / n),
"effective_fps": float(n_unique / (n / fps)) if n else 0.0,
"max_repeat_run": int(max(runs)) if runs else 0,
}
|