BOP-Motion-MCQ — multiple-choice motion questions over dense 6-DoF video

Multiple-choice questions about how objects move, derived exactly from dense 6-DoF (object→camera) pose trajectories rather than guessed from pixels. Each row pairs a short 6fps video clip with one motion MCQ, its per-second motion trajectory, and the whole-video aggregated answer. The intended task: watch the clip and pick the motion that actually happens.

Built with the motion-qa pipeline (motion_qa.datagen.bop_mcq_questions).

The four question types

qa_type	answer space	derived from
motion_direction	left / right · up / down · toward / away	Δtranslation of one object
rotation_spin	clockwise / counter-clockwise	angular-velocity axis vs. the camera
speed	faster / slower · speeding up / slowing down	|velocity| and its trend
relative_motion	approaching / receding	two objects (or object vs. camera)

Every question always includes an explicit "no consistent ⟨motion⟩" option.

How the answer is derived (two-step, noise-guarded)

1. Per-second trajectory. The 6-DoF track is resampled to 6 fps, swept with sliding 1-second windows (step 1 frame), and each window yields an instantaneous motion signal (direction axis / spin sign / speed / inter-object distance). Windows below an adaptive noise floor (a fraction of a high percentile of the track's own magnitude distribution — not a hand-tuned threshold) are marked inactive. Windows are binned into 1-second labels: the per_second list is the motion story.
2. Whole-video answer with an anti-overfit guard. The per-second labels are aggregated, but the answer is only solidified (decided = true) when both gates pass: the dominant label is supported by at least min_observations active bins (default 2) and accounts for more than dominance_threshold (default 80%) of the active bins. Otherwise the answer is the explicit "no consistent …" option (decided = false). The aggregation struct records dominant, dominant_frac, n_active, n_supporting, and both gate settings.

The three sources (all 6-DoF pose GT)

source	motion	timing	notes
ycbineoat	object moves, camera static	real seconds (~30fps → 6fps)	single YCB object per sequence — so no relative_motion here
hope_video	camera moves over a static multi-object tabletop	frame-index / estimated fps_native	multi-object; motion is camera-perspective parallax
bop_ycbv	camera moves, objects static	sparse, irregular BOP19 keyframes	timing is ordinal / approximate; windows with undefined or too-large Δt are skipped — the row/evidence flags this honestly

Per-source caveats to keep in mind:

• ycbineoat is the only source where motion is literally the object's own translation/rotation; the other two are camera-perspective.
• bop_ycbv frames are irregular keyframes (im_id gaps up to ~900). t is not a uniform timeline — spacing is ordinal and timing is approximate; do not read the per-second bins as exact wall-clock seconds for this source.
• BOP-HOPE is excluded: its BOP test split ships no pose ground truth, so no motion can be derived. (The hope_video source above is the HOPE-Video release, which does carry per-frame camera + object poses.)

What's in the repo

val/metadata.parquet / .jsonl   # the table (load_dataset); per_second + aggregation inline
val/metadata.csv                # browsable view (heavy per_second/evidence dropped)
frames/<source>__<seq>.zip      # the 6fps JPEG frames (rgb/000000.jpg …), one zip per sequence
                                #   (+ mask/000000.png where the source ships per-object masks)
README.md                       # this card
LICENSE.md                      # full license + attribution (mixed-provenance)

Only sequences that have shipped rows are included, and the frames are re-encoded to JPEG and downscaled (longest side ≤ 640 px) — the lossless PNG sources are ~100 MB per sequence and the model only needs to watch the 6fps video.

Row schema (val/metadata.parquet / .jsonl)

One row per Item (one MCQ over one or two tracked objects):

field	type	meaning
id	string	⟨source⟩/⟨seq⟩/⟨qa_type⟩/⟨obj⟩ (+ /vs⟨obj2⟩ for relative), unique
source	string	ycbineoat | hope_video | bop_ycbv
seq_key	string	e.g. bop_ycbv/000048
qa_type	string	motion_direction | rotation_spin | speed | relative_motion
reference_frame	string	camera | object_local | relative
object_ids	list[int]	the tracked object slot(s)
category	string	object name(s), e.g. master chef can
question / options / answer_idx / answer_text	string / list / int / string	the MCQ (answer = the aggregated whole-video decision)
per_second	string (JSON)	list of {second,t0,t1,label,active,magnitude,evidence} — the trajectory
aggregation	string (JSON)	{dominant,dominant_frac,n_active,n_supporting,min_observations,dominance_threshold,decided}
n_frames / fps	int / float	resampled clip geometry (fps = 6)
frames_zip	string	path to this sequence's frame zip in the repo
corrected	bool	the auto-derived answer was fixed by a human reviewer
verified	bool	human-verified (the publish gate)
note	string	reviewer note, if any
evidence	string (JSON)	provenance for the derivation (qa_type, timing, gate stats, trajectory, …)

per_second, aggregation, and evidence are JSON-encoded strings so their nested, per-qa_type-varying payloads survive parquet's columnar schema — json.loads to expand them. The CSV view drops per_second and evidence for browsability.

Quickstart — load_dataset

import json
from datasets import load_dataset

ds = load_dataset("livctr/bop-motion-mcq", split="val")
row = ds[0]
print(row["question"])
print(row["options"][row["answer_idx"]])

trajectory = json.loads(row["per_second"])       # per-second motion labels
agg = json.loads(row["aggregation"])             # decided? dominant? gate stats
# frames come from frames/<seq_key with '/'→'__'>.zip  (JPEGs rgb/000000.jpg …)

License & attribution

BOP-Motion-MCQ is non-commercial, research-only, and mixed-provenance. The questions/trajectories/metadata added here are the new material; each source keeps its origin license (YCBInEOAT, HOPE-Video, and YCB-Video/BOP). Per-source terms are in LICENSE.md; use of a source's frames is governed by that source's license. Any use must cite the underlying datasets (see LICENSE.md).