EgoRecall is built on ScanNet++, whose images, depth, and camera poses are not included here. Request access to them on the ScanNet++ website and use them under the ScanNet++ Terms of Use.

To help us review your request, please give your full name (first and last), the name of your advisor or principal investigator (PI), your school or company, and how you plan to use EgoRecall.

Hou In Ivan Tam, Manolis Savva
Simon Fraser University

EgoRecall is a benchmark for 3D visual grounding from streaming egocentric observations. Each query is a referring expression asked at a frame of an egocentric RGB-D video, such as "the box to the left of the chair that showed up first". A method must find the referred objects in 3D using only the frames up to that point, and the targets are often no longer in view.

Dataset version: 1.0.0. This repository contains the annotations: 2.25M queries with ground-truth answers over 183 ScanNet++ v2 scenes, evaluation stages, frame mappings, and per-scene object visibility. The RGB-D frames, camera poses, and object boxes come from ScanNet++, which you obtain separately and prepare with the EgoRecall code.

Directory Structure

EgoRecall_hf/
├── queries/{train,val,test}.parquet   # queries and their answers
├── stages/{val,test}.parquet          # evaluation stage of each val/test query
├── frames/{train,val,test}.parquet    # sampled frame index → ScanNet++ frame name
├── annotations/<scene_id>.json.gz     # object labels and visibility over each scene's timeline
├── scenes.json                        # per-scene split, counts, and sampling settings
├── provenance/                        # generation, balancing, and stage-sampling settings
├── manifest.json                      # version, counts, and SHA-256 of every other file
└── LICENSE, ATTRIBUTION.md, CITATION.cff

Splits and Stages

Split	Scenes	Queries	Stages
train	100	1,202,906	–
val	13	165,340	83
test	70	879,994	440

Scenes do not overlap across splits. Validation and test queries are divided into numbered stages of 2,000 queries; the last stage is smaller (1,340 in val, 1,994 in test). Stages are drawn by stratified sampling over scene, operator family, and target-visibility group, so stages 1 to k together always form a proportional random sample of the split. The paper evaluates on test stages 1–5 (10,000 queries). Every stage includes queries from all scenes of its split, so evaluating any stage needs all of that split's scenes prepared. Training queries have no stages.

Data Fields

Queries

Each row of queries/<split>.parquet is one query, identified by (scene_id, query_idx).

Field	Type	Description
`scene_id`	string	ScanNet++ scene ID
`query_idx`	int32	Query ID within the scene; stable, may have gaps
`split`	string	`train`, `val`, or `test`
`description`	string	Referring expression, e.g. "the monitor above the foot rest currently visible"
`frame`	int32	Frame index at which the query is asked
`program_json`	string	Query program as JSON, e.g. `["above", ["currently_visible", "foot rest"], "monitor"]`
`program_depth`	int32	Nesting depth of the program (1 or 2)
`target_oids`	list	Ground-truth target object IDs
`visible_target_oids`	list	Targets in view at `frame`
`hidden_target_oids`	list	Targets seen earlier but out of view at `frame`
`any_target`	bool	Any one target is a correct answer; otherwise all targets are required
`emit_reason`	string	Why the query was emitted: `new`, `answer_change`, or `rebirth` (see Construction)
`source_query_id`	string	ID of the generated query record before balancing

Object IDs are ScanNet++ object IDs and are unique only within a scene. A method may use the query text and frames 0 to frame; answers, programs, and annotations are ground truth and must not be used as inputs.

Other Files

stages/<split>.parquet: scene_id, query_idx, split, and stage; join with the queries on (scene_id, query_idx).
frames/<split>.parquet: scene_id, frame_idx, and frame_name. Frame indices count sampled frames from 0; with the sampling stride of 10, frame_idx 1 is ScanNet++ image frame_000010.
scenes.json: one record per scene with scene_id, split, num_frames, num_objects, num_queries, source_fps (60), subsample_factor (10), nominal_timeline_fps (6), and annotations (file path).
manifest.json: dataset version, counts per split and in total, stage ranges, and the size and SHA-256 of every other file.
annotations/<scene_id>.json.gz: every object kept by the visibility filter, over the scene's whole timeline:

{
  "schema_version": 1,
  "scene_id": "036bce3393",
  "num_frames": 828,
  "visibility_filter": "visibility_filter_v1",
  "image_pixels": 2764800,
  "objects": {
    "1": {
      "label": "chair",
      "temporal": {"first_seen_frame": 0, "last_seen_frame": 818, "peak_visibility_frame": 20,
                   "total_visible_frames": 243, "peak_visible_area_frac": 0.80},
      "visibility_segments": [[0, 7], [9, 21], ...],
      "per_frame": {"0": {"visible_area_frac": 0.458, "visible_pixels_frac": 0.0102}, ...}
    }
  }
}

Visibility segments are inclusive frame ranges. per_frame has one entry per visible frame: the visible fraction of the object's surface area and the fraction of the image's pixels it covers.

Construction

Visibility. Each ScanNet++ iPhone video is subsampled from 60 to 6 FPS. At every camera pose, the annotated mesh is rasterized and checked against sensor depth to record which objects are visible. Walls, floors, and ceilings are excluded.
Programs. Queries are programs in a domain-specific language with 22 operators over observation history (e.g., first seen), egocentric relationships (e.g., left of), and allocentric structure (e.g., above), composed up to depth 2. Running a program at a frame uses only the objects seen by that frame and gives the ground-truth targets.
Verbalization. Programs are turned into referring expressions with templates.
Emission. Along each video, programs are evaluated every 2 s after a 6 s warm-up. A query is emitted when a program first becomes valid (new), when its answer changes (answer_change), or periodically while its answer stays the same (rebirth).
Balancing. The 9.9M generated queries are balanced per split across scenes, operator families, and six target-visibility groups: all targets in view (20%), some in view (15%), or none in view with the most recent sighting within 2 s (15%), 2–10 s (20%), 10–60 s (20%), or over 60 s earlier (10%). The result is the final set of 2.25M queries.

Usage

Request access on this page, then log in and download:

hf auth login
hf download 3dlg-hcvc/EgoRecall --repo-type dataset --local-dir /path/to/EgoRecall_hf

The tables can also be loaded directly:

from datasets import load_dataset

queries = load_dataset("3dlg-hcvc/EgoRecall", "queries", split="test")  # also "stages" and "frames"

Use the code to prepare the full dataset from ScanNet++. Preparation makes every scene ready for our Python API, which loads each query sample along with its observation history: the RGB-D frames and camera poses up to the query frame.

Limitations

The queries are generated from executable programs and turned into text with templates, so they do not capture the full diversity of human referring language. The scenes are static: objects never move, so the benchmark tests reasoning about what was observed, not about changes in the world. Visibility and answers are computed automatically from the ScanNet++ meshes, depth, and object annotations, so errors in these sources can carry over to some answers. The test answers are public, so do not train or tune on them; tune on the validation split instead.

License

EgoRecall annotations are released under CC BY-NC 4.0 (LICENSE), Copyright (c) 2026 3dlg-hcvc. ScanNet++ data is subject to the ScanNet++ terms of use; see ATTRIBUTION.md. For questions, open a GitHub issue.

Citation

@article{tam2026egorecall,
  title={{EgoRecall}: {3D} Visual Grounding from Streaming Egocentric Observations},
  author={Tam, Hou In Ivan and Savva, Manolis},
  journal={alphaXiv preprint},
  year={2026}
}

EgoRecall is built on ScanNet++, so please cite it as well.

Downloads last month: 15

Total file size:

111 MB