RoPEMover: Captured Object Relocation Dataset

This dataset is part of RoPEMover: Depth-Aware Object Relocation via Positional Embeddings (NeurIPS 2026). It holds the real photographs used for the paper's real-image fine-tuning, which comes after training on the synthetic CLEVR-10k data.

Project page · Paper (arXiv) · Code · Synthetic data: CLEVR-10k

There are 166 real before/after photo pairs of indoor scenes. Each pair shows one everyday object (toys, vases, bottles, books and so on) physically moved to a new place, with the camera fixed. Each sample includes:

• object masks in both images
• a text instruction
• the 2D drag vector and the change in apparent scale
• monocular depth maps for both images

The pairs were augmented by re-pairing photos of the same scene. Some samples are reversed pairs, where the target becomes the source, and others combine two different captures of the scene. So the same photo can appear in more than one sample.

Repository layout

source/        {idx}.png   source (before-edit) photo, RGB, full resolution
target/        {idx}.png   target (after-edit) photo, RGB, same resolution as source
mask_source/   {idx}.png   binary mask of the object in the source photo (L, white = object)
mask_target/   {idx}.png   binary mask of the object in the target photo (L, white = object)
depth_source/  {idx}.npy   depth of the source photo, float32 (512, 512), normalized to [1, 2]
depth_target/  {idx}.npy   depth of the target photo, float32 (512, 512), normalized to [1, 2]
metadata_qwen_train.json   all 166 samples (idx 0-165)
drag_metadata.json         per-sample drag vector, depth offset and scale change, keyed by "{idx}.png"

All files that share an {idx} belong to the same sample. The photos are full resolution and square in most cases: 3024², 4284², 5712², 6048², or 4032×3024. Each sample's size is stored in original_size. All image metadata (EXIF, including location) has been removed.

Metadata format

metadata_qwen_train.json is a JSON list. Paths are relative to the repository root:

{
  "image": "target/0.png",
  "edit_image": ["source/0.png", "mask_source/0.png"],
  "prompt": "The yellow LEGO school bus was moved from the bottom right of the table to a position more centrally located, just above the stack of books. The likely command is: \"Move the yellow LEGO bus to the left and up.\"",
  "depth_path": "depth_target/0.npy",
  "source_depth_path": "depth_source/0.npy",
  "original_size": [4284, 4284]
}

• image: the edit target (ground truth).
• edit_image: the conditioning inputs, [source photo, source object mask].
• prompt: an edit instruction generated by a vision-language model (Qwen3-VL-8B-Instruct) from the image pair. Most prompts are short commands such as "Move the vase down and to the right." Some also include a short description of the change.
• depth_path / source_depth_path: depth maps of the target and source photos.
• original_size: [W, H] of the full-resolution photo. The drag vectors in drag_metadata.json are measured in these pixel units. Rescale them by train_size / original_size when training at a lower resolution.

drag_metadata.json:

"0.png": {"x": -1038.57, "y": -1386.83, "z": 0.349, "scale_label": "smaller", "scale_value": 0.647}

• x, y: shift of the object's mask centroid from source to target, in full-resolution pixels, in image coordinates (y points down).
• z: depth offset of the object. The MoGe target depth is affine-aligned to the source depth using background pixels, and z is the median target object depth minus the median source object depth (positive means the object moved away from the camera). This is an auxiliary value. The RoPEMover training code reads only x, y and scale_value.
• scale_value: sqrt(target_mask_area / source_mask_area), computed with both masks resized to 512×512.
• scale_label: larger / smaller if scale_value differs from 1 by more than 15%, otherwise same (with scale_value set to 1.0). Counts: same 57, larger 56, smaller 53.

Depth maps

Depth was estimated with MoGe-2 (Ruicheng/moge-2-vitl-normal) on each photo resized to 512×512. Infinite values are replaced with the maximum finite depth.

Each depth map is min-max normalized per image to the range [1, 2]:

depth_norm = (depth - depth.min()) / (depth.max() - depth.min() + 1e-8)
depth      = depth_norm + 1.0          # values in [1, 2]

Because the normalization is done per image, depth values are relative and not metric. They are not directly comparable between the source and target of a sample, or across samples. The maps are 512×512 and should be resized to the image resolution you train at. Raw (metric) MoGe outputs are not included.

Loading

import json, numpy as np
from PIL import Image
from huggingface_hub import snapshot_download

root = snapshot_download("ipekoztas/ropemover", repo_type="dataset")
data = json.load(open(f"{root}/metadata_qwen_train.json"))
drag = json.load(open(f"{root}/drag_metadata.json"))

s = data[0]
target = Image.open(f"{root}/{s['image']}")
source, mask = (Image.open(f"{root}/{p}") for p in s["edit_image"])
depth_src = np.load(f"{root}/{s['source_depth_path']}")   # (512, 512) float32 in [1, 2]
d = drag["0.png"]                                          # x, y in original_size pixels

License

Released under CC BY 4.0.

Citation

If you use this dataset, please cite:

@inproceedings{oztas2026ropemover,
  title={RoPEMover: Depth-Aware Object Relocation via Positional Embeddings},
  author={Oztas, Ipek and Ceylan, Duygu and Aksoy, Aybars Bugra and Dundar, Aysegul},
  booktitle={Advances in Neural Information Processing Systems (NeurIPS)},
  year={2026}
}