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. If you accessed the data through that redistribution, the citation is still the SurgSync ICRA 2026 paper — see § 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. 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 for what shipping derived modalities would add, and § Limitations 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 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. 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 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 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.

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) — 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)
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:

surgsync unpack <release_root> --out <raw_out> — reconstruct the raw clip tree from this v1.0 release.
python scripts/run_all_stages.py path_config.data_dir=<raw_out> — generates preprocess/ and rectified video/ next to each clip.
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:

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

@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, 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:

@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 · 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.

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.

Downloads last month: 2,792

Total file size:

714 GB

SurgSync — Multi-modal dVRK Dataset (v1.0)