| --- |
| license: cc-by-nc-4.0 |
| language: |
| - en |
| pretty_name: "SurgSync — Multi-modal dVRK Dataset (v1.0)" |
| size_categories: |
| - 100K<n<1M |
| tags: |
| - robotics |
| - surgical-robotics |
| - da Vinci Surgical System |
| - da Vinci Research Kit (dVRK) |
| - imitation-learning |
| - multimodal |
| - stereo-video |
| - kinematics |
| - action-recognition |
| - surgical-phase-recognition |
| - instrument-tracking |
| - instrument-segmentation |
| - 6d-pose-estimation |
| - surgical-tool-pose |
| - hand-eye-calibration |
| task_categories: |
| - robotics |
| - video-classification |
| - image-segmentation |
| - object-detection |
| - keypoint-detection |
| - other |
| |
| |
| |
| |
| |
| |
| |
| viewer: false |
| --- |
| |
| # SurgSync — Multi-modal dVRK Dataset (v1.0) |
|
|
| > **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.<topic>_ns` offsets on |
| `timestamp.parquet`. |
| - **Hand-eye calibration accuracy.** Two registration formats ship |
| per arm: `<arm>-registration-dVRK.json` (from the dVRK's own |
| calibration routine) and `<arm>-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.<topic>_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 `<arm>-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) |
|
|
| ``` |
| <release_root>/ |
| ├── meta/ # release-level index + manifest |
| ├── online_data/episodes/<task>/<clip_idx>/... # 109 episodes (with setpoint_cp) |
| ├── offline_data/episodes/<task>/<clip_idx>/... # 96 episodes (no setpoint_cp) |
| ├── README.md CHANGELOG.md # version-stamped docs |
| └── .logs/<run_id>.jsonl # structured per-clip pack outcomes |
| ``` |
|
|
| Per episode: |
|
|
| ``` |
| <dataset>/episodes/<task>/<clip_idx>/ |
| ├── 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 <release_root> --out <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: |
|
|
| ``` |
| <out>/<dataset>/<clip_idx>/ |
| ├── meta_data.json # operator skill, case type, tool inventory, ... |
| ├── image/ |
| │ ├── left/<i>.png # frame-aligned to master clock |
| │ ├── right/<i>.png |
| │ └── side/<i>.png # only when a side camera was recorded |
| ├── kinematic/ |
| │ ├── ECM/<i>.json # one file per frame, per arm |
| │ ├── PSM1/<i>.json |
| │ └── PSM2/<i>.json |
| ├── annotation/ |
| │ ├── contact_detection/<i>.json # {"PSM1": 0/1, "PSM2": 0/1} |
| │ ├── phase/<i>.json # verbalized text (see note on id ↔ text mapping below) |
| │ ├── step/<i>.json # verbalized text |
| │ └── gesture/<i>.json # {"PSM1": "<verbalized text>", "PSM2": "<verbalized text>"} |
| ├── time_syn/<i>.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: |
|
|
| ``` |
| <dataset>/episodes/<task>/<clip_idx>/ |
| ├── 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 <release_root> --out <raw_out>` — reconstruct the |
| raw clip tree from this v1.0 release. |
| 2. `python scripts/run_all_stages.py path_config.data_dir=<raw_out>` — |
| generates `preprocess/` and rectified `video/` next to each clip. |
| 3. `surgsync build <raw_out> --out <option_c_root>` — 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). |
|
|
