Add files using upload-large-folder tool

.gitattributes

@@ -1,60 +1,14 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
+# Hugging Face LFS — managed by `passage export`. Edit by regenerating with --force-gitattributes.
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
+*.npy.zst filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+256x256/dataset.ipynb filter=lfs diff=lfs merge=lfs -text
+2048x2048/dataset.ipynb filter=lfs diff=lfs merge=lfs -text
+4096x4096/dataset.ipynb filter=lfs diff=lfs merge=lfs -text
+512x512/dataset.ipynb filter=lfs diff=lfs merge=lfs -text
+1024x1024/dataset.ipynb filter=lfs diff=lfs merge=lfs -text

1024x1024/dataset.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e215650d9e8ba4826fe81ab7a50f532832b608213a02965a29ef680b2cf8f50
+size 25106480

128x128_samples/calibration/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75d329f076d749b5b468c7a69d8e9725c7d576b29e92d837259c6b8afed0c0d6
+size 4387435

128x128_samples/test/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c111f3a7bb1207da77864c68fb3f6858f9588552cae82e35e8b54a2cc64c998a
+size 4882875

128x128_samples/train/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adfd7756580df68705034160c45343b5678e379b9d38c88598b1a04ea58e00b3
+size 4647544

128x128_samples/validation/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5fc6df21092cb8ed1a014d38ce66e0b00829e1948bbc450e02c88b80c2d3b24f
+size 4221782

2048x2048/dataset.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f97c38619bd24e7e54fc64fa83c499501404053081c5a76c8db16f6f60dc1687
+size 23181539

256x256/dataset.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99fe9dccbce8a9bae640e9886b77a957a7cf058a953acca27febfc0a5e245031
+size 18419272

256x256_samples/calibration/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8be604ceabe8f649339c0d24ff2d2bbd4a1099073f2d9c8fd7d1a23c846cec47
+size 14654757

256x256_samples/test/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9eb4d85bf1b42a83215362daf0b198500a0fdbb5ab380321260a9df47d16ff75
+size 16033785

256x256_samples/train/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:963b3141e75c82e75385beebd720d557946f2d287c94e231b0c852ab41ecb0a5
+size 14356660

256x256_samples/validation/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7467fa3c4ab3be11eea39b9dbafb81e905244187b56628cb78fdc637d348b638
+size 15008854

4096x4096/dataset.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fa33ca415026055e2ce28e32a92737bfaab2de8a098edd0cd720559282db8db
+size 20276890

512x512/dataset.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8786f7b1d957ee7e468eb694ba8ddfa2a57d4cb6763de7a1d06a1b266e6efb1
+size 24362766

64x64/train/data-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c685f373a9b8ff1bb3e69807db6d0f4c58fc8a0b282500bf8967f1c2492944c7
+size 157789130

64x64/train/data-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9431fc2366a2656d92bbc42e4934cfb357e7ca687a5503fb781733b09065d48
+size 158705668

64x64/train/data-00003.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8b8a85ba8d8f4419f470d85c59c8fe72c3e6bb50142b93160c4d25d9ab3ea29
+size 159006606

64x64/train/data-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f43c3ad4542fafe216aa836476ac9ec58333573ce775dff4d121553aff35b57c
+size 158509016

64x64/train/data-00007.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56ddb747bcfd09997bfa2c3848ebf90ed7bc81281653eabf97bc41b938b4be60
+size 158187630

64x64/train/data-00011.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1870f83872d7bb68792efaf2a86edcea5f1b7aaf363dcd279d566e6181e0dc5c
+size 158385064

64x64/train/data-00014.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a4c55b95c1ef1ee751e47e2974038bc5207b98aae03a9f76d199b6e52e05f7b
+size 157815831

64x64/train/data-00019.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aaf66fbdd11aef7df887e2277e092b1b17de7b12a25f117b5e5c78aafb4fdaff
+size 157704328

64x64/train/data-00024.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c51d69d546bf8a4d658fa7c631c1a9c0ebd1650452b887fe973e3a24e2f3e3ff
+size 158089171

64x64/train/data-00039.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40b84b7d18290ff7514a02ad2515189007e929c5d5bdd0313a65ae42b74c3191
+size 158153853

64x64/train/data-00043.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc346b4cfe76ee22f6e528c4a322ceac2acaa7120aee211a5853c349edbc67c2
+size 157898612

64x64_samples/calibration/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:180cc0a0546b083f3ee38ea98866956fb246259fcd896f360e620286081d1c3b
+size 1478003

64x64_samples/test/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b820a51627578357c25a932a697c60b00a2ab3d3c43c7cb3d9f95946e1c4e10
+size 1592634

64x64_samples/train/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75563398275d5d6d234db931bbf718c6f7fdda8ebba975aa0b1c774586ded51f
+size 1464420

64x64_samples/validation/data-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a88a84c65d927eb00f536310503d2097294c98b119779c836ee0316e25f7edcb
+size 1442910

CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## Unreleased
+
+### Added
+
+- Deterministic per-sample generation seeding via `generation.seed`, with recorded `generation_seed` and `sample_seed` provenance in sample metadata.
+- Repository release metadata files: `CITATION.cff`, `DATASHEET.md`, `croissant.json`, and `Makefile`.
+- `make manifest` workflow for writing `outputs/export/manifest.sha256` from a prepared export tree.
+- `DATASET_LICENSE.md` to document the dataset-side JAXA AW3D30 obligations separately from the MIT code license.
+
+### Changed
+
+- Corrected public documentation to reflect the default 14,130-sample benchmark size and the current reproducibility contract.
+- Exposed deterministic-generation provenance in the export schema used for Hugging Face parquet preparation.
+- Restored `config/config.yaml` to the 14,130-sample paper benchmark and aligned preview-image defaults with the sample export settings.
+- Made `passage export` stage release metadata files into the export tree, with anonymous submission copies available via `--anonymous`.

CITATION.cff

@@ -0,0 +1,26 @@
+cff-version: 1.2.0
+title: PASSAGE
+message: If you use PASSAGE, please cite the anonymous submission mirror and the accompanying dataset metadata.
+type: software
+authors:
+  - family-names: Anonymous
+    given-names: Authors
+version: 0.1.0
+date-released: 2026-03-30
+license: MIT
+repository-code: https://huggingface.co/datasets/thalesgroup/passage
+url: https://huggingface.co/datasets/thalesgroup/passage
+keywords:
+  - pathfinding
+  - terrain-routing
+  - benchmark
+  - digital-elevation-model
+  - dataset
+preferred-citation:
+  type: article
+  title: "PASSAGE anonymous submission mirror"
+  authors:
+    - family-names: Anonymous
+      given-names: Authors
+  year: 2026
+  url: https://huggingface.co/datasets/thalesgroup/passage

DATASET_LICENSE.md

@@ -0,0 +1,19 @@
+# PASSAGE Dataset Terms
+
+PASSAGE ships two distinct licensing surfaces:
+
+- The generator code in this repository is released under the MIT license in `LICENSE`.
+- The exported dataset artifacts inherit obligations from the upstream JAXA ALOS AW3D30 elevation product used to derive the terrain channel.
+
+For dataset artifacts distributed on Hugging Face and in release bundles:
+
+- Preserve attribution to JAXA ALOS World 3D - 30m (AW3D30) and any other provenance notices carried in the metadata.
+- Do not represent the derived elevation-backed artifacts as public domain.
+- Comply with the upstream AW3D30 usage terms for any redistribution or downstream reuse of the derived terrain data.
+- Treat PASSAGE as a research benchmark, not a safety-of-life product. The dataset and generated paths do not certify operational deployment.
+
+When in doubt:
+
+- Use `LICENSE` for code questions.
+- Use this file plus `DATASHEET.md` for dataset-distribution questions.
+- Preserve both files when mirroring the release tree.

DATASHEET.md

@@ -0,0 +1,191 @@
+# PASSAGE Datasheet
+
+This Datasheet follows the Gebru et al. [*Datasheets for Datasets*](https://arxiv.org/abs/1803.09010) template and is mirrored in the companion Croissant metadata file (`croissant.json`, conforming to MLCommons Croissant 1.1 and Croissant RAI 1.0). It accompanies the NeurIPS 2026 Evaluations & Datasets Track submission of the PASSAGE benchmark.
+
+## Motivation
+
+### For what purpose was the dataset created?
+
+PASSAGE was created to close a reproducibility gap in *constrained path planning on real terrain*: existing benchmarks either synthesize grids that strip geographic structure, rely on ad-hoc GIS workflows without machine-learning-ready splits, or evaluate embodied perception rather than cost-aware long-horizon routing. PASSAGE provides a real-terrain, multi-resolution benchmark with an enumerable Operational Design Domain (ODD), configurable terrain cost models, procedural obstacles, and exact A* ground-truth labels — packaged as ML-ready Parquet shards with a manifest-checked release tree.
+
+### Who created this dataset and on behalf of which entity?
+
+The dataset is released for double-blind review as an anonymous submission artifact. Attribution is intentionally withheld in this mirror and restored at camera-ready.
+
+### Who funded the creation of the dataset?
+
+Anonymous institutional research funding. No external grant is associated with this release.
+
+## Composition
+
+### What do the instances represent?
+
+Each instance is a single path-planning problem on a terrain crop: a three-channel input tensor (elevation, start/goal markers, obstacle mask) at a chosen resolution `N`, plus path annotations (ordered `(row, col)` waypoint lists under each configured cost model), a binary `N×N` path mask per cost model, and structured metadata (source tile, crop bounds, resolution, cost model, weight, obstacle configuration, split, solver backend, path cost, path length, solver wall-clock, seeds).
+
+### How many instances are there?
+
+The default release emits **14,130 samples** across seven resolutions (64, 128, 256, 512, 1024, 2048, 4096). Per-resolution, per-split counts are recorded in `outputs/paper/results/dataset_statistics.csv` and reported in Table 2 of the paper.
+
+### Does the dataset contain all possible instances or is it a sample?
+
+PASSAGE is a deterministically seeded *sample* from an enumerable parameter space. Without obstacles, the ODD is finite and fully enumerable: every `(tile, crop, resolution, cost model, weight, start, goal)` maps deterministically to a unique sample. Additional samples can be generated at will with `make rebuild`.
+
+### What data does each instance consist of?
+
+- `elevation`: real-valued, normalized against globally calibrated min/max.
+- `markers`: binary start/goal channels.
+- `obstacles`: binary forbidden-cell mask (optional; the free-terrain variant is `obstacles=0`).
+- `path_waypoints_<cost_model>`: ordered `(row, col)` pairs.
+- `path_mask_<cost_model>`: binary `N×N`.
+- `metadata`: structured provenance (see Croissant `record_set.metadata`).
+
+### Is there a label or target associated with each instance?
+
+Yes — reference paths under each cost model. Paths are *computational annotations* produced by the A* solver (grid backend, Numba-JIT), not human annotations. There are no ambiguous or missing labels by construction.
+
+### Is any information missing from individual instances?
+
+No; every sample is fully populated by the generator. Upstream AW3D30 tiles may carry sensor artifacts (voids, striping); affected samples are flagged in metadata via the source-tile identifier and, where relevant, the elevation calibration bounds.
+
+### Are relationships between individual instances made explicit?
+
+Yes: samples inherit the `source_tile_id` and `split` fields from their source AW3D30 tile. The geographic hold-out split policy (`split_mask` at 1°/pixel) is versioned alongside the generator configuration.
+
+### Are there recommended data splits?
+
+Yes — the default split is 90% train / 2% calibration / 4% validation / 4% test, with a *geographic hold-out* for test (entire 1°×1° source tiles are reserved for test; no source tile appears in both train and test).
+
+### Are there any errors, sources of noise, or redundancies?
+
+The elevation product inherits JAXA ALOS AW3D30 sensor characteristics (DSM error bounds documented upstream). Path annotations are exact under the documented cost model — no stochastic error. Procedural obstacles are abstractions of real hazards and are not validated against real-world obstacle maps.
+
+### Is the dataset self-contained, or does it link to other resources?
+
+Fully self-contained at the export stage. Raw AW3D30 tiles are re-derivable via `make download` but not shipped in the release.
+
+### Does the dataset contain confidential, personally identifiable, sensitive, or offensive information?
+
+No. PASSAGE contains no personal data, no biometric data, and no human subjects. Offensive content is not possible in this domain.
+
+## Collection Process
+
+### How was the data acquired?
+
+Raw elevation tiles are downloaded from the public JAXA ALOS AW3D30 archive (5°×5° packaging) and extracted into 1°×1° sub-tiles at native 30 m/pixel resolution. A global calibration pass computes elevation min/max across the local tile cache. For each requested `(resolution, sample_idx, split)` triple, a deterministic `blake2b` seed drives tile selection, crop placement, start/goal placement, obstacle synthesis, and cost-weight draw. Reference paths are solved with the Numba-JIT grid-backend A* under each configured cost model (see `src/passage/pathfinding_utils.py`).
+
+### What mechanisms or procedures were used to collect the data?
+
+Code-driven pipeline end-to-end (see `Makefile` and `config/config.yaml`). No crowdsourcing, no human annotators, no subject interaction.
+
+### Was any preprocessing, cleaning, or labeling done?
+
+- Elevation normalised against globally calibrated min/max.
+- Markers placed subject to obstacle-exclusion and minimum separation.
+- Obstacle masks synthesised from log-uniform super-ellipse parameters, rejected if coverage exceeds 30% after up to 50 placement attempts.
+- Paths solved with exact A* under the configured cost model and the 8-connected grid (step lengths 30 m and 30√2 m).
+
+### Was the "raw" data saved in addition to the preprocessed data?
+
+Yes — the upstream AW3D30 archive and the calibrated tile cache are persisted locally under `/data/PASSAGE/download/` and `/data/PASSAGE/calibrate/` respectively. Only the processed export (Parquet shards) is distributed.
+
+### Is the software available for the preprocessing?
+
+Yes — the full generator is open-source in this repository (`src/passage/`), with CI coverage and an end-to-end rebuild via `make rebuild`.
+
+## Uses
+
+### Has the dataset been used for any tasks already?
+
+Yes — PASSAGE is the primary benchmark for the downstream `passage-vision` workspace, which reports dense-field segmentation and cost-to-go regression baselines at the 256×256 operating point, plus a 64→4096 resolution-frontier study.
+
+### What (other) tasks could the dataset be used for?
+
+- Benchmarking classical path-planning algorithms (Dijkstra, Theta*, D\*, JPS) on real terrain.
+- Training and evaluating graph-neural planners and RL planners in bridge comparisons.
+- Studying multi-resolution scaling, geographic distribution shift, and cost-function transfer in dense prediction.
+- Reproducible cost-model design studies with physically interpretable terms.
+
+### Is there anything about the composition of the dataset or the way it was collected that might impact future uses?
+
+- Samples are grid-based; they do not support full 3D motion planning or dynamic environments.
+- Obstacles are synthetic. Conclusions about real-world obstacle distributions cannot be drawn directly.
+- Geographic coverage is bounded by AW3D30 availability.
+
+### Are there tasks for which the dataset should not be used?
+
+- **Operational airborne flight planning or search-and-rescue dispatch**: PASSAGE is an advisory research benchmark. It does not by itself validate safety-critical deployment and does not substitute for EASA/FAA certification processes.
+- **Conclusions about weather, airspace, vegetation, urban structures, or regulations**: out of scope.
+- **Safety-of-life decisions**: predicted paths are not safety-of-life outputs without an in-the-loop deterministic verifier and fallback solver.
+
+## Distribution
+
+### Will the dataset be distributed to third parties?
+
+Yes — the dataset is distributed via Hugging Face (`https://huggingface.co/datasets/thalesgroup/passage`). This mirror is configured for anonymous NeurIPS 2026 review.
+
+### How will it be distributed?
+
+Parquet shards, zstandard-compressed, one file per resolution × split. Accompanied by:
+
+- `croissant.json` (MLCommons 1.1 + RAI 1.0).
+- `outputs/export/manifest.sha256` checksum manifest.
+- README on Hugging Face mirroring the GitHub README.
+- `CITATION.cff`, `CHANGELOG.md`, `LICENSE`, this Datasheet.
+
+### When will it be distributed?
+
+Version 0.1.0 is released with the NeurIPS 2026 submission (May 2026). Future versions follow semantic versioning in `CHANGELOG.md`.
+
+### Will the dataset be distributed under a license? Will it have an associated DOI?
+
+- Code: MIT (see `LICENSE`).
+- Dataset: distributed under `DATASET_LICENSE.md`, which documents the inherited JAXA ALOS AW3D30 obligations for the derived artifacts.
+- A Zenodo DOI is planned for the v1.0 release (camera-ready gate) and will be recorded in `CITATION.cff`.
+
+### Have any third parties imposed IP-based or other restrictions?
+
+JAXA ALOS AW3D30 usage terms are inherited by the derived elevation channel. Users of PASSAGE must comply with the upstream JAXA terms, including attribution.
+
+### Do any export controls or other regulatory restrictions apply?
+
+No export controls apply; AW3D30 is a public global elevation product.
+
+## Maintenance
+
+### Who is supporting / hosting / maintaining the dataset?
+
+Anonymous submission mirror maintained for peer review. Contact details are withheld until de-anonymisation.
+
+### How can the owner be contacted?
+
+Contact details are intentionally withheld in the anonymous submission mirror.
+
+### Is there an erratum?
+
+Errata will be tracked in `CHANGELOG.md`. Breaking schema changes bump the minor or major version and invalidate prior manifest checksums.
+
+### Will the dataset be updated?
+
+Yes. Updates are published via Hugging Face with a corresponding semantic-version tag in this repository and an entry in `CHANGELOG.md`.
+
+### If the dataset relates to people: are there applicable limits on the retention of the data associated with the instances?
+
+Not applicable — no human subjects.
+
+### Will older versions of the dataset continue to be supported/hosted/maintained?
+
+Prior releases remain accessible via their Hugging Face dataset-repo commit SHA and the git tag on GitHub. Deprecations are announced in `CHANGELOG.md`. The deprecation policy: one-minor-version notice, with `rai:dataReleaseMaintenancePlan` documenting active supported versions.
+
+### If others want to extend / augment / build on / contribute to the dataset, is there a mechanism for them to do so?
+
+Yes — pull requests are welcomed (see `CONTRIBUTING.md` and `CODE_OF_CONDUCT.md`). Contributions that change data semantics require a Croissant update and a Datasheet-section review.
+
+---
+
+## Lifecycle Statement (NeurIPS 2026 E&D track requirement)
+
+- **Status**: active.
+- **Versioning**: semantic; authoritative source is `CITATION.cff` `version` and `croissant.json` `version`.
+- **Maintenance owner**: anonymous submission mirror maintainers; de-anonymised ownership is restored at camera-ready.
+- **Deprecation policy**: prior minor version remains supported for at least one subsequent minor release; deprecations announced in `CHANGELOG.md` and the Hugging Face dataset README.
+- **Security contact**: see `SECURITY.md`.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 THALES
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

croissant.json

@@ -0,0 +1,452 @@
+{
+  "@context": {
+    "@language": "en",
+    "@vocab": "https://schema.org/",
+    "cr": "http://mlcommons.org/croissant/",
+    "dct": "http://purl.org/dc/terms/",
+    "extract": "cr:extract",
+    "field": "cr:field",
+    "fileObject": "cr:FileObject",
+    "fileSet": "cr:FileSet",
+    "includes": "cr:includes",
+    "rai": "http://mlcommons.org/croissant/RAI/",
+    "recordSet": "cr:recordSet",
+    "sc": "https://schema.org/",
+    "source": "cr:source"
+  },
+  "@id": "https://huggingface.co/datasets/thalesgroup/passage",
+  "@type": "sc:Dataset",
+  "name": "PASSAGE",
+  "description": "PASSAGE is a multi-resolution terrain-routing benchmark generated from JAXA ALOS AW3D30 elevation data. The default benchmark exports 14,130 samples across 64x64 to 4096x4096 resolutions, with deterministic split assignment and deterministic per-sample seeding for tile selection, crop placement, marker placement, and obstacle synthesis.",
+  "url": "https://huggingface.co/datasets/thalesgroup/passage",
+  "version": "0.1.0",
+  "license": "https://huggingface.co/datasets/thalesgroup/passage/blob/main/DATASET_LICENSE.md",
+  "keywords": [
+    "pathfinding",
+    "terrain routing",
+    "digital elevation model",
+    "benchmark",
+    "remote sensing"
+  ],
+  "datePublished": "2026-03-30",
+  "creator": [
+    {
+      "@type": "sc:Person",
+      "name": "Anonymous Authors"
+    }
+  ],
+  "dct:conformsTo": [
+    {
+      "@id": "http://mlcommons.org/croissant/1.1"
+    },
+    {
+      "@id": "http://mlcommons.org/croissant/RAI/1.0"
+    }
+  ],
+  "distribution": [
+    {
+      "@id": "hf-passage-tree",
+      "@type": "cr:FileObject",
+      "name": "Hugging Face PASSAGE dataset repository tree",
+      "contentUrl": "https://huggingface.co/datasets/thalesgroup/passage/tree/main"
+    },
+    {
+      "@id": "passage-full-parquet",
+      "@type": "cr:FileSet",
+      "name": "PASSAGE full parquet shards",
+      "description": "All full PASSAGE parquet configs from 64x64 through 4096x4096.",
+      "containedIn": {
+        "@id": "hf-passage-tree"
+      },
+      "encodingFormat": "application/x-parquet",
+      "includes": [
+        "64x64/**/*.parquet",
+        "128x128/**/*.parquet",
+        "256x256/**/*.parquet",
+        "512x512/**/*.parquet",
+        "1024x1024/**/*.parquet",
+        "2048x2048/**/*.parquet",
+        "4096x4096/**/*.parquet"
+      ]
+    },
+    {
+      "@id": "passage-sample-parquet",
+      "@type": "cr:FileSet",
+      "name": "PASSAGE sample parquet shards",
+      "description": "Sample PASSAGE parquet configs with per-solver preview images.",
+      "containedIn": {
+        "@id": "hf-passage-tree"
+      },
+      "encodingFormat": "application/x-parquet",
+      "includes": [
+        "64x64_samples/**/*.parquet",
+        "128x128_samples/**/*.parquet",
+        "256x256_samples/**/*.parquet",
+        "512x512_samples/**/*.parquet",
+        "1024x1024_samples/**/*.parquet",
+        "2048x2048_samples/**/*.parquet",
+        "4096x4096_samples/**/*.parquet"
+      ]
+    }
+  ],
+  "recordSet": [
+    {
+      "@id": "passage-full-records",
+      "@type": "cr:RecordSet",
+      "name": "PASSAGE full parquet records",
+      "description": "Rows from the non-sample PASSAGE parquet exports.",
+      "containedIn": {
+        "@id": "passage-full-parquet"
+      },
+      "field": [
+        {
+          "@id": "passage-full/id",
+          "@type": "cr:Field",
+          "name": "id",
+          "description": "Zero-padded sample identifier.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "id"
+            }
+          }
+        },
+        {
+          "@id": "passage-full/tensor",
+          "@type": "cr:Field",
+          "name": "tensor",
+          "description": "Compressed binary tensor storing normalized elevation, markers, and obstacles.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "tensor"
+            }
+          }
+        },
+        {
+          "@id": "passage-full/path-astar-elevation-free",
+          "@type": "cr:Field",
+          "name": "path_astar_elevation_free",
+          "description": "Pixel path for the free-terrain astar_elevation annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "path_astar_elevation_free"
+            }
+          }
+        },
+        {
+          "@id": "passage-full/path-astar-elevation-obstacles",
+          "@type": "cr:Field",
+          "name": "path_astar_elevation_obstacles",
+          "description": "Pixel path for the obstacle-aware astar_elevation annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "path_astar_elevation_obstacles"
+            }
+          }
+        },
+        {
+          "@id": "passage-full/path-astar-energy-free",
+          "@type": "cr:Field",
+          "name": "path_astar_energy_free",
+          "description": "Pixel path for the free-terrain astar_energy annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "path_astar_energy_free"
+            }
+          }
+        },
+        {
+          "@id": "passage-full/path-astar-energy-obstacles",
+          "@type": "cr:Field",
+          "name": "path_astar_energy_obstacles",
+          "description": "Pixel path for the obstacle-aware astar_energy annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "path_astar_energy_obstacles"
+            }
+          }
+        },
+        {
+          "@id": "passage-full/path-astar-slope-free",
+          "@type": "cr:Field",
+          "name": "path_astar_slope_free",
+          "description": "Pixel path for the free-terrain astar_slope annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "path_astar_slope_free"
+            }
+          }
+        },
+        {
+          "@id": "passage-full/path-astar-slope-obstacles",
+          "@type": "cr:Field",
+          "name": "path_astar_slope_obstacles",
+          "description": "Pixel path for the obstacle-aware astar_slope annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "path_astar_slope_obstacles"
+            }
+          }
+        },
+        {
+          "@id": "passage-full/metadata",
+          "@type": "cr:Field",
+          "name": "metadata",
+          "description": "Structured sample metadata including split, resolution, crop geometry, solver settings, timing, and deterministic provenance.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-full-parquet"
+            },
+            "extract": {
+              "column": "metadata"
+            }
+          }
+        }
+      ]
+    },
+    {
+      "@id": "passage-sample-records",
+      "@type": "cr:RecordSet",
+      "name": "PASSAGE sample parquet records",
+      "description": "Rows from the PASSAGE sample parquet exports with preview images.",
+      "containedIn": {
+        "@id": "passage-sample-parquet"
+      },
+      "field": [
+        {
+          "@id": "passage-sample/id",
+          "@type": "cr:Field",
+          "name": "id",
+          "description": "Zero-padded sample identifier.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "id"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/image-astar-elevation",
+          "@type": "cr:Field",
+          "name": "image_astar_elevation",
+          "description": "Preview image rendered for the astar_elevation solver.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "image_astar_elevation"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/image-astar-energy",
+          "@type": "cr:Field",
+          "name": "image_astar_energy",
+          "description": "Preview image rendered for the astar_energy solver.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "image_astar_energy"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/image-astar-slope",
+          "@type": "cr:Field",
+          "name": "image_astar_slope",
+          "description": "Preview image rendered for the astar_slope solver.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "image_astar_slope"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/tensor",
+          "@type": "cr:Field",
+          "name": "tensor",
+          "description": "Compressed binary tensor storing normalized elevation, markers, and obstacles.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "tensor"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/path-astar-elevation-free",
+          "@type": "cr:Field",
+          "name": "path_astar_elevation_free",
+          "description": "Pixel path for the free-terrain astar_elevation annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "path_astar_elevation_free"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/path-astar-elevation-obstacles",
+          "@type": "cr:Field",
+          "name": "path_astar_elevation_obstacles",
+          "description": "Pixel path for the obstacle-aware astar_elevation annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "path_astar_elevation_obstacles"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/path-astar-energy-free",
+          "@type": "cr:Field",
+          "name": "path_astar_energy_free",
+          "description": "Pixel path for the free-terrain astar_energy annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "path_astar_energy_free"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/path-astar-energy-obstacles",
+          "@type": "cr:Field",
+          "name": "path_astar_energy_obstacles",
+          "description": "Pixel path for the obstacle-aware astar_energy annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "path_astar_energy_obstacles"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/path-astar-slope-free",
+          "@type": "cr:Field",
+          "name": "path_astar_slope_free",
+          "description": "Pixel path for the free-terrain astar_slope annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "path_astar_slope_free"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/path-astar-slope-obstacles",
+          "@type": "cr:Field",
+          "name": "path_astar_slope_obstacles",
+          "description": "Pixel path for the obstacle-aware astar_slope annotation.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "path_astar_slope_obstacles"
+            }
+          }
+        },
+        {
+          "@id": "passage-sample/metadata",
+          "@type": "cr:Field",
+          "name": "metadata",
+          "description": "Structured sample metadata including split, resolution, crop geometry, solver settings, timing, and deterministic provenance.",
+          "source": {
+            "fileSet": {
+              "@id": "passage-sample-parquet"
+            },
+            "extract": {
+              "column": "metadata"
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "rai:dataCollection": "Observational JAXA ALOS AW3D30 digital surface model tiles combined with deterministic procedural obstacle synthesis and solver-generated path annotations.",
+  "rai:dataCollectionType": [
+    "observational",
+    "synthetic",
+    "computational annotation"
+  ],
+  "rai:dataCollectionRawData": "Raw source tiles are downloaded from JAXA ALOS AW3D30 5x5 degree archives; PASSAGE generation operates on 1x1 degree 3600x3600 sub-tiles at approximately 30 meters per pixel.",
+  "rai:dataPreprocessingProtocol": [
+    "Calibrate global elevation minima and maxima over the local DSM cache.",
+    "Use deterministic per-sample seeding to choose a target elevation, tile, crop, and markers.",
+    "Optionally synthesize superellipse obstacles under the configured coverage and size limits.",
+    "Solve reference paths with the configured astar_elevation, astar_energy, and astar_slope solvers, with and without obstacles.",
+    "Export tensors, metadata, CSV paths, preview images, notebooks, and parquet shards."
+  ],
+  "rai:dataAnnotationProtocol": "Reference paths are computational annotations produced by the configured pathfinding solvers over the generated terrain crops and obstacle masks.",
+  "rai:dataReleaseMaintenancePlan": "Releases are versioned in CHANGELOG.md, regenerated through the repository Makefile, and verified with outputs/export/manifest.sha256.",
+  "rai:personalSensitiveInformation": "none",
+  "rai:dataBiases": [
+    "Coverage and elevation fidelity are limited by the underlying AW3D30 product and the chosen download footprint.",
+    "Terrain-only routing omits weather, airspace, vegetation, built structures, and operational constraints."
+  ],
+  "rai:dataLimitations": [
+    "Procedural obstacle masks are abstractions rather than measured hazards.",
+    "Deterministic generation covers sample content; runtime timestamps remain informational metadata."
+  ],
+  "rai:dataUseCases": [
+    "Benchmark terrain-aware path planners.",
+    "Train and evaluate learned routing surrogates in vision, graph, and reinforcement-learning settings.",
+    "Study reproducibility and geographic hold-out generalization across resolutions."
+  ],
+  "rai:dataSocialImpact": "PASSAGE is intended for research and evaluation of routing methods in safety-relevant terrain settings. It is not a certified operational navigation product.",
+  "rai:annotationsPerItem": "Every sample carries exactly one ordered path annotation per configured cost model (default: astar_elevation, astar_energy, astar_slope) and, where applicable, per obstacle variant (free-terrain and obstacle-aware). No multi-annotator redundancy.",
+  "rai:annotatorDemographics": "Not applicable: annotations are produced exclusively by the Numba-JIT A* grid solver documented in src/passage/pathfinding_utils.py. No human annotators were involved.",
+  "rai:dataAnnotationAnalysis": "Annotations are exact under the documented cost model and are validated by construction (same solver, same heuristic, same connectivity). Consistency is enforced by deterministic seeding and by the outputs/export/manifest.sha256 checksum file bundled with each release.",
+  "rai:dataAnnotationPlatform": "None: annotations are computational. Generation is driven by the Makefile targets in this repository, executed on CPU with optional GPU used only by downstream baselines, not by dataset generation.",
+  "rai:machineAnnotationTools": [
+    "Numba-JIT grid-backend A* implemented in src/passage/pathfinding_utils.py",
+    "Deterministic blake2b per-sample seed derivation documented in src/passage/seeds.py"
+  ],
+  "rai:dataImpactAssessment": "The dataset is an elevation-derived research benchmark with no personal or biometric content; residual risk is limited to misuse of reference paths as safety-critical navigation outputs outside an in-the-loop deterministic verifier. This risk is mitigated by the scope statement in the Datasheet and by the SECURITY.md misuse disclosure.",
+  "rai:safetyOfLifeStatement": "PASSAGE is an advisory research benchmark. Predicted paths are not safety-of-life outputs without an in-the-loop deterministic verifier and fallback solver, and the dataset does not substitute for system-level verification or EASA/FAA-style certification evidence.",
+  "rai:citation": "Delhomme, G., Trap, F., Kaakai, F. PASSAGE: A Real-Terrain Multi-Resolution Benchmark for Constrained Path Planning. NeurIPS 2026 Evaluations & Datasets Track (submission)."
+}

notebooks/astar_inference_timing.ipynb

@@ -0,0 +1,505 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# A* Solver Inference Timing Benchmark\n",
+    "\n",
+    "Systematic measurement of A* solver inference time across resolutions.\n",
+    "These timings serve as the **exact solver reference** for comparing neural surrogate speedup ratios\n",
+    "in the PASSAGE NeurIPS paper.\n",
+    "\n",
+    "**Resolutions:** 64x64, 256x256\n",
+    "<!-- TODO:RESOLUTION_UPDATE: add 128x128, 512x512, 1024x1024, 2048x2048, 4096x4096 -->\n",
+    "\n",
+    "**Solver backends:**\n",
+    "- `grid:astar` (Numba JIT, our fastest solver — the one used for ground truth generation)\n",
+    "- `grid:dijkstra` (Numba JIT, for comparison)\n",
+    "- `networkx:astar` (pure Python, for baseline comparison)\n",
+    "\n",
+    "**Metrics:**\n",
+    "- Mean solve time (ms)\n",
+    "- Std deviation\n",
+    "- Median\n",
+    "- P95 and P99 latencies\n",
+    "- Peak memory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import logging\n",
+    "import sys\n",
+    "import time\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import yaml\n",
+    "\n",
+    "# Suppress verbose logging\n",
+    "logging.basicConfig(level=logging.WARNING)\n",
+    "\n",
+    "ROOT = Path(\".\").resolve().parent\n",
+    "sys.path.insert(0, str(ROOT / \"src\"))\n",
+    "\n",
+    "from passage.generate import find_path  # noqa: E402\n",
+    "from passage.pathfinding_utils import NUMBA_AVAILABLE  # noqa: E402\n",
+    "\n",
+    "print(f\"Numba available: {NUMBA_AVAILABLE}\")\n",
+    "\n",
+    "# Configuration\n",
+    "TILES_DIR = ROOT / \"outputs\" / \"download\" / \"tiles\"\n",
+    "CALIBRATE_PATH = ROOT / \"outputs\" / \"calibrate\" / \"calibration.json\"\n",
+    "EXPORT_DIR = ROOT / \"outputs\" / \"export\"\n",
+    "\n",
+    "# Load calibration\n",
+    "with open(CALIBRATE_PATH) as f:\n",
+    "    calibration = json.load(f)\n",
+    "GLOBAL_MIN = float(calibration[\"global_min\"])\n",
+    "GLOBAL_MAX = float(calibration[\"global_max\"])\n",
+    "\n",
+    "# Load config for cost model weights\n",
+    "with open(ROOT / \"config\" / \"config.yaml\") as f:\n",
+    "    config = yaml.safe_load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Benchmark parameters\n",
+    "RESOLUTIONS = [64, 256]  # TODO:RESOLUTION_UPDATE: add 128, 512, 1024, 2048, 4096\n",
+    "N_SAMPLES = 100  # Number of samples per resolution\n",
+    "COST_MODEL = \"energy\"  # The default cost model used for labels in passage-vision\n",
+    "\n",
+    "# Solver configurations to benchmark\n",
+    "SOLVERS = [\n",
+    "    {\n",
+    "        \"name\": \"grid:astar\",\n",
+    "        \"backend\": \"grid\",\n",
+    "        \"solver_name\": \"astar\",\n",
+    "        \"diagonal_movement\": \"always\",\n",
+    "        \"heuristic\": \"euclidean\",\n",
+    "        \"cost_model\": COST_MODEL,\n",
+    "        \"weight\": config.get(\"solve\", {}).get(\"cost_weight\", {}).get(COST_MODEL, 1.0),\n",
+    "    },\n",
+    "    {\n",
+    "        \"name\": \"grid:dijkstra\",\n",
+    "        \"backend\": \"grid\",\n",
+    "        \"solver_name\": \"dijkstra\",\n",
+    "        \"diagonal_movement\": \"always\",\n",
+    "        \"heuristic\": \"euclidean\",\n",
+    "        \"cost_model\": COST_MODEL,\n",
+    "        \"weight\": config.get(\"solve\", {}).get(\"cost_weight\", {}).get(COST_MODEL, 1.0),\n",
+    "    },\n",
+    "]\n",
+    "\n",
+    "# Only include networkx for small resolutions (too slow for 512+)\n",
+    "# for res in RESOLUTIONS:\n",
+    "#     if res <= 256:\n",
+    "#         SOLVERS.append({\n",
+    "#             \"name\": f\"networkx:astar\",\n",
+    "#             \"backend\": \"networkx\",\n",
+    "#             ...\n",
+    "#         })\n",
+    "\n",
+    "print(f\"Benchmarking {len(SOLVERS)} solvers at resolutions: {RESOLUTIONS}\")\n",
+    "print(f\"Samples per resolution: {N_SAMPLES}\")\n",
+    "print(f\"Cost model: {COST_MODEL}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Generate Test Samples\n",
+    "\n",
+    "We load samples from the exported parquet data to ensure we benchmark on representative terrain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pyarrow.parquet as pq\n",
+    "import glob as globlib\n",
+    "import zstandard as zstd\n",
+    "import io\n",
+    "import torch\n",
+    "\n",
+    "\n",
+    "def decode_tensor_blob(blob: bytes) -> np.ndarray:\n",
+    "    \"\"\"Decode a zstandard-compressed tensor blob from parquet.\"\"\"\n",
+    "    dctx = zstd.ZstdDecompressor()\n",
+    "    decompressed = dctx.decompress(blob)\n",
+    "    buf = io.BytesIO(decompressed)\n",
+    "    tensor = torch.load(buf, weights_only=True, map_location=\"cpu\")\n",
+    "    return tensor.numpy()\n",
+    "\n",
+    "\n",
+    "def load_samples(resolution: int, split: str = \"test\", n: int = 100) -> list[dict]:\n",
+    "    \"\"\"Load samples from parquet export.\"\"\"\n",
+    "    res_dir = EXPORT_DIR / f\"{resolution}x{resolution}\"\n",
+    "    files = sorted(globlib.glob(str(res_dir / split / \"*.parquet\")))\n",
+    "\n",
+    "    if not files:\n",
+    "        # Fall back to train split\n",
+    "        files = sorted(globlib.glob(str(res_dir / \"train\" / \"*.parquet\")))\n",
+    "        print(f\"  Warning: no {split} split for {resolution}x{resolution}, using train\")\n",
+    "\n",
+    "    samples = []\n",
+    "    for f in files:\n",
+    "        table = pq.read_table(f)\n",
+    "        for i in range(min(n - len(samples), len(table))):\n",
+    "            row = table.slice(i, 1).to_pydict()\n",
+    "            # Decode the tensor\n",
+    "            tensor_data = decode_tensor_blob(row[\"tensor\"][0])\n",
+    "            # tensor_data shape: (3, H, W) -> [elevation, markers, obstacles]\n",
+    "            elevation = tensor_data[0]  # raw elevation\n",
+    "            markers = tensor_data[1]\n",
+    "            obstacles = tensor_data[2] if tensor_data.shape[0] > 2 else np.zeros_like(elevation)\n",
+    "\n",
+    "            # Extract start/end from markers\n",
+    "            start_pos = np.argwhere(np.isclose(markers, 0.0))\n",
+    "            end_pos = np.argwhere(markers > 0.5)\n",
+    "\n",
+    "            if len(start_pos) < 1 or len(end_pos) < 1:\n",
+    "                continue\n",
+    "\n",
+    "            start = (int(start_pos[0, 0]), int(start_pos[0, 1]))\n",
+    "            end = (int(end_pos[0, 0]), int(end_pos[0, 1]))\n",
+    "\n",
+    "            samples.append(\n",
+    "                {\n",
+    "                    \"elevation\": elevation,\n",
+    "                    \"start\": start,\n",
+    "                    \"end\": end,\n",
+    "                    \"obstacles\": obstacles,\n",
+    "                }\n",
+    "            )\n",
+    "\n",
+    "            if len(samples) >= n:\n",
+    "                break\n",
+    "        if len(samples) >= n:\n",
+    "            break\n",
+    "\n",
+    "    print(f\"  Loaded {len(samples)} samples at {resolution}x{resolution}\")\n",
+    "    return samples\n",
+    "\n",
+    "\n",
+    "# Load samples for each resolution\n",
+    "test_samples = {}\n",
+    "for res in RESOLUTIONS:\n",
+    "    test_samples[res] = load_samples(res, split=\"test\", n=N_SAMPLES)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Run Timing Benchmark\n",
+    "\n",
+    "For each (resolution, solver) pair, measure solve time over all samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Numba JIT warmup: run one solve to trigger compilation\n",
+    "if NUMBA_AVAILABLE and test_samples:\n",
+    "    warmup_res = RESOLUTIONS[0]\n",
+    "    warmup_sample = test_samples[warmup_res][0]\n",
+    "    print(\"Warming up Numba JIT...\")\n",
+    "    _ = find_path(\n",
+    "        crop=warmup_sample[\"elevation\"],\n",
+    "        start=warmup_sample[\"start\"],\n",
+    "        end=warmup_sample[\"end\"],\n",
+    "        solver_config=SOLVERS[0],\n",
+    "    )\n",
+    "    print(\"Warmup complete.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Main benchmark loop\n",
+    "all_timings = []\n",
+    "\n",
+    "for res in RESOLUTIONS:\n",
+    "    samples = test_samples.get(res, [])\n",
+    "    if not samples:\n",
+    "        print(f\"No samples for {res}x{res}, skipping.\")\n",
+    "        continue\n",
+    "\n",
+    "    print(f\"\\n=== {res}x{res} ({len(samples)} samples) ===\")\n",
+    "\n",
+    "    for solver in SOLVERS:\n",
+    "        solver_name = solver[\"name\"]\n",
+    "        times_ms = []\n",
+    "        successes = 0\n",
+    "\n",
+    "        for i, sample in enumerate(samples):\n",
+    "            t0 = time.perf_counter()\n",
+    "            path = find_path(\n",
+    "                crop=sample[\"elevation\"],\n",
+    "                start=sample[\"start\"],\n",
+    "                end=sample[\"end\"],\n",
+    "                solver_config=solver,\n",
+    "            )\n",
+    "            elapsed_ms = (time.perf_counter() - t0) * 1000\n",
+    "            times_ms.append(elapsed_ms)\n",
+    "            if len(path) > 0:\n",
+    "                successes += 1\n",
+    "\n",
+    "            if (i + 1) % 25 == 0:\n",
+    "                print(f\"  {solver_name}: {i + 1}/{len(samples)} done, mean so far = {np.mean(times_ms):.2f} ms\")\n",
+    "\n",
+    "        times_arr = np.array(times_ms)\n",
+    "        record = {\n",
+    "            \"resolution\": f\"{res}x{res}\",\n",
+    "            \"solver\": solver_name,\n",
+    "            \"n_samples\": len(samples),\n",
+    "            \"success_rate\": successes / len(samples),\n",
+    "            \"mean_ms\": np.mean(times_arr),\n",
+    "            \"std_ms\": np.std(times_arr),\n",
+    "            \"median_ms\": np.median(times_arr),\n",
+    "            \"p95_ms\": np.percentile(times_arr, 95),\n",
+    "            \"p99_ms\": np.percentile(times_arr, 99),\n",
+    "            \"min_ms\": np.min(times_arr),\n",
+    "            \"max_ms\": np.max(times_arr),\n",
+    "        }\n",
+    "        all_timings.append(record)\n",
+    "        print(\n",
+    "            f\"  {solver_name}: mean={record['mean_ms']:.2f} ms, \"\n",
+    "            f\"median={record['median_ms']:.2f} ms, \"\n",
+    "            f\"p95={record['p95_ms']:.2f} ms, \"\n",
+    "            f\"success={record['success_rate']:.1%}\"\n",
+    "        )\n",
+    "\n",
+    "timings_df = pd.DataFrame(all_timings)\n",
+    "print(\"\\n=== Full Results ===\")\n",
+    "print(timings_df.to_string(index=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Visualization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not timings_df.empty:\n",
+    "    # Bar chart: mean solve time per solver per resolution\n",
+    "    fig, axes = plt.subplots(1, len(RESOLUTIONS), figsize=(7 * len(RESOLUTIONS), 5))\n",
+    "    if len(RESOLUTIONS) == 1:\n",
+    "        axes = [axes]\n",
+    "\n",
+    "    fig.suptitle(\"A* Solver Inference Time by Resolution\", fontsize=14, fontweight=\"bold\")\n",
+    "\n",
+    "    for ax, res in zip(axes, RESOLUTIONS):\n",
+    "        res_df = timings_df[timings_df[\"resolution\"] == f\"{res}x{res}\"]\n",
+    "        if res_df.empty:\n",
+    "            continue\n",
+    "        bars = ax.bar(\n",
+    "            res_df[\"solver\"], res_df[\"mean_ms\"], yerr=res_df[\"std_ms\"], capsize=5, color=\"steelblue\", alpha=0.8\n",
+    "        )\n",
+    "        ax.set_ylabel(\"Time (ms)\")\n",
+    "        ax.set_title(f\"{res}x{res}\")\n",
+    "        ax.grid(True, alpha=0.3, axis=\"y\")\n",
+    "\n",
+    "        # Add value labels\n",
+    "        for bar, val in zip(bars, res_df[\"mean_ms\"]):\n",
+    "            ax.text(\n",
+    "                bar.get_x() + bar.get_width() / 2, bar.get_height(), f\"{val:.1f}\", ha=\"center\", va=\"bottom\", fontsize=9\n",
+    "            )\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.savefig(ROOT / \"outputs\" / \"paper\" / \"astar_timing_bars.pdf\", dpi=150, bbox_inches=\"tight\")\n",
+    "    plt.show()\n",
+    "else:\n",
+    "    print(\"No timing results to plot.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not timings_df.empty:\n",
+    "    # Resolution scaling plot (log-log)\n",
+    "    fig, ax = plt.subplots(figsize=(10, 6))\n",
+    "\n",
+    "    for solver_name in timings_df[\"solver\"].unique():\n",
+    "        solver_df = timings_df[timings_df[\"solver\"] == solver_name].copy()\n",
+    "        solver_df[\"res_int\"] = solver_df[\"resolution\"].str.split(\"x\").str[0].astype(int)\n",
+    "        solver_df = solver_df.sort_values(\"res_int\")\n",
+    "\n",
+    "        ax.plot(solver_df[\"res_int\"], solver_df[\"mean_ms\"], \"o-\", label=solver_name, linewidth=2)\n",
+    "        ax.fill_between(\n",
+    "            solver_df[\"res_int\"],\n",
+    "            solver_df[\"mean_ms\"] - solver_df[\"std_ms\"],\n",
+    "            solver_df[\"mean_ms\"] + solver_df[\"std_ms\"],\n",
+    "            alpha=0.15,\n",
+    "        )\n",
+    "\n",
+    "    ax.set_xscale(\"log\", base=2)\n",
+    "    ax.set_yscale(\"log\")\n",
+    "    ax.set_xlabel(\"Resolution (pixels per side)\")\n",
+    "    ax.set_ylabel(\"Solve Time (ms)\")\n",
+    "    ax.set_title(\"A* Solver Scaling with Resolution\")\n",
+    "    ax.legend()\n",
+    "    ax.grid(True, alpha=0.3)\n",
+    "\n",
+    "    # Add reference lines for neural model times (placeholder)\n",
+    "    # ax.axhline(y=5, color=\"green\", linestyle=\"--\", alpha=0.5, label=\"~Neural model (5ms)\")\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.savefig(ROOT / \"outputs\" / \"paper\" / \"astar_scaling.pdf\", dpi=150, bbox_inches=\"tight\")\n",
+    "    plt.show()\n",
+    "\n",
+    "    # TODO:RESOLUTION_UPDATE: This plot becomes most compelling with all 7 resolutions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not timings_df.empty:\n",
+    "    # Distribution of solve times (histogram)\n",
+    "    fig, axes = plt.subplots(1, len(RESOLUTIONS), figsize=(7 * len(RESOLUTIONS), 4))\n",
+    "    if len(RESOLUTIONS) == 1:\n",
+    "        axes = [axes]\n",
+    "\n",
+    "    fig.suptitle(\"Distribution of A* Solve Times (grid:astar)\", fontsize=14, fontweight=\"bold\")\n",
+    "\n",
+    "    for ax, res in zip(axes, RESOLUTIONS):\n",
+    "        # Use grid:astar times (the reference solver)\n",
+    "        res_grid = timings_df[(timings_df[\"resolution\"] == f\"{res}x{res}\") & (timings_df[\"solver\"] == \"grid:astar\")]\n",
+    "        if res_grid.empty:\n",
+    "            continue\n",
+    "\n",
+    "        mean_val = res_grid[\"mean_ms\"].values[0]\n",
+    "        p95_val = res_grid[\"p95_ms\"].values[0]\n",
+    "\n",
+    "        ax.set_title(f\"{res}x{res} (mean={mean_val:.1f}ms, p95={p95_val:.1f}ms)\")\n",
+    "        ax.set_xlabel(\"Solve Time (ms)\")\n",
+    "        ax.set_ylabel(\"Count\")\n",
+    "        ax.axvline(x=mean_val, color=\"red\", linestyle=\"--\", label=f\"Mean: {mean_val:.1f}ms\")\n",
+    "        ax.axvline(x=p95_val, color=\"orange\", linestyle=\":\", label=f\"P95: {p95_val:.1f}ms\")\n",
+    "        ax.legend(fontsize=9)\n",
+    "        ax.grid(True, alpha=0.3)\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Export Results\n",
+    "\n",
+    "Save timing results for use in the passage-vision experiment notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not timings_df.empty:\n",
+    "    # Save as CSV\n",
+    "    output_dir = ROOT / \"outputs\" / \"paper\"\n",
+    "    output_dir.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "    csv_path = output_dir / \"astar_inference_timing.csv\"\n",
+    "    timings_df.to_csv(csv_path, index=False)\n",
+    "    print(f\"Saved timing results to {csv_path}\")\n",
+    "\n",
+    "    # Also save as JSON for easy loading in passage-vision notebook\n",
+    "    json_path = output_dir / \"astar_inference_timing.json\"\n",
+    "    timing_dict = {}\n",
+    "    for _, row in timings_df[timings_df[\"solver\"] == \"grid:astar\"].iterrows():\n",
+    "        res_int = int(row[\"resolution\"].split(\"x\")[0])\n",
+    "        timing_dict[res_int] = {\n",
+    "            \"mean\": round(row[\"mean_ms\"], 2),\n",
+    "            \"std\": round(row[\"std_ms\"], 2),\n",
+    "            \"median\": round(row[\"median_ms\"], 2),\n",
+    "            \"p95\": round(row[\"p95_ms\"], 2),\n",
+    "            \"p99\": round(row[\"p99_ms\"], 2),\n",
+    "            \"n_samples\": int(row[\"n_samples\"]),\n",
+    "        }\n",
+    "\n",
+    "    with open(json_path, \"w\") as f:\n",
+    "        json.dump(timing_dict, f, indent=2)\n",
+    "    print(f\"Saved JSON timing for passage-vision: {json_path}\")\n",
+    "\n",
+    "    print(\"\\nTo load in passage-vision notebook:\")\n",
+    "    print(f'  import json; ASTAR_TIMING = json.load(open(\"{json_path}\"))')\n",
+    "else:\n",
+    "    print(\"No results to export. Run the benchmark cells above first.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis: A* Solver Timing\n",
+    "\n",
+    "**Expected scaling behavior:**\n",
+    "\n",
+    "- **64x64:** Grid A* should complete in ~5-20 ms. At this resolution, A* is cheap enough that neural surrogates offer only modest speedup.\n",
+    "\n",
+    "- **256x256:** Grid A* should take ~50-500 ms depending on terrain complexity and path length. This is the resolution where neural surrogates start to become compelling.\n",
+    "\n",
+    "- **512x512+:** Grid A* scales roughly as O(N^2 log N). At 1024x1024, expect ~1-10 seconds. At 4096x4096, expect minutes. This is where neural surrogates provide transformative speedup.\n",
+    "\n",
+    "**Numba JIT impact:** The grid backend with Numba should be 10-100x faster than NetworkX at the same resolution. This is itself a contribution of the paper (Section 5).\n",
+    "\n",
+    "**Key paper figure:** The scaling plot (log-log: resolution vs time) with grid and networkx curves diverging at higher resolutions. Overlay neural model inference times to show the crossover point.\n",
+    "\n",
+    "<!-- TODO:RESOLUTION_UPDATE: The full 64->4096 scaling curve is the most impactful figure. -->"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "passage",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

notebooks/costmodel.ipynb

@@ -0,0 +1,1200 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c7488484",
+   "metadata": {},
+   "source": [
+    "MIT License\n",
+    "\n",
+    "Copyright (c) 2026 THALES\n",
+    "\n",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy\n",
+    "of this software and associated documentation files (the \"Software\"), to deal\n",
+    "in the Software without restriction, including without limitation the rights\n",
+    "to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n",
+    "copies of the Software, and to permit persons to whom the Software is\n",
+    "furnished to do so, subject to the following conditions:\n",
+    "\n",
+    "The above copyright notice and this permission notice shall be included in all\n",
+    "copies or substantial portions of the Software.\n",
+    "\n",
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n",
+    "AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n",
+    "OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n",
+    "SOFTWARE."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc454ef6",
+   "metadata": {},
+   "source": [
+    "# Cost Model Comparison & Weight Tuning\n",
+    "\n",
+    "This notebook compares PASSAGE cost models using `grid:astar` and tunes their\n",
+    "weight parameter by balancing three objectives:\n",
+    "\n",
+    "1. **Maximize path diversity** — Hausdorff distance from the flat `distance` baseline\n",
+    "2. **Minimize boundary artifacts** — penalize paths that hug image edges (both overall fraction and contiguous runs)\n",
+    "3. **Minimize weight at asymptote** — prefer the smallest weight achieving near-peak score\n",
+    "\n",
+    "**Combined score** per (cost_model, weight):\n",
+    "\n",
+    "$$\\text{score}(w) = \\hat{H}(w) \\cdot \\bigl(1 - B(w)\\bigr) \\cdot P_{\\text{run}}(w)$$\n",
+    "\n",
+    "where $\\hat{H}(w) \\in [0,1]$ is the normalized mean Hausdorff distance from the\n",
+    "`distance` baseline, $B(w) \\in [0,1]$ is the mean fraction of path points\n",
+    "within a margin of the image boundary, and $P_{\\text{run}}(w) \\in [0,1]$ is a\n",
+    "hard penalty for contiguous boundary runs:\n",
+    "\n",
+    "$$P_{\\text{run}}(w) = 1 - \\text{clamp}\\!\\left(\\frac{C(w) - \\theta}{\\theta},\\; 0,\\; 1\\right)$$\n",
+    "\n",
+    "where $C(w)$ is the mean max-contiguous-boundary fraction and $\\theta$ is the\n",
+    "configurable threshold (`MAX_BOUNDARY_RUN_FRAC`, default 3%). Weights where\n",
+    "$C(w) \\ge 2\\theta$ receive a score of zero.\n",
+    "\n",
+    "Among weights with $\\text{score} \\ge \\tau \\cdot \\max(\\text{score})$, we pick the\n",
+    "**smallest** weight (asymptote minimization)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1ad71f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import importlib\n",
+    "import json\n",
+    "import logging\n",
+    "import math\n",
+    "import multiprocessing as mp\n",
+    "import random\n",
+    "import sys\n",
+    "import time\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from loguru import logger as loguru_logger\n",
+    "from matplotlib.lines import Line2D\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "# Configure logging\n",
+    "logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\")\n",
+    "logger = logging.getLogger(__name__)\n",
+    "logger.setLevel(logging.INFO)\n",
+    "loguru_logger.remove()\n",
+    "loguru_logger.add(sys.stderr, level=\"INFO\")\n",
+    "\n",
+    "ROOT = Path(\"..\").resolve()\n",
+    "sys.path.insert(0, str(ROOT / \"src\"))\n",
+    "\n",
+    "# Reload to pick up new functions added to pathfinding_utils\n",
+    "import passage.pathfinding_utils as pathfinding_utils  # noqa: E402\n",
+    "\n",
+    "importlib.reload(pathfinding_utils)\n",
+    "\n",
+    "from passage.generate import find_path, load_tile, _assemble_crop_from_tiles  # noqa: E402\n",
+    "from passage.pathfinding_utils import (  # noqa: E402\n",
+    "    COST_MODELS,\n",
+    "    boundary_fraction,\n",
+    "    hausdorff_distance,\n",
+    "    max_contiguous_boundary_fraction,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b7c746f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parameters (papermill)\n",
+    "RESOLUTION = 256\n",
+    "NUM_SAMPLES = 1000\n",
+    "NUM_DISPLAY_SAMPLES = 20\n",
+    "BOUNDARY_MARGIN = 2  # pixels from edge considered \"near boundary\"\n",
+    "SCORE_THRESHOLD = 0.95  # fraction of max score for asymptote selection\n",
+    "MAX_BOUNDARY_RUN_FRAC = 0.03  # max allowed contiguous boundary run as fraction of path length\n",
+    "NUM_WORKERS = min(mp.cpu_count(), 16)  # parallel workers for sample generation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae36c5ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configuration\n",
+    "TILES_DIR = ROOT / \"outputs\" / \"download\" / \"tiles\"\n",
+    "CALIBRATE_PATH = ROOT / \"outputs\" / \"calibrate\" / \"calibrate.json\"\n",
+    "\n",
+    "WEIGHTS = np.pow(10, np.linspace(0, 7, num=40)).tolist()\n",
+    "COST_MODELS_LIST = sorted(list(COST_MODELS))\n",
+    "COST_MODELS_TUNABLE = [cm for cm in COST_MODELS_LIST if cm != \"distance\"]\n",
+    "TILE_SIZE_PX = 3600\n",
+    "\n",
+    "# Color palette for cost models (consistent across all plots)\n",
+    "CM_COLORS = {cm: plt.cm.Set2(i / max(1, len(COST_MODELS_LIST) - 1)) for i, cm in enumerate(COST_MODELS_LIST)}\n",
+    "\n",
+    "print(f\"Resolution: {RESOLUTION}\")\n",
+    "print(f\"Num samples: {NUM_SAMPLES}\")\n",
+    "print(f\"Num display samples: {NUM_DISPLAY_SAMPLES}\")\n",
+    "print(f\"Weight range: [{WEIGHTS[0]:.1f} ... {WEIGHTS[-1]:.1f}] ({len(WEIGHTS)} values)\")\n",
+    "print(f\"Cost models: {COST_MODELS_LIST}\")\n",
+    "print(f\"Tunable (non-distance): {COST_MODELS_TUNABLE}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ada0aee0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load calibration data\n",
+    "if not CALIBRATE_PATH.exists():\n",
+    "    raise FileNotFoundError(f\"Calibration file not found: {CALIBRATE_PATH}. Run 'passage calibrate' first.\")\n",
+    "if not TILES_DIR.exists():\n",
+    "    raise FileNotFoundError(f\"Tiles directory not found: {TILES_DIR}. Run 'passage download' first.\")\n",
+    "\n",
+    "with open(CALIBRATE_PATH) as f:\n",
+    "    calibration = json.load(f)\n",
+    "\n",
+    "global_min = float(calibration[\"global_min\"])\n",
+    "global_max = float(calibration[\"global_max\"])\n",
+    "tile_stats_df = pd.DataFrame(calibration[\"tile_stats\"])\n",
+    "\n",
+    "print(f\"Global elevation range: [{global_min:.1f}, {global_max:.1f}]\")\n",
+    "print(f\"Number of tiles: {len(tile_stats_df)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e262ab2",
+   "metadata": {},
+   "source": [
+    "## Helper Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8073ee06",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_random_crop(\n",
+    "    resolution: int,\n",
+    "    tile_stats_df: pd.DataFrame,\n",
+    "    tiles_dirpath: Path,\n",
+    "    global_min: float,\n",
+    "    global_max: float,\n",
+    "    seed: int | None = None,\n",
+    ") -> np.ndarray | None:\n",
+    "    if seed is not None:\n",
+    "        random.seed(seed)\n",
+    "        np.random.seed(seed)\n",
+    "\n",
+    "    half_res = resolution // 2\n",
+    "    half_tiles = max(1, math.ceil(half_res / TILE_SIZE_PX))\n",
+    "    n_tiles = 2 * half_tiles + 1\n",
+    "    grid_h = n_tiles * TILE_SIZE_PX\n",
+    "    grid_w = n_tiles * TILE_SIZE_PX\n",
+    "\n",
+    "    for _ in range(10):\n",
+    "        target_elev = random.uniform(global_min, global_max)\n",
+    "        candidates = tile_stats_df[(tile_stats_df[\"min\"] <= target_elev) & (tile_stats_df[\"max\"] >= target_elev)]\n",
+    "        if candidates.empty:\n",
+    "            continue\n",
+    "        selected = candidates.sample(n=1).iloc[0]\n",
+    "        center_lat = int(selected[\"lat\"])\n",
+    "        center_lon = int(selected[\"lon\"])\n",
+    "        if grid_h < resolution or grid_w < resolution:\n",
+    "            continue\n",
+    "        y1 = random.randint(0, grid_h - resolution)\n",
+    "        x1 = random.randint(0, grid_w - resolution)\n",
+    "        center_tile = load_tile(tiles_dirpath, center_lat, center_lon)\n",
+    "        crop = _assemble_crop_from_tiles(\n",
+    "            tiles_dirpath=tiles_dirpath,\n",
+    "            center_lat=center_lat,\n",
+    "            center_lon=center_lon,\n",
+    "            half_tiles=half_tiles,\n",
+    "            y1=y1,\n",
+    "            x1=x1,\n",
+    "            resolution=resolution,\n",
+    "            center_tile=center_tile,\n",
+    "        )\n",
+    "        return crop\n",
+    "    return None\n",
+    "\n",
+    "\n",
+    "def get_marker_positions(resolution: int) -> tuple[tuple[int, int], tuple[int, int]]:\n",
+    "    pos1 = int(0.2 * resolution)\n",
+    "    pos2 = int(0.8 * resolution)\n",
+    "    return (pos1, pos1), (pos2, pos2)\n",
+    "\n",
+    "\n",
+    "def compute_path_for_crop(\n",
+    "    crop: np.ndarray,\n",
+    "    start: tuple[int, int],\n",
+    "    end: tuple[int, int],\n",
+    "    cost_model_name: str,\n",
+    "    weight: float,\n",
+    ") -> list:\n",
+    "    solver_config = {\n",
+    "        \"name\": \"grid:astar\",\n",
+    "        \"diagonal_movement\": \"always\",\n",
+    "        \"weight\": float(weight),\n",
+    "        \"cost_model\": cost_model_name,\n",
+    "        \"heuristic\": \"euclidean\",\n",
+    "    }\n",
+    "    return find_path(crop, start, end, solver_config)\n",
+    "\n",
+    "\n",
+    "def _process_one_sample(i):\n",
+    "    \"\"\"Worker: generate one sample and compute all paths (for multiprocessing).\"\"\"\n",
+    "    crop = generate_random_crop(RESOLUTION, tile_stats_df, TILES_DIR, global_min, global_max, seed=1000 + i)\n",
+    "    if crop is None:\n",
+    "        return None\n",
+    "    start, end = get_marker_positions(RESOLUTION)\n",
+    "    paths = {}\n",
+    "    for cm in COST_MODELS_LIST:\n",
+    "        paths[cm] = {}\n",
+    "        for w in WEIGHTS:\n",
+    "            paths[cm][w] = compute_path_for_crop(crop, start, end, cm, w)\n",
+    "    return {\"index\": i + 1, \"crop\": crop, \"start\": start, \"end\": end, \"paths\": paths}\n",
+    "\n",
+    "\n",
+    "def _process_one_display_sample(i):\n",
+    "    \"\"\"Worker: generate one display sample with tuned weights (for multiprocessing).\"\"\"\n",
+    "    crop = generate_random_crop(RESOLUTION, tile_stats_df, TILES_DIR, global_min, global_max, seed=5000 + i)\n",
+    "    if crop is None:\n",
+    "        return None\n",
+    "    start, end = get_marker_positions(RESOLUTION)\n",
+    "    paths = {}\n",
+    "    paths[\"distance\"] = compute_path_for_crop(crop, start, end, \"distance\", 1.0)\n",
+    "    for cm, w in weights_tuned.items():\n",
+    "        paths[cm] = compute_path_for_crop(crop, start, end, cm, w)\n",
+    "    return {\"index\": i + 1, \"crop\": crop, \"start\": start, \"end\": end, \"paths\": paths}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2cf60b38",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 1. Generate Samples & Compute Paths\n",
+    "\n",
+    "For each sample, compute paths with every (cost_model, weight) combination."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4ddd798",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t0 = time.time()\n",
+    "ctx = mp.get_context(\"fork\")\n",
+    "with ctx.Pool(NUM_WORKERS) as pool:\n",
+    "    results = list(\n",
+    "        tqdm(\n",
+    "            pool.imap_unordered(_process_one_sample, range(NUM_SAMPLES)),\n",
+    "            total=NUM_SAMPLES,\n",
+    "            desc=f\"Generating samples ({NUM_WORKERS} workers)\",\n",
+    "        )\n",
+    "    )\n",
+    "\n",
+    "samples = sorted([r for r in results if r is not None], key=lambda s: s[\"index\"])\n",
+    "\n",
+    "elapsed = time.time() - t0\n",
+    "print(f\"\\nGenerated {len(samples)}/{NUM_SAMPLES} samples in {elapsed:.1f}s ({NUM_WORKERS} workers)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc957c76",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 2. Path Length Analysis\n",
+    "\n",
+    "How does path length vary with weight for each cost model?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8858d965",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Build per-(sample, cost_model, weight) records\n",
+    "records = []\n",
+    "for sample in samples:\n",
+    "    for cm in COST_MODELS_LIST:\n",
+    "        for w in WEIGHTS:\n",
+    "            path = sample[\"paths\"][cm][w]\n",
+    "            records.append(\n",
+    "                {\n",
+    "                    \"sample\": sample[\"index\"],\n",
+    "                    \"cost_model\": cm,\n",
+    "                    \"weight\": w,\n",
+    "                    \"path_length\": len(path),\n",
+    "                    \"found\": len(path) > 0,\n",
+    "                }\n",
+    "            )\n",
+    "\n",
+    "results_df = pd.DataFrame(records)\n",
+    "print(f\"Records: {len(results_df)}\")\n",
+    "results_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2dfb4d67",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Mean path length vs weight per cost model\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(16, 5))\n",
+    "\n",
+    "# Left: mean path length\n",
+    "ax = axes[0]\n",
+    "for cm in COST_MODELS_LIST:\n",
+    "    sub = results_df[results_df[\"cost_model\"] == cm]\n",
+    "    agg = sub.groupby(\"weight\")[\"path_length\"].mean()\n",
+    "    ax.plot(agg.index, agg.values, \"o-\", lw=1.2, markersize=3, label=cm, color=CM_COLORS[cm])\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_xlabel(\"Weight\")\n",
+    "ax.set_ylabel(\"Mean path length (px)\")\n",
+    "ax.set_title(\"Mean Path Length vs Weight\")\n",
+    "ax.legend(fontsize=8)\n",
+    "ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "# Right: path-found rate\n",
+    "ax = axes[1]\n",
+    "for cm in COST_MODELS_LIST:\n",
+    "    sub = results_df[results_df[\"cost_model\"] == cm]\n",
+    "    agg = sub.groupby(\"weight\")[\"found\"].mean()\n",
+    "    ax.plot(agg.index, agg.values, \"o-\", lw=1.2, markersize=3, label=cm, color=CM_COLORS[cm])\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_xlabel(\"Weight\")\n",
+    "ax.set_ylabel(\"Path found rate\")\n",
+    "ax.set_title(\"Path Success Rate vs Weight\")\n",
+    "ax.set_ylim(-0.05, 1.05)\n",
+    "ax.legend(fontsize=8)\n",
+    "ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf159867",
+   "metadata": {},
+   "source": [
+    "### Analysis: Path Length & Success Rate\n",
+    "\n",
+    "**Left panel — Mean path length vs weight:**\n",
+    "- The `distance` model (flat cost) produces a constant, short path regardless of weight — it always follows the Euclidean-shortest route, confirming it as our \"straight-line\" baseline.\n",
+    "- All elevation-aware cost models show increasing path length with weight: higher weight amplifies the terrain penalty, forcing the solver to route around obstacles instead of crossing them.\n",
+    "- `elevation` and `slope_uphill` show the steepest length increase, indicating they generate the most tortuous detours. `absolute_elevation` saturates earliest, meaning its terrain signal is relatively weak compared to distance costs at moderate weights.\n",
+    "- Beyond ~$10^5$, most models plateau — the path cannot deviate much further within a 256×256 crop.\n",
+    "\n",
+    "**Right panel — Path success rate:**\n",
+    "- All cost models maintain a 100% success rate across the full weight range. This confirms that the A* solver with 8-connectivity always finds a valid path within the crop, and no weight causes the solver to fail. This is expected since the grid is fully connected (diagonal movement = \"always\") and the start/end points are always at fixed positions (20%/80% of resolution)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2a3afc7",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 3. Hausdorff Distance from `distance` Baseline\n",
+    "\n",
+    "Measure how different each cost model's path is from the flat `distance` model\n",
+    "(straight-line baseline). Higher Hausdorff = more elevation-aware deviation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "90af6c1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compute per-(sample, cost_model, weight): Hausdorff vs distance, boundary fraction, contiguous run\n",
+    "metric_records = []\n",
+    "\n",
+    "for sample in tqdm(samples, desc=\"Computing metrics\"):\n",
+    "    crop = sample[\"crop\"]\n",
+    "    paths = sample[\"paths\"]\n",
+    "    res = crop.shape[0]\n",
+    "\n",
+    "    # distance model is weight-independent — use first weight as baseline\n",
+    "    distance_path = paths[\"distance\"][WEIGHTS[0]]\n",
+    "\n",
+    "    for cm in COST_MODELS_LIST:\n",
+    "        for w in WEIGHTS:\n",
+    "            path = paths[cm][w]\n",
+    "            hd = hausdorff_distance(path, distance_path)\n",
+    "            bf = boundary_fraction(path, res, BOUNDARY_MARGIN)\n",
+    "            mcbf = max_contiguous_boundary_fraction(path, res, BOUNDARY_MARGIN)\n",
+    "            metric_records.append(\n",
+    "                {\n",
+    "                    \"sample\": sample[\"index\"],\n",
+    "                    \"cost_model\": cm,\n",
+    "                    \"weight\": w,\n",
+    "                    \"hausdorff_vs_distance\": hd,\n",
+    "                    \"boundary_frac\": bf,\n",
+    "                    \"hits_boundary\": bf > 0,\n",
+    "                    \"max_contiguous_boundary_frac\": mcbf,\n",
+    "                    \"path_length\": len(path),\n",
+    "                }\n",
+    "            )\n",
+    "\n",
+    "metric_df = pd.DataFrame(metric_records)\n",
+    "print(f\"Metric records: {len(metric_df)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "558b0c4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Aggregate across samples\n",
+    "agg_df = (\n",
+    "    metric_df.groupby([\"cost_model\", \"weight\"])\n",
+    "    .agg(\n",
+    "        mean_hausdorff=(\"hausdorff_vs_distance\", \"mean\"),\n",
+    "        std_hausdorff=(\"hausdorff_vs_distance\", \"std\"),\n",
+    "        mean_boundary_frac=(\"boundary_frac\", \"mean\"),\n",
+    "        boundary_hit_rate=(\"hits_boundary\", \"mean\"),\n",
+    "        mean_max_contig_boundary=(\"max_contiguous_boundary_frac\", \"mean\"),\n",
+    "        mean_path_length=(\"path_length\", \"mean\"),\n",
+    "    )\n",
+    "    .reset_index()\n",
+    ")\n",
+    "agg_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e3f61f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hausdorff distance vs weight — all tunable cost models overlaid\n",
+    "fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "\n",
+    "for cm in COST_MODELS_TUNABLE:\n",
+    "    sub = agg_df[agg_df[\"cost_model\"] == cm].sort_values(\"weight\")\n",
+    "    ax.plot(\n",
+    "        sub[\"weight\"],\n",
+    "        sub[\"mean_hausdorff\"],\n",
+    "        \"o-\",\n",
+    "        lw=1.5,\n",
+    "        markersize=4,\n",
+    "        label=cm,\n",
+    "        color=CM_COLORS[cm],\n",
+    "    )\n",
+    "    ax.fill_between(\n",
+    "        sub[\"weight\"],\n",
+    "        sub[\"mean_hausdorff\"] - sub[\"std_hausdorff\"],\n",
+    "        sub[\"mean_hausdorff\"] + sub[\"std_hausdorff\"],\n",
+    "        alpha=0.15,\n",
+    "        color=CM_COLORS[cm],\n",
+    "    )\n",
+    "\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_xlabel(\"Weight\")\n",
+    "ax.set_ylabel(\"Mean Hausdorff distance from `distance` baseline (px)\")\n",
+    "ax.set_title(\"Path Diversity: Hausdorff Distance vs Weight\")\n",
+    "ax.legend(fontsize=9)\n",
+    "ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4d8bb99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Per-cost-model Hausdorff subplots with individual y-scales\n",
+    "n_cm = len(COST_MODELS_TUNABLE)\n",
+    "fig, axes = plt.subplots(1, n_cm, figsize=(5 * n_cm, 4), sharey=False)\n",
+    "if n_cm == 1:\n",
+    "    axes = [axes]\n",
+    "\n",
+    "for idx, cm in enumerate(COST_MODELS_TUNABLE):\n",
+    "    ax = axes[idx]\n",
+    "    sub = agg_df[agg_df[\"cost_model\"] == cm].sort_values(\"weight\")\n",
+    "    ax.plot(sub[\"weight\"], sub[\"mean_hausdorff\"], \"o-\", lw=1.5, markersize=4, color=CM_COLORS[cm])\n",
+    "    ax.fill_between(\n",
+    "        sub[\"weight\"],\n",
+    "        sub[\"mean_hausdorff\"] - sub[\"std_hausdorff\"],\n",
+    "        sub[\"mean_hausdorff\"] + sub[\"std_hausdorff\"],\n",
+    "        alpha=0.2,\n",
+    "        color=CM_COLORS[cm],\n",
+    "    )\n",
+    "    # Mark peak\n",
+    "    peak_idx = sub[\"mean_hausdorff\"].idxmax()\n",
+    "    peak_row = sub.loc[peak_idx]\n",
+    "    ax.scatter([peak_row[\"weight\"]], [peak_row[\"mean_hausdorff\"]], color=\"red\", s=50, zorder=10)\n",
+    "    ax.annotate(\n",
+    "        f\"w={peak_row['weight']:.0f}\",\n",
+    "        xy=(peak_row[\"weight\"], peak_row[\"mean_hausdorff\"]),\n",
+    "        xytext=(5, 8),\n",
+    "        textcoords=\"offset points\",\n",
+    "        fontsize=8,\n",
+    "        color=\"red\",\n",
+    "    )\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.set_title(cm, fontsize=11)\n",
+    "    ax.set_xlabel(\"Weight\")\n",
+    "    if idx == 0:\n",
+    "        ax.set_ylabel(\"Mean Hausdorff (px)\")\n",
+    "    ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "fig.suptitle(\"Hausdorff Distance per Cost Model\", fontsize=13)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6398ef31",
+   "metadata": {},
+   "source": [
+    "### Analysis: Hausdorff Distance from Distance Baseline\n",
+    "\n",
+    "**Overlay plot:** All tunable cost models show a characteristic rise-then-plateau pattern in Hausdorff distance vs weight, but with very different magnitudes:\n",
+    "\n",
+    "- **`elevation`** achieves the highest Hausdorff distance (~50 px at peak), meaning it produces the most divergent paths from the straight-line baseline. This makes sense: the `elevation` model penalizes elevation *differences* between successive cells, so it actively routes around ridges and valleys.\n",
+    "- **`energy`** and **`slope_uphill`** reach intermediate peaks (~40 px). The `energy` model penalizes cumulative elevation gain, while `slope_uphill` only penalizes uphill slopes — both produce meaningful but more moderate deviations.\n",
+    "- **`absolute_elevation`** has the lowest Hausdorff distance (~5 px). This model penalizes *absolute* elevation values rather than gradients, so in crops with relatively uniform elevation, it produces near-straight paths. It only deviates when there are large absolute elevation differences (e.g., sea-level vs mountains).\n",
+    "\n",
+    "**Per-model subplots (with peaks):** The red markers show the weight at which each model's Hausdorff distance peaks. Beyond these peaks, further weight increases yield diminishing returns (the path has already deviated as far as the 256×256 crop allows). The ±1σ bands show significant sample-to-sample variance, especially for `elevation`, reflecting the diversity of terrain encountered across 1000 random crops.\n",
+    "\n",
+    "> **Key insight:** Raw Hausdorff maximization alone would always pick the highest possible weight. But as we'll see in the boundary analysis, very high weights cause paths to hug image edges — an artifact, not a meaningful route."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7eb0f6aa",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 4. Boundary Hit Analysis\n",
+    "\n",
+    "At high weights, paths may deviate so much that they hug image boundaries —\n",
+    "an artifact of the finite crop, not a meaningful route choice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "316ae35a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Boundary hit rate and boundary fraction vs weight\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(16, 5))\n",
+    "\n",
+    "# Left: boundary hit rate (fraction of samples with any boundary contact)\n",
+    "ax = axes[0]\n",
+    "for cm in COST_MODELS_TUNABLE:\n",
+    "    sub = agg_df[agg_df[\"cost_model\"] == cm].sort_values(\"weight\")\n",
+    "    ax.plot(sub[\"weight\"], sub[\"boundary_hit_rate\"], \"o-\", lw=1.2, markersize=3, label=cm, color=CM_COLORS[cm])\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_xlabel(\"Weight\")\n",
+    "ax.set_ylabel(\"Boundary hit rate (fraction of samples)\")\n",
+    "ax.set_title(\"Boundary Hit Rate vs Weight\")\n",
+    "ax.set_ylim(-0.05, 1.05)\n",
+    "ax.legend(fontsize=8)\n",
+    "ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "# Right: mean boundary fraction (fraction of path points at boundary)\n",
+    "ax = axes[1]\n",
+    "for cm in COST_MODELS_TUNABLE:\n",
+    "    sub = agg_df[agg_df[\"cost_model\"] == cm].sort_values(\"weight\")\n",
+    "    ax.plot(sub[\"weight\"], sub[\"mean_boundary_frac\"], \"s-\", lw=1.2, markersize=3, label=cm, color=CM_COLORS[cm])\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_xlabel(\"Weight\")\n",
+    "ax.set_ylabel(\"Mean boundary fraction\")\n",
+    "ax.set_title(\"Mean Boundary Fraction vs Weight\")\n",
+    "ax.legend(fontsize=8)\n",
+    "ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ffd51a4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Per-cost-model boundary fraction subplots\n",
+    "fig, axes = plt.subplots(1, n_cm, figsize=(5 * n_cm, 4), sharey=True)\n",
+    "if n_cm == 1:\n",
+    "    axes = [axes]\n",
+    "\n",
+    "for idx, cm in enumerate(COST_MODELS_TUNABLE):\n",
+    "    ax = axes[idx]\n",
+    "    sub = agg_df[agg_df[\"cost_model\"] == cm].sort_values(\"weight\")\n",
+    "    ax.fill_between(sub[\"weight\"], 0, sub[\"mean_boundary_frac\"], alpha=0.3, color=CM_COLORS[cm])\n",
+    "    ax.plot(sub[\"weight\"], sub[\"mean_boundary_frac\"], \"s-\", lw=1.2, markersize=3, color=CM_COLORS[cm])\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.set_title(cm, fontsize=11)\n",
+    "    ax.set_xlabel(\"Weight\")\n",
+    "    if idx == 0:\n",
+    "        ax.set_ylabel(\"Mean boundary fraction\")\n",
+    "    ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "fig.suptitle(\"Boundary Fraction per Cost Model\", fontsize=13)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d751dfa",
+   "metadata": {},
+   "source": [
+    "### Analysis: Boundary Artifacts\n",
+    "\n",
+    "**Left panel — Boundary hit rate:** The fraction of samples where *any* path point falls within 2 pixels of the crop edge. For most models this remains near zero for moderate weights, but:\n",
+    "- **`elevation`** stands out with a boundary hit rate climbing to ~20-40% at high weights ($w > 10^4$). This is the most aggressive model — when terrain penalties dominate, the solver finds it cheaper to route along the flat boundary pixels (which have constant elevation) than to cross real terrain features.\n",
+    "- **`slope_uphill`** shows a smaller but non-negligible boundary hit rate at very high weights.\n",
+    "- **`absolute_elevation`** and **`energy`** remain well-behaved with near-zero boundary contact across all weights.\n",
+    "\n",
+    "**Right panel — Mean boundary fraction:** Even among samples that *do* hit the boundary, how much of the path is affected? The `elevation` model is again the outlier, with up to ~4% of path points near the boundary at extreme weights. This confirms the need for a penalty term.\n",
+    "\n",
+    "**Per-model area charts:** Visualize the boundary fraction profile per model. The `elevation` model's boundary fraction rises sharply above $w \\approx 10^3$, precisely the weight range where Hausdorff distance also saturates — confirming that the additional \"deviation\" is actually boundary hugging, not meaningful terrain avoidance.\n",
+    "\n",
+    "> **Rationale for the boundary penalty:** Without penalizing boundary contact, weight tuning would select extreme weights that produce visually implausible paths running along crop edges. The term $(1 - B(w))$ in the combined score elegantly suppresses these artifact weights."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d7b275b",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 5. Weight Tuning: Combined Score\n",
+    "\n",
+    "Compute the combined score $\\text{score}(w) = \\hat{H}(w) \\cdot (1 - B(w)) \\cdot P_{\\text{run}}(w)$\n",
+    "and select the optimal weight per cost model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a0e4e1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compute normalized Hausdorff, contiguous-run penalty, and combined score\n",
+    "tune_df = agg_df[agg_df[\"cost_model\"] != \"distance\"].copy()\n",
+    "\n",
+    "tune_df[\"h_norm\"] = tune_df.groupby(\"cost_model\")[\"mean_hausdorff\"].transform(\n",
+    "    lambda s: s / s.max() if s.max() > 0 else 0.0\n",
+    ")\n",
+    "\n",
+    "# Contiguous-run penalty: linear ramp from 1→0 between threshold and 2×threshold\n",
+    "tune_df[\"run_penalty\"] = 1.0 - np.clip(\n",
+    "    (tune_df[\"mean_max_contig_boundary\"] - MAX_BOUNDARY_RUN_FRAC) / MAX_BOUNDARY_RUN_FRAC,\n",
+    "    0.0,\n",
+    "    1.0,\n",
+    ")\n",
+    "\n",
+    "tune_df[\"score\"] = tune_df[\"h_norm\"] * (1.0 - tune_df[\"mean_boundary_frac\"]) * tune_df[\"run_penalty\"]\n",
+    "tune_df.sort_values([\"cost_model\", \"weight\"], inplace=True)\n",
+    "\n",
+    "tune_df[\n",
+    "    [\"cost_model\", \"weight\", \"h_norm\", \"mean_boundary_frac\", \"mean_max_contig_boundary\", \"run_penalty\", \"score\"]\n",
+    "].head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "50ac9e18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Select optimal weight per cost model\n",
+    "weights_tuned = {}\n",
+    "tuning_details = {}\n",
+    "\n",
+    "for cm in COST_MODELS_TUNABLE:\n",
+    "    cm_df = tune_df[tune_df[\"cost_model\"] == cm].sort_values(\"weight\")\n",
+    "    w_arr = cm_df[\"weight\"].values\n",
+    "    scores = cm_df[\"score\"].values\n",
+    "    hausdorffs = cm_df[\"mean_hausdorff\"].values\n",
+    "    b_fracs = cm_df[\"mean_boundary_frac\"].values\n",
+    "    contig_runs = cm_df[\"mean_max_contig_boundary\"].values\n",
+    "    run_pens = cm_df[\"run_penalty\"].values\n",
+    "\n",
+    "    max_score = scores.max()\n",
+    "    if max_score <= 0:\n",
+    "        weights_tuned[cm] = 1.0\n",
+    "        tuning_details[cm] = {\"max_score\": 0, \"chosen_idx\": 0}\n",
+    "        continue\n",
+    "\n",
+    "    # Among weights achieving >= SCORE_THRESHOLD of max, pick smallest\n",
+    "    candidates = np.where(scores >= SCORE_THRESHOLD * max_score)[0]\n",
+    "    idx = int(candidates[0]) if len(candidates) > 0 else int(np.argmax(scores))\n",
+    "\n",
+    "    weights_tuned[cm] = float(w_arr[idx])\n",
+    "    tuning_details[cm] = {\n",
+    "        \"max_score\": float(max_score),\n",
+    "        \"chosen_score\": float(scores[idx]),\n",
+    "        \"chosen_hausdorff\": float(hausdorffs[idx]),\n",
+    "        \"chosen_boundary_frac\": float(b_fracs[idx]),\n",
+    "        \"chosen_max_contig_run\": float(contig_runs[idx]),\n",
+    "        \"chosen_run_penalty\": float(run_pens[idx]),\n",
+    "        \"n_candidates\": len(candidates),\n",
+    "    }\n",
+    "\n",
+    "print(\"Tuned weights (Hausdorff + boundary + contig-run penalty + asymptote minimization):\")\n",
+    "for cm, w in sorted(weights_tuned.items()):\n",
+    "    d = tuning_details[cm]\n",
+    "    print(\n",
+    "        f\"  {cm:25s} -> w={w:12.1f}  \"\n",
+    "        f\"(score={d.get('chosen_score', 0):.4f}, \"\n",
+    "        f\"H={d.get('chosen_hausdorff', 0):.2f}, \"\n",
+    "        f\"B={d.get('chosen_boundary_frac', 0):.4f}, \"\n",
+    "        f\"C={d.get('chosen_max_contig_run', 0):.4f}, \"\n",
+    "        f\"P_run={d.get('chosen_run_penalty', 1):.3f})\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "377f2718",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 4-panel per-cost-model: Hausdorff | Boundary | Contig Run Penalty | Combined score\n",
+    "fig, axes = plt.subplots(n_cm, 4, figsize=(24, 5 * n_cm), squeeze=False)\n",
+    "fig.suptitle(\n",
+    "    f\"Weight Tuning (score threshold = {SCORE_THRESHOLD:.0%}, max contig run = {MAX_BOUNDARY_RUN_FRAC:.0%})\",\n",
+    "    fontsize=14,\n",
+    "    y=1.01,\n",
+    ")\n",
+    "\n",
+    "for row, cm in enumerate(COST_MODELS_TUNABLE):\n",
+    "    cm_df = tune_df[tune_df[\"cost_model\"] == cm].sort_values(\"weight\")\n",
+    "    ws = cm_df[\"weight\"].values\n",
+    "    hs = cm_df[\"mean_hausdorff\"].values\n",
+    "    bs = cm_df[\"mean_boundary_frac\"].values\n",
+    "    cs = cm_df[\"mean_max_contig_boundary\"].values\n",
+    "    rps = cm_df[\"run_penalty\"].values\n",
+    "    ss = cm_df[\"score\"].values\n",
+    "    w_opt = weights_tuned[cm]\n",
+    "\n",
+    "    # Col 0: Hausdorff\n",
+    "    ax = axes[row, 0]\n",
+    "    ax.plot(ws, hs, \"o-\", lw=1.5, color=\"tab:blue\")\n",
+    "    ax.axvline(w_opt, color=\"red\", ls=\"--\", lw=1, label=f\"w*={w_opt:.0f}\")\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.set_ylabel(\"Mean Hausdorff (px)\")\n",
+    "    ax.set_title(f\"{cm} — Hausdorff\")\n",
+    "    ax.legend(fontsize=8)\n",
+    "    ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "    # Col 1: Boundary fraction\n",
+    "    ax = axes[row, 1]\n",
+    "    ax.plot(ws, bs, \"s-\", lw=1.5, color=\"tab:orange\")\n",
+    "    ax.axvline(w_opt, color=\"red\", ls=\"--\", lw=1, label=f\"w*={w_opt:.0f}\")\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.set_ylabel(\"Mean boundary fraction\")\n",
+    "    ax.set_title(f\"{cm} — Boundary frac\")\n",
+    "    ax.legend(fontsize=8)\n",
+    "    ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "    # Col 2: Contiguous run & penalty\n",
+    "    ax = axes[row, 2]\n",
+    "    ax.plot(ws, cs, \"^-\", lw=1.5, color=\"tab:purple\", label=\"Mean max contig run\")\n",
+    "    ax.axhline(MAX_BOUNDARY_RUN_FRAC, color=\"gray\", ls=\":\", lw=1, label=f\"θ={MAX_BOUNDARY_RUN_FRAC:.0%}\")\n",
+    "    ax.axhline(\n",
+    "        2 * MAX_BOUNDARY_RUN_FRAC, color=\"gray\", ls=\"--\", lw=1, alpha=0.5, label=f\"2θ={2 * MAX_BOUNDARY_RUN_FRAC:.0%}\"\n",
+    "    )\n",
+    "    ax2 = ax.twinx()\n",
+    "    ax2.plot(ws, rps, \"v-\", lw=1, color=\"tab:red\", alpha=0.6, label=\"P_run\")\n",
+    "    ax2.set_ylabel(\"Run penalty P_run\", color=\"tab:red\", fontsize=8)\n",
+    "    ax2.set_ylim(-0.05, 1.15)\n",
+    "    ax.axvline(w_opt, color=\"red\", ls=\"--\", lw=1, label=f\"w*={w_opt:.0f}\")\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.set_ylabel(\"Max contiguous boundary frac\")\n",
+    "    ax.set_title(f\"{cm} — Contig Run\")\n",
+    "    # Merge legends from both axes\n",
+    "    h1, l1 = ax.get_legend_handles_labels()\n",
+    "    h2, l2 = ax2.get_legend_handles_labels()\n",
+    "    ax.legend(h1 + h2, l1 + l2, fontsize=7, loc=\"upper left\")\n",
+    "    ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "    # Col 3: Combined score\n",
+    "    ax = axes[row, 3]\n",
+    "    ax.plot(ws, ss, \"D-\", lw=1.5, color=\"tab:green\")\n",
+    "    max_s = ss.max()\n",
+    "    ax.axhline(SCORE_THRESHOLD * max_s, color=\"purple\", ls=\":\", lw=1, label=f\"{SCORE_THRESHOLD:.0%} threshold\")\n",
+    "    ax.axvline(w_opt, color=\"red\", ls=\"--\", lw=1, label=f\"w*={w_opt:.0f}\")\n",
+    "    opt_idx = int(np.searchsorted(ws, w_opt))\n",
+    "    ax.scatter([w_opt], [ss[min(opt_idx, len(ss) - 1)]], color=\"red\", s=60, zorder=10)\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.set_ylabel(\"Score = Ĥ·(1-B)·P_run\")\n",
+    "    ax.set_title(f\"{cm} — Score\")\n",
+    "    ax.legend(fontsize=8)\n",
+    "    ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "\n",
+    "    if row == n_cm - 1:\n",
+    "        for c in range(4):\n",
+    "            axes[row, c].set_xlabel(\"Weight\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f7edfec9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# All cost models overlaid: combined score vs weight\n",
+    "fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "\n",
+    "for cm in COST_MODELS_TUNABLE:\n",
+    "    cm_df = tune_df[tune_df[\"cost_model\"] == cm].sort_values(\"weight\")\n",
+    "    ax.plot(\n",
+    "        cm_df[\"weight\"],\n",
+    "        cm_df[\"score\"],\n",
+    "        \"o-\",\n",
+    "        lw=1.5,\n",
+    "        markersize=4,\n",
+    "        label=cm,\n",
+    "        color=CM_COLORS[cm],\n",
+    "    )\n",
+    "    # Mark chosen weight\n",
+    "    w_opt = weights_tuned[cm]\n",
+    "    opt_row = cm_df.iloc[(cm_df[\"weight\"] - w_opt).abs().argsort().iloc[0]]\n",
+    "    ax.scatter([w_opt], [opt_row[\"score\"]], color=\"red\", s=60, zorder=10, edgecolors=\"black\", linewidths=0.5)\n",
+    "    ax.annotate(\n",
+    "        f\"{w_opt:.0f}\",\n",
+    "        xy=(w_opt, opt_row[\"score\"]),\n",
+    "        xytext=(6, 6),\n",
+    "        textcoords=\"offset points\",\n",
+    "        fontsize=8,\n",
+    "        color=\"red\",\n",
+    "    )\n",
+    "\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_xlabel(\"Weight\")\n",
+    "ax.set_ylabel(\"Combined score\")\n",
+    "ax.set_title(\"Combined Score vs Weight (all tunable cost models)\")\n",
+    "ax.legend(fontsize=9)\n",
+    "ax.grid(True, ls=\":\", alpha=0.5)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a607f0fd",
+   "metadata": {},
+   "source": [
+    "### Analysis: Weight Tuning Results\n",
+    "\n",
+    "**4-panel per-model view (Hausdorff | Boundary | Contig Run | Score):**\n",
+    "Each row shows the four signals for one cost model. The red dashed line marks the selected weight $w^*$:\n",
+    "\n",
+    "- **Column 1 — Hausdorff:** Path diversity from the distance baseline (higher = more diverse).\n",
+    "- **Column 2 — Boundary fraction:** Overall fraction of path points near the edge.\n",
+    "- **Column 3 — Contiguous run penalty:** The purple curve shows the mean longest contiguous boundary run as a fraction of path length. The gray dotted/dashed lines mark the $\\theta$ (3%) and $2\\theta$ (6%) thresholds. The red overlay shows the resulting penalty $P_{\\text{run}}$: it equals 1.0 below $\\theta$, ramps linearly to 0.0 at $2\\theta$, and stays at 0.0 beyond. This penalizes weights where paths run along edges for extended stretches, especially affecting the `elevation` cost model.\n",
+    "- **Column 4 — Combined score:** The product $\\hat{H} \\cdot (1-B) \\cdot P_{\\text{run}}$.\n",
+    "\n",
+    "With $\\theta = 3\\%$, `elevation` now selects $w^* = 62.4$ — a compromise between the overly strict 1% threshold ($w^* = 11.9$) and the permissive 10% threshold ($w^* = 142.5$). At this weight, the elevation model achieves a Hausdorff distance of ~48 px with a contiguous run of ~2.6%, staying within the 3% bound. The score plateaus around 0.88, reflecting a good balance between path diversity and boundary control.\n",
+    "\n",
+    "> **Asymptote minimization principle:** Among all weights achieving $\\ge 95\\%$ of the peak score, we always pick the *smallest*. This avoids unnecessarily large weights that would waste computation on negligible improvements and risk overfitting the weight to specific terrain patterns."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43df6a25",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 6. Summary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aa498fb6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Summary table\n",
+    "summary_rows = []\n",
+    "for cm in sorted(weights_tuned.keys()):\n",
+    "    d = tuning_details[cm]\n",
+    "    summary_rows.append(\n",
+    "        {\n",
+    "            \"cost_model\": cm,\n",
+    "            \"weight\": weights_tuned[cm],\n",
+    "            \"score\": d.get(\"chosen_score\", 0),\n",
+    "            \"hausdorff\": d.get(\"chosen_hausdorff\", 0),\n",
+    "            \"boundary_frac\": d.get(\"chosen_boundary_frac\", 0),\n",
+    "            \"max_contig_run\": d.get(\"chosen_max_contig_run\", 0),\n",
+    "            \"run_penalty\": d.get(\"chosen_run_penalty\", 1),\n",
+    "        }\n",
+    "    )\n",
+    "\n",
+    "summary_table = pd.DataFrame(summary_rows).set_index(\"cost_model\")\n",
+    "display(summary_table)\n",
+    "\n",
+    "print(\"\\nFinal tuned weights:\")\n",
+    "for cm, w in sorted(weights_tuned.items()):\n",
+    "    print(f\"  {cm}: {w:.1f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "114dbff8",
+   "metadata": {},
+   "source": [
+    "### Summary Interpretation\n",
+    "\n",
+    "The summary table shows the final tuned weights with both boundary metrics:\n",
+    "\n",
+    "- **`boundary_frac`**: overall fraction of path points near edges (global average)\n",
+    "- **`max_contig_run`**: longest contiguous boundary segment as fraction of total path\n",
+    "- **`run_penalty`**: the multiplicative penalty applied from the contiguous-run constraint ($P_{\\text{run}}$)\n",
+    "\n",
+    "With $\\theta = 3\\%$, all tuned weights produce paths with contiguous runs below the threshold ($P_{\\text{run}} = 1.0$ for all). The `elevation` model selects $w^* = 62.4$ with a contiguous run of 2.6% — just under the 3% limit — while achieving a Hausdorff distance of ~48 px. The other three models remain unaffected since their contiguous runs are well below 1%.\n",
+    "\n",
+    "> **Practical implication:** These tuned weights can be used directly in `passage generate` to produce a balanced dataset of shortest-path annotations. Each cost model at its tuned weight creates meaningfully different paths from the distance baseline while keeping boundary artifacts — both overall and contiguous — under control."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "305f41f7",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 7. Final Visualization with Tuned Weights\n",
+    "\n",
+    "Show paths from all non-distance cost models at their tuned weight,\n",
+    "side by side on fresh samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d93cd7b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate display samples with tuned weights\n",
+    "t0 = time.time()\n",
+    "ctx = mp.get_context(\"fork\")\n",
+    "with ctx.Pool(NUM_WORKERS) as pool:\n",
+    "    results = list(\n",
+    "        tqdm(\n",
+    "            pool.imap_unordered(_process_one_display_sample, range(NUM_DISPLAY_SAMPLES)),\n",
+    "            total=NUM_DISPLAY_SAMPLES,\n",
+    "            desc=f\"Display samples ({NUM_WORKERS} workers)\",\n",
+    "        )\n",
+    "    )\n",
+    "\n",
+    "display_samples = sorted([r for r in results if r is not None], key=lambda s: s[\"index\"])\n",
+    "\n",
+    "elapsed = time.time() - t0\n",
+    "print(f\"Display samples: {len(display_samples)} in {elapsed:.1f}s ({NUM_WORKERS} workers)\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "feccd12f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize each display sample\n",
+    "display_cms = sorted(weights_tuned.keys())\n",
+    "n_cols = len(display_cms)\n",
+    "\n",
+    "legend_handles = [\n",
+    "    Line2D([0], [0], color=\"red\", lw=2, label=\"Tuned path\"),\n",
+    "    Line2D([0], [0], color=\"gray\", lw=1, ls=\"--\", label=\"Distance baseline\"),\n",
+    "    Line2D([0], [0], marker=\"o\", color=\"w\", markerfacecolor=\"lime\", markersize=6, label=\"Start\"),\n",
+    "    Line2D([0], [0], marker=\"x\", color=\"cyan\", markersize=6, label=\"End\"),\n",
+    "]\n",
+    "\n",
+    "for sample in display_samples:\n",
+    "    crop = sample[\"crop\"]\n",
+    "    start = sample[\"start\"]\n",
+    "    end = sample[\"end\"]\n",
+    "    paths = sample[\"paths\"]\n",
+    "    elev_min, elev_max = float(np.min(crop)), float(np.max(crop))\n",
+    "\n",
+    "    fig, axes = plt.subplots(1, n_cols, figsize=(5 * n_cols, 5))\n",
+    "    if n_cols == 1:\n",
+    "        axes = [axes]\n",
+    "\n",
+    "    for col, cm in enumerate(display_cms):\n",
+    "        ax = axes[col]\n",
+    "        ax.imshow(crop, cmap=\"terrain\", vmin=elev_min, vmax=elev_max, origin=\"upper\")\n",
+    "\n",
+    "        # Distance baseline in gray\n",
+    "        dp = paths.get(\"distance\", [])\n",
+    "        if len(dp) > 0:\n",
+    "            pa = np.array(dp)\n",
+    "            ax.plot(pa[:, 1], pa[:, 0], color=\"gray\", lw=1, ls=\"--\", alpha=0.6)\n",
+    "\n",
+    "        # Tuned path in red\n",
+    "        path = paths[cm]\n",
+    "        if len(path) > 0:\n",
+    "            pa = np.array(path)\n",
+    "            ax.plot(pa[:, 1], pa[:, 0], color=\"red\", lw=2)\n",
+    "\n",
+    "        ax.plot(start[1], start[0], \"o\", color=\"lime\", markersize=6)\n",
+    "        ax.plot(end[1], end[0], \"x\", color=\"cyan\", markersize=6)\n",
+    "        w = weights_tuned[cm]\n",
+    "        ax.set_title(f\"{cm}  (w={w:.0f})\", fontsize=10)\n",
+    "        ax.axis(\"off\")\n",
+    "\n",
+    "    fig.legend(handles=legend_handles, loc=\"upper right\", fontsize=8)\n",
+    "    fig.suptitle(f\"Sample {sample['index']}  |  elev=[{elev_min:.0f}, {elev_max:.0f}]\", fontsize=12)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5d9ef267",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# All tuned paths overlaid on a single elevation map per sample\n",
+    "for sample in display_samples:\n",
+    "    crop = sample[\"crop\"]\n",
+    "    start = sample[\"start\"]\n",
+    "    end = sample[\"end\"]\n",
+    "    paths = sample[\"paths\"]\n",
+    "    elev_min, elev_max = float(np.min(crop)), float(np.max(crop))\n",
+    "\n",
+    "    fig, ax = plt.subplots(figsize=(7, 7))\n",
+    "    ax.imshow(crop, cmap=\"terrain\", vmin=elev_min, vmax=elev_max, origin=\"upper\")\n",
+    "\n",
+    "    for cm in display_cms:\n",
+    "        path = paths[cm]\n",
+    "        if len(path) > 0:\n",
+    "            pa = np.array(path)\n",
+    "            ax.plot(pa[:, 1], pa[:, 0], lw=2, label=f\"{cm} (w={weights_tuned[cm]:.0f})\", color=CM_COLORS[cm])\n",
+    "\n",
+    "    # Distance baseline\n",
+    "    dp = paths.get(\"distance\", [])\n",
+    "    if len(dp) > 0:\n",
+    "        pa = np.array(dp)\n",
+    "        ax.plot(pa[:, 1], pa[:, 0], color=\"gray\", lw=1.5, ls=\"--\", label=\"distance\", alpha=0.7)\n",
+    "\n",
+    "    ax.plot(start[1], start[0], \"o\", color=\"lime\", markersize=8, zorder=10)\n",
+    "    ax.plot(end[1], end[0], \"x\", color=\"cyan\", markersize=8, zorder=10)\n",
+    "    ax.legend(fontsize=8, loc=\"lower left\")\n",
+    "    ax.set_title(f\"Sample {sample['index']}  |  elev=[{elev_min:.0f}, {elev_max:.0f}]\", fontsize=11)\n",
+    "    ax.axis(\"off\")\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ac43856",
+   "metadata": {},
+   "source": [
+    "### Analysis: Visual Validation of Tuned Weights\n",
+    "\n",
+    "**Side-by-side view** (one subplot per cost model): Each panel shows the tuned path (red) against the distance baseline (gray dashed). Key observations:\n",
+    "\n",
+    "- **`absolute_elevation`:** Paths are nearly identical to the distance baseline in most samples, consistent with its low Hausdorff distance (~5 px). This model is only useful for subtle variation.\n",
+    "- **`elevation`:** Produces the most visually distinct paths — long detours that follow contour lines, avoiding steep gradients. In some samples (e.g., mountainous terrain), the path may traverse the entire crop perimeter to stay on gentle slopes.\n",
+    "- **`energy`** and **`slope_uphill`:** Intermediate behavior — paths visibly avoid steep terrain but remain more direct than `elevation`. The difference between these two models is subtle and depends on whether the terrain has symmetric or asymmetric slopes.\n",
+    "\n",
+    "**Overlay view** (all models on one map): When multiple cost models are superimposed on the same elevation map, we can directly compare their routing strategies:\n",
+    "- On flat terrain (e.g., Sample 7 with elev=[0, 0]), all models produce identical straight-line paths — correct behavior since there is no terrain to avoid.\n",
+    "- On rugged terrain, the paths fan out, with `elevation` taking the widest detour and `absolute_elevation` staying closest to the diagonal.\n",
+    "- Samples near coastlines or tile edges (with zero-elevation ocean pixels) expose boundary-hugging behavior that our tuning procedure successfully mitigates — at the tuned weights, paths may approach but do not systematically follow the boundary.\n",
+    "\n",
+    "> **Validation:** The visual results confirm that the automated weight selection produces qualitatively sensible paths across diverse terrain conditions, and that none of the tuned weights lead to degenerate boundary-following behavior."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d2dc54b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "weights_tuned"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "passage",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/demo.ipynb

@@ -0,0 +1,361 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "64bb19d9",
+   "metadata": {},
+   "source": [
+    "MIT License\n",
+    "\n",
+    "Copyright (c) 2026 THALES\n",
+    "\n",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy\n",
+    "of this software and associated documentation files (the \"Software\"), to deal\n",
+    "in the Software without restriction, including without limitation the rights\n",
+    "to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n",
+    "copies of the Software, and to permit persons to whom the Software is\n",
+    "furnished to do so, subject to the following conditions:\n",
+    "\n",
+    "The above copyright notice and this permission notice shall be included in all\n",
+    "copies or substantial portions of the Software.\n",
+    "\n",
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n",
+    "AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n",
+    "OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n",
+    "SOFTWARE."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5d8c6d7",
+   "metadata": {},
+   "source": [
+    "# Demo: load and visualize dataset by resolution & split\n",
+    "This notebook demonstrates how to load a single sample from the generated dataset for a specific resolution and split, and visualize the full image and the three tensor layers:\n",
+    "\n",
+    "- Elevation (normalized float32) ✅\n",
+    "- Start / End markers (marker channel: -1 background, 0=start, 1=end) ✅\n",
+    "- Obstacles mask (binary) ✅"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd4ec8b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import datasets\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pathlib import Path\n",
+    "from passage.visualization import tensor_to_image\n",
+    "from passage.utils import decode_tensor_blob"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a51c7c0",
+   "metadata": {
+    "tags": [
+     "parameters"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "# Configuration: update these paths if needed\n",
+    "RESOLUTION = 256\n",
+    "SPLIT = \"train\"  # train / validation / test / calibration\n",
+    "\n",
+    "# Load solver names from config\n",
+    "ROOT = Path.cwd().parent if Path.cwd().name == \"notebooks\" else Path.cwd()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4fd1c106",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"Resolution: {RESOLUTION}, Split: {SPLIT}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a72ad7c1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds = datasets.load_dataset(\n",
+    "    \"thalesgroup/passage\",\n",
+    "    name=f\"{RESOLUTION}x{RESOLUTION}\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "60732416",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sample = ds[SPLIT][np.random.randint(len(ds[SPLIT]))]\n",
+    "sample.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "af722980",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if \"image\" in sample.keys():\n",
+    "    plt.imshow(sample[\"image\"])\n",
+    "    plt.axis(\"off\")\n",
+    "    plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b70dee9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "metadata = sample[\"metadata\"]\n",
+    "solvers = metadata[\"paths\"].keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f0b5e1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load paths for all solvers\n",
+    "solver_paths = {}\n",
+    "for solver_name in solvers:\n",
+    "    free_key = f\"path_{solver_name}_free\"\n",
+    "    obs_key = f\"path_{solver_name}_obstacles\"\n",
+    "    solver_paths[solver_name] = {\n",
+    "        \"free\": sample.get(free_key, []),\n",
+    "        \"obstacles\": sample.get(obs_key, []),\n",
+    "    }\n",
+    "    print(\n",
+    "        f\"{solver_name}: free={len(solver_paths[solver_name]['free'])} pts, obstacles={len(solver_paths[solver_name]['obstacles'])} pts\"\n",
+    "    )\n",
+    "\n",
+    "metadata = sample[\"metadata\"]\n",
+    "print(f\"\\nMetadata keys: {list(metadata.keys()) if isinstance(metadata, dict) else 'N/A'}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8bdad721",
+   "metadata": {},
+   "source": [
+    "**NOTE**: Be careful, in order to optimize storage, tensors are saved in **compressed** format. They need to be uncompressed using `decode_tensor_blob` function!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4fef0c42",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tensor = decode_tensor_blob(sample[\"tensor\"], (RESOLUTION, RESOLUTION, 3))\n",
+    "print(\"tensor.shape:\", tensor.shape, \"dtype:\", tensor.dtype)\n",
+    "\n",
+    "elevation = (\n",
+    "    tensor[:, :, 0] * (metadata[\"calibration\"][\"max\"] - metadata[\"calibration\"][\"min\"]) + metadata[\"calibration\"][\"min\"]\n",
+    ")\n",
+    "marker = tensor[:, :, 1]\n",
+    "obstacles = tensor[:, :, 2]\n",
+    "\n",
+    "print(\"Elevation min/max:\", float(elevation.min()), float(elevation.max()))\n",
+    "print(\"Marker unique values:\", np.unique(marker)[:10])\n",
+    "print(\"Obstacles unique values:\", np.unique(obstacles)[:10])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a81ada6e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img_bgr = tensor_to_image(tensor)\n",
+    "img_rgb = img_bgr[:, :, ::-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2c9eaa83",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize each channel and paths for all solvers\n",
+    "n_solvers = len(solvers)\n",
+    "n_base_plots = 3  # Elevation, Obstacles, Markers\n",
+    "n_path_plots = n_solvers * 2  # free + obstacles for each solver\n",
+    "n_plots = n_base_plots + n_path_plots\n",
+    "\n",
+    "fig, axes = plt.subplots(1, len(solvers), figsize=(15, 15 * len(solvers)))\n",
+    "\n",
+    "for i, solver_name in enumerate(solvers):\n",
+    "    ax = axes[i]\n",
+    "    img_bgr = tensor_to_image(tensor, solver_paths[solver_name][\"free\"], solver_paths[solver_name][\"obstacles\"])\n",
+    "    img_rgb = img_bgr[:, :, ::-1]\n",
+    "    ax.imshow(img_rgb)\n",
+    "    ax.set_title(f\"Paths from {solver_name}\")\n",
+    "    ax.axis(\"off\")\n",
+    "\n",
+    "fig.show()\n",
+    "\n",
+    "fig, axes = plt.subplots(n_plots, figsize=(10, 10 * n_plots))\n",
+    "if n_plots == 1:\n",
+    "    axes = [axes]\n",
+    "\n",
+    "# 2. Elevation\n",
+    "ax = axes[0]\n",
+    "im = ax.imshow(elevation, cmap=\"terrain\")\n",
+    "plt.colorbar(im, ax=ax)\n",
+    "ax.set_title(\"Elevation (normalized)\")\n",
+    "ax.axis(\"off\")\n",
+    "\n",
+    "# 3. Obstacles\n",
+    "ax = axes[1]\n",
+    "ax.imshow(obstacles, cmap=\"gray\")\n",
+    "ax.set_title(\"Obstacles (mask)\")\n",
+    "ax.axis(\"off\")\n",
+    "\n",
+    "# 4. Markers\n",
+    "ax = axes[2]\n",
+    "start_mask = marker == 0.0\n",
+    "end_mask = marker == 1.0\n",
+    "combined = np.zeros((marker.shape[0], marker.shape[1], 3), dtype=np.uint8)\n",
+    "combined[start_mask] = [0, 255, 255]  # cyan for start\n",
+    "combined[end_mask] = [0, 0, 255]  # blue for end\n",
+    "ax.imshow(combined)\n",
+    "ax.set_title(\"Markers — cyan=start, blue=end\")\n",
+    "ax.axis(\"off\")\n",
+    "\n",
+    "# 5+. Path visualizations per solver\n",
+    "colors_free = plt.cm.tab10.colors  # Different colors for each solver\n",
+    "colors_obs = plt.cm.Set2.colors\n",
+    "ax_idx = 3\n",
+    "for solver_idx, solver_name in enumerate(solvers):\n",
+    "    free_path = solver_paths[solver_name][\"free\"]\n",
+    "    obs_path = solver_paths[solver_name][\"obstacles\"]\n",
+    "\n",
+    "    # Free path\n",
+    "    ax = axes[ax_idx]\n",
+    "    paths_img = np.zeros((marker.shape[0], marker.shape[1], 3), dtype=np.uint8)\n",
+    "    color_free = [int(c * 255) for c in colors_free[solver_idx % len(colors_free)][:3]]\n",
+    "    for x, y in free_path:\n",
+    "        if 0 <= x < paths_img.shape[0] and 0 <= y < paths_img.shape[1]:\n",
+    "            paths_img[x, y] = color_free\n",
+    "    ax.imshow(paths_img)\n",
+    "    ax.set_title(f\"{solver_name}: Free Path (n={len(free_path)} pts)\")\n",
+    "    ax.axis(\"off\")\n",
+    "    ax_idx += 1\n",
+    "\n",
+    "    # Obstacles path\n",
+    "    ax = axes[ax_idx]\n",
+    "    paths_img = np.zeros((marker.shape[0], marker.shape[1], 3), dtype=np.uint8)\n",
+    "    color_obs = [int(c * 255) for c in colors_obs[solver_idx % len(colors_obs)][:3]]\n",
+    "    for x, y in obs_path:\n",
+    "        if 0 <= x < paths_img.shape[0] and 0 <= y < paths_img.shape[1]:\n",
+    "            paths_img[x, y] = color_obs\n",
+    "    ax.imshow(paths_img)\n",
+    "    ax.set_title(f\"{solver_name}: Obstacles Path (n={len(obs_path)} pts)\")\n",
+    "    ax.axis(\"off\")\n",
+    "    ax_idx += 1\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "963e943c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# All solver paths overlaid for comparison\n",
+    "if solvers:\n",
+    "    fig, axes = plt.subplots(1, 2, figsize=(16, 8))\n",
+    "\n",
+    "    # Free paths comparison\n",
+    "    ax = axes[0]\n",
+    "    paths_overlay = np.zeros((marker.shape[0], marker.shape[1], 3), dtype=np.uint8)\n",
+    "    for solver_idx, solver_name in enumerate(solvers):\n",
+    "        free_path = solver_paths[solver_name][\"free\"]\n",
+    "        color = [int(c * 255) for c in plt.cm.tab10.colors[solver_idx % 10][:3]]\n",
+    "        for x, y in free_path:\n",
+    "            if 0 <= x < paths_overlay.shape[0] and 0 <= y < paths_overlay.shape[1]:\n",
+    "                paths_overlay[x, y] = color\n",
+    "    ax.imshow(paths_overlay)\n",
+    "    ax.set_title(\"All Solvers: Free Paths Overlay\")\n",
+    "    ax.axis(\"off\")\n",
+    "    # Add legend\n",
+    "    from matplotlib.patches import Patch\n",
+    "\n",
+    "    legend_elements = [Patch(facecolor=plt.cm.tab10.colors[i % 10], label=s) for i, s in enumerate(solvers)]\n",
+    "    ax.legend(handles=legend_elements, loc=\"upper right\", fontsize=8)\n",
+    "\n",
+    "    # Obstacles paths comparison\n",
+    "    ax = axes[1]\n",
+    "    paths_overlay = np.zeros((marker.shape[0], marker.shape[1], 3), dtype=np.uint8)\n",
+    "    for solver_idx, solver_name in enumerate(solvers):\n",
+    "        obs_path = solver_paths[solver_name][\"obstacles\"]\n",
+    "        color = [int(c * 255) for c in plt.cm.tab10.colors[solver_idx % 10][:3]]\n",
+    "        for x, y in obs_path:\n",
+    "            if 0 <= x < paths_overlay.shape[0] and 0 <= y < paths_overlay.shape[1]:\n",
+    "                paths_overlay[x, y] = color\n",
+    "    ax.imshow(paths_overlay)\n",
+    "    ax.set_title(\"All Solvers: Obstacles Paths Overlay\")\n",
+    "    ax.axis(\"off\")\n",
+    "    ax.legend(handles=legend_elements, loc=\"upper right\", fontsize=8)\n",
+    "\n",
+    "    plt.suptitle(f\"Solver Path Comparison (Resolution: {RESOLUTION})\", fontsize=14, fontweight=\"bold\")\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "else:\n",
+    "    print(\"No solvers configured.\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "passage (3.12.3)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/obstacles.ipynb

@@ -0,0 +1,435 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e51ffcfb",
+   "metadata": {},
+   "source": [
+    "MIT License\n",
+    "\n",
+    "Copyright (c) 2026 THALES\n",
+    "\n",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy\n",
+    "of this software and associated documentation files (the \"Software\"), to deal\n",
+    "in the Software without restriction, including without limitation the rights\n",
+    "to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n",
+    "copies of the Software, and to permit persons to whom the Software is\n",
+    "furnished to do so, subject to the following conditions:\n",
+    "\n",
+    "The above copyright notice and this permission notice shall be included in all\n",
+    "copies or substantial portions of the Software.\n",
+    "\n",
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n",
+    "AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n",
+    "OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n",
+    "SOFTWARE."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "34f045f2",
+   "metadata": {},
+   "source": [
+    "# Obstacle Mask Generation\n",
+    "\n",
+    "This notebook loads an elevation sample and markers, then generates an obstacle mask using randomized superellipses. The obstacle mask uses **0** for valid path cells and **1** for forbidden cells."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c019cfff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import logging\n",
+    "import sys\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import yaml\n",
+    "from passage.utils import load_tensor, TENSOR_SUFFIX\n",
+    "from loguru import logger as loguru_logger\n",
+    "\n",
+    "# Configure info logging\n",
+    "logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\")\n",
+    "logger = logging.getLogger(__name__)\n",
+    "logger.setLevel(logging.INFO)\n",
+    "\n",
+    "# Configure loguru for info level\n",
+    "loguru_logger.remove()\n",
+    "loguru_logger.add(sys.stderr, level=\"INFO\")\n",
+    "\n",
+    "ROOT = Path(\"..\").resolve()\n",
+    "sys.path.insert(0, str(ROOT / \"src\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "094ec38b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from passage.generate import (\n",
+    "    _generate_obstacles_mask,\n",
+    "    _resolve_obstacle_config,\n",
+    "    _resolve_solver_config,\n",
+    "    generate_sample,\n",
+    "    lat_to_str,\n",
+    "    lon_to_str,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b3e5dbf",
+   "metadata": {
+    "tags": [
+     "parameters"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "# Parameters (papermill)\n",
+    "RESOLUTION = 512\n",
+    "SAMPLE_INDEX = 0\n",
+    "CENTER_LAT = None\n",
+    "CENTER_LON = None\n",
+    "DISABLE_IMAGES = False\n",
+    "OVERRIDE_EXISTING = True\n",
+    "NUM_MASKS_TO_GENERATE = 30"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d122918f",
+   "metadata": {},
+   "source": [
+    "## Configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "939fb066",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Paths\n",
+    "OUTPUTS_DIR = ROOT / \"outputs\" / \"obstacles\"\n",
+    "TILES_DIR = ROOT / \"outputs\" / \"download\" / \"tiles\"\n",
+    "CALIBRATE_PATH = ROOT / \"outputs\" / \"calibrate\" / \"calibrate.json\"\n",
+    "CONFIG_PATH = ROOT / \"config\" / \"config.yaml\"\n",
+    "\n",
+    "with open(CONFIG_PATH) as f:\n",
+    "    config = yaml.safe_load(f) or {}\n",
+    "\n",
+    "# read obstacles config\n",
+    "obstacles_cfg = config.get(\"obstacles\", {})\n",
+    "OBSTACLES_ENABLED = bool(obstacles_cfg.get(\"enabled\", False))\n",
+    "OBSTACLE_RATIO_MAX = float(obstacles_cfg.get(\"ratio_max\", 0.2))\n",
+    "shape_cfg = obstacles_cfg.get(\"shape\", {})\n",
+    "size_cfg = shape_cfg.get(\"size\", {})\n",
+    "OBSTACLE_SIZE_MIN_RATIO = float(size_cfg.get(\"min_ratio\", 0.20))\n",
+    "OBSTACLE_SIZE_MAX_RATIO = float(size_cfg.get(\"max_ratio\", 0.50))\n",
+    "N_CFG = shape_cfg.get(\"n\", {})\n",
+    "N_DISTRIBUTION_CFG = N_CFG.get(\"distribution\", {})\n",
+    "\n",
+    "# generation tuning\n",
+    "GENERATION_CFG = obstacles_cfg.get(\"generation\", {})\n",
+    "obstacle_settings = _resolve_obstacle_config(config)\n",
+    "\n",
+    "# Obstacle mask generation settings\n",
+    "NUM_MASKS_MAX = 40  # Upper bound constant (used for display/experiments)\n",
+    "NUM_MASKS_TO_GENERATE = 20  # Number of masks to generate and display (<= NUM_MASKS_MAX)\n",
+    "\n",
+    "COST_MODEL = (\n",
+    "    config.get(\"solver\", {}).get(\"grid\", {}).get(\"cost_model\")\n",
+    "    or config.get(\"solver\", {}).get(\"networkx\", {}).get(\"cost_model\")\n",
+    "    or config.get(\"solver\", {}).get(\"pathfinding\", {}).get(\"cost_model\")\n",
+    "    or \"elevation\"\n",
+    ")\n",
+    "\n",
+    "# Solver defaults for sample generation read from config\n",
+    "GEN_SOLVER_CONFIG = _resolve_solver_config(config.get(\"solver\", {}))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "229302ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Shape and n distribution config (nested structure)\n",
+    "shape_cfg = obstacles_cfg.get(\"shape\", {})\n",
+    "size_cfg = shape_cfg.get(\"size\", {})\n",
+    "OBSTACLE_SIZE_MIN_RATIO = float(size_cfg.get(\"min_ratio\", 0.20))\n",
+    "OBSTACLE_SIZE_MAX_RATIO = float(size_cfg.get(\"max_ratio\", 0.50))\n",
+    "N_CFG = shape_cfg.get(\"n\", {})\n",
+    "N_DISTRIBUTION_CFG = N_CFG.get(\"distribution\", {})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a57eb31",
+   "metadata": {},
+   "source": [
+    "**Note:** The superellipse exponent `n` may be sampled from different distributions configured under `shape.n.distribution`:\n",
+    "\n",
+    "- `log_uniform` (default)\n",
+    "- `uniform`\n",
+    "- `beta`\n",
+    "- `exponential` (new): accepts parameter `lambda` (rate) to bias toward lower values; example: `{\"type\": \"exponential\", \"lambda\": 2.0}`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff613d2d",
+   "metadata": {},
+   "source": [
+    "## Load or Generate Sample"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7195444e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Validate required inputs\n",
+    "if not CALIBRATE_PATH.exists():\n",
+    "    raise FileNotFoundError(f\"Calibration file not found: {CALIBRATE_PATH}. Run 'passage calibrate' first.\")\n",
+    "if not TILES_DIR.exists():\n",
+    "    raise FileNotFoundError(f\"Tiles directory not found: {TILES_DIR}. Run 'passage download' first.\")\n",
+    "\n",
+    "# Load calibration data\n",
+    "with open(CALIBRATE_PATH) as f:\n",
+    "    calibration = json.load(f)\n",
+    "global_min = float(calibration[\"global_min\"])\n",
+    "global_max = float(calibration[\"global_max\"])\n",
+    "tile_stats_df = pd.DataFrame(calibration[\"tile_stats\"])\n",
+    "\n",
+    "# Import tensor utilities\n",
+    "\n",
+    "\n",
+    "def resolve_sample_paths(outputs_dir: Path, resolution: int, index: int, center_lat=None, center_lon=None):\n",
+    "    \"\"\"Resolve tensor and metadata paths, supporting both compressed (.npy.zst) and legacy (.npy) formats.\"\"\"\n",
+    "    tensors_root = outputs_dir / str(resolution) / \"tensors\"\n",
+    "    metadata_root = outputs_dir / str(resolution) / \"metadata\"\n",
+    "    if center_lat is not None and center_lon is not None:\n",
+    "        lat_dir = lat_to_str(int(center_lat))\n",
+    "        lon_dir = lon_to_str(int(center_lon))\n",
+    "        # Try compressed format first, fall back to legacy\n",
+    "        tensor_path_compressed = tensors_root / lat_dir / lon_dir / f\"{index:010d}{TENSOR_SUFFIX}\"\n",
+    "        tensor_path_legacy = tensors_root / lat_dir / lon_dir / f\"{index:010d}.npy\"\n",
+    "        tensor_path = tensor_path_compressed if tensor_path_compressed.exists() else tensor_path_legacy\n",
+    "        metadata_path = metadata_root / lat_dir / lon_dir / f\"{index:010d}.yaml\"\n",
+    "        return tensor_path, metadata_path\n",
+    "    # Search for tensor with either suffix\n",
+    "    tensor_matches_compressed = list(tensors_root.rglob(f\"{index:010d}{TENSOR_SUFFIX}\"))\n",
+    "    tensor_matches_legacy = list(tensors_root.rglob(f\"{index:010d}.npy\"))\n",
+    "    tensor_matches = tensor_matches_compressed or tensor_matches_legacy\n",
+    "    metadata_matches = list(metadata_root.rglob(f\"{index:010d}.yaml\"))\n",
+    "    tensor_path = tensor_matches[0] if tensor_matches else tensors_root / f\"{index:010d}{TENSOR_SUFFIX}\"\n",
+    "    metadata_path = metadata_matches[0] if metadata_matches else metadata_root / f\"{index:010d}.yaml\"\n",
+    "    return tensor_path, metadata_path\n",
+    "\n",
+    "\n",
+    "def load_tensor_compat(path: Path, resolution: int) -> np.ndarray:\n",
+    "    \"\"\"Load a tensor from either compressed (.npy.zst) or legacy (.npy) format.\"\"\"\n",
+    "    if path.suffix == \".zst\" or str(path).endswith(TENSOR_SUFFIX):\n",
+    "        return load_tensor(path, (resolution, resolution, 3), \"float32\")\n",
+    "    else:\n",
+    "        return np.load(path)\n",
+    "\n",
+    "\n",
+    "tensor_path, metadata_path = resolve_sample_paths(OUTPUTS_DIR, RESOLUTION, SAMPLE_INDEX, CENTER_LAT, CENTER_LON)\n",
+    "\n",
+    "if OVERRIDE_EXISTING or not tensor_path.exists() or not metadata_path.exists():\n",
+    "    OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "    args = (\n",
+    "        SAMPLE_INDEX,\n",
+    "        TILES_DIR,\n",
+    "        OUTPUTS_DIR,\n",
+    "        RESOLUTION,\n",
+    "        tile_stats_df,\n",
+    "        global_min,\n",
+    "        global_max,\n",
+    "        DISABLE_IMAGES,\n",
+    "        GEN_SOLVER_CONFIG,\n",
+    "        obstacle_settings,\n",
+    "    )\n",
+    "    index, success, message, duration = generate_sample(args)\n",
+    "    print(f\"Generate sample: success={success}, message='{message}', duration={duration:.2f}s\")\n",
+    "    if not success:\n",
+    "        raise RuntimeError(\"Sample generation failed. Try a different resolution or re-run calibration.\")\n",
+    "    # Re-resolve paths after generation (new format)\n",
+    "    tensor_path, metadata_path = resolve_sample_paths(OUTPUTS_DIR, RESOLUTION, SAMPLE_INDEX, CENTER_LAT, CENTER_LON)\n",
+    "else:\n",
+    "    print(f\"Using existing tensor: {tensor_path}\")\n",
+    "\n",
+    "tensor = load_tensor_compat(tensor_path, RESOLUTION)\n",
+    "elevation_norm = tensor[:, :, 0]\n",
+    "marker_channel = tensor[:, :, 1]\n",
+    "obstacle_channel = tensor[:, :, 2] if tensor.shape[2] > 2 else np.zeros_like(marker_channel)\n",
+    "elevation_raw = elevation_norm * (global_max - global_min) + global_min\n",
+    "\n",
+    "print(f\"Loaded tensor shape: {tensor.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "009b48e9",
+   "metadata": {},
+   "source": [
+    "## Obstacle Generation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dbdef6b0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Using _generate_obstacles_mask from generate.py\n",
+    "# The function signature is:\n",
+    "# _generate_obstacles_mask(\n",
+    "#     shape, ratio_max, size_min_ratio, size_max_ratio, obstacles_cfg,\n",
+    "#     marker_positions=None, rng=None, max_attempts=None, generation_cfg=None\n",
+    "# ) -> tuple[np.ndarray, float]\n",
+    "#\n",
+    "# Note: obstacles_cfg is required and contains the full obstacles config dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ada07c41",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start_positions = np.argwhere(np.isclose(marker_channel, 0.0))\n",
+    "end_positions = np.argwhere(marker_channel > 0.5)\n",
+    "marker_positions = np.vstack([start_positions, end_positions])\n",
+    "\n",
+    "# Respect the notebook-level constants and ensure we don't exceed the defined maximum\n",
+    "NUM_MASKS = min(NUM_MASKS_TO_GENERATE, NUM_MASKS_MAX)\n",
+    "\n",
+    "masks = []\n",
+    "ratios = []\n",
+    "for i in range(NUM_MASKS):\n",
+    "    # Use _generate_obstacles_mask from generate.py\n",
+    "    mask, ratio = _generate_obstacles_mask(\n",
+    "        shape=elevation_raw.shape,\n",
+    "        ratio_max=OBSTACLE_RATIO_MAX,\n",
+    "        size_min_ratio=OBSTACLE_SIZE_MIN_RATIO,\n",
+    "        size_max_ratio=OBSTACLE_SIZE_MAX_RATIO,\n",
+    "        obstacles_cfg=obstacles_cfg,\n",
+    "        marker_positions=marker_positions,\n",
+    "        generation_cfg=GENERATION_CFG,\n",
+    "    )\n",
+    "    masks.append(mask)\n",
+    "    ratios.append(ratio)\n",
+    "\n",
+    "masks_arr = np.stack(masks, axis=0)\n",
+    "\n",
+    "# Choose the first generated mask as the active obstacles_mask for downstream cells\n",
+    "obstacles_mask = masks_arr[0]\n",
+    "tensor_with_obstacles = np.stack([elevation_norm, marker_channel, obstacles_mask], axis=-1)\n",
+    "\n",
+    "print(f\"Generated {NUM_MASKS} obstacle masks (displaying {NUM_MASKS}).\")\n",
+    "print(f\"Target obstacle ratio stats: min={min(ratios):.3f}, mean={np.mean(ratios):.3f}, max={max(ratios):.3f}\")\n",
+    "print(f\"Tensor with obstacles shape: {tensor_with_obstacles.shape}\")\n",
+    "\n",
+    "# Display the masks in a compact grid gallery\n",
+    "n = masks_arr.shape[0]\n",
+    "cols = min(5, n)\n",
+    "rows = int(np.ceil(n / cols))\n",
+    "\n",
+    "fig, axes = plt.subplots(rows, cols, figsize=(4 * cols, 4 * rows))\n",
+    "if rows == 1:\n",
+    "    axes = axes.reshape(1, -1)\n",
+    "if cols == 1:\n",
+    "    axes = axes.reshape(-1, 1)\n",
+    "\n",
+    "for idx in range(n):\n",
+    "    r = idx // cols\n",
+    "    c = idx % cols\n",
+    "    axes[r, c].imshow(masks_arr[idx], cmap=\"gray\", origin=\"upper\")\n",
+    "    axes[r, c].set_title(f\"Mask {idx} (r={ratios[idx]:.3f})\", fontsize=9)\n",
+    "    axes[r, c].axis(\"off\")\n",
+    "\n",
+    "# Hide empty subplots\n",
+    "for idx in range(n, rows * cols):\n",
+    "    r = idx // cols\n",
+    "    c = idx % cols\n",
+    "    axes[r, c].axis(\"off\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b4e554d",
+   "metadata": {},
+   "source": [
+    "## Pathfinding (grid:astar)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a28f930",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start_positions = np.argwhere(np.isclose(marker_channel, 0.0))\n",
+    "end_positions = np.argwhere(marker_channel > 0.5)\n",
+    "if start_positions.shape[0] < 1 or end_positions.shape[0] < 1:\n",
+    "    raise RuntimeError(\"Expected start and end markers in marker channel.\")\n",
+    "\n",
+    "start = tuple(start_positions[0])\n",
+    "end = tuple(end_positions[0])\n",
+    "\n",
+    "# Resolve solver config from config.yaml (supports common + backend sections)\n",
+    "solver_config = _resolve_solver_config(config.get(\"solver\", {}))\n",
+    "# Ensure sensible defaults\n",
+    "solver_config.setdefault(\"diagonal_movement\", \"always\")\n",
+    "solver_config.setdefault(\"weight\", 30.0)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "passage (3.12.3)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/solve.ipynb

@@ -0,0 +1,684 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "969eb9d5",
+   "metadata": {},
+   "source": [
+    "MIT License\n",
+    "\n",
+    "Copyright (c) 2026 THALES\n",
+    "\n",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy\n",
+    "of this software and associated documentation files (the \"Software\"), to deal\n",
+    "in the Software without restriction, including without limitation the rights\n",
+    "to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n",
+    "copies of the Software, and to permit persons to whom the Software is\n",
+    "furnished to do so, subject to the following conditions:\n",
+    "\n",
+    "The above copyright notice and this permission notice shall be included in all\n",
+    "copies or substantial portions of the Software.\n",
+    "\n",
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n",
+    "AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n",
+    "OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n",
+    "SOFTWARE."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b0f8c0e",
+   "metadata": {},
+   "source": [
+    "# Solver Comparison (NetworkX + Pathfinding + Grid)\n",
+    "\n",
+    "This notebook generates a single sample at a chosen resolution using `passage.generate.generate_sample`,\n",
+    "then compares NetworkX, Pathfinding and internal Grid (NumPy) solvers from `passage.generate.find_path`.\n",
+    "\n",
+    "It records computation time, summarizes results, and visualizes all paths on the elevation map.\n",
+    "\n",
+    "We report solve time statistics; for a set of times $t_i$, the mean is $\\mu = \\frac{1}{N}\\sum_i t_i$ and the maximum is $\\max_i t_i$.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb548b04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import logging\n",
+    "import sys\n",
+    "import time\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.cm as cm\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import yaml\n",
+    "from loguru import logger as loguru_logger\n",
+    "\n",
+    "# Configure info logging\n",
+    "logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\")\n",
+    "logger = logging.getLogger(__name__)\n",
+    "logger.setLevel(logging.INFO)\n",
+    "\n",
+    "# Configure loguru for info level\n",
+    "loguru_logger.remove()\n",
+    "loguru_logger.add(sys.stderr, level=\"INFO\")\n",
+    "\n",
+    "# Add src to path for imports\n",
+    "ROOT = Path(\"..\").resolve()\n",
+    "sys.path.insert(0, str(ROOT / \"src\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "625f6f13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from passage.generate import generate_sample, find_path, lat_to_str, lon_to_str, _resolve_obstacle_config\n",
+    "from passage.visualization import tensor_to_image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2baab49f",
+   "metadata": {
+    "tags": [
+     "parameters"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "# Parameters (papermill)\n",
+    "RESOLUTION = 512"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "94a64955",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solvers list (moved to top for visibility)\n",
+    "CONFIG_PATH = ROOT / \"config\" / \"config.yaml\"\n",
+    "DEFAULT_COST_MODEL = \"elevation\"\n",
+    "\n",
+    "try:\n",
+    "    with open(CONFIG_PATH) as f:\n",
+    "        _config = yaml.safe_load(f) or {}\n",
+    "    _solver_cfg = _config.get(\"solver\", {})\n",
+    "    _obstacle_settings = _resolve_obstacle_config(_config)\n",
+    "    COST_MODEL = (\n",
+    "        _solver_cfg.get(\"grid\", {}).get(\"cost_model\")\n",
+    "        or _solver_cfg.get(\"networkx\", {}).get(\"cost_model\")\n",
+    "        or _solver_cfg.get(\"pathfinding\", {}).get(\"cost_model\")\n",
+    "        or DEFAULT_COST_MODEL\n",
+    "    )\n",
+    "    OBSTACLES_ENABLED = bool(_obstacle_settings.get(\"enabled\", False))\n",
+    "    OBSTACLE_PENALTY = float(_obstacle_settings.get(\"obstacle_penalty\", 1e8))\n",
+    "except Exception:\n",
+    "    COST_MODEL = DEFAULT_COST_MODEL\n",
+    "    OBSTACLES_ENABLED = False\n",
+    "    OBSTACLE_PENALTY = 1e8\n",
+    "\n",
+    "SOLVERS = [\n",
+    "    # NetworkX\n",
+    "    {\"name\": \"networkx:astar\", \"heuristic\": \"euclidean\", \"cost_model\": COST_MODEL, \"label\": \"NetworkX A* (Euclidean)\"},\n",
+    "    {\n",
+    "        \"name\": \"networkx:astar_bi\",\n",
+    "        \"heuristic\": \"euclidean\",\n",
+    "        \"cost_model\": COST_MODEL,\n",
+    "        \"label\": \"NetworkX A* (Bidirectional)\",\n",
+    "    },\n",
+    "    {\"name\": \"networkx:dijkstra\", \"cost_model\": COST_MODEL, \"label\": \"NetworkX Dijkstra\"},\n",
+    "    {\"name\": \"networkx:dijkstra_bi\", \"cost_model\": COST_MODEL, \"label\": \"NetworkX Dijkstra (Bidirectional)\"},\n",
+    "    {\"name\": \"networkx:bellman_ford\", \"cost_model\": COST_MODEL, \"label\": \"NetworkX Bellman-Ford\"},\n",
+    "    {\"name\": \"networkx:unweighted\", \"cost_model\": COST_MODEL, \"label\": \"NetworkX Unweighted (BFS)\"},\n",
+    "    # Pathfinding\n",
+    "    {\n",
+    "        \"name\": \"pathfinding:astar\",\n",
+    "        \"heuristic\": \"euclidean\",\n",
+    "        \"cost_model\": COST_MODEL,\n",
+    "        \"label\": \"Pathfinding A* (Euclidean)\",\n",
+    "    },\n",
+    "    {\"name\": \"pathfinding:dijkstra\", \"cost_model\": COST_MODEL, \"label\": \"Pathfinding Dijkstra\"},\n",
+    "    {\n",
+    "        \"name\": \"pathfinding:best_first\",\n",
+    "        \"heuristic\": \"euclidean\",\n",
+    "        \"cost_model\": COST_MODEL,\n",
+    "        \"label\": \"Pathfinding Best-First\",\n",
+    "    },\n",
+    "    # Grid (NumPy-based internal solvers)\n",
+    "    {\"name\": \"grid:astar\", \"heuristic\": \"euclidean\", \"cost_model\": COST_MODEL, \"label\": \"Grid A* (NumPy)\"},\n",
+    "    {\"name\": \"grid:dijkstra\", \"cost_model\": COST_MODEL, \"label\": \"Grid Dijkstra (NumPy)\"},\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0e9f208",
+   "metadata": {},
+   "source": [
+    "## Configuration\n",
+    "\n",
+    "Choose a resolution and where to store the generated sample."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c8de1380",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Sample generation settings\n",
+    "RESOLUTION = 256  # 64, 128, 256, 512, 1024, 2048, 4096\n",
+    "SAMPLE_INDEX = 0\n",
+    "CENTER_LAT = None  # Set to int if known\n",
+    "CENTER_LON = None  # Set to int if known\n",
+    "DISABLE_IMAGES = False\n",
+    "OVERRIDE_EXISTING = True\n",
+    "\n",
+    "# Paths\n",
+    "OUTPUTS_DIR = ROOT / \"outputs\" / \"solve\"\n",
+    "TILES_DIR = ROOT / \"outputs\" / \"download\" / \"tiles\"\n",
+    "CALIBRATE_PATH = ROOT / \"outputs\" / \"calibrate\" / \"calibrate.json\"\n",
+    "OBSTACLE_SETTINGS = _resolve_obstacle_config(_config if \"_config\" in globals() else {})\n",
+    "USE_OBSTACLES = bool(OBSTACLE_SETTINGS.get(\"enabled\", False))\n",
+    "OBSTACLE_PENALTY = float(OBSTACLE_SETTINGS.get(\"obstacle_penalty\", 1e8))\n",
+    "\n",
+    "# Solver defaults for sample generation (used only to ensure a valid path exists)\n",
+    "GEN_SOLVER_CONFIG = {\n",
+    "    \"name\": \"grid:astar\",\n",
+    "    \"diagonal_movement\": \"always\",\n",
+    "    \"weight\": 30.0,\n",
+    "    \"cost_model\": COST_MODEL,\n",
+    "    \"heuristic\": \"euclidean\",\n",
+    "}\n",
+    "\n",
+    "# Solver comparison settings\n",
+    "WEIGHT = 30.0\n",
+    "DIAGONAL_MOVEMENT = \"always\"\n",
+    "COST_MODEL = COST_MODEL  # Pathfinding supports elevation, distance, absolute_elevation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b275ed67",
+   "metadata": {},
+   "source": [
+    "## Generate or Load Sample\n",
+    "\n",
+    "This uses `generate_sample` from `passage.generate` to create a single tensor if it does not exist yet."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2971a50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Validate required inputs\n",
+    "if not CALIBRATE_PATH.exists():\n",
+    "    raise FileNotFoundError(f\"Calibration file not found: {CALIBRATE_PATH}. Run 'passage calibrate' first.\")\n",
+    "if not TILES_DIR.exists():\n",
+    "    raise FileNotFoundError(f\"Tiles directory not found: {TILES_DIR}. Run 'passage download' first.\")\n",
+    "\n",
+    "# Load calibration data\n",
+    "with open(CALIBRATE_PATH) as f:\n",
+    "    calibration = json.load(f)\n",
+    "global_min = float(calibration[\"global_min\"])\n",
+    "global_max = float(calibration[\"global_max\"])\n",
+    "tile_stats_df = pd.DataFrame(calibration[\"tile_stats\"])\n",
+    "\n",
+    "\n",
+    "def resolve_sample_paths(outputs_dir: Path, resolution: int, index: int, center_lat=None, center_lon=None):\n",
+    "    tensors_root = outputs_dir / str(resolution) / \"tensors\"\n",
+    "    metadata_root = outputs_dir / str(resolution) / \"metadata\"\n",
+    "    if center_lat is not None and center_lon is not None:\n",
+    "        lat_dir = lat_to_str(int(center_lat))\n",
+    "        lon_dir = lon_to_str(int(center_lon))\n",
+    "        tensor_path = tensors_root / lat_dir / lon_dir / f\"{index:010d}.npy\"\n",
+    "        metadata_path = metadata_root / lat_dir / lon_dir / f\"{index:010d}.yaml\"\n",
+    "        return tensor_path, metadata_path\n",
+    "    tensor_matches = list(tensors_root.rglob(f\"{index:010d}.npy\"))\n",
+    "    metadata_matches = list(metadata_root.rglob(f\"{index:010d}.yaml\"))\n",
+    "    tensor_path = tensor_matches[0] if tensor_matches else tensors_root / f\"{index:010d}.npy\"\n",
+    "    metadata_path = metadata_matches[0] if metadata_matches else metadata_root / f\"{index:010d}.yaml\"\n",
+    "    return tensor_path, metadata_path\n",
+    "\n",
+    "\n",
+    "# Generate sample if not present (or if OVERRIDE_EXISTING is True)\n",
+    "tensor_path, metadata_path = resolve_sample_paths(OUTPUTS_DIR, RESOLUTION, SAMPLE_INDEX, CENTER_LAT, CENTER_LON)\n",
+    "\n",
+    "if OVERRIDE_EXISTING or not tensor_path.exists() or not metadata_path.exists():\n",
+    "    OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "    args = (\n",
+    "        SAMPLE_INDEX,\n",
+    "        TILES_DIR,\n",
+    "        OUTPUTS_DIR,\n",
+    "        RESOLUTION,\n",
+    "        tile_stats_df,\n",
+    "        global_min,\n",
+    "        global_max,\n",
+    "        DISABLE_IMAGES,\n",
+    "        GEN_SOLVER_CONFIG,\n",
+    "        OBSTACLE_SETTINGS,\n",
+    "    )\n",
+    "    index, success, message, duration = generate_sample(args)\n",
+    "    print(f\"Generate sample: success={success}, message='{message}', duration={duration:.2f}s\")\n",
+    "    if not success:\n",
+    "        raise RuntimeError(\"Sample generation failed. Try a different resolution or re-run calibration.\")\n",
+    "else:\n",
+    "    print(f\"Using existing tensor: {tensor_path}\")\n",
+    "\n",
+    "# Load tensor (shape: H, W, 3) -> channels: elevation (normalized), markers, obstacles\n",
+    "tensor = np.load(tensor_path)\n",
+    "elevation_norm = tensor[:, :, 0]\n",
+    "markers = tensor[:, :, 1]\n",
+    "obstacles_mask = tensor[:, :, 2] if tensor.shape[2] > 2 else np.zeros_like(markers)\n",
+    "# elevation_raw is the unnormalized elevation in the original units\n",
+    "elevation_raw = elevation_norm * (global_max - global_min) + global_min"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f8c657f",
+   "metadata": {},
+   "source": [
+    "## Extract Markers\n",
+    "\n",
+    "Use the marker channel to recover the start/end coordinates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "957e9865",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start_positions = np.argwhere(np.isclose(markers, 0.0))\n",
+    "end_positions = np.argwhere(markers > 0.5)\n",
+    "if len(start_positions) < 1 or len(end_positions) < 1:\n",
+    "    raise ValueError(\"Expected start and end markers in the tensor.\")\n",
+    "\n",
+    "start = tuple(start_positions[0])\n",
+    "end = tuple(end_positions[0])\n",
+    "\n",
+    "print(f\"Start: {start}\")\n",
+    "print(f\"End:   {end}\")\n",
+    "print(f\"Euclidean distance: {np.hypot(start[0] - end[0], start[1] - end[1]):.1f} pixels\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b7b951d",
+   "metadata": {},
+   "source": [
+    "## Visualize Elevation Map\n",
+    "\n",
+    "Visualize elevation map and markers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f7817ebc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Display elevation map with matplotlib and show markers if available\n",
+    "fig, ax = plt.subplots(figsize=(8, 8))\n",
+    "im = ax.imshow(elevation_norm, cmap=\"terrain\", origin=\"upper\")\n",
+    "ax.set_title(f\"Elevation (normalized) - {RESOLUTION}x{RESOLUTION} (obstacles={'on' if USE_OBSTACLES else 'off'})\")\n",
+    "plt.colorbar(im, ax=ax, label=\"Normalized elevation\")\n",
+    "\n",
+    "if USE_OBSTACLES:\n",
+    "    obs_overlay = np.ma.masked_where(obstacles_mask == 0, obstacles_mask)\n",
+    "    ax.imshow(obs_overlay, cmap=\"Reds\", alpha=0.35, origin=\"upper\")\n",
+    "\n",
+    "# Plot start/end markers if present\n",
+    "try:\n",
+    "    s = start\n",
+    "    e = end\n",
+    "except NameError:\n",
+    "    start_positions = np.argwhere(np.isclose(markers, 0.0))\n",
+    "    end_positions = np.argwhere(markers > 0.5)\n",
+    "    s = tuple(start_positions[0]) if len(start_positions) > 0 else None\n",
+    "    e = tuple(end_positions[0]) if len(end_positions) > 0 else None\n",
+    "\n",
+    "if s is not None:\n",
+    "    ax.plot(s[1], s[0], \"o\", color=\"lime\", markersize=8, label=\"Start\")\n",
+    "if e is not None:\n",
+    "    ax.plot(e[1], e[0], \"x\", color=\"cyan\", markersize=8, label=\"End\")\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.axis(\"off\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# Show tensor_to_image visualization (terrain colormap + overlays)\n",
+    "# Extract path pixels and elevation bounds from metadata, then call tensor_to_image\n",
+    "path_pixels = None\n",
+    "elev_range = None\n",
+    "try:\n",
+    "    if metadata_path.exists():\n",
+    "        with open(metadata_path) as f:\n",
+    "            md_local = yaml.safe_load(f)\n",
+    "        if md_local is not None:\n",
+    "            # Prefer with_obstacles when obstacles enabled, else without_obstacles\n",
+    "            if \"paths\" in md_local:\n",
+    "                path_section = md_local.get(\"paths\", {}).get(\"with_obstacles\") or md_local.get(\"paths\", {}).get(\n",
+    "                    \"without_obstacles\"\n",
+    "                )\n",
+    "                if path_section is None:\n",
+    "                    path_section = md_local.get(\"path\", {})\n",
+    "            else:\n",
+    "                path_section = md_local.get(\"path\", {})\n",
+    "\n",
+    "            if path_section:\n",
+    "                path_pixels = [(p[\"i\"], p[\"j\"]) for p in path_section.get(\"pixels\", [])]\n",
+    "\n",
+    "            crop_info = md_local.get(\"crop\", {})\n",
+    "            if \"min_elevation\" in crop_info and \"max_elevation\" in crop_info:\n",
+    "                elev_range = (crop_info.get(\"min_elevation\"), crop_info.get(\"max_elevation\"))\n",
+    "except Exception:\n",
+    "    path_pixels = None\n",
+    "\n",
+    "tensor_vis = np.stack([elevation_norm, markers, obstacles_mask], axis=-1)\n",
+    "img_bgr = tensor_to_image(tensor_vis, path_pixels=path_pixels, elev_range=elev_range)\n",
+    "img_rgb = img_bgr[:, :, ::-1]\n",
+    "\n",
+    "fig2, ax2 = plt.subplots(figsize=(8, 8))\n",
+    "ax2.imshow(img_rgb, origin=\"upper\")\n",
+    "ax2.set_title(\"tensor_to_image visualization (terrain + obstacles + markers)\")\n",
+    "ax2.axis(\"off\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f243d356",
+   "metadata": {},
+   "source": [
+    "## Run Solver Comparison\n",
+    "\n",
+    "Compare all NetworkX and Pathfinding solvers and record execution time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "914168d5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Apply obstacles if configured\n",
+    "elevation_input = elevation_raw\n",
+    "if USE_OBSTACLES:\n",
+    "    elevation_input = elevation_raw.copy()\n",
+    "    elevation_input[obstacles_mask == 1] = elevation_input.max() + OBSTACLE_PENALTY\n",
+    "\n",
+    "# Prebuild NetworkX graphs for each cost_model used by networkx solvers (reuse if multiple solvers use same model)\n",
+    "networkx_solvers = [s for s in SOLVERS if s[\"name\"].split(\":\", 1)[0] == \"networkx\"]\n",
+    "G_prebuilt_map = {}\n",
+    "if networkx_solvers:\n",
+    "    from passage.generate import build_graph_from_elevation\n",
+    "\n",
+    "    # Build a shared graph per cost_model (defaults to global COST_MODEL)\n",
+    "    cost_models = set(s.get(\"cost_model\", COST_MODEL) for s in networkx_solvers)\n",
+    "    for cost_model_name in cost_models:\n",
+    "        G_prebuilt_map[cost_model_name] = build_graph_from_elevation(\n",
+    "            elevation_input, weight=WEIGHT, diagonal_movement=DIAGONAL_MOVEMENT, cost_model=cost_model_name\n",
+    "        )\n",
+    "\n",
+    "results = []\n",
+    "\n",
+    "for solver_info in SOLVERS:\n",
+    "    solver_config = {\n",
+    "        \"name\": solver_info[\"name\"],\n",
+    "        \"diagonal_movement\": DIAGONAL_MOVEMENT,\n",
+    "        \"weight\": WEIGHT,\n",
+    "        \"cost_model\": solver_info.get(\"cost_model\", COST_MODEL),\n",
+    "    }\n",
+    "    if \"heuristic\" in solver_info:\n",
+    "        solver_config[\"heuristic\"] = solver_info[\"heuristic\"]\n",
+    "\n",
+    "    t0 = time.perf_counter()\n",
+    "\n",
+    "    backend_name = solver_info[\"name\"].split(\":\", 1)[0]\n",
+    "    if backend_name == \"networkx\":\n",
+    "        prebuilt = G_prebuilt_map.get(solver_config[\"cost_model\"])\n",
+    "        path = find_path(elevation_input, start, end, solver_config, prebuilt_graph=prebuilt)\n",
+    "    else:\n",
+    "        path = find_path(elevation_input, start, end, solver_config)\n",
+    "\n",
+    "    elapsed = (time.perf_counter() - t0) * 1000\n",
+    "\n",
+    "    results.append(\n",
+    "        {\n",
+    "            \"solver\": solver_info[\"label\"],\n",
+    "            \"backend\": backend_name,\n",
+    "            \"path_length\": len(path),\n",
+    "            \"time_ms\": elapsed,\n",
+    "            \"path\": path,\n",
+    "        }\n",
+    "    )\n",
+    "\n",
+    "    print(f\"{solver_info['label']}: path_len={len(path)}, time={elapsed:.1f} ms\")\n",
+    "\n",
+    "\n",
+    "timings_df = pd.DataFrame(\n",
+    "    [\n",
+    "        {\"Solver\": r[\"solver\"], \"Backend\": r[\"backend\"], \"Path Length\": r[\"path_length\"], \"Time (ms)\": r[\"time_ms\"]}\n",
+    "        for r in results\n",
+    "    ]\n",
+    ")\n",
+    "csv_path = OUTPUTS_DIR / f\"solver_times_{RESOLUTION}_{SAMPLE_INDEX:010d}.csv\"\n",
+    "csv_path.parent.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "timings_df.to_csv(csv_path, index=False)\n",
+    "print(f\"Saved timings to: {csv_path}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "298c4433",
+   "metadata": {},
+   "source": [
+    "**Note:** The *Grid* solvers (`grid:astar`, `grid:dijkstra`) are internal NumPy‑based implementations that avoid constructing a NetworkX graph. They typically run faster and use less memory for large grids (e.g., 1024, 2048, 4096). Consider using these when performance is a priority."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bac3c234",
+   "metadata": {},
+   "source": [
+    "## Results Summary\n",
+    "\n",
+    "Sort the solvers by execution time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b4d422c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = timings_df.sort_values(\"Time (ms)\").reset_index(drop=True)\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0ea3ad7b",
+   "metadata": {},
+   "source": [
+    "## Timing Bar Chart"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "655c84fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(10, 6))\n",
+    "y_pos = range(len(df))\n",
+    "bars = ax.barh(y_pos, df[\"Time (ms)\"], color=\"steelblue\")\n",
+    "ax.set_yticks(y_pos)\n",
+    "ax.set_yticklabels(df[\"Solver\"])\n",
+    "ax.set_xlabel(\"Time (ms)\")\n",
+    "ax.set_title(f\"Solver Comparison - {RESOLUTION}x{RESOLUTION}\")\n",
+    "ax.invert_yaxis()\n",
+    "\n",
+    "# Add time labels\n",
+    "for i, (bar, time_val) in enumerate(zip(bars, df[\"Time (ms)\"])):\n",
+    "    ax.text(bar.get_width() + 0.5, bar.get_y() + bar.get_height() / 2, f\"{time_val:.1f} ms\", va=\"center\", fontsize=9)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eef28b05",
+   "metadata": {},
+   "source": [
+    "## Path Visualization (All Solvers)\n",
+    "\n",
+    "Overlay all solver paths on the elevation map."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef48fc78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "ax.imshow(elevation_norm, cmap=\"terrain\", alpha=0.85, origin=\"upper\")\n",
+    "\n",
+    "if USE_OBSTACLES:\n",
+    "    obs_overlay = np.ma.masked_where(obstacles_mask == 0, obstacles_mask)\n",
+    "    ax.imshow(obs_overlay, cmap=\"Reds\", alpha=0.25, origin=\"upper\")\n",
+    "\n",
+    "# Use a colormap for different solvers\n",
+    "\n",
+    "colors = cm.tab20(np.linspace(0, 1, len(results)))\n",
+    "\n",
+    "for idx, result in enumerate(results):\n",
+    "    path = result[\"path\"]\n",
+    "    if len(path) == 0:\n",
+    "        continue\n",
+    "    path_arr = np.array(path)\n",
+    "    ax.plot(path_arr[:, 1], path_arr[:, 0], linewidth=2, color=colors[idx], label=result[\"solver\"])\n",
+    "\n",
+    "ax.plot(start[1], start[0], \"o\", color=\"lime\", markersize=8, label=\"Start\")\n",
+    "ax.plot(end[1], end[0], \"x\", color=\"cyan\", markersize=8, label=\"End\")\n",
+    "\n",
+    "ax.set_title(\"All Solver Paths\")\n",
+    "ax.legend(loc=\"upper left\", fontsize=8, bbox_to_anchor=(1.02, 1))\n",
+    "ax.axis(\"off\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4b011ca",
+   "metadata": {},
+   "source": [
+    "## Path Visualization (Per Solver)\n",
+    "\n",
+    "Show one subplot per solver to compare route shapes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "63d892f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_solvers = len(results)\n",
+    "cols = min(3, n_solvers)\n",
+    "rows = (n_solvers + cols - 1) // cols\n",
+    "\n",
+    "fig, axes = plt.subplots(rows, cols, figsize=(5 * cols, 5 * rows))\n",
+    "if rows == 1:\n",
+    "    axes = axes.reshape(1, -1)\n",
+    "if cols == 1:\n",
+    "    axes = axes.reshape(-1, 1)\n",
+    "\n",
+    "for idx, result in enumerate(results):\n",
+    "    r = idx // cols\n",
+    "    c = idx % cols\n",
+    "    ax = axes[r, c]\n",
+    "\n",
+    "    ax.imshow(elevation_norm, cmap=\"terrain\", alpha=0.85, origin=\"upper\")\n",
+    "\n",
+    "    if USE_OBSTACLES:\n",
+    "        obs_overlay = np.ma.masked_where(obstacles_mask == 0, obstacles_mask)\n",
+    "        ax.imshow(obs_overlay, cmap=\"Reds\", alpha=0.25, origin=\"upper\")\n",
+    "\n",
+    "    path = result[\"path\"]\n",
+    "    if len(path) > 0:\n",
+    "        path_arr = np.array(path)\n",
+    "        ax.plot(path_arr[:, 1], path_arr[:, 0], \"r-\", linewidth=2)\n",
+    "\n",
+    "    ax.plot(start[1], start[0], \"o\", color=\"lime\", markersize=6)\n",
+    "    ax.plot(end[1], end[0], \"x\", color=\"cyan\", markersize=6)\n",
+    "    ax.set_title(f\"{result['solver']}\\n{result['time_ms']:.1f}ms, {result['path_length']} px\", fontsize=9)\n",
+    "    ax.axis(\"off\")\n",
+    "\n",
+    "# Hide empty subplots\n",
+    "for idx in range(n_solvers, rows * cols):\n",
+    "    r = idx // cols\n",
+    "    c = idx % cols\n",
+    "    axes[r, c].axis(\"off\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "passage (3.12.3)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}