README.md

---
license: cc-by-sa-4.0
pretty_name: Just Zoom In Cross-View Geo-Localization Dataset
task_categories:
- image-to-image
- image-feature-extraction
- robotics
- other
language:
- en
tags:
- cross-view-geo-localization
- visual-localization
- visual-place-recognition
- image-retrieval
- computer-vision
- geolocation
- satellite-imagery
- aerial-imagery
- street-view
- mapillary
- open-data-dc
- tiledwebmaps
- autoregressive-zooming
size_categories:
- 100K<n<1M
---

# Just Zoom In Cross-View Geo-Localization Dataset
![Just Zoom In Dataset Preview](assets/justzoomin_trial_zoom.gif)

This dataset accompanies **Just Zoom In: Cross-View Geo-Localization via Autoregressive Zooming**. It supports cross-view geo-localization, where a ground-level street-view image is localized using geo-referenced overhead imagery. The dataset pairs crowd-sourced, limited-field-of-view street-view images with a multi-scale satellite/aerial tile hierarchy over Washington, D.C., making it suitable for realistic evaluation of both retrieval-based and coarse-to-fine localization methods.

The current release contains approximately 300k ground-level images over a 10 km × 10 km Washington, D.C. area, together with the corresponding multi-scale overhead tile hierarchy.

The data is stored as TAR shards to keep the Hugging Face repository manageable. After extraction, the directory layout matches the path-based PyTorch/tiledwebmaps loader used in the paper.
## Links

- 📄 Paper: [Just Zoom In: Cross-View Geo-Localization via Autoregressive Zooming](https://arxiv.org/abs/2603.25686)
- 💻 GitHub: [Official Repository](https://github.com/OSUPCVLab/justzoomin)
- 🌐 [Project Website](https://osupcvlab.github.io/just-zoom-in/)

## Motivation

Most cross-view geo-localization benchmarks are built around single-shot retrieval from fixed satellite crops. This setup is useful, but it can underrepresent key challenges of real-world localization: street-view images may have unknown orientation, limited field of view, variable image quality, and visual cues that fall outside a single overhead crop. In addition, flat retrieval databases do not explicitly expose the geographic hierarchy of maps.

This benchmark is designed to address these limitations by combining realistic crowd-sourced street-view imagery with a multi-scale overhead tile structure. It enables evaluation of methods that reason from coarse geographic context to fine local detail, including autoregressive zooming models, hierarchical search methods, and standard retrieval baselines.

## Data Sources and Licensing

This dataset contains data derived from two sources.

| Component | Source | License |
|---|---|---|
| Street-view images | Mapillary | CC BY-SA 4.0 |
| Street-view metadata derived from Mapillary imagery | Mapillary / dataset authors | CC BY-SA 4.0 |
| Aerial orthophotography / satellite tile imagery | Open Data DC / Government of the District of Columbia | CC BY 4.0 |
| Split files and derived benchmark metadata | Dataset authors | CC BY-SA 4.0 |

Because the repository contains Mapillary-derived imagery, the dataset is distributed under **CC BY-SA 4.0**.

Required source attributions:

```text
Street-view imagery derived from Mapillary, licensed under CC BY-SA 4.0.
Aerial orthophotography derived from Open Data DC / Government of the District of Columbia, licensed under CC BY 4.0.
```

License references:

- Mapillary open imagery license: https://help.mapillary.com/hc/en-us/articles/115001770409-CC-BY-SA-license-for-open-data
- CC BY-SA 4.0: https://creativecommons.org/licenses/by-sa/4.0/
- Open Data DC: https://opendata.dc.gov/
- CC BY 4.0: https://creativecommons.org/licenses/by/4.0/

Users are responsible for complying with the licenses of the underlying data sources.

## Repository Layout

```text
.
├── README.md
├── metadata/
│   ├── large_area_train_map.csv
│   └── large_area_val_map.csv
├── streetview/
│   ├── metadata_satellite_covered.csv
│   └── metadata_satellite_covered.parquet
├── satellite/
│   └── layout.yaml
└── archives/
    ├── streetview_images_000.tar
    ├── streetview_images_001.tar
    ├── streetview_images_002.tar
    ├── streetview_images_003.tar
    ├── satellite_level_0_000.tar
    ├── satellite_level_0_001.tar
    ├── ...
    ├── satellite_level_m1_000.tar
    ├── satellite_level_m2_000.tar
    └── ...
```

The archive names use `m1`, `m2`, etc. for negative satellite levels. For example, `satellite_level_m1_000.tar` contains files under `satellite/-1/`.

After extraction, the data has this structure:

```text
extracted/
├── streetview/
│   └── images/
│       ├── <image_id>_undistorted.jpg
│       └── ...
└── satellite/
    ├── layout.yaml
    ├── 0/
    ├── -1/
    ├── -2/
    ├── ...
    └── -9/
```

## Metadata

The split CSV files contain the fields used by the paper's training/evaluation loader.

| Field | Description |
|---|---|
| `image_id` | Ground-level image identifier |
| `sequence` | Ground-truth zoom-action sequence |
| `latitude` | Ground-truth latitude |
| `longitude` | Ground-truth longitude |

Ground images are named:

```text
<image_id>_undistorted.jpg
```

## Download and Extract


```python
from pathlib import Path
import shutil
import tarfile

from huggingface_hub import snapshot_download

repo_dir = Path(snapshot_download(
    repo_id="pcvlab/justzoomin",
    repo_type="dataset",
))

extract_dir = Path("./justzoomin_data")
extract_dir.mkdir(parents=True, exist_ok=True)

for tar_path in sorted((repo_dir / "archives").glob("*.tar")):
    print(f"Extracting {tar_path.name}")
    with tarfile.open(tar_path, "r") as tar:
        tar.extractall(extract_dir)

# Place the tiledwebmaps layout file beside the extracted satellite folders.
(extract_dir / "satellite").mkdir(exist_ok=True)
shutil.copy2(
    repo_dir / "satellite" / "layout.yaml",
    extract_dir / "satellite" / "layout.yaml",
)
```

## Loader Paths

After extraction, use the following paths in the paper's dataset loader:

```python
metadata_csv = repo_dir / "metadata" / "large_area_train_map.csv"
ground_root = extract_dir / "streetview" / "images"
tile_layout = extract_dir / "satellite" / "layout.yaml"
```

For validation:

```python
metadata_csv = repo_dir / "metadata" / "large_area_val_map.csv"
```

The satellite tile folders are loaded through `satellite/layout.yaml` using `tiledwebmaps`.
## Samples from the Dataset
![](assets/hf_readme_20_samples.jpg)

Each sample consists of a ground-level street-view image, its latitude/longitude, and a ground-truth zoom-action sequence over the satellite tile hierarchy. The standard task is to predict the correct overhead cell, or equivalently the zoom-action sequence, for a given street-view query. However, users are not limited to use discrete sequences, since dataset supports many different zoom levels.
## Dataset Notes

The benchmark uses limited-field-of-view, non-panoramic, crowd-sourced street-view images and a multi-scale overhead tile hierarchy. It is intended for within-area cross-view geo-localization over the Washington, D.C. region.

The data is not stored as loose image files on the Hub. The TAR shards should be extracted before using the original path-based loader.

## Citation

If you use this dataset, cite the paper:

```bibtex
@article{erzurumlu2026justzoomin,
  title={Just Zoom In: Cross-View Geo-Localization via Autoregressive Zooming},
  author={Erzurumlu, Yunus Talha and Kwag, Jiyong and Yilmaz, Alper},
  journal={arXiv preprint arXiv:2603.25686},
  year={2026}
}
```

Please also attribute the underlying data sources:

```text
Street-view imagery: Mapillary, CC BY-SA 4.0.
Aerial orthophotography: Open Data DC / Government of the District of Columbia, CC BY 4.0.
```