EgoSample

Head-mounted stereo video + IMU recorded by people doing their actual jobs — fabrication and packaging workshops, repair bays, bakeries, farms and similar working environments. Each episode is a continuous first-person clip with both eyes, a time-aligned inertial track, and a per-frame timestamp so the two can be joined exactly.

375 episodes across 107 clips, 38.4 hours. Every episode carries per-frame exposure timestamps.

Structure

<run>/                       e.g. starcap11_0709-0247
    seg_00/                  one episode (one trim of the source recording)
        left.mp4             stereo left  eye, H.265, 1920x1200
        right.mp4            stereo right eye, H.265, 1920x1200
        imu.csv              inertial track, unmodified sensor output
        frames.csv           each frame's exposure time
        labels.json          episode metadata
    seg_01/
    ...

A run is one continuous recording; a seg_NN is one usable episode cut from it.

Aligning video and IMU

Use frames.csv. It carries one row per video frame with the exposure time the sensor recorded, on the same ts_us clock as imu.csv:

frame_idx,ts_us
0,3667385323
1,3667385340

So alignment is a join on time, not a calculation:

frames = {int(a): int(b) for a, b in (l.split(",") for l in open("frames.csv").readlines()[1:])}
t = frames[n]                      # exposure time of frame n
rows = imu[(imu.ts_us >= t) & (imu.ts_us < frames[n + 1])]   # its ~10 IMU samples

Do not compute frame times as t0 + n/fps. Exposure intervals jitter and frames are occasionally dropped, so a constant-rate model drifts — by over a second on longer episodes. The per-frame timestamps are measured, not modelled, and stay correct through both.

labels.json also carries video_first_frame_ts_us, video_last_frame_ts_us and video_fps_measured for convenience, but frames.csv is authoritative.

Coverage

Every frame is bracketed by inertial data: each episode's imu.csv window is cut from the source on that episode's own frame range, with ~0.1 s of padding either side. labels.json carries imu_covers_video: true on every episode.

Video

H.265 (HEVC), 1920x1200 per eye. Capture rate varies by clip — most near 60 fps, some near 30 — so read video_fps_measured, or derive it from frames.csv, rather than assuming.

Both eyes are frame-count identical within an episode; this is enforced, not assumed. The published video is remuxed, never re-encoded — the pixels are the delivered encoder output. White balance was corrected upstream, before encoding.

IMU

imu.csv is the sensor's own output: contiguous rows, original timestamps, nothing recomputed. Roughly 10 samples per video frame (~600 Hz against 60 fps video).

imu.csv columns are ts_us,ax_ms2,ay_ms2,az_ms2,gx_dps,gy_dps,gz_dps — microseconds, m/s² and deg/s. labels.json repeats this in imu_columns / imu_units.

ts_us never runs backwards inside an episode, and frames.csv is on the same clock as imu.csv — which is all an alignment join needs.

Its origin differs by episode, so do not compare ts_us between episodes:

• most episodes carry the device's free-running microsecond counter, which wraps at 2³² (~71.6 min) in the raw recordings and has been unwrapped here (so values may exceed 2³²);
• 67 episodes were rebuilt from the delivered MCAP and carry unix epoch microseconds instead.

labels.json states which, in ts_us_origin, on the episodes where it is epoch-based. In both cases the values are the sensor's own; only the window and the origin differ.

Guarantees

Enforced on every published episode:

• every episode has frames.csv; episodes whose timing could not be established exactly were removed rather than shipped as approximate
• frames.csv row count equals the video's frame count
• every frame's timestamp falls inside that episode's imu.csv window, so no frame lacks inertial data
• left and right frame counts equal
• ~10 IMU samples per video frame (measured p50 10.03)
• IMU timestamps never run backwards

labels.json

Measurement fields (video_frames, imu_samples, imu_per_frame, duration_s, fps) describe the published files. The nested labels object carries capture metadata:

Field	Meaning
episode-uuid	stable episode identifier
operator-id	pseudonymous operator identifier (no names)
operator-job	the wearer's real-world role, e.g. "packaging technician"
task-id, task_category, task_difficulty	what was being done
environment-id, environment_l1/l2/l3	environment, coarse to fine
business_size, workforce	workplace context
device_id	capture rig
start_time_unix, end_time_unix	capture window

Privacy

Recordings were made by consenting operators in their own workplaces. Identifiers are pseudonymous — operator-id and environment-id are opaque tokens, and the published metadata carries no names, no street addresses and no geolocation.

The footage is first-person, so it shows hands, workspaces, and at times other people and premises. Treat it accordingly.

Limitations

• Coverage is uneven across environments and operators; this is a sample, not a balanced benchmark.
• Episode lengths vary widely: median 60 s, but roughly half are under a minute and ~150 are under ten seconds, because the source recording ran out mid-trim. Filter on duration_s if you need sustained footage; the longest run to ~54 minutes.
• No camera calibration or pose is published alongside these files.
• Audio is not included.