| |
| """Render the three RGB views, exact uint16 depth, and both tactile surfaces.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| from pathlib import Path |
|
|
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| import numpy as np |
|
|
|
|
| RGB_KEYS = ( |
| ("observation.images.cam_front", "Front RGB"), |
| ("observation.images.cam_side", "Side RGB"), |
| ("observation.images.cam_fisheye", "Fisheye RGB"), |
| ) |
|
|
|
|
| def lerobot_dataset_class(): |
| try: |
| from lerobot.datasets.lerobot_dataset import LeRobotDataset |
| except ModuleNotFoundError: |
| from lerobot.common.datasets.lerobot_dataset import LeRobotDataset |
| return LeRobotDataset |
|
|
|
|
| def to_numpy(value: object) -> np.ndarray: |
| if hasattr(value, "detach"): |
| value = value.detach().cpu().numpy() |
| return np.asarray(value) |
|
|
|
|
| def rgb_hwc(value: object) -> np.ndarray: |
| image = to_numpy(value) |
| if image.ndim != 3: |
| raise ValueError(f"expected RGB rank 3, got {image.shape}") |
| if image.shape[0] in (1, 3, 4) and image.shape[-1] not in (1, 3, 4): |
| image = np.moveaxis(image, 0, -1) |
| if image.shape[-1] == 4: |
| image = image[..., :3] |
| if np.issubdtype(image.dtype, np.integer): |
| image = image.astype(np.float32) / 255.0 |
| return np.clip(image, 0.0, 1.0) |
|
|
|
|
| def exact_depth_uint16(value: object) -> np.ndarray: |
| depth = np.ascontiguousarray(np.squeeze(to_numpy(value))) |
| if depth.ndim != 2: |
| raise ValueError(f"expected depth HW/HW1/1HW, got {depth.shape}") |
| if depth.dtype == np.int16: |
| return depth.view(np.uint16) |
| if depth.dtype == np.uint16: |
| return depth |
| if np.issubdtype(depth.dtype, np.floating) and float(np.nanmax(depth)) <= 1.0: |
| raise TypeError( |
| "depth was normalized to [0,1]; exact millimetres are unavailable from " |
| "this loader version. Read the PNG bytes from data/*.parquet instead." |
| ) |
| return depth.astype(np.uint16, copy=False) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--repo-id", default="Tachintech/TacRich-Manip") |
| parser.add_argument("--revision", default="main") |
| parser.add_argument("--root", type=Path, help="Optional existing local dataset root") |
| parser.add_argument("--episode-index", type=int, default=0) |
| parser.add_argument("--frame-index", type=int, |
| help="Episode-local frame; default is the midpoint") |
| parser.add_argument("--video-backend", default="pyav") |
| parser.add_argument("--depth-max-mm", type=float, default=2000.0) |
| parser.add_argument("--tactile-vmax", type=float, |
| help="Shared tactile upper limit; default uses current-frame max") |
| parser.add_argument("--output", type=Path, default=Path("episode_preview.png")) |
| return parser.parse_args() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| dataset = lerobot_dataset_class()( |
| repo_id=args.repo_id, |
| root=args.root, |
| revision=args.revision, |
| episodes=[args.episode_index], |
| video_backend=args.video_backend, |
| ) |
| frame_index = len(dataset) // 2 if args.frame_index is None else args.frame_index |
| if not 0 <= frame_index < len(dataset): |
| raise IndexError(f"frame {frame_index} outside [0, {len(dataset) - 1}]") |
| if args.depth_max_mm <= 0: |
| raise ValueError("--depth-max-mm must be positive") |
| sample = dataset[frame_index] |
|
|
| depth = exact_depth_uint16(sample["observation.depth.cam_front"]) |
| tactile = to_numpy(sample["observation.tactile"]).astype(np.float32) |
| if tactile.shape[0] != 2: |
| raise ValueError(f"expected tactile [2,H,W], got {tactile.shape}") |
| tactile_vmax = args.tactile_vmax |
| if tactile_vmax is None: |
| tactile_vmax = max(float(np.nanmax(tactile)), 1.0e-6) |
|
|
| figure, axes = plt.subplots(2, 3, figsize=(16, 9), constrained_layout=True) |
| for axis, (key, title) in zip(axes[0], RGB_KEYS, strict=True): |
| axis.imshow(rgb_hwc(sample[key]), interpolation="nearest") |
| axis.set_title(title) |
| axis.axis("off") |
|
|
| depth_artist = axes[1, 0].imshow( |
| depth, cmap="cividis", vmin=0.0, vmax=args.depth_max_mm, |
| interpolation="nearest" |
| ) |
| axes[1, 0].set_title("Front depth (lossless uint16)") |
| axes[1, 0].axis("off") |
| figure.colorbar(depth_artist, ax=axes[1, 0], label="millimetres", fraction=0.046) |
|
|
| tactile_artists = [] |
| for axis, values, title in zip( |
| axes[1, 1:], tactile, ("Left tactile", "Right tactile"), strict=True |
| ): |
| tactile_artists.append(axis.imshow( |
| values, cmap="magma", vmin=0.0, vmax=tactile_vmax, |
| interpolation="nearest", aspect="auto" |
| )) |
| axis.set_title(title) |
| axis.set_xlabel("sensor column") |
| axis.set_ylabel("sensor row") |
| figure.colorbar( |
| tactile_artists[-1], ax=list(axes[1, 1:]), label="calibrated response", |
| fraction=0.023 |
| ) |
|
|
| state_tip = to_numpy(sample["observation.state_gripper"]) |
| action_tip = to_numpy(sample["action_gripper"]) |
| relative_time = float(to_numpy(sample["timestamp"]).reshape(-1)[0]) |
| figure.suptitle( |
| f"multiple tasks | episode {args.episode_index} | frame {frame_index} | " |
| f"t={relative_time:.3f}s\n" |
| f"tip xyz={np.array2string(state_tip[:3], precision=4)} m | " |
| f"target xyz={np.array2string(action_tip[:3], precision=4)} m" |
| ) |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| figure.savefig(args.output, dpi=140, facecolor="white") |
| plt.close(figure) |
| print(args.output.resolve()) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
