| """Standalone reader for Diffraction human egocentric RGB-D samples. | |
| Dependencies: numpy, polars, opencv-python. No pipeline or robot software needed. | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import zipfile | |
| from pathlib import Path | |
| import cv2 | |
| import numpy as np | |
| import polars as pl | |
| class ObservationDataset: | |
| def __init__(self, root): | |
| self.root = Path(root) | |
| self.info = json.loads((self.root / "dataset.json").read_text(encoding="utf-8")) | |
| self.episodes = {e["capture_id"]: e for e in self.info["episodes"]} | |
| def table(self, capture_id, name): | |
| e = self.episodes[capture_id] | |
| return pl.read_parquet(self.root / e["signals"][name]) | |
| def frame(self, capture_id, frame_index): | |
| """Return aligned native RGB, metric depth, confidence, K and camera pose. | |
| ARKit pose is device VIO; no ground-truth or robot-action claim is implied. | |
| Depth zero is invalid. Confidence filtering is explicit and reproducible. | |
| """ | |
| e = self.episodes[capture_id] | |
| if not isinstance(frame_index, int) or not 0 <= frame_index < e["frame_count"]: | |
| raise IndexError(frame_index) | |
| mapping = self.table(capture_id, "frame_mapping").filter(pl.col("rgb_frame_index") == frame_index).row(0, named=True) | |
| source_frame_index = mapping["source_frame_index"] | |
| intr = self.table(capture_id, "camera_intrinsics").filter(pl.col("source_frame_index") == source_frame_index).row(0, named=True) | |
| pose = self.table(capture_id, "arkit_poses").filter(pl.col("t_s") == mapping["t_s"]).row(0, named=True) | |
| cap = cv2.VideoCapture(str(self.root / e["video"])) | |
| try: | |
| cap.set(cv2.CAP_PROP_POS_FRAMES, frame_index) | |
| ok, bgr = cap.read() | |
| finally: | |
| cap.release() | |
| if not ok: raise RuntimeError(f"RGB decode failed at frame {frame_index}") | |
| stem = f"{source_frame_index:06d}.png" | |
| with zipfile.ZipFile(self.root / e["sensors"]) as z: | |
| depth_raw = cv2.imdecode(np.frombuffer(z.read("depth/" + stem), np.uint8), cv2.IMREAD_UNCHANGED) | |
| conf = cv2.imdecode(np.frombuffer(z.read("confidence/" + stem), np.uint8), cv2.IMREAD_UNCHANGED) | |
| if depth_raw is None or conf is None or depth_raw.shape != conf.shape: | |
| raise ValueError("Invalid depth/confidence pair") | |
| depth = depth_raw.astype(np.float32) / 1000. | |
| valid = (depth > 0) & (conf >= self.info["min_depth_confidence"]) | |
| depth[~valid] = 0 | |
| K = np.array([[intr["fx"], 0, intr["cx"]], [0, intr["fy"], intr["cy"]], [0, 0, 1]], np.float64) | |
| return {"rgb": cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB), "depth_m": depth, | |
| "depth_valid": valid, "confidence": conf, "K_rgb": K, | |
| "camera_pose_xyzw": np.array([pose[k] for k in ("tx", "ty", "tz", "qx", "qy", "qz", "qw")]), | |
| "timestamp_s": mapping["t_s"], "sensor_timestamp_s": mapping["sensor_timestamp_s"], | |
| "instruction": e["instruction"], "source_frame_index": source_frame_index, "rgb_frame_index": frame_index} | |
| def annotations_near(self, capture_id, channel, timestamp_s, max_age_s=0.05): | |
| """Sparse annotations stay absent beyond the caller's explicit age gate.""" | |
| df = self.table(capture_id, channel) | |
| if df.is_empty(): return df | |
| distance = (pl.col("t_s") - timestamp_s).abs() | |
| nearby = df.filter(distance <= max_age_s) | |
| if nearby.is_empty(): return nearby | |
| nearest = nearby.select((pl.col("t_s") - timestamp_s).abs().arg_min()).item() | |
| return nearby.filter(pl.col("t_s") == nearby["t_s"][nearest]) | |
| def camera_points(frame): | |
| """Valid depth pixels backprojected in OpenCV camera axes (+x right,+y down,+z forward).""" | |
| depth, K = frame["depth_m"], frame["K_rgb"].copy() | |
| dh, dw = depth.shape; rh, rw = frame["rgb"].shape[:2] | |
| K[0, :] *= dw / rw; K[1, :] *= dh / rh | |
| yy, xx = np.indices(depth.shape) | |
| xyz = np.stack([(xx-K[0, 2])*depth/K[0, 0], (yy-K[1, 2])*depth/K[1, 1], depth], -1) | |
| return xyz[frame["depth_valid"]] | |
| if __name__ == "__main__": | |
| import argparse | |
| p = argparse.ArgumentParser(); p.add_argument("root", type=Path) | |
| args = p.parse_args(); ds = ObservationDataset(args.root) | |
| for key, episode in ds.episodes.items(): | |
| frame = ds.frame(key, episode["frame_count"] // 2) | |
| points = camera_points(frame) | |
| print(key, frame["rgb"].shape, frame["depth_m"].shape, len(points), "valid camera points") | |