The GelSight Mini simulation set of FVL-Lab/OpenViTac (Simulation/GelSight_mini: 11 tasks, 1,300 expert demonstrations), regenerated seed for seed with the OpenViTac simulator and experts, and extended with per-frame:

metric depth plus camera intrinsics/extrinsics for the head and wrist cameras,
pointmaps unprojected from that depth,
frozen DINOv3 ViT-B/16 CLS and patch features of the same camera frames,

next to everything the original episodes contain: head/wrist RGB, the full left/right GelSight Mini streams (RGB, marker image, marker positions, gel depth, sensor pose), joint and end-effector states, and object poses. The derived streams follow the Flex-π LIBERO recipe (rendered depth -> pointmap, frozen DINOv3 features).

1,299 of the 1,300 published episodes (307,671 frames, about 513 GB). One published seed could not be reproduced with the current OpenViTac expert and is missing: insert_USB episode 66 (seed 102; the plan succeeds but the success check failed on all 14 attempts).

Pairing with the published episodes

Every published episode records the seed it was collected with (meta/conversion_manifest.jsonl of each task), and in OpenViTac a seed fixes the scene. This dataset re-collects exactly those seeds, and an episode is stored under the published episode_index of its task:

<task>/hdf5/episode_000123.hdf5 here <-> episode 123 of Simulation/GelSight_mini/<task> in FVL-Lab/OpenViTac.

The expert motion is re-executed, so trajectories are not bit-identical. On the same seeds, episode lengths agree with the published ones to within about 1-3 frames. Known differences:

empty_can_selection, pepsi variant: the current OpenViTac expert lifts the arm after returning, so these episodes are about 32 frames longer than the published ones.
insert_block_v2 episodes end right after the gripper opens, like the published v2 data (the expert still lets the block settle before checking success; those frames are not recorded). insert_block_v1 episodes keep the post-release frames, like the published v1 data.

Tasks

Task (`hf_task`)	Episodes	Mean frames	Conditions
weight_classify	100	141	heavy / light
hardness_classify	100	139	hard / soft
roughness_classify	100	140	rough / smooth
empty_can_selection	100	247	fanta / pepsi
roughness_guided_regrasp	100	190	rough block left/right x initial grasp left/right
gear_assembly	100	273
pull_drawer	100	241
insert_USB	99	238
insert_block_v1	100	254	cube
insert_block_v2	300	261	cube / half_cylinder / hexagon, 100 each
grasp_chip	100	433	force-controlled fragile chip transfer

Frames are recorded at 60 Hz (every second step of the 120 Hz simulation).

Layout

The data comes in two formats with the same episodes:

<task>/hdf5/episode_<index>.hdf5       HDF5: everything recorded, one file per episode
<task>/videos/episode_<index>.mp4      preview video (cameras + tactile) of the same episode
episodes.jsonl                         one row per HDF5 episode (see below)
lerobot/<task>/                        LeRobot v2.1 dataset of the task (see "LeRobot version")
generation/                            collection configs and the pointmap/DINO code used
LICENSE-DINOv3.md                      DINOv3 license (applies to the DINOv3 model used for the features)

episodes.jsonl fields: hf_task, variant (published variant directory, . if none), seed, episode_index, instruction, task_module (OpenViTac env module), conditions (task config used), num_frames, hdf5, video, and scene (the per-seed scene record written by OpenViTac: object poses, condition labels, instruction, timing).

LeRobot version

lerobot/<task>/ holds one LeRobot v2.1 dataset per task, converted like the published set (same LeRobot version, column names, float32 state, xyzw end-effector quaternion, gripper fraction, H.264 videos at 60 fps, LeRobot per-episode statistics; see meta/dataset_metadata.json of each task). On the same episode, the shared columns agree with the published parquet and the first video frames differ by about 1-3 grey levels (video compression). Columns:

as published: observation.state (7 joints + gripper open fraction), observation.joint_position, observation.eef_pose_quaternion, observation.eef_pose_rotvec, observation.eef_rotation_matrix, observation.gripper, observation.finger_position, observation.gripper_width_m, and the videos observation.images.{head,wrist,tactile_left,tactile_right} (tactile = marker images); no action column.
added per camera view (head, wrist): observation.pointmap.<view> (224x224x3), observation.dino_cls.<view> (768), observation.dino_patch.<view> (14x14x768), all float16, plus observation.camera_intrinsics.<view> and observation.camera_extrinsics.<view>. Statistics of the pointmap and patch features are per channel (shape (3,) and (768,)), which broadcasts against a frame.

Native-resolution depth, the plain tactile images, marker positions, gel depth, object poses and expert annotations are only in the HDF5 files. insert_USB lacks published episode 66, so its LeRobot episodes are renumbered contiguously (LeRobot requires it); every task's meta/conversion_manifest.jsonl maps each episode to its published index and seed.

from huggingface_hub import snapshot_download
from lerobot.common.datasets.lerobot_dataset import LeRobotDataset  # lerobot with dataset format v2.1

root = snapshot_download("armanakbari4/OpenViTac-GelSight-Multimodal", repo_type="dataset",
                         allow_patterns="lerobot/insert_USB/*")
dataset = LeRobotDataset("OpenViTac/insert_USB", root=f"{root}/lerobot/insert_USB")
frame = dataset[0]  # frame["observation.dino_patch.head"].shape == (14, 14, 768)

The parquet files hold the float16 arrays (about 1 MB per frame), and datasets caches them uncompressed when loading, so expect a cache of about 1.6 MB per frame (roughly 40 GB for a 100-episode task).

HDF5 contents

T = number of frames. Views are head and wrist; tactile sensors are left_tactile and right_tactile.

Key	Shape, dtype	Content
`observation/<view>/rgb`	`(T,)` bytes	JPEG, 480x270, encoded with OpenCV from RGB arrays: `cv2.imdecode` returns RGB as rendered (no `cvtColor`; PIL-style decoders swap R and B)
`observation/<view>/depth_mm`	`(T, 270, 480)` uint16	z-depth in mm, 0 = no hit (gzip)
`observation/<view>/intrinsics`	`(T, 3, 3)` float32	K of the 480x270 image
`observation/<view>/extrinsics`	`(T, 4, 4)` float32	OpenCV camera frame (x right, y down, z forward) -> robot base frame; per frame because the wrist camera moves
`observation/<view>/pointmap`	`(T, 224, 224, 3)` float16	xyz in metres, OpenCV camera frame (gzip)
`observation/<view>/dino_cls`	`(T, 768)` float16	DINOv3 CLS token
`observation/<view>/dino_patch`	`(T, 14, 14, 768)` float16	DINOv3 patch tokens (16x16-pixel patches of the 224x224 input)
`tactile/<sensor>/rgb`	`(T,)` bytes	JPEG, 320x240 tactile image (decode like the camera RGB)
`tactile/<sensor>/rgb_marker`	`(T,)` bytes	JPEG, 320x240 tactile image with markers (the stream in the published videos)
`tactile/<sensor>/marker`	`(T, 2, 64, 2)` float32	marker positions in tactile-image pixels, as output by the OpenViTac sensor model
`tactile/<sensor>/depth`	`(T, 240, 320)` float32	gel depth map from the sensor model
`tactile/<sensor>/pose`	`(T, 7)` float32	sensor pose
`embodiment/joint`	`(T, 9)` float32	7 Franka joints + 2 finger joints
`embodiment/ee`	`(T, 7)` float32	end-effector position + quaternion (w, x, y, z), robot base frame
`actor/<object>`	`(T, 7)` float32	object poses
`atom/id`, `atom/tag`	`(T,)`	expert primitive index and name
`phase/id`, `phase/name`	`(T,)`	0 `pre_move` (setup), 1 `policy`, 2 terminal
`step`, `phase/sim_step`, `phase/policy_step`	`(T,)` int64	counters

Root attributes: instruction, episode_context_json (task, seed, instruction) and derived_modalities (JSON with the pointmap and DINO settings).

There is no action column, as in the published data; joint or end-effector targets can be taken from the next frame's state.

Pointmaps and DINOv3 features

Both are computed on the same 224x224 view of each camera frame: the 480x270 frame is stretched to 224x224 (OpenCV INTER_AREA), so pointmap pixels line up with the 14x14 DINO patch grid.

Pointmap: for each output pixel, the depth of the native pixel under its centre, unprojected with the intrinsics into the OpenCV camera frame. Pixels without a hit, or farther than 2 m, are placed at 2 m along their ray. Use extrinsics to move points to the robot base frame. Pointmaps can be recomputed exactly from depth_mm and intrinsics with generation/modalities.py.
DINOv3: vit_base_patch16_dinov3.lvd1689m (timm port of facebook/dinov3-vitb16-pretrain-lvd1689m), ImageNet mean/std normalisation, final-LayerNorm tokens from forward_features; register tokens are dropped. Stored as float16.

For a policy that consumes these streams at test time, compute them on live observations with the same functions (generation/modalities.py) so the inputs match training.

Reading an episode

import cv2, h5py, json, numpy as np

with h5py.File("insert_USB/hdf5/episode_000000.hdf5", "r") as f:
    print(f.attrs["instruction"])
    rgb = cv2.imdecode(np.frombuffer(f["observation/head/rgb"][0], np.uint8), cv2.IMREAD_COLOR)  # RGB
    depth_m = f["observation/head/depth_mm"][0] / 1000.0
    pointmap = f["observation/head/pointmap"][:]          # (T, 224, 224, 3)
    dino = f["observation/head/dino_patch"][:]            # (T, 14, 14, 768)
    tactile = cv2.imdecode(np.frombuffer(f["tactile/left_tactile/rgb_marker"][0], np.uint8), cv2.IMREAD_COLOR)
    joints = f["embodiment/joint"][:]                     # (T, 9)

How it was made

Simulator: OpenViTac on Isaac Sim 4.5.0 / Isaac Lab 2.1.1 with UIPC soft-body gel pads, GelSight Mini on a Franka arm, scripted cuRobo experts. Configs: generation/gelsight_multimodal.yml (all tasks but grasp_chip) and generation/grasp_fragile_chip_multimodal.yml (grasp_chip, force-task path).
Only successful expert episodes are kept, as in the published set. insert_block seeds below 1000 use the block-base layout 0,1,4 and seeds from 1000 use 1,3,2.
Pointmaps and DINO features were added after collection with generation/add_pointmap_dino.py.

License and acknowledgements

The data is released under Apache-2.0, the license of the source dataset FVL-Lab/OpenViTac. Please credit the OpenViTac authors when using it.

The dino_cls and dino_patch features were produced with Meta's DINOv3 model, which is distributed under the DINOv3 License (copy in LICENSE-DINOv3.md). If you publish work that uses these features, acknowledge DINOv3 as that license requires.

Downloads last month: 92

Total file size:

856 GB