stream3D-rebuttal

Multi-view RGB-D recordings captured with two Intel RealSense D435I cameras, released as supporting material for a paper rebuttal.

Four table-top manipulation sessions, each recorded simultaneously from two third-person viewpoints with synchronized colour and aligned depth.

Contents

Archive	Frames	Duration	Size
banana_success.zip	2147	92.9 s	0.88 GB
banana_fail.zip	2453	90.5 s	1.01 GB
red_pepper_success.zip	2525	88.1 s	1.04 GB
red_pepper_fail.zip	2959	103.9 s	1.20 GB

Each archive unpacks to:

<session>/
    prompt.txt
    third_person/
        cameras.json                  # camN -> {physical_index, serial, name}
        cam1/
            rgb.mp4                   # 1280x720, MPEG-4 Part 2 (mp4v)
            depth.npz                 # 'depth' [N,720,1280] uint16, 'timestamps' [N] float64
            rgb_timestamps.npy        # [N] float64, POSIX seconds
            intrinsics.json
        cam2/
            rgb.mp4                   # 640x480
            depth.npz                 # 'depth' [N,480,640] uint16
            rgb_timestamps.npy
            intrinsics.json

Cameras

	Device	Serial	Resolution
cam1	Intel RealSense D435I	346222073791	1280 × 720
cam2	Intel RealSense D435I	344422072190	640 × 480

The two cameras run at different resolutions because cam2 was connected over a USB 2.1 link, where the D435I offers 1280×720 only at 6 fps. 640×480 is the highest mode it can sustain at 30 fps on that link.

Colour intrinsics are constant across all sessions:

cam1   fx 913.4   fy 912.5   ppx 655.6   ppy 378.5
cam2   fx 605.5   fy 605.5   ppx 324.3   ppy 240.9

Frame correspondence

Within a camera, depth[i] corresponds exactly to frame i of rgb.mp4 — both are written from the same RealSense frameset in a single call, so the indices cannot drift. Verified for every session: raw depth frame count equals the decoded video frame count.

Depth is aligned to the colour stream (rs.align(rs.stream.color)), so the correspondence is per-pixel as well: depth[i][y, x] is the depth of colour pixel [y, x].

Across the two cameras, frame i of cam1 and frame i of cam2 are written in the same capture loop iteration and are therefore near-simultaneous, but they are not hardware-synchronized — each camera's own capture instant can differ by up to one frame period. Use rgb_timestamps.npy when exact cross-camera timing matters.

Back-projection

Depth is stored as uint16 millimetres (depth_scale = 0.001). Because depth is aligned to colour, back-projection must use the colour intrinsics, not the depth block in intrinsics.json (those describe the depth sensor's own unaligned optical frame):

import json, numpy as np

z    = np.load("cam1/depth.npz")
dep  = z["depth"][i]                        # (H, W) uint16, millimetres
ci   = json.load(open("cam1/intrinsics.json"))["color"]

v, u = np.mgrid[0:dep.shape[0], 0:dep.shape[1]]
Z = dep * 0.001                             # metres
X = (u - ci["ppx"]) * Z / ci["fx"]
Y = (v - ci["ppy"]) * Z / ci["fy"]          # X right, Y down, Z forward

depth == 0 marks invalid/no-return pixels and should be masked out.

Known limitations

• red_pepper_success and red_pepper_fail have no rgb_timestamps.npy for cam2, and their cam2/depth.npz contains only the depth array (no timestamps key). Those timestamps were lost to a failure in the recording pipeline's save step; the depth frames themselves are intact and were rebuilt from the on-disk raw buffer and byte-verified. Frame-index alignment with rgb.mp4 is unaffected. See RECOVERY_NOTE.txt inside those two archives. Code reading depth.npz["timestamps"] unconditionally will raise KeyError on these two files.
• Effective capture rate is 23–29 fps against a 30 fps target; the recording loop could not always keep up at 1280×720. Frame intervals are not uniform — use the timestamps rather than assuming a fixed 1/30 s step.
• rgb.mp4 is MPEG-4 Part 2 (mp4v), which browsers cannot decode natively. Use OpenCV/FFmpeg, or transcode to H.264 for in-browser playback.
• prompt.txt contains placeholder text, not a meaningful task description.