Document ~15-frame tactile acquisition latency + loader compensation (tactile_latency=); tasks.json + README + loader

README.md

@@ -134,6 +134,27 @@ sample = ds[0]
 ```
 `mode="segment"` iterates clean spans (no bad frames by construction); `mode="window"` slides over whole episodes and skips `bad_frames.json` intervals. Backend: PyAV (install `decord` for faster random access).
 
+## ⚠️ Known issue: tactile acquisition latency (~15 frames)
+
+Recordings **up to and including 2026-06-18** have a GelSight-vs-camera capture
+lag of **≈15 frames (~0.5 s)**: the tactile stream at index `i` was physically
+captured ~15 frames *before* the camera/pose at the same index. Cause: a
+recording-side `cv2.VideoCapture` V4L2 buffer that was never flushed
+(throttled reads + no `BUFFERSIZE=1` + default pixel format). Fixed in the rig
+on 2026-06-27; **future recordings will not have this lag**.
+
+The streams are stored frame-aligned by tick index, so this lag is baked in but
+**correctable**. The reference loader compensates at load time:
+
+```python
+ds = ReactVideoDataset("data/motherboard", tactile_latency=15)  # pairs view[i] with tactile[i+15]
+```
+
+`tactile_latency` shifts both the tactile videos and the tactile contact-scalar
+columns; poses/views/depth are unchanged. Set `tactile_latency=0` for the raw
+(uncompensated) data. The exact per-session value should be re-measured with
+`camera_stream/measure_gelsight_latency.py`.
+
 ## Data quality
 Per-task `bad_frames.json` flags `intensity_spikes`, `pose_teleports_{L,R}`, `ot_loss_{L,R}` (OptiTrack track loss). Overall flagged: motherboard 0.90 %, pushT 0.67 %. `segments.json` already excludes them.
 

examples/react_video_dataset.py

@@ -80,7 +80,7 @@ def _decode_frames(mp4_path: Path, frame_indices, depth=False):
 class ReactVideoDataset:
     def __init__(self, task_root, window_length=16, stride=1, window_step=None,
                  mode="segment", streams=ALL_STREAMS, skip_bad=True,
-                 which_sensors="any", load_depth=False):
+                 which_sensors="any", load_depth=False, tactile_latency=0):
         self.root = Path(task_root)
         self.W = window_length
         self.stride = stride
@@ -91,6 +91,16 @@ class ReactVideoDataset:
         self.which = which_sensors
         # depth only if requested AND present on disk for this task
         self.load_depth = load_depth and (self.root / "depth").is_dir()
+        # GelSight acquisition lag (frames): tactile stream was captured
+        # `tactile_latency` frames BEFORE the view at the same index, due to a
+        # recording-side V4L2 buffer bug (fixed in the rig from 2026-06-27).
+        # When >0, the loader pairs view[i] with tactile[i+latency] (and the
+        # tactile contact scalars likewise), and trims `latency` frames from
+        # the end of each window range so the shifted index stays in bounds.
+        self.tactile_latency = int(tactile_latency)
+        self._TACT = ("tactile_left", "tactile_right")
+        self._TACT_COLS = ("tactile_left_intensity", "tactile_right_intensity",
+                           "tactile_left_mixed", "tactile_right_mixed")
 
         self.segments = json.loads((self.root / "segments.json").read_text())["segments"]
         self.bad = json.loads((self.root / "bad_frames.json").read_text())["episodes"]
@@ -116,22 +126,21 @@ class ReactVideoDataset:
     def _build_index(self):
         items = []
         span = (self.W - 1) * self.stride + 1
+        lat = self.tactile_latency        # tactile read at idx+lat must stay in bounds
         if self.mode == "segment":
             for s in self.segments:
                 ek, a, b = s["source_episode"], s["frame_range"][0], s["frame_range"][1]
                 start = a
-                while start + span - 1 <= b:
+                while start + span - 1 + lat <= b:
                     items.append((ek, start))
                     start += self.step
         else:  # window over whole episode
-            for s in self.segments:  # reuse episode list via segments' episodes
-                pass
             eps = sorted({s["source_episode"] for s in self.segments})
             for ek in eps:
                 T = self.bad.get(ek, {}).get("n_frames", 0)
                 bad = self._bad_mask(ek, T) if self.skip_bad else np.zeros(T, bool)
                 start = 0
-                while start + span - 1 < T:
+                while start + span - 1 + lat < T:
                     idx = range(start, start + span, self.stride)
                     if not (self.skip_bad and bad[list(idx)].any()):
                         items.append((ek, start))
@@ -143,28 +152,36 @@ class ReactVideoDataset:
 
     def __getitem__(self, i):
         ek, start = self.index[i]
+        lat = self.tactile_latency
         idx = list(range(start, start + (self.W - 1) * self.stride + 1, self.stride))
+        idx_tac = [r + lat for r in idx]        # tactile is `lat` frames behind view
         vd = self._video_dir(ek)
-        out = {s: _decode_frames(vd / f"{s}.mp4", idx) for s in self.streams}
-        if self.load_depth:
+        out = {}
+        for s in self.streams:
+            read_idx = idx_tac if s in self._TACT else idx   # shift only tactile
+            out[s] = _decode_frames(vd / f"{s}.mp4", read_idx)
+        if self.load_depth:                      # depth is a view-side cam, no shift
             date, ep = ek.split("/")
             dd = self.root / "depth" / date / ep
             for s in DEPTH_STREAMS:
                 p = dd / f"{s}.mkv"
                 if p.exists():
                     out[s] = _decode_frames(p, idx, depth=True)   # (T,H,W) uint16 mm
-        tbl = pq.read_table(self._parquet(ek)).slice(start, idx[-1] - start + 1)
-        # subsample by stride
-        rows = [r - start for r in idx]
+        # parquet: read a range covering both idx and idx_tac
+        lo, hi = start, idx_tac[-1]
+        tbl = pq.read_table(self._parquet(ek)).slice(lo, hi - lo + 1)
+        v_rows = [r - lo for r in idx]
+        t_rows = [r - lo for r in idx_tac]
         for c in ("sensor_left_pose", "sensor_right_pose"):
-            out[c] = np.array(tbl.column(c).to_pylist(), np.float32)[rows]
+            out[c] = np.array(tbl.column(c).to_pylist(), np.float32)[v_rows]
         if "object_pose" in tbl.column_names:
-            out["object_pose"] = np.array(tbl.column("object_pose").to_pylist(), np.float32)[rows]
-        for c in ("tactile_left_intensity", "tactile_right_intensity",
-                  "tactile_left_mixed", "tactile_right_mixed"):
-            out[c] = np.array(tbl.column(c).to_pylist(), np.float32)[rows]
+            out["object_pose"] = np.array(tbl.column("object_pose").to_pylist(), np.float32)[v_rows]
+        # tactile contact scalars follow the tactile frames -> shifted rows
+        for c in self._TACT_COLS:
+            out[c] = np.array(tbl.column(c).to_pylist(), np.float32)[t_rows]
         out["episode"] = ek
         out["frame_start"] = start
+        out["tactile_latency"] = lat
         return out
 
 

tasks.json

@@ -88,5 +88,15 @@
       "with_depth": "python examples/download.py",
       "middle_depth_only": "python examples/download.py --depth-cams middle"
     }
+  },
+  "tactile_latency": {
+    "frames_estimate": 15,
+    "fps": 30,
+    "seconds_estimate": 0.5,
+    "applies_to": "all recordings up to and including 2026-06-18",
+    "fixed_in_rig": "2026-06-27",
+    "cause": "recording-side cv2.VideoCapture V4L2 buffer never flushed (throttled reads + no BUFFERSIZE=1 + default pixfmt)",
+    "compensation": "ReactVideoDataset(tactile_latency=15) pairs view[i] with tactile[i+15]; shifts tactile videos + contact scalars only",
+    "note": "tactile[i] was captured ~15 frames BEFORE view[i] at the same index; streams stored frame-aligned by tick so lag is baked in but correctable."
   }
 }