--- license: cc-by-nc-4.0 language: - en pretty_name: "SurgSync — Multi-modal dVRK Dataset (v1.0)" size_categories: - 100K **Project page:** **https://surgsync.github.io/** > **Toolkit (reader / packer / unpacker, processing pipelines, full > docs, code examples):** **https://github.com/jackzhy96/dvrk_multimodal_data_collection** > **Upstream use:** a subset of SurgSync has been incorporated into > NVIDIA's **PhysicalAI-Robotics-Open-H-Embodiment** dataset collection > under > [`Surgical/jhu/lcsr/smarts`](https://huggingface.co/datasets/nvidia/PhysicalAI-Robotics-Open-H-Embodiment/tree/main/Surgical/jhu/lcsr/smarts). > If you accessed the data through that redistribution, the citation > is still the SurgSync ICRA 2026 paper — see [§ Citation](#citation). This dataset card is intentionally a **summary only**. For schema specifications, the loader API, packing / unpacking workflow, the preprocessing pipelines (rectify, depth, optical flow, kinematic heatmaps), and every command-line invocation, see the toolkit repository linked above. > 📺 **No HF dataset viewer.** SurgSync's structure (FFV1 video + > Hive-partitioned parquets + per-episode JSON + calibration files) > doesn't fit Hugging Face's tabular preview model, and FFV1 doesn't > render in most browsers. The viewer is disabled by design — for a > browseable preview of episodes, tasks, annotations, and example > clips, **visit the project page at > [surgsync.github.io](https://surgsync.github.io/)**. Programmatic > access to the data is unchanged: use the toolkit's loader API > (`dvrk_data_processing.surgsync.open_dataset(...)`) against either > a local clone or `huggingface_hub.snapshot_download`'d copy. --- ## Dataset summary **SurgSync** is a multi-modal recording of the **da Vinci Research Kit (dVRK) Patient Side Manipulator** performing six dry-lab and ex-vivo surgical tasks. Each episode bundles synchronized stereo + side video, per-arm kinematics (ECM, PSM1, PSM2), frame-level contact / phase / step / gesture annotation, and full camera + hand-eye calibration. The release is packed in the **SurgSync** archive format — bit-exact FFV1 video plus columnar Parquet — and is fully invertible back to its original raw layout via `surgsync unpack`. | | | |---|---| | **Episodes** | **205** | | **Total frames** | **168,132** | | **Total duration** | **≈ 6 h 37 m** of synchronized recordings (10 Hz master clock) | | **Tasks** | **6** task partitions (see below) | | **Recorder variants** | 109 online (real-time PSM Cartesian setpoints) + 96 offline (no Cartesian setpoint) | | **Operator skill** | 74 Expert · 94 Intermediate · 37 Novice | | **Case types** | 185 Ex-vivo · 20 Table-Top Phantom | | **Raw image resolution** | 1920 × 1080 (stereo + side) | | **Release size** | ≈ 670 GB on disk (3,912 SHA-256-tracked files) | | **Format** | SurgSync release option **B** (raw FFV1 + per-modality parquets + calibration) | | **schema / data version** | `1.0.0` / `1.0` | | **License** | CC-BY-NC-4.0 | > ⚠ **v1.0 ships raw modalities only — derived modalities are > user-generated.** Rectified H.264 video, FoundationStereo **depth**, > RAFT **optical flow**, kinematic-projection **heatmaps**, and > hand-eye-projected `measured_cp_calibrated` / `setpoint_cp_calibrated` > columns are **not bundled in this release**, but the toolkit ships > every preprocessing stage that produces them — run > `scripts/run_all_stages.py` against the unpacked raw clips and you > can generate the full option-C layout locally with whatever GPU / > pipeline version you prefer. The raw FFV1 + parquets that v1.0 ships > are the source of truth; the derived streams are deterministic > functions of (raw inputs × pipeline version). See > [§ This release vs. the dataset described on surgsync.github.io](#this-release-vs-the-dataset-described-on-surgsyncgithubio) > for what shipping derived modalities would add, and > [§ Limitations](#known-limitations--data-quality-notes) for the > per-modality details. --- ## Supported downstream tasks Beyond the workflow-recognition tasks the dataset was primarily collected for (phase / step / gesture / contact annotation), SurgSync's combination of synchronized stereo video, full PSM kinematics, and hand-eye-calibrated arm-to-camera transforms also enables several **instrument-centric vision tasks**. The table below lists the level of ground-truth supervision each task gets from the release as it stands, distinguishing what works directly off the v1.0 bytes vs. what additional convenience comes from running the toolkit's preprocessing pipeline yourself (see [§ Limitations 2](#2-derived--preprocessed-streams-are-not-bundled-in-v10-but-the-toolkit-generates-them) for the workflow). | Task | Ground-truth source | Out of the box (v1.0) | After local preprocessing | |---|---|:--:|:--:| | **Instrument 6-DoF pose estimation** | PSM `measured_cp` (per-arm Cartesian pose at the tool tip) combined with hand-eye calibration files (`PSM{1,2}-registration-{dVRK,open-cv}.json`) projects the tool tip into the stereo-left / stereo-right camera frame. Both PSMs annotated per-frame. | ✅ (compute it yourself by composing `PSM*.parquet:measured_cp.*` with the hand-eye JSON; see toolkit's hand-eye-mapping pipeline) | ✅ (`PSM*.parquet:measured_cp_calibrated.*` columns populated by `gen_kinematic_heatmap_handeye.py` — drop-in, no client-side composition) | | **Instrument tracking** | Same pipeline as 6-DoF pose — projected tool-tip pose gives a per-frame 2D image-plane location for each PSM in both stereo views. Frame-level contact annotation (`annotation.parquet:contact.PSM{1,2}`) marks when each tool is interacting with tissue, useful for filtering / evaluating contact-aware trackers. | ✅ (same client-side composition as above) | ✅ (`preprocess/heatmap_PSM{1,2}_{left,right}.mkv` Gaussian heatmaps centered on the projected tool tip — drop-in supervision for tracker training) | | **Instrument segmentation** | **No pixel-level masks ship in either form.** Running the toolkit's preprocessing locally adds the kinematic-projection heatmaps, which provide a localized prior (where the tool tip is) usable as a weak label for SAM-style mask propagation or as a self-supervised cue. Users who need pixel-precise masks should run an off-the-shelf model (SAM2, FoundationModelStereo segmentation heads) or hand-annotate a subset. | ⚠ Possible only via external models / hand annotation | ⚠ Heatmaps available as weak supervision; pixel-precise masks still external | | **Surgical phase / step / gesture recognition** | Per-frame verbalized labels in `annotation.parquet` (`phase`, `step`, `gesture.PSM{1,2}`) on every episode. | ✅ | — (no change; already in v1.0) | | **Action recognition / imitation learning** | Per-frame PSM joint and Cartesian state + setpoints (`PSM{1,2}.parquet:measured_js`, `setpoint_js`, `setpoint_cp` on online episodes) paired with stereo + side video gives a state ↔ action ↔ observation tuple at the 10 Hz master clock. | ✅ (online_data partition for setpoint_cp; both partitions for measured states + setpoint_js) | — (no change; already in v1.0) | | **Stereo depth estimation** | Bit-exact stereo pairs (`video_raw/stereo_{left,right}.mkv`) + stereo calibration (`calibration/stereo_calib_params.json`). | ✅ for *running* a stereo model on the pairs | ✅ Pre-computed FoundationStereo `preprocess/depth.mkv` ground-truth-like reference becomes available | | **Optical flow** | Bit-exact monocular streams in `video_raw/`. | ✅ for *running* a flow model | ✅ Pre-computed RAFT `preprocess/flow_{left,right}.mkv` shipped | | **Contact / interaction detection** | Frame-level binary `annotation.parquet:contact.PSM{1,2}` on every episode (205/205 coverage). | ✅ | — (no change) | ### Notes specific to the instrument-vision tasks - **Cameras and arms.** PSM1 and PSM2 are the two operative arms. ECM is the endoscope arm — its kinematics give the camera's pose in world frame, which is used by the hand-eye solver but isn't a per-frame target itself. The stereo-left camera is the **master clock reference**; stereo-right and side share the same master timeline via per-modality `delta_to_master._ns` offsets on `timestamp.parquet`. - **Hand-eye calibration accuracy.** Two registration formats ship per arm: `-registration-dVRK.json` (from the dVRK's own calibration routine) and `-registration-open-cv.json` (from an OpenCV-based solver). They are not byte-equivalent — pick the one matching your downstream toolkit. See the hand-eye-mapping module in the toolkit repo for the recommended composition order. - **Per-task vision-task coverage.** Suturing (92 episodes, 90,068 frames) and dissection (70 combined episodes, 64,890 frames) dominate the release — pose / tracking models will see the most varied tissue interactions there. `peg_transfer` (18 episodes, table-top phantom) is closer to a controlled benchmark. - **Two operative arms is the norm, not the exception.** Every episode in v1.0 carries both PSM1 and PSM2; bimanual handoffs are routinely present in `peg_transfer` and `tissue_manipulation`. Single-arm subsets are not provided — filter by PSM activity yourself if needed. --- ## This release vs. the dataset described on surgsync.github.io The figures on the project page describe the **target / proposed** dataset. This v1.0 release is a **subset**: nine episodes short and without the derived modalities. The breakdown: ### Episode count: 205 (this release) vs. 214 (proposed on surgsync.github.io) | Task group (project-page labels) | Proposed on surgsync.github.io | In this v1.0 release | Δ | How this release maps to the proposed groups | |---|---:|---:|---:|---| | Suturing & Knot Tying | 104 | 92 | **−12** | `single_interrupted_stitch` | | Peg Transfer | 18 | 18 | 0 | `peg_transfer` | | Tissue Manipulation | 21 | 25 | **+4** | `tissue_manipulation` (this release carries 4 extra clips beyond the project-page count) | | Dissection | 71 | 70 | **−1** | `cold_cut_dissection` (61) + `cold_cut_dissection_intestine` (8) + `cold_cut_dissection_skin_peel` (1) | | **Total** | **214** | **205** | **−9** | | ### Recorder-variant split | | Proposed | This release | Δ | |---|---:|---:|---:| | Online-matching | 112 | 109 | **−3** | | Offline-matching | 102 | 96 | **−6** | | **Total** | **214** | **205** | **−9** | ### Operator-skill split The project page reports Novice / Experienced / Professional; this release uses Novice / Intermediate / Expert (same three buckets, different labels): | | Proposed | This release | Δ | |---|---:|---:|---:| | Novice / Novice | 37 | 37 | 0 | | Experienced / Intermediate | 95 | 94 | **−1** | | Professional / Expert | 82 | 74 | **−8** | ### Derived modalities planned by surgsync.github.io — **not bundled in v1.0, but reproducible locally** | Modality | Project page | v1.0 ships? | How to obtain | |---|:--:|:--:|---| | Stereo rectification (rectified H.264 video) | planned | ❌ | toolkit: `gen_rectify_resize.py` | | Depth estimation (FoundationStereo) | planned | ❌ | toolkit: `gen_depth_estimate.py` (GPU + FoundationStereo weights) | | Optical flow (RAFT) | planned | ❌ | toolkit: `gen_optical_flow_raft.py` (GPU) | | Kinematic reprojection via Gaussian heatmap | planned | ❌ | toolkit: `gen_kinematic_heatmap_handeye.py` | | Hand-eye-projected kinematics (`*_calibrated.*`) | planned | ❌ (columns exist in schema, NULL on every row) | side-effect of the kinematic-heatmap stage above | The source raw clips for v1.0 were not run through the preprocessing pipeline upstream of packing, so the packer had nothing to encode for those streams. Every episode's `episode_meta.json` reflects this: `has_video_raw=true`, `has_preprocess=false`, `has_preview=false`, `has_calibrated_kinematic=false`. **Users can generate these streams themselves.** The toolkit ships every preprocessing stage as a Hydra-configured script under `src/dvrk_data_processing/`. The end-to-end runner `scripts/run_all_stages.py` chains rectify → kinematic heatmap → depth → optical flow and emits a v1.1-equivalent `preprocess/` tree next to the unpacked raw clips. Re-packing the augmented clips with `surgsync build` then produces the option-C layout shown in [§ Hypothetical layout *with* derived modalities](#hypothetical-layout-with-derived-modalities-v11-target). Compute cost is GPU-bound (FoundationStereo dominates); end-to-end processing of the full release takes ~1 day on a single high-end consumer GPU. ### Other diffs worth flagging - **Capture rate is by design, not a downsample artifact.** The project page describes the native capture at **stereo 1080p @ 60 Hz** and **side 1080p @ 30 Hz**. The packed release's per-frame master clock is **10 Hz** — chosen as a deliberate **trade-off between cross-modal time alignment and per-frame frequency**. At the native rates, individual topics drift several ms apart between samples (PSM kinematics at ~100 Hz, ECM at ~100 Hz, stereo-left header stamps at 60 Hz, side at 30 Hz), and a strict nearest-neighbor join would either reject many frames or accept high per-modality deltas. At 10 Hz the worst-case master ↔ topic delta sits well inside the alignment tolerance bands, so every shipped frame has every modality populated within spec. If you need higher temporal resolution for a downstream task, the native-rate samples are still recoverable through `surgsync unpack` (which re-emits the raw per-modality files at their original capture times). Native source frequencies are preserved per-modality on `PSM*.parquet:source_frequency_hz` and via the `delta_to_master._ns` offsets on `timestamp.parquet`. - **Subject demographics.** The project page references 13 human subjects (3 female / 10 male) as operators. This release does **not** ship per-episode operator identity — only the three-bucket skill level — in line with anonymization for the public archive. --- ## Tasks | Task partition (this release) | Episodes | Frames | |---|---:|---:| | `single_interrupted_stitch` | 92 | 90,068 | | `cold_cut_dissection` | 61 | 55,595 | | `tissue_manipulation` | 25 | 5,907 | | `peg_transfer` | 18 | 7,267 | | `cold_cut_dissection_intestine` | 8 | 7,176 | | `cold_cut_dissection_skin_peel` | 1 | 2,119 | | **Total** | **205** | **168,132** | Per-task vocabulary (phase / step / gesture id → English phrase) ships in `meta/tasks.jsonl`. The packer **verbalizes** ids at pack time, so the per-frame annotation parquet columns carry full text — see [§ Limitations 1](#1-tasksjsonl-vocab-is-best-effort-not-a-closed-enumeration) for caveats around strict id→text joins. --- ## Modalities (what's in v1.0) - **Video** — `video_raw/{stereo_left, stereo_right, side}.mkv` (FFV1, bit-exact, 1920 × 1080). Every episode has stereo; side is present when a side camera was recorded. - **Kinematics** — `ECM.parquet`, `PSM1.parquet`, `PSM2.parquet` with measured / setpoint joint state, measured Cartesian pose / velocity, and (PSM1/2 only, online episodes only) `setpoint_cp.*`. Jaw position is carried for the PSMs. Units: m, rad, xyzw quaternions. - **Annotations** — `annotation.parquet` with `contact.PSM{1,2}` (int8 0/1), `gesture.PSM{1,2}` (verbalized text), `phase` (verbalized text), `step` (verbalized text). - **Calibration** — raw `left.yaml` / `right.yaml`, stereo extrinsics, hand-eye `-registration-{dVRK,open-cv}.json` files, all copied byte-exact from the source clip. - **Release-level meta** — `meta/{dataset.json, tasks.jsonl, episodes.parquet, episodes.jsonl, index.parquet, stats.parquet, modalities.json, manifest.json}`. Full schema, column-by-column field descriptions, and the loader API live in the toolkit repository. --- ## Layout on disk ### Packed release (this v1.0 — what HF actually ships) ``` / ├── meta/ # release-level index + manifest ├── online_data/episodes///... # 109 episodes (with setpoint_cp) ├── offline_data/episodes///... # 96 episodes (no setpoint_cp) ├── README.md CHANGELOG.md # version-stamped docs └── .logs/.jsonl # structured per-clip pack outcomes ``` Per episode: ``` /episodes/// ├── episode_meta.json modalities.json time_sync_stat.json ├── timestamp.parquet ECM.parquet PSM1.parquet PSM2.parquet annotation.parquet ├── video_raw/{stereo_left, stereo_right, side}.mkv # FFV1, bit-exact, 1920×1080 ├── calibration/ # camera intrinsics/extrinsics + hand-eye └── .surgsync_complete.json ``` ### After unpacking (`surgsync unpack --out `) The unpacker is **fully invertible**: every file in the original raw clip layout is reconstructed from the packed parquets + MKVs. The image bytes are **pixel** bit-exact (decoded ndarrays match byte-for-byte); see [§ Limitations 10](#10-image-bytes--raw-image-bytes-after-unpack-pixel-bit-exact-not-byte) for the PNG-encoder caveat. Per-episode layout produced by unpack: ``` /// ├── meta_data.json # operator skill, case type, tool inventory, ... ├── image/ │ ├── left/.png # frame-aligned to master clock │ ├── right/.png │ └── side/.png # only when a side camera was recorded ├── kinematic/ │ ├── ECM/.json # one file per frame, per arm │ ├── PSM1/.json │ └── PSM2/.json ├── annotation/ │ ├── contact_detection/.json # {"PSM1": 0/1, "PSM2": 0/1} │ ├── phase/.json # verbalized text (see note on id ↔ text mapping below) │ ├── step/.json # verbalized text │ └── gesture/.json # {"PSM1": "", "PSM2": ""} ├── time_syn/.json # per-frame per-topic master-clock deltas ├── camera_calibration/ │ ├── left.yaml right.yaml stereo_calib_params.json ├── hand_eye_calibration/ │ ├── PSM1-registration-dVRK.json PSM1-registration-open-cv.json │ └── PSM2-registration-dVRK.json PSM2-registration-open-cv.json └── .surgsync_unpacked.json # resume sentinel; presence means clip is done ``` Unpack is resume-friendly — re-running without `--force` skips clips whose `.surgsync_unpacked.json` is present. The fidelity table for every modality lives in `HOW_to_RUN_unpack.md` in the toolkit repo. **Note on `phase` / `step` / `gesture` formats.** The unpacked JSONs carry **verbalized text** for these fields — the packer enriches at pack time using `workflow_description.json`, and the unpacker writes back whatever the parquet carries. Both numeric ids and verbalized text are first-class — the **id ↔ text mapping ships with the release** in `meta/tasks.jsonl` (per task) and `workflow_description.json` (the master vocabulary), so consumers can convert in either direction depending on what their downstream code prefers. Numeric ids are a compact, convenient shorthand for annotation tools; verbalized text is friendlier for LLM-style pipelines that consume natural-language labels directly. ```python import json tasks = {json.loads(line)["task"]: json.loads(line) for line in open("meta/tasks.jsonl")} # id → text (forward, what the packer uses): step_id_to_text = tasks["single_interrupted_stitch"]["step_vocab"] # text → id (inverse, for re-encoding): step_text_to_id = {v: k for k, v in step_id_to_text.items()} # Caveat: ~1.8% of step rows carry text outside the task's own # step_vocab (see § Limitations 1) — use a global union lookup if # you need strict round-tripping. ``` ### Layout *with* derived modalities (after you run the preprocessing pipeline locally) The same per-episode tree gains a `video/`, `preprocess/`, and an extra `calibration/rectify_params.json` once you run the toolkit's preprocessing stages on the unpacked raw clips. **None of these files are in the v1.0 release as shipped** (see [§ Limitations 2](#2-no-rectified--depth--flow--heatmap--hand-eye-streams-in-v10)) — they are produced locally by `scripts/run_all_stages.py` (or by running each stage individually), then optionally re-packed via `surgsync build` to emit an option-C release on your own disk. The tree below shows what an episode looks like after that user-driven processing pass, with `★ NEW` annotations on every file that the preprocessing pipeline adds on top of v1.0: ``` /episodes/// ├── episode_meta.json modalities.json time_sync_stat.json ├── timestamp.parquet ECM.parquet PSM1.parquet PSM2.parquet annotation.parquet │ # ⇧ PSM{1,2}.parquet gains non-NULL │ # measured_cp_calibrated.* and │ # setpoint_cp_calibrated.* columns ├── video_raw/{stereo_left, stereo_right, side}.mkv # unchanged from v1.0 ├── video/ # ★ NEW — rectified + resized H.264 │ ├── stereo_left.mp4 # CRF 18, yuv420p, 512×288 │ └── stereo_right.mp4 ├── preprocess/ # ★ NEW — derived per-frame streams │ ├── depth.mkv # FoundationStereo colorized depth viz │ ├── flow_left.mkv # RAFT optical flow (left), colorized │ ├── flow_right.mkv # RAFT optical flow (right), colorized │ ├── heatmap_PSM1_left.mkv # kinematic-projection Gaussian heatmap │ ├── heatmap_PSM1_right.mkv # (one stream per PSM × camera side) │ ├── heatmap_PSM2_left.mkv │ └── heatmap_PSM2_right.mkv ├── calibration/ │ ├── camera.json left.yaml right.yaml stereo_calib_params.json │ ├── rectify_params.json # ★ NEW — P1/P2/Q at rectified resolution │ └── hand_eye/PSM{1,2}-registration-{dVRK,open-cv}.json └── .surgsync_complete.json ``` After a local preprocessing pass and a re-pack with `surgsync build`, the release-level flags in each `episode_meta.json` flip from `false` to `true` to reflect the new content: | Flag | v1.0 as shipped | After your local preprocessing + re-pack | |---|:--:|:--:| | `has_video_raw` | ✅ | ✅ | | `has_preprocess` | ❌ | ✅ | | `has_preview` | ❌ | ✅ | | `has_calibrated_kinematic` | ❌ | ✅ | `meta/dataset.json:pipeline_versions.*` (`null` everywhere in v1.0) will then carry the exact preprocessing-stage version that produced each derived stream, so downstream users can pin against a specific pipeline build for reproducibility. --- ## Conventions | | | |---|---| | Master clock | `stereo_left_capture_ros_header_stamp` (per-clip, rebased to 0; absolute t0 in `episode_meta.json:master_t0_ns`) | | Alignment policy | `nearest_neighbor_within_tolerance` | | Alignment tolerance | online 2 ms; offline image_side 33 ms; offline kinematic `1000 / source_frequency_hz` | | Frame index basis | master clock | | Length / angle units | meters / radians | | Quaternion order | xyzw (dVRK CRTK convention) | | Master frame rate | 10 Hz (by design — a deliberate trade-off between cross-modal time alignment and per-frame frequency; see [§ Other diffs worth flagging](#other-diffs-worth-flagging)) | | Raw image size | `[1920, 1080]` | | Post-processing image size | `[512, 288]` (preprocessing-pipeline target — not present in v1.0) | --- ## Known limitations + data-quality notes The data on disk is internally self-consistent (sums add up, SHAs match), but several **vocabulary** and **convention** items need up-front disclosure. ### 1. `tasks.jsonl` vocab is best-effort, not a closed enumeration **41 of 205 episodes (~20%)** carry verbalized `phase` and/or `step` text drawn from a different task's vocabulary than the episode's own partition. Counts per task (from `meta/index.parquet`): | Task | Total frames | Orphan-phase rows | Cross-task step rows | Affected episodes | |---|---:|---:|---:|---:| | `single_interrupted_stitch` | 90,068 | **2,961** | **2,961** | 31 of 92 | | `cold_cut_dissection` | 55,595 | 0 | 21 | 4 of 61 | | `tissue_manipulation` | 5,907 | 1,868 | 0 | 6 of 25 | | Others | 16,562 | 0 | 0 | 0 | | **Total** | **168,132** | **4,829** | **2,982** | **41** | Root cause: `workflow_description.json` carries a shared "exposure" phase (`phase_id=0`) that isn't routed to any task by `_task_routing`, and the v1.0 packer's `verbalize_step(value)` is task-agnostic. Consequence: - `meta/index.parquet` and per-episode `annotation.parquet` are the **source of truth** for verbalized strings. - `meta/tasks.jsonl` is **documentation, not a closed enumeration** — strict `(task, step_id) → text` joins miss ~1.8% of step rows and ~2.9% of phase rows. - `meta/stats.parquet:phase.vocab_size = 7` but `tasks.jsonl` lists only **6** phase strings — the gap is the orphan `phase_id=0`. **v1.1 plan:** engage the existing `verbalize_step(value, task)` overload in the packer and surface `phase_id=0` explicitly. ### 2. Derived / preprocessed streams are not bundled in v1.0 (but the toolkit generates them) v1.0 ships **only the raw modalities** — bit-exact stereo + side FFV1, per-modality parquets, and calibration. The preprocessing-stage outputs are absent on disk: - `video/stereo_left.mp4`, `video/stereo_right.mp4` (H.264 rectified) - `preprocess/depth.mkv` - `preprocess/flow_left.mkv`, `preprocess/flow_right.mkv` - `preprocess/heatmap_PSM{1,2}_{left,right}.mkv` - `calibration/rectify_params.json` - `PSM{1,2}.parquet:measured_cp_calibrated.*` / `setpoint_cp_calibrated.*` (columns exist in schema; NULL on every row) Per episode, `episode_meta.json` reflects this: `has_preprocess=false`, `has_preview=false`, `has_calibrated_kinematic=false`, and `meta/dataset.json:pipeline_versions.*` are all `null`. **This is intentional, not a data-quality failure.** The raw FFV1 + parquets are the source of truth. Derived modalities are deterministic functions of (raw inputs × pipeline version), and the toolkit ships every stage that produces them: | Derived stream | Generator script (in the toolkit repo) | GPU? | |---|---|:--:| | Rectified H.264 video | `src/dvrk_data_processing/raw_image_processing/gen_rectify_resize.py` | no | | Hand-eye-projected kinematics + heatmaps | `src/dvrk_data_processing/kinematic_mapping/gen_kinematic_heatmap_handeye.py` | no | | Depth estimation | `src/dvrk_data_processing/depth_estimation/gen_depth_estimate.py` (FoundationStereo) | yes | | Optical flow | `src/dvrk_data_processing/optical_flow/gen_optical_flow_raft.py` (RAFT) | yes | | End-to-end runner | `scripts/run_all_stages.py` (chains all of the above) | yes | Workflow to obtain the full option-C layout on your own disk: 1. `surgsync unpack --out ` — reconstruct the raw clip tree from this v1.0 release. 2. `python scripts/run_all_stages.py path_config.data_dir=` — generates `preprocess/` and rectified `video/` next to each clip. 3. `surgsync build --out ` — re-packs with the derived streams included. Compute cost: FoundationStereo dominates. End-to-end processing of the full v1.0 release runs ~1 day on a single high-end consumer GPU (e.g. RTX 4090 / A6000). Skip the depth/flow stages and the runtime drops to a few hours. ### 3. ECM Cartesian setpoint is not shipped The packer's ECM schema carries `setpoint_js` only — no `setpoint_cp`. The reader exposes the same; the unpacker cannot reproduce that block. PSMs are unaffected. ### 4. Gesture vocabulary is incomplete for 4 of 6 tasks `meta/tasks.jsonl` ships an empty `gesture_vocab: {}` for `peg_transfer`, `tissue_manipulation`, `cold_cut_dissection_intestine`, and `cold_cut_dissection_skin_peel`. **77 episodes have no decodable gesture annotations** because their task's vocabulary has no entries. `gesture.PSM{1,2}` columns are NULL on those episodes. `meta/modalities.json:topics_present_in_n_episodes.annotation.gesture.PSM*` reports the **128/205** coverage authoritatively; a further **35 episodes** have *partial* gesture coverage. ### 5. `single_interrupted_stitch.gesture_vocab["16"]` (`Cut suture`) is unused in v1.0 Gesture id `16` — **"Cut suture"** — is a valid entry in the suturing gesture taxonomy, but no frame in v1.0 carries it because the recording protocol for this release stops at the secured knot (suture-tail cutting was not performed). The text in `tasks.jsonl` includes a parenthetical editorial note flagging it as unobserved: > `"Cut suture (We do NOT have this, but it should be defined) (Closing scissors or a cutting instrument to sever the suture tail at the target distance from the knot.)"` The entry itself is correct — it's not a placeholder, just an unused gesture in this release. Future recordings that include suture cutting would populate it. The bracketed editorial note may be cleaned up in v1.1 for cosmetic clarity, but the id mapping is stable across versions. ### 6. Minor typos in `tasks.jsonl` - `cold_cut_dissection.phase_description` — `"surigal"` → `"surgical"`. - `tissue_manipulation.step_vocab["45"]` — `"roposition"` → `"reposition"`. Cosmetic — text-as-data only. ### 7. 8 suturing clips extend the gesture vocab with two ad-hoc codes (`'00'`, `'01'`) Eight `single_interrupted_stitch` clips carry the **literal strings** `'00'` or `'01'` in `gesture.PSM{1,2}` instead of verbalized text. These are not canonical gestures — the suturing `gesture_vocab` in `meta/tasks.jsonl` only defines ids `1`–`18`. The two codes were used ad-hoc by the annotators of these specific clips to mark motion-state events, drawing their meanings from the **suturing step vocab**, where the same texts already exist: - `"00"` ≈ `"bilateral pause (both hand not moving > 20 frames)"` - `"01"` ≈ `"move camera"` **Affected clips and counts** (always paired across PSM1 and PSM2 — identical literal on both arms on the same frame): | Partition | Clip | Frames in clip | `"00"` frames | `"01"` frames | |---|---|---:|---:|---:| | online_data | 0 | 314 | 0 | 31 | | online_data | 1 | 157 | 0 | 35 | | online_data | 11 | 452 | 0 | 28 | | online_data | 35 | 1,129 | 36 | 0 | | online_data | 38 | 1,181 | 28 | 0 | | online_data | 42 | 712 | 66 | 0 | | online_data | 43 | 1,041 | 70 | 0 | | offline_data | 47 | 990 | 0 | 38 | | **Total** | | **5,976** | **200** | **132** | That's **332 frames out of 168,132 (≈ 0.197 %)** across the entire release, or **0.369 %** within the suturing partition (90,068 frames). Each affected clip uses **either** `"00"` **or** `"01"`, never both — i.e. an annotator chose one motion-state code consistently for the clip and used it alongside the canonical 18-gesture vocab on the remaining frames. **Why this is contained, not systematic.** An empirical scan of all 92 suturing clips shows: - Only **8 / 92 clips** carry `"00"` or `"01"`. - **Zero** clips have the other suturing step ids (`"11"`–`"15"`) leaking into the gesture column — which rules out a copy-paste-step- into-gesture-field bug. Only the two motion-state codes leak. - All 8 affected clips also carry the **canonical verbalized gestures** on the majority of frames, so the literals coexist with valid data. **Recommended consumer recipe.** Either filter the rows, or post-map the two literals at load time: ```python GESTURE_AD_HOC = { "00": "bilateral pause (both hand not moving > 20 frames)", "01": "move camera", } g = df["gesture.PSM1"].map(lambda v: GESTURE_AD_HOC.get(v, v)) ``` **Status.** Deferred to v1.1: promote `"00"` / `"01"` into the canonical suturing `gesture_vocab` (and decide whether they are suturing-only or task-agnostic motion-state codes), so the packer's verbalizer can resolve them at pack time rather than relying on a downstream patch. The v1.0 data on disk is otherwise correct. ### 8. `duration_s` is `float32` `episodes.parquet:duration_s` is the real first-to-last `master_timestamp_ns` delta in seconds, stored as `float32`. Values exhibit sub-millisecond noise (e.g. `162.599999904`, `112.699997`, `90.000000`) — not an off-by-one error. For exact frame timing use `index.parquet:master_timestamp_ns` (int64 ns). Don't compute `int(duration_s * 10) == length_frames`. ### 9. CUDA non-determinism in preprocessing-derived streams (future) When preprocessing IS run (not in v1.0), depth and optical-flow outputs depend on GPU/driver. Two builds against the same raw clip pixel-match within encoder tolerance but are not byte-exact across machines. Irrelevant to v1.0; relevant to any v1.1+ re-pack that includes the derived modalities. ### 10. Image bytes ≠ raw image bytes after unpack (pixel bit-exact, not byte) The pack→unpack round-trip is **pixel** bit-exact (decoded ndarrays match byte-for-byte). PNG file bytes differ because cv2's encoder picks different compression filters than whatever produced the original. The toolkit ships `scripts/verify_unpack_vs_raw.py` (pixel comparison) for round-trip checks. ### 11. `meta/manifest.json` excludes a small known set The SHA-256 manifest covers 3,912 of the 4,123 files on disk. The 211 untracked files are intentional: 205 × `.surgsync_complete.json` per-episode sentinels, the manifest itself, `README.md` / `CHANGELOG.md` (stamped *after* the manifest), and 1 × `.logs/*.jsonl` operational log. ### 12. `stats.parquet` uses reservoir-sampled percentiles `meta/stats.parquet:q01` and `:q99` come from a 10,000-sample reservoir per column. Expect ±0.5% error — fine for ImageNet-style normalization presets, **not** for tight outlier detection. Re-running `build_stats()` produces slightly different `q01`/`q99` because of RNG. --- ## Citation ```bibtex @inproceedings{zhou2026surgsync, author = {Zhou, Haoying and Liu, Chang and Wu, Yimeng and Wu, Junlin and Wu, Zijian and Lee, Yu Chung and Martuscelli, Sara and Salcudean, Septimiu E. and Fischer, Gregory S. and Kazanzides, Peter}, title = {{SurgSync}: Time-Synchronized Multi-modal Data Collection Framework and Dataset for Surgical Robotics}, booktitle = {IEEE International Conference on Robotics and Automation (ICRA)}, year = {2026}, } ``` If you accessed SurgSync (or a subset of it) through NVIDIA's **PhysicalAI-Robotics-Open-H-Embodiment** collection at [`Surgical/jhu/lcsr/smarts`](https://huggingface.co/datasets/nvidia/PhysicalAI-Robotics-Open-H-Embodiment/tree/main/Surgical/jhu/lcsr/smarts), the citation is the same — use the `zhou2026surgsync` BibTeX above. That ICRA 2026 paper is the canonical reference for the underlying dVRK recordings; the Open-H-Embodiment collection redistributes a curated subset of the v1.0 packed release described here. External backbones used by the (future) preprocessing pipeline — cite separately if you rely on derived streams: ```bibtex @inproceedings{wen2025foundationstereo, title = {FoundationStereo: Zero-Shot Stereo Matching}, author = {Wen, Bowen and Trepte, Matthew and Aribido, Joseph and Kautz, Jan and Gallo, Orazio and Birchfield, Stan}, booktitle = {CVPR}, year = {2025} } @inproceedings{teed2020raft, title = {{RAFT}: Recurrent All-Pairs Field Transforms for Optical Flow}, author = {Teed, Zachary and Deng, Jia}, booktitle = {ECCV}, year = {2020} } ``` --- ## Maintainer / contact **Haoying (Jack) Zhou** — `hzhou62@jh.edu` / `hzhou6@wpi.edu` · [github.com/jackzhy96](https://github.com/jackzhy96) · project page **https://surgsync.github.io/**. For questions about the data format, the loader API, or this specific release, open an issue on the [toolkit repository](https://github.com/jackzhy96/dvrk_multimodal_data_collection). --- ## License Released under **Creative Commons Attribution-NonCommercial 4.0 International (CC-BY-NC-4.0)**. The dVRK recordings follow the same licensing terms as the raw source data; contact the maintainer for clarifications on specific clinical sub-partitions. The accompanying **SurgSync toolkit** (reader, packer, unpacker, processing pipelines) is released under its own license — see `LICENSE` in the [toolkit repository](https://github.com/jackzhy96/dvrk_multimodal_data_collection).