---
license: mit
pretty_name: TrajectoryBench
size_categories:
- 1K<n<10K
task_categories:
- image-to-video
tags:
- world-models
- video-generation
- benchmark
configs:
- config_name: default
  data_files:
  - split: test
    path: metadata.jsonl
dataset_info:
  features:
  - name: id
    dtype: string
  - name: category
    dtype: string
  - name: difficulty
    dtype: string
  - name: stylized
    dtype: bool
  - name: art_style
    dtype: string
  - name: num_frames
    dtype: int64
  - name: caption
    dtype: string
  - name: camera_prompt
    dtype: string
---

# TrajectoryBench

TrajectoryBench is a benchmark for long-horizon, camera-controlled video generation with complex trajectories. Each of its 2000 samples pairs a first frame with a camera trajectory and a text prompt. The model generates a video that starts from the frame and follows the trajectory, and is scored on 3D consistency, camera following, and video quality.

Paper: [LoGo: Local-Global Rewards for Consistent Long-Horizon Video Generation](https://arxiv.org/abs/2610.03636)

## Contents

```
metadata.jsonl        one row per sample
data/
  0001/
    first_frame.png   832x480 conditioning frame
    trajectory.npz    camera path to follow
    prompt.json       caption and camera prompt
  0002/
  ...
  2000/
```

## Metadata

`metadata.jsonl` has one JSON object per line, one per sample, with these fields:

- `id`: sample folder name under `data/`
- `category`: `indoor`, `outdoor`, or `transition` (passing through a door into a new space)
- `difficulty`: `easy`, `medium`, or `hard`
- `stylized`: `true` for non-photorealistic first frames
- `art_style`: the style of a stylized sample, one of `minecraft_blocks`, `japanese_anime`, `oil_painting`, `watercolor`, `low_poly_3d`, `studio_3d_cartoon`, `neon_cyberpunk`, `victorian_steampunk`, or `null`
- `num_frames`: number of camera poses, and so the number of frames to generate
- `caption`: a video-style description of the scene, about 90 words
- `camera_prompt`: description of the camera motion

`prompt.json` in each sample folder holds the same `caption` and `camera_prompt`.

The benchmark covers:

- indoor: 125 easy, 125 medium, 500 hard
- outdoor: 125 easy, 125 medium, 500 hard
- transition: 250 medium, 250 hard

Each group is 80% photoreal and 20% stylized. For each hard indoor or outdoor scene, there are two trajectories: one focusing on expansion (generating content far from the initial view), and one focusing on revisit (revisiting the same region from different angles multiple times).

## Difficulty

- **easy**: one camera primitive (push in, pull back, move, orbit, or pan) over 81 frames, subset from WorldScore.
- **medium**: medium includes transition scenes which go through a door into a new space. For indoor and outdoor, the medium split evaluates three chained primitives over 241 frames. This corresponds to WorldScore's small split of "composite camera motion", which is three separate 80-frame generations in a loop and thus not truly long-horizon. The indoor and outdoor initial images are sourced from this split of WorldScore for comparability.
- **hard**: 241-frame generation with 7-8 camera motions. Indoor and outdoor initial images are sourced from [Pexels](https://www.pexels.com), with trajectories either focusing on expansion far from the initial view or looking away and revisiting the same region from multiple viewpoints. Transition initial images are generated with [Nano Banana](https://deepmind.google/models/gemini-image/) to specify the location and size of the door, so that the trajectories can reasonably pass through it and generate a new space.

## Trajectory format

`trajectory.npz` contains:

- `w2c`: `(N, 4, 4)` float32 world-to-camera matrices, one per frame. Frame 0 is the identity, so poses are relative to the first frame.
- `intrinsics`: `(N, 3, 3)` float32 pinhole intrinsics in pixels.
- `image_wh`: `(2,)` int32 image width and height, `[832, 480]`.

Translations are given at the scale the samples are evaluated at, so a model follows `w2c` as
published without rescaling it.

Camera axes follow the OpenCV convention: +x right, +y down, +z forward.

## Usage

```python
import json
import numpy as np
import pandas as pd
from huggingface_hub import snapshot_download
from PIL import Image

root = snapshot_download("ziqima/TrajectoryBench", repo_type="dataset")
meta = pd.read_json(f"{root}/metadata.jsonl", lines=True, dtype={"id": str})

sample = meta.iloc[0]
d = f"{root}/data/{sample.id}"
frame = Image.open(f"{d}/first_frame.png")
traj = np.load(f"{d}/trajectory.npz")
prompt = json.load(open(f"{d}/prompt.json"))

w2c, K = traj["w2c"], traj["intrinsics"]  # (N, 4, 4), (N, 3, 3)
```

Generate one video per sample with `num_frames` frames at 832x480, conditioned on `first_frame.png` and following `w2c` and `intrinsics`.

## Citation

```bibtex
@misc{ma2026logo,
  title={LoGo: Local-Global Rewards for Consistent Long-Horizon Video Generation},
  author={Ziqi Ma and Shreya Sharma and Mohamed El Banani and Katja Schwarz and Chongjie Ye and Chao-Yuan Wu and Li Fei-Fei and Ben Mildenhall and Georgia Gkioxari and Justin Johnson and Gowthami Somepalli},
  year={2026},
  eprint={2610.03636},
  archivePrefix={arXiv},
  primaryClass={cs.CV},
  url={https://arxiv.org/abs/2610.03636},
}
```

## License

TrajectoryBench is released under the MIT License.