From acc1313f64c0b620f7310d6012afb4c50eac1cec Mon Sep 17 00:00:00 2001 From: James Le Houx <37665786+jameslehoux@users.noreply.github.com> Date: Tue, 17 Nov 2026 21:55:54 +0000 Subject: [PATCH] feat(v0.3.0): multi-scan gap closing, lazy HDF5 streaming, 4D HTML explorer, ImageD11/NeXus exports, and DINOv2 benchmarks --- CHANGELOG.md | 14 + CITATION.cff | 15 +- CONTRIBUTING.md | 10 +- README.md | 93 ++- braggtrack/__init__.py | 4 +- braggtrack/cli/detect_events.py | 131 ++-- braggtrack/cli/embed_dataset.py | 56 +- braggtrack/cli/report_dataset.py | 140 ++++ braggtrack/cli/run_pipeline.py | 108 ++- braggtrack/cli/segment_dataset.py | 18 +- braggtrack/cli/track_dataset.py | 64 +- braggtrack/io/__init__.py | 32 +- braggtrack/io/crystallography.py | 146 ++++ braggtrack/io/export.py | 256 +++++++ braggtrack/io/lazy.py | 144 ++++ braggtrack/segmentation/dino_segment.py | 39 +- braggtrack/semantic/dino.py | 3 + braggtrack/semantic/mips.py | 6 +- braggtrack/tracking/__init__.py | 4 + braggtrack/tracking/gap_closing.py | 275 +++++++ braggtrack/tracking/lifecycle.py | 15 +- braggtrack/tracking/metrics.py | 14 +- braggtrack/viz/__init__.py | 17 + braggtrack/viz/_style.py | 45 ++ braggtrack/viz/html_report.py | 696 ++++++++++++++++++ braggtrack/viz/kinematics.py | 103 +++ braggtrack/viz/lineage.py | 216 ++++++ braggtrack/viz/mips.py | 104 +++ braggtrack/viz/precursors.py | 149 ++++ docs/architecture.md | 54 +- docs/benchmarks.md | 115 +++ docs/figures/benchmark_comparison.png | Bin 0 -> 182861 bytes .../fracture_lineage_and_precursors.png | Bin 0 -> 358773 bytes notebooks/braggtrack_demo.ipynb | 14 +- paper.bib | 16 +- paper.md | 124 ++-- pyproject.toml | 3 +- scripts/benchmark_suite.py | 477 ++++++++++++ scripts/check_report_and_export_acceptance.py | 223 ++++++ scripts/ci_report.py | 8 +- scripts/generate_paper_figures.py | 261 +++++++ tests/test_benchmark_suite.py | 69 ++ tests/test_gap_closing.py | 151 ++++ tests/test_lazy_and_export.py | 199 +++++ tests/test_report_and_export_acceptance.py | 26 + tests/test_segmentation_dino.py | 24 + tests/test_viz_and_report.py | 134 ++++ 47 files changed, 4551 insertions(+), 264 deletions(-) create mode 100644 braggtrack/cli/report_dataset.py create mode 100644 braggtrack/io/crystallography.py create mode 100644 braggtrack/io/export.py create mode 100644 braggtrack/io/lazy.py create mode 100644 braggtrack/tracking/gap_closing.py create mode 100644 braggtrack/viz/__init__.py create mode 100644 braggtrack/viz/_style.py create mode 100644 braggtrack/viz/html_report.py create mode 100644 braggtrack/viz/kinematics.py create mode 100644 braggtrack/viz/lineage.py create mode 100644 braggtrack/viz/mips.py create mode 100644 braggtrack/viz/precursors.py create mode 100644 docs/benchmarks.md create mode 100644 docs/figures/benchmark_comparison.png create mode 100644 docs/figures/fracture_lineage_and_precursors.png create mode 100644 scripts/benchmark_suite.py create mode 100644 scripts/check_report_and_export_acceptance.py create mode 100644 scripts/generate_paper_figures.py create mode 100644 tests/test_benchmark_suite.py create mode 100644 tests/test_gap_closing.py create mode 100644 tests/test_lazy_and_export.py create mode 100644 tests/test_report_and_export_acceptance.py create mode 100644 tests/test_viz_and_report.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f6424c7..6fffb35 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,20 @@ All notable changes to BraggTrack will be documented in this file. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [0.3.0] - 2026-11-17 + +### Added +- **Multi-scan beam-dropout gap closing (`braggtrack.tracking.gap_closing`)**: Added Jaqaman-style augmented linear assignment (`GapClosingConfig`, `GapCloseRecord`, `resolve_track_gaps`) with diffusive displacement scaling (`pos_d2 / delta_scans`), bidirectional spurious jump-edge severing, semantic cosine gating, and chronological track ID propagation (`--max-gap` across `track_dataset`, `detect_events`, and `run_pipeline`). +- **Chunked & lazy HDF5 streaming (`braggtrack.io.lazy`)**: Added context-managed `LazyVolume` (`open_lazy_volume`, `read_roi`, `iter_z_chunks`) and exact two-pass `otsu_threshold_chunked`, wired into `segment_dataset` Pass 1, `embed_dataset`, `detect_events`, and `crop_spot_cube` to avoid full-volume `float64` allocations on gigabyte-scale detector stacks. +- **Crystallographic scattering geometry & downstream exports (`braggtrack.io.crystallography`, `braggtrack.io.export`)**: Added `DetectorGeometry` (`spot_to_scattering`, `annotate_crystallographic_columns`) converting spot centroids into `(omega_deg, two_theta_deg, eta_deg, d_spacing_angstrom, qx/qy/qz/q_mag_inv_angstrom)` via Bragg's law, plus direct `ImageD11` columnfile export/parsing (`export_imaged11_flt`, `read_imaged11_flt`) and self-describing NeXus `NXprocess` HDF5 archival export (`export_nexus_process`). +- **Publication visualization package & interactive HTML 4D Explorer (`braggtrack.viz`, `braggtrack-report`)**: Added `plot_spot_mip_card`, `plot_scan_projection_overlay`, `plot_lineage_dag`, `plot_kinematics_dashboard`, `plot_precursor_timeline`, and `generate_html_report` (zero-CDN offline `report.html` with stdlib-encoded base64 3-view MIP thumbnails, pan/zoom SVG Lineage DAG, filter pills, and synchronized strain/precursor inspector), plus the 9th CLI entry point `braggtrack-report` and `--report` flag on `braggtrack-run`. +- **Quantitative 5-scenario real DINOv2 benchmark suite (`scripts/benchmark_suite.py`, `docs/benchmarks.md`)**: Added multi-trial bootstrap-CI benchmark harness comparing **Geometry-Only**, **Mock-Hash**, and **Real `facebook/dinov2-small`** across crossing tilted reflections, beam-flux jitter, mosaic rocking broadening, staggered beam dropouts (`max_gap=2`), and 4D chemomechanical fracture/precursor contrast, alongside publication figures (`docs/figures/`) and an ESRF-ID03 `facebook/dinov2-small` case study. +- **9th CI acceptance gate (`scripts/check_report_and_export_acceptance.py`)**: Wired automated verification of `--max-gap`, `report.html` + static figures, `ImageD11` `.flt` round-trip parsing, and NeXus `NXprocess` HDF5 schema into `scripts/ci_report.py`. + +### Fixed +- Fixed patch-grid shape mismatch and far-edge clipping in `segment_dino` when HuggingFace ViT processors resize non-multiple slices (e.g. `250x250 -> 224x224`, `16x16` tokens vs `250 // 14 = 17`), and honored `BRAGGTRACK_DINO_BACKEND` when `backend="auto"` in `braggtrack.semantic.dino`. +- Fixed `@Finegan2017` citation key/year mismatch (`2017`, DOI `10.1039/C7EE00385D`) and added `@Jaqaman2008` in `paper.bib` and `paper.md`; synced `CITATION.cff`, `CONTRIBUTING.md`, `docs/architecture.md`, and `README.md` to `v0.3.0`. + ## [0.2.0] - 2026-11-17 ### Added diff --git a/CITATION.cff b/CITATION.cff index 8b445ef..8d1e56b 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -2,22 +2,25 @@ cff-version: 1.2.0 message: "If you use this software, please cite it as below." title: "BraggTrack" type: software -version: 0.1.0 +version: 0.3.0 date-released: "2026-05-16" license: MIT repository-code: "https://github.com/BASE-Laboratory/BraggTrack" url: "https://github.com/BASE-Laboratory/BraggTrack" abstract: >- - Semantic 4D kinematics and fracture tracking for operando - X-ray diffraction. BraggTrack segments Bragg reflections in - 3D reciprocal-space volumes and tracks them across time using - classical image processing and self-supervised vision-transformer - embeddings. + Semantic 4D kinematics, multi-scan gap closing, and chemomechanical + fracture tracking for operando X-ray diffraction. BraggTrack segments + Bragg reflections in 3D reciprocal-space volumes, tracks trajectories + and split/merge lineage using classical crystallography and + vision-transformer embeddings, and exports ImageD11, NeXus HDF5, and + interactive HTML 4D lineage reports. keywords: - X-ray diffraction - operando crystallography - 3D segmentation - object tracking + - grain fracture + - synchrotron - materials science - Python authors: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1833647..f9b3376 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -4,13 +4,15 @@ Thanks for helping improve BraggTrack. ## Before you open a PR -1. Install the package in editable mode with dev/runtime dependencies you need (`pip install -e .` plus `numpy`, `scipy`, `scikit-image`, `networkx`; add `h5py` / `torch` / `transformers` as required). -2. Run **`python scripts/pre_pr_check.py`** (conflict markers and optional sync hint against `origin/main`). -3. Run **`python scripts/ci_report.py`** (unit tests + Week 1–4 acceptance scripts). +1. Install the package in editable mode with developer dependencies (`pip install -e ".[dev]"` for full PyTorch, notebook, pytest, and Ruff tooling, or `pip install -e .` for the lightweight core). +2. Run **`ruff check braggtrack/ tests/ scripts/`** and **`ruff format --check braggtrack/ tests/ scripts/`**. +3. Run **`python scripts/pre_pr_check.py`** (conflict markers and optional sync hint against `origin/main`). +4. Run **`python scripts/ci_report.py`** (unit tests + all 9 acceptance gates covering IO, smoke, segmentation, tracking, embedding, DINO, events/pipeline, and interactive report + ImageD11/NeXus exports). ## Where things live -- **[Architecture](docs/architecture.md)** — package layers, data flow, extension points. +- **[Architecture](docs/architecture.md)** — package layers (`io`, `segmentation`, `semantic`, `tracking`, `viz`, `cli`), data flow, extension points. +- **[Benchmarks](docs/benchmarks.md)** — 5-scenario quantitative evaluation (`scripts/benchmark_suite.py`) and ESRF-ID03 `facebook/dinov2-small` case study. - **[Coding practices](docs/coding-practices.md)** — style, testing, optional deps, CI expectations. - **Sample scan data** — versioned under [`data/sample_operando/`](data/sample_operando/README.md) (not the repo root). diff --git a/README.md b/README.md index 8f43b53..d61abd5 100644 --- a/README.md +++ b/README.md @@ -4,15 +4,24 @@ [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BASE-Laboratory/BraggTrack/blob/main/notebooks/braggtrack_demo.ipynb) -Semantic 4D kinematics, grain lineage (`1 -> 2+` fracture splits & `2+ -> 1` coalescence merges), and persistent fracture precursor tracking for operando X-ray diffraction using classical 3D crystallography and foundation vision transformers. +Semantic 4D kinematics, multi-scan beam-dropout gap closing, grain lineage (`1 -> 2+` fracture splits & `2+ -> 1` coalescence merges), and persistent fracture precursor tracking for operando X-ray diffraction using classical 3D crystallography and foundation vision transformers. + +

+ BraggTrack 4D lineage, precursor decomposition, and ESRF-ID03 strain kinematics +

## Key Capabilities -- **Beamline-ready NeXus/HDF5 I/O & calibration (`braggtrack.io`)** — Auto-discovers 3D detector cubes across standard NeXus paths, ESRF-ID03 LIMA files (`/entry_0000/ESRF-ID03/pco_nf/data`), and arbitrary HDF5 trees (`auto_discover=True`), with optional physical `(mu, chi, d)` coordinate calibration via `AxisCalibration`. -- **Stabilised 3D Bragg reflection segmentation (`braggtrack.segmentation`)** — Intensity-domain Otsu foreground masking with cross-scan rolling-median smoothing (`smooth_thresholds`), 3D LoG peak enhancement, robust `h`-maxima seeding, 3D watershed, nearby-basin merging, and physical or voxel-space covariance/eigenvalue extraction. Includes an experimental dense patch-feature + HDBSCAN slice-stitching segmenter (`--method dino`). +- **Beamline-scale NeXus/HDF5 I/O, lazy ROI streaming & crystallographic mapping (`braggtrack.io`)** — Auto-discovers 3D detector cubes across standard NeXus paths, ESRF-ID03 LIMA files (`/entry_0000/ESRF-ID03/pco_nf/data`), and arbitrary HDF5 trees (`auto_discover=True`). Streams `z`-slabs via `LazyVolume` (`otsu_threshold_chunked`, `read_roi`), calibrates `(mu, chi, d)` via `AxisCalibration`, maps transmission geometry `(2theta, eta, d, |Q|)` via `DetectorGeometry`, and exports directly to **`ImageD11` (`.flt`)** and **NeXus `NXprocess` HDF5 (`.nxs`)**. +- **Stabilised 3D Bragg reflection segmentation (`braggtrack.segmentation`)** — Streaming Otsu foreground masking with cross-scan rolling-median smoothing (`smooth_thresholds`), 3D LoG peak enhancement, robust `h`-maxima seeding, 3D watershed, nearby-basin merging, and physical or voxel-space covariance/eigenvalue extraction. Includes an experimental dense patch-feature + HDBSCAN slice-stitching segmenter (`--method dino`). - **Multi-view foundation vision descriptors (`braggtrack.semantic`)** — Orthogonal $(\mu, \chi, d)$ maximum-intensity projections (MIPs) encoded with ungated **`facebook/dinov2-small`** by default (zero HuggingFace login required), drop-in support for **DINOv3** (`facebook/dinov3-vitb16-pretrain-lvd1689m`), or a deterministic zero-GPU `mock` backend for CI. -- **4D grain kinematics, split/merge lineage & fracture precursors (`braggtrack.tracking`)** — Vectorised geometry + semantic Hungarian association into a NetworkX trajectory DAG, per-grain lattice strain ($\Delta d / d_0$) and angular misorientation ($\Delta\mu$, $\Delta\chi$), intensity-partitioned `1 -> 2+` split and `2+ -> 1` merge DAG edges, and persistent multi-scan fracture precursor ranking combining 3D shape anisotropy, covariance spread growth, and spot ROI sub-peak / DINO patch-token dispersion. -- **One-command reproducible pipeline (`braggtrack-run`)** — Runs validation, segmentation, semantic embedding, tracking, kinematics, and fracture event analysis end-to-end, emitting SHA-256 input checksums, stage timings, and `run_manifest.json`. +- **4D grain kinematics, multi-scan gap closing, split/merge lineage & precursors (`braggtrack.tracking`)** — Vectorised geometry + semantic Hungarian association, Jaqaman-style multi-scan gap closing (`--max-gap`) across transient beam dropouts, per-grain lattice strain ($\Delta d / d_0$) and angular misorientation ($\Delta\mu$, $\Delta\chi$), intensity-partitioned `1 -> 2+` split and `2+ -> 1` merge DAG edges, and persistent multi-scan fracture precursor ranking combining 3D shape anisotropy, covariance spread growth, and spot ROI sub-peak / DINO patch-token dispersion. +- **Publication figures & offline interactive HTML 4D Explorer (`braggtrack.viz`, `braggtrack-report`)** — Generates Okabe–Ito styled lineage DAGs, strain/misorientation dashboards, precursor heatmaps, 3-view MIP cards, and a single-file interactive `report.html` with embedded base64 MIP thumbnails that opens offline on air-gapped beamline networks. +- **One-command reproducible pipeline (`braggtrack-run`)** — Runs validation, segmentation, semantic embedding, tracking, kinematics, fracture event analysis, HTML reporting, and `ImageD11`/NeXus export end-to-end, emitting SHA-256 input checksums, stage timings, and `run_manifest.json`. + +

+ BraggTrack v0.3.0 Quantitative 4D Diffraction Benchmark Suite +

--- @@ -25,7 +34,7 @@ pip install -e . # With PyTorch + HuggingFace Transformers for real DINOv2 / DINOv3 backbones pip install -e ".[torch]" -# With Jupyter, Matplotlib, and Pandas for interactive notebooks +# With Jupyter, Matplotlib, and Pandas for interactive notebooks & static figures pip install -e ".[notebook]" # Full developer environment (torch + notebook + pytest + ruff) @@ -38,10 +47,14 @@ pip install -e ".[dev]" BraggTrack ships with three real ESRF ID03 operando Ni-rich cathode scans under [`data/sample_operando/`](data/sample_operando/README.md) (`100 x 250 x 250` `uint16` cubes). Omit the dataset path to run on the bundled scans automatically, or pass your own directory of `scanXXXX/` folders: -### One-command end-to-end pipeline +### One-command end-to-end pipeline (with interactive HTML report & NeXus/`ImageD11` exports) ```bash -braggtrack-run --outdir artifacts/pipeline +braggtrack-run --outdir artifacts/pipeline \ + --max-gap 1 \ + --report \ + --export-nexus artifacts/pipeline/results.nxs \ + --export-imaged11 artifacts/pipeline/peaks.flt ``` Produces: @@ -50,26 +63,29 @@ Produces: - `artifacts/pipeline/embedding/` (`embeddings.npz`, `embedding_manifest.json`) - `artifacts/pipeline/tracking/` (`tracks.csv`, `kinematics.csv`, `kinematics_summary.json`, `tracking_summary.json`, QC notebook) - `artifacts/pipeline/events/` (`events.csv`, `events.json`, `precursors.csv`, `events_summary.json`) +- `artifacts/pipeline/report/` (`report.html` interactive 4D Explorer + `figures/*.png`) +- `artifacts/pipeline/results.nxs` & `artifacts/pipeline/peaks.flt` - `artifacts/pipeline/run_manifest.json` (SHA-256 input checksums, git SHA, config, stage timings) -### Stage-by-stage CLI commands +### Stage-by-stage CLI commands (9 Entry Points) | CLI Entry Point | Module Equivalent | Purpose | |---|---|---| | `braggtrack-inspect` | `python -m braggtrack.cli.inspect_datasets` | Discover `scan*` folders, primary 3D HDF5 dataset paths, and metadata | | `braggtrack-validate` | `python -m braggtrack.cli.validate_dataset` | Validate sequence ordering, monotonic timestamps, and axis contracts | | `braggtrack-segment-synthetic` | `python -m braggtrack.cli.segment_synthetic` | Run fast synthetic 3D segmentation smoke test | -| `braggtrack-segment-dataset` | `python -m braggtrack.cli.segment_dataset` | Segment 3D Bragg spots across scans with smoothed thresholds & optional calibration | -| `braggtrack-embed-dataset` | `python -m braggtrack.cli.embed_dataset` | Compute orthogonal MIP embeddings (`auto`, `mock`, or `torch` DINOv2/DINOv3) | -| `braggtrack-track-dataset` | `python -m braggtrack.cli.track_dataset` | Build trajectory DAG, export `tracks.csv` + `kinematics.csv` (+ optional `--detect-events`) | -| `braggtrack-events` | `python -m braggtrack.cli.detect_events` | Resolve `1 -> 2+` splits, `2+ -> 1` merges, and ROI-based fracture precursors | -| `braggtrack-run` | `python -m braggtrack.cli.run_pipeline` | Execute the full pipeline with optional `--config config.json` and `run_manifest.json` | +| `braggtrack-segment-dataset` | `python -m braggtrack.cli.segment_dataset` | Segment 3D Bragg spots via chunked Otsu + smoothed thresholds & optional calibration | +| `braggtrack-embed-dataset` | `python -m braggtrack.cli.embed_dataset` | Stream lazy 3D spot ROIs & compute orthogonal MIP embeddings (`auto`, `mock`, `torch`) | +| `braggtrack-track-dataset` | `python -m braggtrack.cli.track_dataset` | Build trajectory DAG (`--max-gap`), export `tracks.csv`, `kinematics.csv`, `.flt`, `.nxs` | +| `braggtrack-events` | `python -m braggtrack.cli.detect_events` | Resolve `1 -> 2+` splits, `2+ -> 1` merges, and lazy-ROI fracture precursors | +| `braggtrack-report` | `python -m braggtrack.cli.report_dataset` | Render publication PNG/PDF figures and self-contained interactive `report.html` | +| `braggtrack-run` | `python -m braggtrack.cli.run_pipeline` | Execute the full pipeline with optional `--config config.json`, `--report`, and exports | --- -## Physical Axis Calibration (`mu`, `chi`, `d`) +## Physical Axis Calibration (`mu`, `chi`, `d`) & Crystallographic Geometry (`2theta`, `eta`, `|Q|`) -Cropped detector cubes store integer voxel indices `[0..N)`. For physically meaningful lattice strain $\varepsilon = (d(t) - d_0) / d_0$ and angular misorientation in degrees, supply an `AxisCalibration` JSON file (or CLI flags) when segmenting: +Cropped detector cubes store integer voxel indices `[0..N)`. For physically meaningful lattice strain $\varepsilon = (d(t) - d_0) / d_0$ and angular misorientation in degrees, supply an `AxisCalibration` JSON file when segmenting: ```json { @@ -82,30 +98,36 @@ Cropped detector cubes store integer voxel indices `[0..N)`. For physically mean } ``` -```bash -braggtrack-segment-dataset data/sample_operando \ - --calibration-json calibration.json \ - --outdir artifacts/segmentation -``` +For transmission 3DXRD / `ImageD11` indexing workflows, supply a `DetectorGeometry` JSON file (`--detector-json`) to annotate `omega_deg`, `two_theta_deg`, `eta_deg`, `d_spacing_angstrom`, and `(qx, qy, qz, q_mag_inv_angstrom)` and export `.flt` columnfiles: -If HDF5 scans already include 1D `mu`, `chi`, `d` coordinate datasets or `/entry/calibration` attributes, `extract_axis_calibration()` detects them automatically. +```json +{ + "distance_mm": 150.0, + "pixel_size_y_mm": 0.075, + "pixel_size_x_mm": 0.075, + "beam_center_y_px": 1024.0, + "beam_center_x_px": 1024.0, + "wavelength_angstrom": 0.2898, + "omega_origin_deg": 0.0, + "omega_step_deg": 0.05 +} +``` --- -## Vision Backbone Options (DINOv2 Default & Optional DINOv3) +## Vision Backbone Options & Quantitative Benchmarks - **Default (`facebook/dinov2-small`)**: Public and ungated on HuggingFace — works out of the box with `pip install -e ".[torch]"` without tokens or license gates. -- **DINOv3 (`facebook/dinov3-vitb16-pretrain-lvd1689m`)**: Supported via `--model` / `--dino-model` after accepting Meta's license on HuggingFace and setting `HF_TOKEN` (or running `huggingface-cli login`): - ```bash - braggtrack-embed-dataset --backend torch --model facebook/dinov3-vitb16-pretrain-lvd1689m - ``` +- **DINOv3 (`facebook/dinov3-vitb16-pretrain-lvd1689m`)**: Supported via `--model` / `--dino-model` after accepting Meta's license on HuggingFace and setting `HF_TOKEN`. - **Offline / CI (`mock`)**: Deterministic SHA-256 multi-view projection encoder requiring zero GPU or network access (`--backend mock` or `BRAGGTRACK_DINO_BACKEND=mock`). +See [`docs/benchmarks.md`](docs/benchmarks.md) for the full 5-scenario benchmark evaluation (`scripts/benchmark_suite.py`) comparing **Geometry-Only**, **Mock-Hash**, and **Real `facebook/dinov2-small`** alongside the ESRF-ID03 case study. + --- ## Notebooks -- [`notebooks/braggtrack_demo.ipynb`](notebooks/braggtrack_demo.ipynb) — End-to-end tutorial on the bundled ESRF-ID03 scans: discovery, stabilised 3D segmentation, physics & semantic tracking, per-grain kinematics, α/β ablation, and synthetic 4D grain fracture + precursor ranking. +- [`notebooks/braggtrack_demo.ipynb`](notebooks/braggtrack_demo.ipynb) — End-to-end tutorial on the bundled ESRF-ID03 scans: discovery, lazy/chunked segmentation, physics & semantic tracking, multi-scan gap closing, per-grain kinematics, `braggtrack.viz` lineage & precursor plots, and crystallographic geometry mapping. - [`notebooks/dino_segmentation_comparison.ipynb`](notebooks/dino_segmentation_comparison.ipynb) — Side-by-side comparison of stabilised classical 3D watershed vs. experimental DINO patch-clustering segmentation. --- @@ -120,9 +142,12 @@ ruff format --check braggtrack/ tests/ scripts/ # Unit test suite with coverage pytest tests/ -v --cov=braggtrack -# Full CI gate runner (unit tests + IO, smoke, segmentation, tracking, embedding, DINO, and events acceptance) +# Full CI gate runner (unit tests + all 9 acceptance gates) python scripts/ci_report.py +# Quantitative 5-scenario benchmark suite (add --include-torch for real DINOv2) +python scripts/benchmark_suite.py --trials 5 + # Pre-PR hygiene check python scripts/pre_pr_check.py ``` @@ -131,16 +156,16 @@ python scripts/pre_pr_check.py ## Troubleshooting & FAQ -- **`MissingH5DependencyError` or custom HDF5 dataset paths:** `h5py` is installed by default with `pip install -e .`. `load_primary_volume()` automatically inspects standard NeXus paths, `/entry_0000/ESRF-ID03/pco_nf/data`, and falls back to the largest 3D numeric dataset in the file. Pass `--allow-synthetic-fallback` only when testing schema plumbing on empty/metadata-only HDF5 stubs. +- **`MissingH5DependencyError` or custom HDF5 dataset paths:** `h5py` is installed by default with `pip install -e .`. `load_primary_volume()` and `LazyVolume` automatically inspect standard NeXus paths, `/entry_0000/ESRF-ID03/pco_nf/data`, and fall back to the largest 3D numeric dataset in the file. Pass `--allow-synthetic-fallback` only when testing schema plumbing on empty/metadata-only HDF5 stubs. - **`401 Unauthorized` / gated HuggingFace model error:** You passed a gated model ID (such as `facebook/dinov3-*`) without authenticating. Either omit `--model` to use the ungated default (`facebook/dinov2-small`), or accept the model license on HuggingFace and export `HF_TOKEN`. -- **Unphysical strain percentages in `kinematics.csv`:** Check `"calibrated_axes"` in `kinematics_summary.json`. When `false`, `centroid_d` is measured in cropped detector pixels (`y` index) rather than Angstroms — pass `--calibration-json` (or `--d-origin` / `--d-step`) to compute true crystallographic $\Delta d / d_0$. +- **Unphysical strain percentages in `kinematics.csv`:** Check `"calibrated_axes"` in `kinematics_summary.json`. When `false`, `centroid_d` is measured in cropped detector pixels (`y` index) rather than Angstroms — pass `--calibration-json` (or `--detector-json`) to compute physical crystallographic quantities. ## Repository Layout & Contributing -- **`braggtrack/`** — Installable Python library (`io`, `segmentation`, `semantic`, `tracking`, `cli`). +- **`braggtrack/`** — Installable Python library (`io`, `segmentation`, `semantic`, `tracking`, `viz`, `cli`). - **`data/sample_operando/`** — Bundled ESRF-ID03 operando test scans (`scan0001`–`scan0003`). -- **`docs/`** — [Architecture](docs/architecture.md) and [Coding Practices](docs/coding-practices.md). -- **`scripts/`** — Acceptance gates, semantic α/β ablation (`ablation_semantic.py`), and CI runner (`ci_report.py`). +- **`docs/`** — [Architecture](docs/architecture.md), [Benchmarks](docs/benchmarks.md), [Coding Practices](docs/coding-practices.md), and publication figures (`docs/figures/`). +- **`scripts/`** — 9 acceptance gates, 5-scenario benchmark suite (`benchmark_suite.py`), semantic α/β ablation (`ablation_semantic.py`), and CI runner (`ci_report.py`). - **`artifacts/`** — Generated pipeline outputs (gitignored; never commit). See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines and [paper.md](paper.md) for the manuscript overview. diff --git a/braggtrack/__init__.py b/braggtrack/__init__.py index 20123fa..14eeacb 100644 --- a/braggtrack/__init__.py +++ b/braggtrack/__init__.py @@ -5,6 +5,6 @@ try: __version__ = version("braggtrack") except PackageNotFoundError: - __version__ = "0.2.0.dev0" + __version__ = "0.3.0.dev0" -__all__ = ["io", "segmentation", "semantic", "tracking"] +__all__ = ["io", "segmentation", "semantic", "tracking", "viz"] diff --git a/braggtrack/cli/detect_events.py b/braggtrack/cli/detect_events.py index 321dfaf..9eb799d 100644 --- a/braggtrack/cli/detect_events.py +++ b/braggtrack/cli/detect_events.py @@ -4,6 +4,7 @@ import argparse import json +from contextlib import ExitStack from pathlib import Path from typing import Any @@ -13,14 +14,16 @@ from braggtrack.cli.track_dataset import _load_embeddings_npz, _merge_embeddings from braggtrack.io import ( BeamlineAdapter, + LazyVolume, MissingH5DependencyError, discover_operando_scans, - load_primary_volume, + open_lazy_volume, resolve_dataset_root, ) from braggtrack.semantic import DEFAULT_DINO_MODEL, make_patch_encoder from braggtrack.semantic.dino import _requested_backend, _resolve_backend from braggtrack.tracking import ( + GapClosingConfig, GeometrySemanticCost, PositionShapeCost, PrecursorConfig, @@ -66,6 +69,8 @@ def build_parser() -> argparse.ArgumentParser: parser.add_argument("--gate-chi", type=float, default=float("inf")) parser.add_argument("--gate-d", type=float, default=float("inf")) parser.add_argument("--max-cost", type=float, default=float("inf")) + parser.add_argument("--max-gap", type=int, default=0, help="Max missing intermediate scans to bridge (0 disables)") + parser.add_argument("--gap-max-cost", type=float, default=25.0, help="Max penalized cost for gap-closing bridges") parser.add_argument("--cost-alpha", type=float, default=1.0) parser.add_argument("--cost-beta", type=float, default=0.0) parser.add_argument("--split-max-distance", type=float, default=25.0) @@ -83,13 +88,14 @@ def build_parser() -> argparse.ArgumentParser: def _try_load_roi_inputs( + stack: ExitStack, root_arg: str | None, scan_dirs: list[Path], scan_names: list[str], *, allow_synthetic_fallback: bool, -) -> tuple[dict[int, np.ndarray], dict[int, np.ndarray], dict[int, str | None]]: - volumes: dict[int, np.ndarray] = {} +) -> tuple[dict[int, Any], dict[int, np.ndarray], dict[int, str | None]]: + volumes: dict[int, Any] = {} label_volumes: dict[int, np.ndarray] = {} timestamps: dict[int, str | None] = {} @@ -123,13 +129,13 @@ def _try_load_roi_inputs( if sf is None or idx not in label_volumes: continue try: - vol = load_primary_volume(sf.path) + vol: LazyVolume = stack.enter_context(open_lazy_volume(sf.path)) except MissingH5DependencyError: - vol = synth_volume_from_file(sf.path) + vol = LazyVolume.from_array(synth_volume_from_file(sf.path)) except (KeyError, ValueError): if not allow_synthetic_fallback: continue - vol = synth_volume_from_file(sf.path) + vol = LazyVolume.from_array(synth_volume_from_file(sf.path)) if vol.shape == label_volumes[idx].shape: volumes[idx] = vol @@ -175,63 +181,69 @@ def main(argv: list[str] | None = None) -> int: print(json.dumps({"error": "Missing embeddings.npz", "path": str(npz)})) return 1 - volumes, label_volumes, scan_timestamps = _try_load_roi_inputs( - args.root, - used_scan_dirs, - scan_names, - allow_synthetic_fallback=bool(args.allow_synthetic_fallback), - ) + with ExitStack() as stack: + volumes, label_volumes, scan_timestamps = _try_load_roi_inputs( + stack, + args.root, + used_scan_dirs, + scan_names, + allow_synthetic_fallback=bool(args.allow_synthetic_fallback), + ) - geo = PositionShapeCost( - position_weight=args.position_weight, - shape_weight=args.shape_weight, - gate_mu=args.gate_mu, - gate_chi=args.gate_chi, - gate_d=args.gate_d, - ) - cost_fn = ( - GeometrySemanticCost(geo, cost_alpha=args.cost_alpha, cost_beta=args.cost_beta) - if args.cost_beta != 0.0 - else geo - ) - sm_cfg = SplitMergeConfig( - max_distance=args.split_max_distance, - gate_mu=args.gate_mu, - gate_chi=args.gate_chi, - gate_d=args.gate_d, - min_intensity_ratio=args.min_intensity_ratio, - max_intensity_ratio=args.max_intensity_ratio, - min_fragment_share=args.min_fragment_share, - ) + geo = PositionShapeCost( + position_weight=args.position_weight, + shape_weight=args.shape_weight, + gate_mu=args.gate_mu, + gate_chi=args.gate_chi, + gate_d=args.gate_d, + ) + cost_fn = ( + GeometrySemanticCost(geo, cost_alpha=args.cost_alpha, cost_beta=args.cost_beta) + if args.cost_beta != 0.0 + else geo + ) + gap_cfg = GapClosingConfig(max_gap=args.max_gap, max_cost=args.gap_max_cost) if args.max_gap > 0 else None + sm_cfg = SplitMergeConfig( + max_distance=args.split_max_distance, + gate_mu=args.gate_mu, + gate_chi=args.gate_chi, + gate_d=args.gate_d, + min_intensity_ratio=args.min_intensity_ratio, + max_intensity_ratio=args.max_intensity_ratio, + min_fragment_share=args.min_fragment_share, + ) - G = build_tracks( - scan_tables, - cost_fn=cost_fn, - max_cost=args.max_cost, - split_merge_config=sm_cfg, - scan_timestamps=scan_timestamps or None, - ) - metrics = compute_tracking_metrics(G, n_scans=len(scan_tables)) - lineage_events = list(G.graph.get("lineage_events", [])) - track_rows = tracks_to_table(G) - for tr in track_rows: - tr.pop("embedding", None) + G = build_tracks( + scan_tables, + cost_fn=cost_fn, + max_cost=args.max_cost, + gap_closing_config=gap_cfg, + split_merge_config=sm_cfg, + scan_timestamps=scan_timestamps or None, + ) + metrics = compute_tracking_metrics(G, n_scans=len(scan_tables)) + lineage_events = list(G.graph.get("lineage_events", [])) + track_rows = tracks_to_table(G) + for tr in track_rows: + tr.pop("embedding", None) - resolved_backend = _resolve_backend(_requested_backend(args.backend)) # type: ignore[arg-type] - patch_encoder = make_patch_encoder(resolved_backend, model_name=args.model) if (volumes and label_volumes) else None + resolved_backend = _resolve_backend(_requested_backend(args.backend)) # type: ignore[arg-type] + patch_encoder = ( + make_patch_encoder(resolved_backend, model_name=args.model) if (volumes and label_volumes) else None + ) - prec_cfg = PrecursorConfig( - score_threshold=args.precursor_threshold, - min_persistence=max(1, args.precursor_persistence), - ) - candidates, obs_scores = compute_fracture_precursors( - track_rows, - prec_cfg, - volumes=volumes or None, - label_volumes=label_volumes or None, - patch_encoder=patch_encoder, - lineage_events=lineage_events, - ) + prec_cfg = PrecursorConfig( + score_threshold=args.precursor_threshold, + min_persistence=max(1, args.precursor_persistence), + ) + candidates, obs_scores = compute_fracture_precursors( + track_rows, + prec_cfg, + volumes=volumes or None, + label_volumes=label_volumes or None, + patch_encoder=patch_encoder, + lineage_events=lineage_events, + ) event_rows = events_to_table(lineage_events) prec_rows = precursors_to_table(candidates) @@ -262,6 +274,7 @@ def main(argv: list[str] | None = None) -> int: "scan_names": scan_names, "n_scans": len(scan_tables), "total_tracks": metrics["total_tracks"], + "gap_closed_count": metrics["gap_closed_count"], "split_count": metrics["split_count"], "merge_count": metrics["merge_count"], "event_count": len(event_rows), diff --git a/braggtrack/cli/embed_dataset.py b/braggtrack/cli/embed_dataset.py index b819c01..f1baec7 100644 --- a/braggtrack/cli/embed_dataset.py +++ b/braggtrack/cli/embed_dataset.py @@ -10,9 +10,10 @@ from braggtrack.cli._utils import load_feature_csv, synth_volume_from_file from braggtrack.io import ( + LazyVolume, MissingH5DependencyError, discover_operando_scans, - load_primary_volume, + open_lazy_volume, resolve_dataset_root, ) from braggtrack.semantic import DEFAULT_DINO_MODEL, crop_spot_cube, make_multiview_encoder, orthogonal_mips @@ -83,38 +84,39 @@ def main(argv: list[str] | None = None) -> int: return 1 try: - volume = load_primary_volume(scan_file.path) + lazy_vol = open_lazy_volume(scan_file.path) except MissingH5DependencyError: - volume = synth_volume_from_file(scan_file.path) + lazy_vol = LazyVolume.from_array(synth_volume_from_file(scan_file.path)) except (KeyError, ValueError): if not args.allow_synthetic_fallback: raise - volume = synth_volume_from_file(scan_file.path) - - if volume.shape != labels_full.shape: - print( - json.dumps( - { - "error": "Volume/labels shape mismatch", - "scan": name, - "volume": list(volume.shape), - "labels": list(labels_full.shape), - } + lazy_vol = LazyVolume.from_array(synth_volume_from_file(scan_file.path)) + + with lazy_vol: + if lazy_vol.shape != labels_full.shape: + print( + json.dumps( + { + "error": "Volume/labels shape mismatch", + "scan": name, + "volume": list(lazy_vol.shape), + "labels": list(labels_full.shape), + } + ) ) - ) - return 1 + return 1 + + label_ids: list[int] = [] + vectors: list[np.ndarray] = [] - label_ids: list[int] = [] - vectors: list[np.ndarray] = [] - - for row in rows: - lid = int(row["label"]) - mip_mu, mip_chi, mip_d = orthogonal_mips( - crop_spot_cube(volume, labels_full, lid, row, margin=max(0, args.margin))[0] - ) - vec = enc.embed(mip_mu, mip_chi, mip_d) - label_ids.append(lid) - vectors.append(vec) + for row in rows: + lid = int(row["label"]) + mip_mu, mip_chi, mip_d = orthogonal_mips( + crop_spot_cube(lazy_vol, labels_full, lid, row, margin=max(0, args.margin))[0] + ) + vec = enc.embed(mip_mu, mip_chi, mip_d) + label_ids.append(lid) + vectors.append(vec) if not vectors: dim = 384 diff --git a/braggtrack/cli/report_dataset.py b/braggtrack/cli/report_dataset.py new file mode 100644 index 0000000..f6ac4fc --- /dev/null +++ b/braggtrack/cli/report_dataset.py @@ -0,0 +1,140 @@ +"""Generate publication figures and an interactive HTML 4D beamtime explorer from BraggTrack outputs.""" + +from __future__ import annotations + +import argparse +import csv +import json +from pathlib import Path +from typing import Any + +from braggtrack.viz import ( + generate_html_report, + plot_kinematics_dashboard, + plot_lineage_dag, + plot_precursor_timeline, +) + + +def build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "artifact_dir", + nargs="?", + default="artifacts/pipeline", + help="Pipeline or tracking output directory containing tracks.csv / events / manifest", + ) + parser.add_argument( + "--dataset-root", + default=None, + help="Optional raw HDF5 dataset root for embedding 3-axis MIP spot thumbnails", + ) + parser.add_argument( + "--outdir", + default=None, + help="Optional report output directory (defaults to /report)", + ) + parser.add_argument( + "--no-figures", + action="store_true", + help="Skip static Matplotlib PNG/PDF generation and emit only the self-contained HTML explorer", + ) + parser.add_argument( + "--max-mip-tracks", + type=int, + default=16, + help="Maximum priority tracks for lazy 3-view MIP thumbnail extraction", + ) + return parser + + +def _read_csv_rows(path: Path) -> list[dict[str, str]]: + if not path.exists() or path.stat().st_size == 0: + return [] + with path.open(newline="") as f: + return list(csv.DictReader(f)) + + +def main(argv: list[str] | None = None) -> int: + args = build_parser().parse_args(argv) + in_root = Path(args.artifact_dir) + if not in_root.is_dir(): + print(json.dumps({"error": "Artifact directory not found", "artifact_dir": str(in_root)})) + return 1 + + out_root = Path(args.outdir) if args.outdir else (in_root / "report") + out_root.mkdir(parents=True, exist_ok=True) + + trk_dir = in_root / "tracking" if (in_root / "tracking").is_dir() else in_root + evt_dir = in_root / "events" if (in_root / "events").is_dir() else trk_dir + track_rows = _read_csv_rows(evt_dir / "tracks.csv") or _read_csv_rows(trk_dir / "tracks.csv") + if not track_rows: + print(json.dumps({"error": "No tracks.csv found under artifact directory", "artifact_dir": str(in_root)})) + return 1 + + html_path = generate_html_report( + in_root, + out_root / "report.html", + dataset_root=args.dataset_root, + max_mip_tracks=max(0, args.max_mip_tracks), + ) + + figures: dict[str, str] = {} + if not args.no_figures: + try: + import matplotlib + + matplotlib.use("Agg", force=False) + import matplotlib.pyplot as plt + + fig_dir = out_root / "figures" + fig_dir.mkdir(parents=True, exist_ok=True) + event_rows = _read_csv_rows(evt_dir / "events.csv") or _read_csv_rows(trk_dir / "events.csv") + prec_rows = _read_csv_rows(evt_dir / "precursors.csv") or _read_csv_rows(trk_dir / "precursors.csv") + prec_obs_rows = _read_csv_rows(evt_dir / "precursor_observations.csv") + + calibrated = False + ts_path = trk_dir / "tracking_summary.json" + if ts_path.exists(): + try: + calibrated = bool(json.loads(ts_path.read_text()).get("calibrated_axes", False)) + except (OSError, json.JSONDecodeError): + calibrated = False + + fig_dag, _ = plot_lineage_dag(track_rows, events=event_rows, save_path=fig_dir / "lineage_dag.png") + plt.close(fig_dag) + figures["lineage_dag"] = str((fig_dir / "lineage_dag.png").resolve()) + + fig_kin, _ = plot_kinematics_dashboard( + track_rows, + events=event_rows, + calibrated=calibrated, + save_path=fig_dir / "kinematics_dashboard.png", + ) + plt.close(fig_kin) + figures["kinematics_dashboard"] = str((fig_dir / "kinematics_dashboard.png").resolve()) + + if prec_obs_rows: + fig_prec, _ = plot_precursor_timeline( + prec_obs_rows, + candidates=prec_rows, + save_path=fig_dir / "precursor_timeline.png", + ) + plt.close(fig_prec) + figures["precursor_timeline"] = str((fig_dir / "precursor_timeline.png").resolve()) + except ImportError: + pass + + summary: dict[str, Any] = { + "schema_version": "report.v1", + "html_report": str(html_path.resolve()), + "figures": figures, + "track_row_count": len(track_rows), + } + (out_root / "report_summary.json").write_text(json.dumps(summary, indent=2)) + print(json.dumps(summary, indent=2)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/braggtrack/cli/run_pipeline.py b/braggtrack/cli/run_pipeline.py index 12ef93e..756f5b1 100644 --- a/braggtrack/cli/run_pipeline.py +++ b/braggtrack/cli/run_pipeline.py @@ -14,7 +14,7 @@ from typing import Any import braggtrack -from braggtrack.cli import detect_events, embed_dataset, segment_dataset, track_dataset +from braggtrack.cli import detect_events, embed_dataset, report_dataset, segment_dataset, track_dataset from braggtrack.io import BeamlineAdapter, discover_operando_scans, resolve_dataset_root, validate_sequence from braggtrack.semantic import DEFAULT_DINO_MODEL @@ -48,8 +48,12 @@ def build_parser() -> argparse.ArgumentParser: ) parser.add_argument("--smooth-window", type=int, default=5, help="Cross-scan rolling median threshold window") parser.add_argument("--calibration-json", default=None, help="Optional AxisCalibration JSON path") + parser.add_argument( + "--detector-json", default=None, help="Optional DetectorGeometry JSON path for (2theta, eta, Q)" + ) parser.add_argument("--cost-alpha", type=float, default=1.0, help="Geometry weight in semantic cost") parser.add_argument("--cost-beta", type=float, default=0.25, help="Semantic embedding weight in tracking cost") + parser.add_argument("--max-gap", type=int, default=0, help="Max missing intermediate scans to bridge (0 disables)") parser.add_argument( "--split-max-distance", type=float, default=25.0, help="Max centroid distance for splits/merges" ) @@ -61,6 +65,13 @@ def build_parser() -> argparse.ArgumentParser: default=True, help="Run split/merge lineage and fracture precursor detection stage (default: enabled)", ) + parser.add_argument( + "--report", + action="store_true", + help="Generate static publication figures and interactive HTML 4D explorer under /report", + ) + parser.add_argument("--export-imaged11", default=None, help="Optional ImageD11 .flt export path") + parser.add_argument("--export-nexus", default=None, help="Optional NeXus NXprocess .nxs/.h5 export path") parser.add_argument( "--allow-synthetic-fallback", action="store_true", @@ -102,12 +113,17 @@ def _merge_config_overrides(args: argparse.Namespace) -> dict[str, Any]: "method": args.method, "smooth_window": args.smooth_window, "calibration_json": args.calibration_json, + "detector_json": args.detector_json, "cost_alpha": args.cost_alpha, "cost_beta": args.cost_beta, + "max_gap": args.max_gap, "split_max_distance": args.split_max_distance, "precursor_threshold": args.precursor_threshold, "precursor_persistence": args.precursor_persistence, "detect_events": bool(args.detect_events), + "report": bool(args.report), + "export_imaged11": args.export_imaged11, + "export_nexus": args.export_nexus, "allow_synthetic_fallback": bool(args.allow_synthetic_fallback), "segmentation_extra_args": [], "tracking_extra_args": [], @@ -132,6 +148,7 @@ def main(argv: list[str] | None = None) -> int: emb_dir = outdir / "embedding" trk_dir = outdir / "tracking" evt_dir = outdir / "events" + rep_dir = outdir / "report" timings: dict[str, float] = {} t_total0 = time.perf_counter() @@ -190,7 +207,7 @@ def main(argv: list[str] | None = None) -> int: if rc_seg != 0: return rc_seg - # 3. Embed dataset (whenever cost_beta != 0 or detect_events is enabled) + # 3. Embed dataset (whenever cost_beta != 0) need_embed = float(cfg["cost_beta"]) != 0.0 if need_embed: t0 = time.perf_counter() @@ -222,6 +239,8 @@ def main(argv: list[str] | None = None) -> int: str(cfg["cost_alpha"]), "--cost-beta", str(cfg["cost_beta"]), + "--max-gap", + str(cfg["max_gap"]), "--split-max-distance", str(cfg["split_max_distance"]), "--precursor-threshold", @@ -233,6 +252,12 @@ def main(argv: list[str] | None = None) -> int: trk_argv.extend(["--embedding-dir", str(emb_dir)]) if cfg.get("detect_events"): trk_argv.append("--detect-events") + if cfg.get("detector_json"): + trk_argv.extend(["--detector-json", str(cfg["detector_json"])]) + if cfg.get("export_imaged11"): + trk_argv.extend(["--export-imaged11", str(cfg["export_imaged11"])]) + if cfg.get("export_nexus") and not cfg.get("detect_events"): + trk_argv.extend(["--export-nexus", str(cfg["export_nexus"])]) trk_argv.extend(str(x) for x in cfg.get("tracking_extra_args", [])) rc_trk = track_dataset.main(trk_argv) timings["track"] = round(time.perf_counter() - t0, 4) @@ -256,6 +281,8 @@ def main(argv: list[str] | None = None) -> int: str(cfg["cost_alpha"]), "--cost-beta", str(cfg["cost_beta"]), + "--max-gap", + str(cfg["max_gap"]), "--split-max-distance", str(cfg["split_max_distance"]), "--precursor-threshold", @@ -272,34 +299,57 @@ def main(argv: list[str] | None = None) -> int: if rc_evt != 0: return rc_evt - total_sec = round(time.perf_counter() - t_total0, 4) - manifest = { - "schema_version": "manifest.v1", - "created_at": datetime.now(timezone.utc).isoformat(), - "braggtrack_version": braggtrack.__version__, - "git_sha": _resolve_git_sha(), - "python_version": sys.version.split()[0], - "platform": platform.platform(), - "dataset_root": str(root.resolve()), - "outdir": str(outdir.resolve()), - "config": cfg, - "inputs": input_files, - "stage_timings_sec": timings, - "total_duration_sec": total_sec, - "artifacts": { - "validation_summary": str((outdir / "validation_summary.json").resolve()), - "segmentation_summary": str((seg_dir / "segmentation_summary.json").resolve()), - "embedding_summary": str((emb_dir / "embedding_summary.json").resolve()) if need_embed else None, - "tracking_summary": str((trk_dir / "tracking_summary.json").resolve()), - "kinematics_csv": str((trk_dir / "kinematics.csv").resolve()), - "kinematics_summary": str((trk_dir / "kinematics_summary.json").resolve()), - "events_summary": str((evt_dir / "events_summary.json").resolve()) if cfg.get("detect_events") else None, - "events_csv": str((evt_dir / "events.csv").resolve()) if cfg.get("detect_events") else None, - "precursors_csv": str((evt_dir / "precursors.csv").resolve()) if cfg.get("detect_events") else None, - }, - } + if cfg.get("export_nexus") and cfg.get("detect_events"): + from braggtrack.io import DetectorGeometry, export_nexus_process + + dgeom = DetectorGeometry.from_json(cfg["detector_json"]) if cfg.get("detector_json") else None + export_nexus_process(outdir, cfg["export_nexus"], geometry=dgeom) + manifest_path = outdir / "run_manifest.json" - manifest_path.write_text(json.dumps(manifest, indent=2)) + + def _build_manifest(cur_total_sec: float) -> dict[str, Any]: + return { + "schema_version": "manifest.v1", + "created_at": datetime.now(timezone.utc).isoformat(), + "braggtrack_version": braggtrack.__version__, + "git_sha": _resolve_git_sha(), + "python_version": sys.version.split()[0], + "platform": platform.platform(), + "dataset_root": str(root.resolve()), + "outdir": str(outdir.resolve()), + "config": cfg, + "inputs": input_files, + "stage_timings_sec": timings, + "total_duration_sec": cur_total_sec, + "artifacts": { + "validation_summary": str((outdir / "validation_summary.json").resolve()), + "segmentation_summary": str((seg_dir / "segmentation_summary.json").resolve()), + "embedding_summary": str((emb_dir / "embedding_summary.json").resolve()) if need_embed else None, + "tracking_summary": str((trk_dir / "tracking_summary.json").resolve()), + "kinematics_csv": str((trk_dir / "kinematics.csv").resolve()), + "kinematics_summary": str((trk_dir / "kinematics_summary.json").resolve()), + "events_summary": str((evt_dir / "events_summary.json").resolve()) + if cfg.get("detect_events") + else None, + "events_csv": str((evt_dir / "events.csv").resolve()) if cfg.get("detect_events") else None, + "precursors_csv": str((evt_dir / "precursors.csv").resolve()) if cfg.get("detect_events") else None, + "html_report": str((rep_dir / "report.html").resolve()) if cfg.get("report") else None, + }, + } + + total_sec = round(time.perf_counter() - t_total0, 4) + manifest_path.write_text(json.dumps(_build_manifest(total_sec), indent=2)) + + # 6. Optional interactive HTML & static figure report + if cfg.get("report"): + t0 = time.perf_counter() + rc_rep = report_dataset.main([str(outdir), "--dataset-root", str(root), "--outdir", str(rep_dir)]) + timings["report"] = round(time.perf_counter() - t0, 4) + if rc_rep != 0: + return rc_rep + total_sec = round(time.perf_counter() - t_total0, 4) + manifest_path.write_text(json.dumps(_build_manifest(total_sec), indent=2)) + print(json.dumps({"manifest": str(manifest_path.resolve()), "total_duration_sec": total_sec}, indent=2)) return 0 diff --git a/braggtrack/cli/segment_dataset.py b/braggtrack/cli/segment_dataset.py index aaaf79e..9f6ff29 100644 --- a/braggtrack/cli/segment_dataset.py +++ b/braggtrack/cli/segment_dataset.py @@ -16,6 +16,8 @@ discover_primary_volume_path, extract_axis_calibration, load_primary_volume, + open_lazy_volume, + otsu_threshold_chunked, resolve_dataset_root, ) from braggtrack.segmentation import ( @@ -191,12 +193,20 @@ def _load_one(scan_obj: object) -> tuple[np.ndarray, str, str | None, AxisCalibr src = "synthetic_fallback" return vol, src, dpath, scan_cal - # First pass: compute scalar per-scan Otsu thresholds in O(1) volume memory. + # First pass: compute scalar per-scan Otsu thresholds via streaming z-slabs. raw_thresholds: list[float] = [] for scan in scans: - vol_tmp, _, _, _ = _load_one(scan) - raw_thresholds.append(otsu_threshold(vol_tmp.ravel()) * float(args.threshold_fraction)) - del vol_tmp + scan_path = scan.path # type: ignore[attr-defined] + try: + with open_lazy_volume(scan_path) as lazy_tmp: + thr = otsu_threshold_chunked(lazy_tmp) + except MissingH5DependencyError: + thr = otsu_threshold(synth_volume_from_file(scan_path)) + except (KeyError, ValueError): + if not args.allow_synthetic_fallback: + raise + thr = otsu_threshold(synth_volume_from_file(scan_path)) + raw_thresholds.append(thr * float(args.threshold_fraction)) if args.method == "classical" and args.smooth_window > 1 and len(raw_thresholds) > 1: effective_thresholds = [float(x) for x in smooth_thresholds(raw_thresholds, window=args.smooth_window)] diff --git a/braggtrack/cli/track_dataset.py b/braggtrack/cli/track_dataset.py index 2472cf2..c73c107 100644 --- a/braggtrack/cli/track_dataset.py +++ b/braggtrack/cli/track_dataset.py @@ -10,7 +10,15 @@ import numpy as np from braggtrack.cli._utils import load_feature_csv, write_csv, write_qc_notebook +from braggtrack.io import ( + AxisCalibration, + DetectorGeometry, + annotate_crystallographic_columns, + export_imaged11_flt, + export_nexus_process, +) from braggtrack.tracking import ( + GapClosingConfig, GeometrySemanticCost, PositionShapeCost, PrecursorConfig, @@ -40,6 +48,18 @@ def build_parser() -> argparse.ArgumentParser: parser.add_argument("--gate-chi", type=float, default=float("inf")) parser.add_argument("--gate-d", type=float, default=float("inf")) parser.add_argument("--max-cost", type=float, default=float("inf")) + parser.add_argument( + "--max-gap", + type=int, + default=0, + help="Maximum missing intermediate scans to bridge via gap closing (0 disables)", + ) + parser.add_argument( + "--gap-max-cost", + type=float, + default=25.0, + help="Maximum penalized cost allowed when bridging missing scans", + ) parser.add_argument( "--embedding-dir", default=None, @@ -80,6 +100,21 @@ def build_parser() -> argparse.ArgumentParser: default=2, help="Minimum contiguous scans above threshold to rank as a fracture precursor", ) + parser.add_argument( + "--detector-json", + default=None, + help="Optional DetectorGeometry JSON path to annotate (omega, 2theta, eta, d, |Q|) columns", + ) + parser.add_argument( + "--export-imaged11", + default=None, + help="Optional path to write an ImageD11 .flt columnfile of tracked reflections", + ) + parser.add_argument( + "--export-nexus", + default=None, + help="Optional path to write a NeXus NXprocess HDF5 summary file", + ) return parser @@ -100,7 +135,7 @@ def _merge_embeddings(rows: list[dict[str, Any]], emb: dict[int, np.ndarray]) -> row["embedding"] = emb[lid] -def _detect_calibrated_axes(scan_dirs: list[Path]) -> bool: +def _detect_calibration(scan_dirs: list[Path]) -> AxisCalibration | None: for sd in scan_dirs: summary_path = sd / "summary.json" if not summary_path.exists(): @@ -111,8 +146,8 @@ def _detect_calibrated_axes(scan_dirs: list[Path]) -> bool: continue cal = meta.get("calibration") if isinstance(cal, dict) and bool(cal.get("calibrated", False)): - return True - return False + return AxisCalibration.from_dict(cal) + return None _TRACKING_QC_CODE = [ @@ -204,6 +239,7 @@ def main(argv: list[str] | None = None) -> int: else: cost_fn = geo + gap_cfg = GapClosingConfig(max_gap=args.max_gap, max_cost=args.gap_max_cost) if args.max_gap > 0 else None sm_cfg = ( SplitMergeConfig( max_distance=args.split_max_distance, @@ -214,17 +250,28 @@ def main(argv: list[str] | None = None) -> int: if args.detect_events else None ) - G = build_tracks(scan_tables, cost_fn=cost_fn, max_cost=args.max_cost, split_merge_config=sm_cfg) + G = build_tracks( + scan_tables, + cost_fn=cost_fn, + max_cost=args.max_cost, + gap_closing_config=gap_cfg, + split_merge_config=sm_cfg, + ) metrics = compute_tracking_metrics(G, n_scans=len(scan_tables)) + active_cal = _detect_calibration(used_scan_dirs) + calibrated_axes = active_cal is not None + detector_geom = DetectorGeometry.from_json(args.detector_json) if args.detector_json else None + track_rows = tracks_to_table(G) for tr in track_rows: tr.pop("embedding", None) + if detector_geom is not None: + track_rows = annotate_crystallographic_columns(track_rows, detector_geom, calibration=active_cal) write_csv(outdir / "tracks.csv", track_rows) (outdir / "tracking_metrics.json").write_text(json.dumps(metrics, indent=2)) # Per-grain kinematics export. - calibrated_axes = _detect_calibrated_axes(used_scan_dirs) gk = compute_grain_kinematics(track_rows) kin_summary = summarize_kinematics(gk, n_scans=len(scan_tables), calibrated_axes=calibrated_axes) write_csv(outdir / "kinematics.csv", kinematics_to_table(gk, include_delta_d=True)) @@ -257,12 +304,19 @@ def main(argv: list[str] | None = None) -> int: "schema_version": schema_version, "cost_alpha": args.cost_alpha, "cost_beta": args.cost_beta, + "max_gap": args.max_gap, "embedding_dir": str(emb_root) if emb_root else None, "detect_events": bool(args.detect_events), + "detector_geometry": detector_geom.to_dict() if detector_geom is not None else None, } (outdir / "tracking_summary.json").write_text(json.dumps(summary, indent=2)) write_qc_notebook(outdir / "qc" / "tracking_qc.ipynb", title="Tracking QC", code_source=_TRACKING_QC_CODE) + if args.export_imaged11: + export_imaged11_flt(track_rows, args.export_imaged11, geometry=detector_geom, calibration=active_cal) + if args.export_nexus: + export_nexus_process(outdir, args.export_nexus, geometry=detector_geom, calibration=active_cal) + print(json.dumps(summary, indent=2)) return 0 diff --git a/braggtrack/io/__init__.py b/braggtrack/io/__init__.py index c2b0577..9a37a54 100644 --- a/braggtrack/io/__init__.py +++ b/braggtrack/io/__init__.py @@ -1,7 +1,10 @@ """Data I/O helpers for BraggTrack.""" from .beamline import BeamlineAdapter +from .crystallography import DetectorGeometry, annotate_crystallographic_columns from .discovery import discover_operando_scans +from .export import IMAGED11_COLUMNS, export_imaged11_flt, export_nexus_process, read_imaged11_flt +from .lazy import LazyVolume, open_lazy_volume, otsu_threshold_chunked from .models import AxisCalibration, AxisSpec, ExperimentSequence, ScanVolumeMeta from .nexus import ( MissingH5DependencyError, @@ -15,21 +18,30 @@ from .validation import ValidationIssue, validate_sequence __all__ = [ + "AxisCalibration", + "AxisSpec", + "BeamlineAdapter", + "DetectorGeometry", + "ExperimentSequence", + "IMAGED11_COLUMNS", + "LazyVolume", + "MissingH5DependencyError", + "ScanVolumeMeta", + "ValidationIssue", + "annotate_crystallographic_columns", "default_dataset_root", - "resolve_dataset_root", - "sample_operando_root", "discover_operando_scans", "discover_primary_volume_path", + "export_imaged11_flt", + "export_nexus_process", "extract_axis_calibration", "extract_scan_metadata", - "summarize_hdf5_tree", "load_primary_volume", - "MissingH5DependencyError", - "AxisCalibration", - "AxisSpec", - "ScanVolumeMeta", - "ExperimentSequence", - "BeamlineAdapter", - "ValidationIssue", + "open_lazy_volume", + "otsu_threshold_chunked", + "read_imaged11_flt", + "resolve_dataset_root", + "sample_operando_root", + "summarize_hdf5_tree", "validate_sequence", ] diff --git a/braggtrack/io/crystallography.py b/braggtrack/io/crystallography.py new file mode 100644 index 0000000..d7169f8 --- /dev/null +++ b/braggtrack/io/crystallography.py @@ -0,0 +1,146 @@ +"""Transmission diffraction detector geometry and reciprocal-space (2theta, eta, |Q|) mapping.""" + +from __future__ import annotations + +import json +import math +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from .models import AxisCalibration + + +@dataclass(frozen=True) +class DetectorGeometry: + """Area-detector diffraction geometry for crystallographic angle & Q conversion. + + Follows standard transmission 3DXRD conventions (e.g. ESRF / ImageD11): + incident beam along ``+X_lab``, detector plane at ``X_lab = distance_mm``, + horizontal detector coordinate ``x_px`` (BraggTrack ``chi`` axis), + vertical detector coordinate ``y_px`` (BraggTrack ``d`` axis), and + rotation stack ``z_idx`` (BraggTrack ``mu`` / ``omega`` axis). + """ + + distance_mm: float = 150.0 + pixel_size_y_mm: float = 0.075 + pixel_size_x_mm: float = 0.075 + beam_center_y_px: float = 1024.0 + beam_center_x_px: float = 1024.0 + wavelength_angstrom: float = 0.2898 + omega_origin_deg: float = 0.0 + omega_step_deg: float = 0.05 + + def __post_init__(self) -> None: + if self.distance_mm <= 0.0: + raise ValueError("distance_mm must be positive.") + if self.pixel_size_y_mm <= 0.0 or self.pixel_size_x_mm <= 0.0: + raise ValueError("pixel_size_y_mm and pixel_size_x_mm must be positive.") + if self.wavelength_angstrom <= 0.0: + raise ValueError("wavelength_angstrom must be positive.") + + def to_dict(self) -> dict[str, float]: + return { + "distance_mm": float(self.distance_mm), + "pixel_size_y_mm": float(self.pixel_size_y_mm), + "pixel_size_x_mm": float(self.pixel_size_x_mm), + "beam_center_y_px": float(self.beam_center_y_px), + "beam_center_x_px": float(self.beam_center_x_px), + "wavelength_angstrom": float(self.wavelength_angstrom), + "omega_origin_deg": float(self.omega_origin_deg), + "omega_step_deg": float(self.omega_step_deg), + } + + @classmethod + def from_dict(cls, data: dict[str, Any]) -> DetectorGeometry: + return cls( + distance_mm=float(data.get("distance_mm", 150.0)), + pixel_size_y_mm=float(data.get("pixel_size_y_mm", 0.075)), + pixel_size_x_mm=float(data.get("pixel_size_x_mm", 0.075)), + beam_center_y_px=float(data.get("beam_center_y_px", 1024.0)), + beam_center_x_px=float(data.get("beam_center_x_px", 1024.0)), + wavelength_angstrom=float(data.get("wavelength_angstrom", 0.2898)), + omega_origin_deg=float(data.get("omega_origin_deg", 0.0)), + omega_step_deg=float(data.get("omega_step_deg", 0.05)), + ) + + @classmethod + def from_json(cls, path: str | Path) -> DetectorGeometry: + raw = json.loads(Path(path).read_text()) + if not isinstance(raw, dict): + raise ValueError("DetectorGeometry JSON must contain an object.") + return cls.from_dict(raw) + + def save_json(self, path: str | Path) -> None: + out = Path(path) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(self.to_dict(), indent=2), encoding="utf-8") + + def spot_to_scattering(self, z_idx: float, y_px: float, x_px: float) -> dict[str, float]: + """Convert detector voxel centroid ``(z_idx, y_px, x_px)`` to ``(omega, 2theta, eta, d, Q)``.""" + dx_mm = (float(x_px) - self.beam_center_x_px) * self.pixel_size_x_mm + dy_mm = (float(y_px) - self.beam_center_y_px) * self.pixel_size_y_mm + r_mm = math.hypot(dx_mm, dy_mm) + path_len = math.hypot(self.distance_mm, r_mm) + + two_theta_rad = math.atan2(r_mm, self.distance_mm) + two_theta_deg = math.degrees(two_theta_rad) + eta_deg = math.degrees(math.atan2(dy_mm, dx_mm)) + omega_deg = self.omega_origin_deg + float(z_idx) * self.omega_step_deg + omega_rad = math.radians(omega_deg) + + sin_theta = math.sin(0.5 * two_theta_rad) + if sin_theta > 1e-12: + d_angstrom = self.wavelength_angstrom / (2.0 * sin_theta) + else: + d_angstrom = float("inf") + + k_mag = (2.0 * math.pi) / self.wavelength_angstrom + qlab_x = k_mag * (self.distance_mm / path_len - 1.0) + qlab_y = k_mag * (dx_mm / path_len) + qlab_z = k_mag * (dy_mm / path_len) + + cos_w = math.cos(omega_rad) + sin_w = math.sin(omega_rad) + qx = qlab_x * cos_w + qlab_y * sin_w + qy = -qlab_x * sin_w + qlab_y * cos_w + qz = qlab_z + q_mag = math.sqrt(qx * qx + qy * qy + qz * qz) + + return { + "omega_deg": round(omega_deg, 6), + "two_theta_deg": round(two_theta_deg, 6), + "eta_deg": round(eta_deg, 6), + "d_spacing_angstrom": round(d_angstrom, 6) if math.isfinite(d_angstrom) else float("inf"), + "qx_inv_angstrom": round(qx, 6), + "qy_inv_angstrom": round(qy, 6), + "qz_inv_angstrom": round(qz, 6), + "q_mag_inv_angstrom": round(q_mag, 6), + } + + +def _recover_voxel_centroid(row: dict[str, Any], calibration: AxisCalibration | None) -> tuple[float, float, float]: + mu = float(row["centroid_mu"]) + chi = float(row["centroid_chi"]) + d_val = float(row["centroid_d"]) + if calibration is not None and calibration.calibrated: + z_idx = (mu - calibration.mu_origin) / calibration.mu_step + x_px = (chi - calibration.chi_origin) / calibration.chi_step + y_px = (d_val - calibration.d_origin) / calibration.d_step + return z_idx, y_px, x_px + return mu, d_val, chi + + +def annotate_crystallographic_columns( + rows: list[dict[str, Any]], + geometry: DetectorGeometry, + *, + calibration: AxisCalibration | None = None, +) -> list[dict[str, Any]]: + """Return shallow-copied rows augmented with ``(omega_deg, two_theta_deg, eta_deg, d_spacing_angstrom, q_*)``.""" + enriched: list[dict[str, Any]] = [] + for row in rows: + z_idx, y_px, x_px = _recover_voxel_centroid(row, calibration) + scat = geometry.spot_to_scattering(z_idx, y_px, x_px) + enriched.append({**row, **scat}) + return enriched diff --git a/braggtrack/io/export.py b/braggtrack/io/export.py new file mode 100644 index 0000000..5b67a2d --- /dev/null +++ b/braggtrack/io/export.py @@ -0,0 +1,256 @@ +"""Interoperability exporters for ImageD11 columnfiles (.flt) and NeXus NXprocess HDF5.""" + +from __future__ import annotations + +import csv +import json +import math +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +import braggtrack + +from .crystallography import DetectorGeometry, _recover_voxel_centroid +from .models import AxisCalibration +from .nexus import _require_h5py + +IMAGED11_COLUMNS = ( + "sc", + "fc", + "omega", + "Number_of_pixels", + "avg_intensity", + "sum_intensity", + "tth", + "eta", + "d_spacing", + "gx", + "gy", + "gz", + "scan_idx", + "spot_id", + "track_id", +) + + +def export_imaged11_flt( + rows: list[dict[str, Any]], + out_path: str | Path, + *, + geometry: DetectorGeometry | None = None, + calibration: AxisCalibration | None = None, +) -> Path: + """Write segmented or tracked Bragg reflections as an ImageD11 ``.flt`` columnfile. + + In ImageD11 convention, ``sc`` is the slow (vertical, ``y``) pixel coordinate, + ``fc`` is the fast (horizontal, ``x``) pixel coordinate, and ``(gx, gy, gz)`` + are reciprocal-space scattering vectors in ``1/d`` (``Q / 2*pi``) units. + """ + dest = Path(out_path) + dest.parent.mkdir(parents=True, exist_ok=True) + geom = geometry or DetectorGeometry() + two_pi = 2.0 * math.pi + + lines: list[str] = [ + f"# ImageD11 columnfile exported by BraggTrack {braggtrack.__version__}", + f"# wavelength = {geom.wavelength_angstrom:.6f}", + f"# distance = {geom.distance_mm * 1000.0:.3f}", + f"# y_center = {geom.beam_center_y_px:.3f}", + f"# z_center = {geom.beam_center_x_px:.3f}", + f"# y_size = {geom.pixel_size_y_mm * 1000.0:.3f}", + f"# z_size = {geom.pixel_size_x_mm * 1000.0:.3f}", + "# " + " ".join(IMAGED11_COLUMNS), + ] + + for idx, row in enumerate(rows): + z_idx, y_px, x_px = _recover_voxel_centroid(row, calibration) + scat = geom.spot_to_scattering(z_idx, y_px, x_px) + vox = max(1, int(float(row.get("voxel_count", 1)))) + sum_int = float(row.get("integrated_intensity", 0.0)) + avg_int = sum_int / float(vox) + scan_idx = int(float(row.get("scan_idx", 0))) + spot_id = int(float(row.get("label", row.get("spot_idx", idx + 1)))) + track_id = int(float(row.get("track_id", -1))) + d_val = scat["d_spacing_angstrom"] if math.isfinite(scat["d_spacing_angstrom"]) else 0.0 + gx = scat["qx_inv_angstrom"] / two_pi + gy = scat["qy_inv_angstrom"] / two_pi + gz = scat["qz_inv_angstrom"] / two_pi + + lines.append( + f"{y_px:10.4f} {x_px:10.4f} {scat['omega_deg']:10.4f} " + f"{vox:8d} {avg_int:12.4f} {sum_int:14.4f} " + f"{scat['two_theta_deg']:10.5f} {scat['eta_deg']:10.4f} {d_val:10.5f} " + f"{gx:11.6f} {gy:11.6f} {gz:11.6f} " + f"{scan_idx:6d} {spot_id:6d} {track_id:6d}" + ) + + dest.write_text("\n".join(lines) + "\n") + return dest + + +def read_imaged11_flt(path: str | Path) -> tuple[dict[str, str], list[dict[str, float]]]: + """Parse an ImageD11 ``.flt`` columnfile back into header parameters and numeric row dicts.""" + params: dict[str, str] = {} + columns: list[str] = [] + rows: list[dict[str, float]] = [] + + for raw_line in Path(path).read_text().splitlines(): + line = raw_line.strip() + if not line: + continue + if line.startswith("#"): + body = line[1:].strip() + if "=" in body: + k, v = body.split("=", 1) + params[k.strip()] = v.strip() + elif body.startswith("sc ") or body.startswith("sc\t"): + columns = body.split() + continue + if not columns: + raise ValueError("Missing '# sc fc ...' column header in ImageD11 file.") + parts = line.split() + if len(parts) != len(columns): + raise ValueError(f"Expected {len(columns)} columns, got {len(parts)} in line: {line}") + rows.append({col: float(val) for col, val in zip(columns, parts)}) + + return params, rows + + +def _read_csv_rows(path: Path) -> list[dict[str, str]]: + if not path.exists() or path.stat().st_size == 0: + return [] + with path.open(newline="") as f: + return list(csv.DictReader(f)) + + +def _write_table_group(grp: Any, h5py: Any, rows: list[dict[str, Any]]) -> None: + if not rows: + grp.attrs["row_count"] = 0 + return + grp.attrs["row_count"] = len(rows) + str_dt = h5py.string_dtype(encoding="utf-8") + keys = list(rows[0].keys()) + for key in keys: + vals = [r.get(key, "") for r in rows] + # Attempt numeric conversion first (float64 or int64), else UTF-8 strings. + is_int = True + is_float = True + int_vals: list[int] = [] + float_vals: list[float] = [] + for v in vals: + s = str(v).strip() + if s == "" or s.lower() in ("true", "false") or ";" in s: + is_int = False + is_float = False + break + try: + iv = int(s) + int_vals.append(iv) + except ValueError: + is_int = False + try: + fv = float(s) + float_vals.append(fv) + except ValueError: + is_float = False + break + if is_int: + grp.create_dataset(key, data=np.asarray(int_vals, dtype=np.int64), compression="gzip") + elif is_float: + grp.create_dataset(key, data=np.asarray(float_vals, dtype=np.float64), compression="gzip") + else: + arr = np.asarray([str(v) for v in vals], dtype=object) + grp.create_dataset(key, data=arr, dtype=str_dt) + + +def export_nexus_process( + artifact_dir: str | Path, + out_h5: str | Path, + *, + geometry: DetectorGeometry | None = None, + calibration: AxisCalibration | None = None, +) -> Path: + """Package BraggTrack pipeline/tracking outputs into a NeXus ``NXentry`` / ``NXprocess`` HDF5 file.""" + h5py = _require_h5py() + root = Path(artifact_dir) + dest = Path(out_h5) + dest.parent.mkdir(parents=True, exist_ok=True) + + # Support either a pipeline root (containing tracking/ & events/) or a direct tracking output dir. + trk_dir = root / "tracking" if (root / "tracking").is_dir() else root + evt_dir = root / "events" if (root / "events").is_dir() else trk_dir + + track_rows: list[dict[str, Any]] = [dict(r) for r in _read_csv_rows(trk_dir / "tracks.csv")] + if geometry is not None and track_rows: + from .crystallography import annotate_crystallographic_columns + + track_rows = annotate_crystallographic_columns(track_rows, geometry, calibration=calibration) + + kin_rows = _read_csv_rows(trk_dir / "kinematics.csv") + event_rows = _read_csv_rows(evt_dir / "events.csv") + prec_rows = _read_csv_rows(evt_dir / "precursors.csv") + + provenance_json = "{}" + for cand in (root / "run_manifest.json", trk_dir / "tracking_summary.json"): + if cand.exists(): + provenance_json = cand.read_text() + break + + str_dt = h5py.string_dtype(encoding="utf-8") + with h5py.File(dest, "w") as h5: + h5.attrs["NX_class"] = "NXroot" + h5.attrs["default"] = "entry" + + entry = h5.create_group("entry") + entry.attrs["NX_class"] = "NXentry" + entry.attrs["default"] = "braggtrack" + entry.create_dataset("title", data="BraggTrack 4D Diffraction Tracking & Fracture Analysis", dtype=str_dt) + + proc = entry.create_group("braggtrack") + proc.attrs["NX_class"] = "NXprocess" + proc.create_dataset("program", data="braggtrack", dtype=str_dt) + proc.create_dataset("version", data=str(braggtrack.__version__), dtype=str_dt) + proc.create_dataset("date", data=datetime.now(timezone.utc).isoformat(), dtype=str_dt) + proc.create_dataset("provenance_json", data=provenance_json, dtype=str_dt) + + if geometry is not None: + geom_grp = proc.create_group("detector_geometry") + geom_grp.attrs["NX_class"] = "NXparameters" + for k, v in geometry.to_dict().items(): + geom_grp.create_dataset(k, data=float(v)) + + tracks_grp = proc.create_group("tracks") + tracks_grp.attrs["NX_class"] = "NXdata" + _write_table_group(tracks_grp, h5py, track_rows) + + kin_grp = proc.create_group("kinematics") + kin_grp.attrs["NX_class"] = "NXdata" + _write_table_group(kin_grp, h5py, kin_rows) + + evt_grp = proc.create_group("events") + evt_grp.attrs["NX_class"] = "NXcollection" + _write_table_group(evt_grp, h5py, event_rows) + + prec_grp = proc.create_group("precursors") + prec_grp.attrs["NX_class"] = "NXcollection" + _write_table_group(prec_grp, h5py, prec_rows) + + # Attach summary metrics if available + trk_summary_path = trk_dir / "tracking_summary.json" + if trk_summary_path.exists(): + try: + ts = json.loads(trk_summary_path.read_text()) + metrics_grp = proc.create_group("metrics") + metrics_grp.attrs["NX_class"] = "NXparameters" + for k, v in ts.items(): + if isinstance(v, bool): + metrics_grp.create_dataset(k, data=bool(v)) + elif isinstance(v, (int, float)): + metrics_grp.create_dataset(k, data=v) + except (OSError, json.JSONDecodeError): + pass + + return dest diff --git a/braggtrack/io/lazy.py b/braggtrack/io/lazy.py new file mode 100644 index 0000000..968a26e --- /dev/null +++ b/braggtrack/io/lazy.py @@ -0,0 +1,144 @@ +"""Chunked and ROI-lazy 3D volume access for multi-gigabyte HDF5 detector stacks.""" + +from __future__ import annotations + +from collections.abc import Iterator +from pathlib import Path +from typing import Any + +import numpy as np +from skimage.filters import threshold_otsu + +from .nexus import _require_h5py, _resolve_volume_dataset + + +class LazyVolume: + """Lazy 3D volume wrapper supporting bounded ROI reads and z-slab streaming. + + Works seamlessly over either an open ``h5py.Dataset`` or an in-memory + ``numpy.ndarray`` fallback so downstream stages (:func:`crop_spot_cube`, + chunked Otsu thresholding) never materialize full ``float64`` detector + cubes unless explicitly requested via ``vol[()]``. + """ + + def __init__( + self, + dataset: Any, + *, + handle: Any | None = None, + dataset_path: str | None = None, + ) -> None: + shape = tuple(int(x) for x in dataset.shape) + if len(shape) != 3: + if handle is not None: + handle.close() + raise ValueError(f"LazyVolume requires a 3D dataset, got shape={shape}") + self._dataset = dataset + self._handle = handle + self._shape: tuple[int, int, int] = (shape[0], shape[1], shape[2]) + self._dtype = np.dtype(dataset.dtype) + self._dataset_path = dataset_path + + @classmethod + def from_array(cls, array: np.ndarray, *, dataset_path: str | None = None) -> LazyVolume: + arr = np.asarray(array) + return cls(arr, handle=None, dataset_path=dataset_path) + + @property + def shape(self) -> tuple[int, int, int]: + return self._shape + + @property + def ndim(self) -> int: + return 3 + + @property + def dtype(self) -> np.dtype[Any]: + return self._dtype + + @property + def dataset_path(self) -> str | None: + return self._dataset_path + + def read_roi(self, z_slice: slice, y_slice: slice, x_slice: slice) -> np.ndarray: + """Read a bounded 3D sub-block into memory as ``float64``.""" + return np.asarray(self._dataset[z_slice, y_slice, x_slice], dtype=np.float64) + + def __getitem__(self, key: Any) -> np.ndarray: + return np.asarray(self._dataset[key], dtype=np.float64) + + def iter_z_chunks(self, chunk_z: int = 32) -> Iterator[np.ndarray]: + """Yield contiguous ``(dz, ny, nx)`` ``float64`` slabs along axis 0.""" + step = max(1, int(chunk_z)) + nz = self._shape[0] + for z0 in range(0, nz, step): + z1 = min(nz, z0 + step) + yield np.asarray(self._dataset[z0:z1, :, :], dtype=np.float64) + + def to_dense(self) -> np.ndarray: + """Materialize the full 3D volume as ``float64``.""" + return np.asarray(self._dataset[()], dtype=np.float64) + + def close(self) -> None: + if self._handle is not None: + self._handle.close() + self._handle = None + + def __enter__(self) -> LazyVolume: + return self + + def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None: + self.close() + + +def open_lazy_volume( + path: str | Path, + candidates: list[str] | None = None, + *, + auto_discover: bool = True, +) -> LazyVolume: + """Open an HDF5 file and return a :class:`LazyVolume` bound to its primary 3D dataset.""" + h5py = _require_h5py() + handle = h5py.File(path, "r") + try: + ds_path = _resolve_volume_dataset(handle, h5py, candidates=candidates, auto_discover=auto_discover) + ds = handle[ds_path] + except Exception: + handle.close() + raise + return LazyVolume(ds, handle=handle, dataset_path=ds_path) + + +def otsu_threshold_chunked( + volume: LazyVolume | np.ndarray, + *, + nbins: int = 256, + chunk_z: int = 32, +) -> float: + """Compute global Otsu threshold via streaming z-slabs in ``O(chunk)`` memory.""" + lazy = volume if isinstance(volume, LazyVolume) else LazyVolume.from_array(np.asarray(volume)) + nz, ny, nx = lazy.shape + if nz * ny * nx == 0: + raise ValueError("Otsu threshold requires at least one value.") + + vmin = float("inf") + vmax = float("-inf") + for slab in lazy.iter_z_chunks(chunk_z=chunk_z): + s_min = float(np.min(slab)) + s_max = float(np.max(slab)) + if s_min < vmin: + vmin = s_min + if s_max > vmax: + vmax = s_max + + if vmin == vmax: + return float(vmin) + + edges = np.linspace(vmin, vmax, max(2, int(nbins)) + 1, dtype=np.float64) + counts = np.zeros(len(edges) - 1, dtype=np.int64) + for slab in lazy.iter_z_chunks(chunk_z=chunk_z): + c, _ = np.histogram(slab, bins=edges) + counts += c + + bin_centers = 0.5 * (edges[:-1] + edges[1:]) + return float(threshold_otsu(hist=(counts, bin_centers))) diff --git a/braggtrack/segmentation/dino_segment.py b/braggtrack/segmentation/dino_segment.py index d5b48ef..1250b23 100644 --- a/braggtrack/segmentation/dino_segment.py +++ b/braggtrack/segmentation/dino_segment.py @@ -61,10 +61,13 @@ def _patch_foreground_masks( threshold: float, patch_size: int, axis: int = 0, + grid_hw: tuple[int, int] | None = None, ) -> list[np.ndarray]: """Boolean foreground mask at patch resolution for each slice. A patch is foreground if any of its pixels exceed *threshold*. + Handles both fixed-stride grids (``mock``) and resized ViT patch grids + (e.g. ``16x16`` ``facebook/dinov2-small`` tokens on ``250x250`` slices). """ n_slices = volume.shape[axis] masks: list[np.ndarray] = [] @@ -72,11 +75,22 @@ def _patch_foreground_masks( slc = np.take(volume, i, axis=axis) fg = (slc >= threshold).astype(np.float64) h, w = slc.shape - hp = max(1, h // patch_size) - wp = max(1, w // patch_size) - cropped = fg[: hp * patch_size, : wp * patch_size] - blocks = cropped.reshape(hp, patch_size, wp, patch_size) - masks.append(blocks.max(axis=(1, 3)) > 0) + default_hw = (max(1, h // patch_size), max(1, w // patch_size)) + hp, wp = grid_hw if grid_hw is not None else default_hw + if (hp, wp) == default_hw and hp * patch_size <= h and wp * patch_size <= w: + cropped = fg[: hp * patch_size, : wp * patch_size] + blocks = cropped.reshape(hp, patch_size, wp, patch_size) + masks.append(blocks.max(axis=(1, 3)) > 0) + else: + r_edges = np.linspace(0, h, hp + 1, dtype=int) + c_edges = np.linspace(0, w, wp + 1, dtype=int) + pooled = np.zeros((hp, wp), dtype=bool) + for r_i in range(hp): + r0, r1 = r_edges[r_i], max(r_edges[r_i] + 1, r_edges[r_i + 1]) + for c_i in range(wp): + c0, c1 = c_edges[c_i], max(c_edges[c_i] + 1, c_edges[c_i + 1]) + pooled[r_i, c_i] = bool(np.any(fg[r0:r1, c0:c1] > 0)) + masks.append(pooled) return masks @@ -159,6 +173,13 @@ def _upsample_labels( patch_size: int, ) -> np.ndarray: """Nearest-neighbor upsample patch-resolution labels to pixel resolution.""" + th, tw = target_shape + hp, wp = patch_labels.shape + default_hw = (max(1, th // patch_size), max(1, tw // patch_size)) + if (hp, wp) != default_hw and th > 0 and tw > 0 and hp > 0 and wp > 0: + r_idx = (np.arange(th) * hp) // th + c_idx = (np.arange(tw) * wp) // tw + return patch_labels[np.ix_(r_idx, c_idx)].astype(np.int32) expanded = np.repeat(np.repeat(patch_labels, patch_size, axis=0), patch_size, axis=1) out = np.zeros(target_shape, dtype=np.int32) h = min(expanded.shape[0], target_shape[0]) @@ -302,7 +323,13 @@ def segment_dino( features, slice_hw = _extract_slice_features(volume, encoder, axis=axis) # Foreground mask at patch resolution — exclude background from clustering. - fg_masks = _patch_foreground_masks(volume, threshold, encoder.patch_size, axis=axis) + fg_masks = _patch_foreground_masks( + volume, + threshold, + encoder.patch_size, + axis=axis, + grid_hw=(features.shape[1], features.shape[2]), + ) # Global PCA across all foreground patches for a consistent feature space # (per-slice PCA causes wildly different cluster counts). diff --git a/braggtrack/semantic/dino.py b/braggtrack/semantic/dino.py index 4430380..c636052 100644 --- a/braggtrack/semantic/dino.py +++ b/braggtrack/semantic/dino.py @@ -25,6 +25,9 @@ def _resolve_backend(requested: BackendName) -> Literal["mock", "torch"]: return "mock" if requested == "torch": return "torch" + env_override = os.environ.get("BRAGGTRACK_DINO_BACKEND", "").strip().lower() + if env_override in ("mock", "torch"): + return "mock" if env_override == "mock" else "torch" try: import torch # noqa: F401 except ImportError: diff --git a/braggtrack/semantic/mips.py b/braggtrack/semantic/mips.py index e3240c7..11e58af 100644 --- a/braggtrack/semantic/mips.py +++ b/braggtrack/semantic/mips.py @@ -5,14 +5,16 @@ from __future__ import annotations +from typing import Any + import numpy as np def crop_spot_cube( - volume: np.ndarray, + volume: np.ndarray | Any, labels: np.ndarray, label_id: int, - bbox: dict[str, int], + bbox: dict[str, Any], margin: int = 2, ) -> tuple[np.ndarray, np.ndarray]: """Crop a padded sub-volume and binary mask for one instance. diff --git a/braggtrack/tracking/__init__.py b/braggtrack/tracking/__init__.py index bc5d52d..68a1f62 100644 --- a/braggtrack/tracking/__init__.py +++ b/braggtrack/tracking/__init__.py @@ -3,6 +3,7 @@ from .assignment import associate_frames from .cost import CostFunction, GeometrySemanticCost, PositionShapeCost from .events import LineageEvent, SplitMergeConfig, events_to_table, resolve_splits_and_merges +from .gap_closing import GapCloseRecord, GapClosingConfig, resolve_track_gaps from .kinematics import ( GrainKinematics, KinematicsSummary, @@ -24,6 +25,8 @@ __all__ = [ "CostFunction", + "GapCloseRecord", + "GapClosingConfig", "GeometrySemanticCost", "GrainKinematics", "KinematicsSummary", @@ -45,6 +48,7 @@ "kinematics_to_table", "precursors_to_table", "resolve_splits_and_merges", + "resolve_track_gaps", "summarize_kinematics", "summary_to_dict", "tracks_to_table", diff --git a/braggtrack/tracking/gap_closing.py b/braggtrack/tracking/gap_closing.py new file mode 100644 index 0000000..c40ce8f --- /dev/null +++ b/braggtrack/tracking/gap_closing.py @@ -0,0 +1,275 @@ +"""Multi-scan gap closing for transient beam dropouts and rocking-clip recovery.""" + +from __future__ import annotations + +import math +from dataclasses import dataclass +from typing import Any + +import networkx as nx +import numpy as np +from scipy.optimize import linear_sum_assignment + +from .cost import CostFunction, GeometrySemanticCost, PositionShapeCost +from .lifecycle import TrackEvent + + +@dataclass(frozen=True) +class GapClosingConfig: + """Configuration for reconnecting tracks across missing intermediate scans. + + Parameters + ---------- + max_gap : int + Maximum number of missing intermediate scans (``1 <= gap_scans <= max_gap``). + ``0`` disables gap closing. + gap_penalty_per_scan : float + Multiplicative penalty per missing scan: ``cost * (1 + gap_penalty_per_scan * gap_scans)``. + max_cost : float + Upper bound on the penalized association cost for accepting a gap bridge. + min_cosine_similarity : float + Minimum embedding cosine similarity when both endpoints carry ``embedding``. + """ + + max_gap: int = 2 + gap_penalty_per_scan: float = 0.15 + max_cost: float = 25.0 + min_cosine_similarity: float = 0.50 + + +@dataclass(frozen=True) +class GapCloseRecord: + """Metadata record for an accepted multi-scan gap closure.""" + + track_id: int + from_scan: int + to_scan: int + gap_scans: int + from_node: str + to_node: str + cost: float + + +def _cosine_sim(a_raw: Any, b_raw: Any) -> float | None: + if a_raw is None or b_raw is None: + return None + a = np.asarray(a_raw, dtype=np.float64).ravel() + b = np.asarray(b_raw, dtype=np.float64).ravel() + if a.size == 0 or b.size == 0 or a.shape != b.shape: + return None + na = float(np.linalg.norm(a)) + nb = float(np.linalg.norm(b)) + if na <= 0.0 or nb <= 0.0: + return None + return float(np.clip(np.dot(a, b) / (na * nb), -1.0, 1.0)) + + +def _eval_gap_cost( + cost_fn: CostFunction, + u_data: dict[str, Any], + v_data: dict[str, Any], + delta_scans: int, + min_cos_sim: float, +) -> float: + """Evaluate gap-normalized cost across ``delta_scans = to_scan - from_scan >= 2``.""" + sim = _cosine_sim(u_data.get("embedding"), v_data.get("embedding")) + if sim is not None and sim < min_cos_sim: + return math.inf + + geo: PositionShapeCost | None = None + alpha = 1.0 + beta = 0.0 + if isinstance(cost_fn, PositionShapeCost): + geo = cost_fn + elif isinstance(cost_fn, GeometrySemanticCost): + geo = cost_fn.geometry + alpha = cost_fn.cost_alpha + beta = cost_fn.cost_beta + + if geo is not None: + dmu = abs(float(u_data["centroid_mu"]) - float(v_data["centroid_mu"])) + dchi = abs(float(u_data["centroid_chi"]) - float(v_data["centroid_chi"])) + dd = abs(float(u_data["centroid_d"]) - float(v_data["centroid_d"])) + step_scale = float(max(1, delta_scans)) + if (dmu / step_scale) > geo.gate_mu or (dchi / step_scale) > geo.gate_chi or (dd / step_scale) > geo.gate_d: + return math.inf + + # Diffusive scaling (dx^2 / delta_t) keeps gap costs comparable to 1-step costs. + pos_dist2 = (dmu**2 + dchi**2 + dd**2) / step_scale + deig1 = float(u_data.get("eig_1", 0.0)) - float(v_data.get("eig_1", 0.0)) + deig2 = float(u_data.get("eig_2", 0.0)) - float(v_data.get("eig_2", 0.0)) + deig3 = float(u_data.get("eig_3", 0.0)) - float(v_data.get("eig_3", 0.0)) + shape_dist2 = deig1**2 + deig2**2 + deig3**2 + g_cost = geo.position_weight * pos_dist2 + geo.shape_weight * shape_dist2 + if beta == 0.0: + return alpha * g_cost + if sim is None: + return math.inf + return alpha * g_cost + beta * (1.0 - sim) + + return float(cost_fn(u_data, v_data)) + + +def _propagate_track_id_forward(G: nx.DiGraph, start_nid: str, old_tid: int, new_tid: int) -> None: + queue = [start_nid] + visited: set[str] = set() + while queue: + curr = queue.pop(0) + if curr in visited: + continue + visited.add(curr) + if G.nodes[curr].get("track_id") == old_tid: + G.nodes[curr]["track_id"] = new_tid + for _, succ in G.out_edges(curr): + queue.append(succ) + + +def resolve_track_gaps( + G: nx.DiGraph, + *, + n_scans: int, + cost_fn: CostFunction | None = None, + config: GapClosingConfig | None = None, +) -> list[GapCloseRecord]: + """Reconnect prematurely terminated tracks to matching births across ``1..max_gap`` missing scans.""" + cfg = config or GapClosingConfig() + if cfg.max_gap <= 0 or G.number_of_nodes() == 0 or n_scans < 3: + G.graph.setdefault("gap_closures", []) + return [] + + active_cost: CostFunction = cost_fn if cost_fn is not None else PositionShapeCost() + next_tid = max((int(G.nodes[n]["track_id"]) for n in G.nodes), default=0) + 1 + + # Pass 0: Sever forced cross-detector 1-to-1 jump edges created when max_cost=inf + # paired a dropping-out track with a distant stray spot on an intermediate frame. + nodes_by_scan: dict[int, list[str]] = {} + for nid in G.nodes: + nodes_by_scan.setdefault(int(G.nodes[nid]["scan_idx"]), []).append(nid) + + sever_threshold = max(cfg.max_cost * 4.0, 100.0) + + def _edge_is_jump(a: str, b: str) -> bool: + c_ab = float(active_cost(G.nodes[a], G.nodes[b])) + return not math.isfinite(c_ab) or c_ab > sever_threshold + + edges_to_sever: list[tuple[str, str]] = [] + for u, v, edata in list(G.edges(data=True)): + if edata.get("edge_type", "continuation") != "continuation": + continue + if not _edge_is_jump(u, v): + continue + su = int(G.nodes[u]["scan_idx"]) + sv = int(G.nodes[v]["scan_idx"]) + has_gap_partner = False + # Forward check: u can bridge over the jump to w at su + gap + 1 + for gap in range(1, cfg.max_gap + 1): + for w in nodes_by_scan.get(su + gap + 1, []): + if G.in_degree(w) == 0 or all(_edge_is_jump(p, w) for p, _ in G.in_edges(w)): + gc = _eval_gap_cost(active_cost, G.nodes[u], G.nodes[w], gap + 1, cfg.min_cosine_similarity) + if gc * (1.0 + cfg.gap_penalty_per_scan * gap) <= cfg.max_cost * 0.6: + has_gap_partner = True + break + if has_gap_partner: + break + # Backward check: v can receive a bridge from p at sv - gap - 1 + if not has_gap_partner: + for gap in range(1, cfg.max_gap + 1): + for p in nodes_by_scan.get(sv - gap - 1, []): + if G.out_degree(p) == 0 or all(_edge_is_jump(p, q) for _, q in G.out_edges(p)): + gc = _eval_gap_cost(active_cost, G.nodes[p], G.nodes[v], gap + 1, cfg.min_cosine_similarity) + if gc * (1.0 + cfg.gap_penalty_per_scan * gap) <= cfg.max_cost * 0.6: + has_gap_partner = True + break + if has_gap_partner: + break + if has_gap_partner: + edges_to_sever.append((u, v)) + + for u, v in edges_to_sever: + old_tid = int(G.nodes[u]["track_id"]) + G.remove_edge(u, v) + G.nodes[u]["event"] = TrackEvent.TERMINATED + G.nodes[v]["event"] = TrackEvent.BORN + _propagate_track_id_forward(G, v, old_tid, next_tid) + next_tid += 1 + + term_nodes = sorted( + [n for n in G.nodes if G.out_degree(n) == 0 and int(G.nodes[n]["scan_idx"]) < n_scans - 1], + key=lambda n: (int(G.nodes[n]["scan_idx"]), int(G.nodes[n]["spot_idx"])), + ) + born_nodes = sorted( + [n for n in G.nodes if G.in_degree(n) == 0 and int(G.nodes[n]["scan_idx"]) > 0], + key=lambda n: (int(G.nodes[n]["scan_idx"]), int(G.nodes[n]["spot_idx"])), + ) + + n_term = len(term_nodes) + n_born = len(born_nodes) + if n_term == 0 or n_born == 0: + G.graph["gap_closures"] = [] + return [] + + inadmissible = 1e12 + unmatched_cost = cfg.max_cost + 1e-6 + aug_matrix = np.full((n_term, n_born + n_term), inadmissible, dtype=np.float64) + for i in range(n_term): + aug_matrix[i, n_born + i] = unmatched_cost + + for i, u in enumerate(term_nodes): + u_data = G.nodes[u] + su = int(u_data["scan_idx"]) + for j, v in enumerate(born_nodes): + v_data = G.nodes[v] + sv = int(v_data["scan_idx"]) + gap_scans = sv - su - 1 + if gap_scans < 1 or gap_scans > cfg.max_gap: + continue + base = _eval_gap_cost(active_cost, u_data, v_data, gap_scans + 1, cfg.min_cosine_similarity) + if not math.isfinite(base): + continue + penalized = base * (1.0 + cfg.gap_penalty_per_scan * gap_scans) + if penalized <= cfg.max_cost: + aug_matrix[i, j] = penalized + + row_ind, col_ind = linear_sum_assignment(aug_matrix) + + accepted_pairs: list[tuple[int, int, str, str, float]] = [] + for r, c in zip(row_ind, col_ind): + if c < n_born and aug_matrix[r, c] <= cfg.max_cost: + u = term_nodes[int(r)] + v = born_nodes[int(c)] + su = int(G.nodes[u]["scan_idx"]) + sv = int(G.nodes[v]["scan_idx"]) + accepted_pairs.append((su, sv, u, v, float(aug_matrix[r, c]))) + + # Process chronologically so multi-gap chains (e.g., 0 -> 2 -> 4) propagate a single track_id. + accepted_pairs.sort(key=lambda item: (item[0], item[1], item[2])) + + records: list[GapCloseRecord] = [] + for su, sv, u, v, cost_val in accepted_pairs: + tid = int(G.nodes[u]["track_id"]) + old_v_tid = int(G.nodes[v]["track_id"]) + gap_scans = sv - su - 1 + + G.add_edge(u, v, edge_type="gap_close", gap_scans=gap_scans, cost=round(cost_val, 4)) + _propagate_track_id_forward(G, v, old_v_tid, tid) + + G.nodes[u]["event"] = TrackEvent.BORN if G.in_degree(u) == 0 else TrackEvent.CONTINUED + if G.out_degree(v) > 0 or sv == n_scans - 1: + G.nodes[v]["event"] = TrackEvent.CONTINUED + else: + G.nodes[v]["event"] = TrackEvent.TERMINATED + + records.append( + GapCloseRecord( + track_id=tid, + from_scan=su, + to_scan=sv, + gap_scans=gap_scans, + from_node=u, + to_node=v, + cost=round(cost_val, 4), + ) + ) + + G.graph["gap_closures"] = records + return records diff --git a/braggtrack/tracking/lifecycle.py b/braggtrack/tracking/lifecycle.py index d72089c..54b8c8c 100644 --- a/braggtrack/tracking/lifecycle.py +++ b/braggtrack/tracking/lifecycle.py @@ -12,6 +12,7 @@ if TYPE_CHECKING: from .events import SplitMergeConfig + from .gap_closing import GapClosingConfig class TrackEvent(str, enum.Enum): @@ -30,6 +31,7 @@ def build_tracks( cost_fn: CostFunction | None = None, max_cost: float = float("inf"), *, + gap_closing_config: GapClosingConfig | None = None, split_merge_config: SplitMergeConfig | None = None, scan_timestamps: dict[int, str | None] | None = None, ) -> nx.DiGraph: @@ -37,7 +39,8 @@ def build_tracks( Each node represents a spot observation ``(scan_index, spot_index)`` and carries the full feature dict plus a ``track_id`` and ``event`` - attribute. Edges connect matched spots across consecutive frames, and + attribute. Edges connect matched spots across consecutive frames, + optional *gap_closing_config* reconnects missing intermediate scans, and optional *split_merge_config* resolves ``1 -> 2+`` splits and ``2+ -> 1`` merges. """ @@ -106,6 +109,16 @@ def build_tracks( # Still alive at end — leave as CONTINUED (not terminated) pass + if gap_closing_config is not None and gap_closing_config.max_gap > 0: + from .gap_closing import resolve_track_gaps + + resolve_track_gaps( + G, + n_scans=n_scans, + cost_fn=active_cost, + config=gap_closing_config, + ) + if split_merge_config is not None: from .events import resolve_splits_and_merges diff --git a/braggtrack/tracking/metrics.py b/braggtrack/tracking/metrics.py index 6901b51..3b6ae49 100644 --- a/braggtrack/tracking/metrics.py +++ b/braggtrack/tracking/metrics.py @@ -53,7 +53,17 @@ def compute_tracking_metrics( terminated_count += 1 total_tracks = len(tracks) - full_length_tracks = sum(1 for obs in tracks.values() if len(obs) >= n_scans) + full_length_tracks = sum( + 1 + for obs in tracks.values() + if len(obs) >= n_scans + or ( + n_scans > 0 + and bool(G.graph.get("gap_closures")) + and min(int(r["scan_idx"]) for r in obs) == 0 + and max(int(r["scan_idx"]) for r in obs) >= n_scans - 1 + ) + ) fragmentation_ratio = 1.0 - full_length_tracks / total_tracks if total_tracks > 0 else 0.0 # ID-switch rate (requires ground truth). @@ -89,6 +99,7 @@ def compute_tracking_metrics( lineage_events = G.graph.get("lineage_events", []) split_count = sum(1 for ev in lineage_events if getattr(ev, "event_type", None) == "split") merge_count = sum(1 for ev in lineage_events if getattr(ev, "event_type", None) == "merge") + gap_closed_count = len(G.graph.get("gap_closures", [])) return { "total_tracks": total_tracks, @@ -97,6 +108,7 @@ def compute_tracking_metrics( "born_count": born_count, "continued_count": continued_count, "terminated_count": terminated_count, + "gap_closed_count": gap_closed_count, "split_count": split_count, "merge_count": merge_count, "id_switch_count": id_switch_count, diff --git a/braggtrack/viz/__init__.py b/braggtrack/viz/__init__.py new file mode 100644 index 0000000..52705e6 --- /dev/null +++ b/braggtrack/viz/__init__.py @@ -0,0 +1,17 @@ +"""Publication plotting and interactive HTML 4D beamtime explorer for BraggTrack.""" + +from .html_report import build_explorer_payload, generate_html_report +from .kinematics import plot_kinematics_dashboard +from .lineage import plot_lineage_dag +from .mips import plot_scan_projection_overlay, plot_spot_mip_card +from .precursors import plot_precursor_timeline + +__all__ = [ + "build_explorer_payload", + "generate_html_report", + "plot_kinematics_dashboard", + "plot_lineage_dag", + "plot_precursor_timeline", + "plot_scan_projection_overlay", + "plot_spot_mip_card", +] diff --git a/braggtrack/viz/_style.py b/braggtrack/viz/_style.py new file mode 100644 index 0000000..7306263 --- /dev/null +++ b/braggtrack/viz/_style.py @@ -0,0 +1,45 @@ +"""Shared styling and optional-dependency guards for braggtrack.viz.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +# Colorblind-safe Okabe-Ito inspired scientific palette +OKABE_ITO = ( + "#0072B2", # blue + "#D55E00", # vermilion / split highlight + "#009E73", # bluish green / merge highlight + "#CC79A7", # reddish purple + "#E69F00", # amber / gap-close highlight + "#56B4E9", # sky blue + "#F0E442", # yellow + "#333333", # charcoal +) + + +def _require_matplotlib() -> tuple[Any, Any]: + try: + import matplotlib + import matplotlib.pyplot as plt + except ImportError as exc: + raise ImportError( + "braggtrack.viz requires matplotlib. Install with `pip install braggtrack[notebook]`." + ) from exc + return matplotlib, plt + + +def apply_axis_style(ax: Any) -> None: + """Apply crisp publication-ready spine and grid styling to a Matplotlib Axes.""" + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + ax.grid(True, linestyle="--", linewidth=0.5, alpha=0.35) + + +def maybe_save(fig: Any, save_path: str | Path | None, *, dpi: int = 200) -> Path | None: + if save_path is None: + return None + out = Path(save_path) + out.parent.mkdir(parents=True, exist_ok=True) + fig.savefig(out, dpi=dpi, bbox_inches="tight") + return out diff --git a/braggtrack/viz/html_report.py b/braggtrack/viz/html_report.py new file mode 100644 index 0000000..49518ef --- /dev/null +++ b/braggtrack/viz/html_report.py @@ -0,0 +1,696 @@ +"""Self-contained offline interactive HTML 4D Lineage, Kinematics & Fracture Explorer.""" + +from __future__ import annotations + +import base64 +import csv +import html +import json +import struct +import zlib +from contextlib import ExitStack +from pathlib import Path +from typing import Any + +import numpy as np + +from braggtrack.io import ( + LazyVolume, + MissingH5DependencyError, + discover_operando_scans, + open_lazy_volume, + resolve_dataset_root, +) +from braggtrack.semantic.mips import crop_spot_cube, orthogonal_mips +from braggtrack.tracking.kinematics import compute_grain_kinematics + + +def _encode_rgb_png_base64(rgb: np.ndarray) -> str: + """Encode a ``(H, W, 3)`` ``uint8`` RGB array to a base64 PNG data URI using stdlib ``zlib``.""" + h, w, _ = rgb.shape + raw_rows = b"".join(b"\x00" + rgb[y].tobytes() for y in range(h)) + + def _chunk(tag: bytes, payload: bytes) -> bytes: + crc = zlib.crc32(tag + payload) & 0xFFFFFFFF + return struct.pack(">I", len(payload)) + tag + payload + struct.pack(">I", crc) + + ihdr = struct.pack(">IIBBBBB", w, h, 8, 2, 0, 0, 0) + png = ( + b"\x89PNG\r\n\x1a\n" + + _chunk(b"IHDR", ihdr) + + _chunk(b"IDAT", zlib.compress(raw_rows, 6)) + + _chunk(b"IEND", b"") + ) + return "data:image/png;base64," + base64.b64encode(png).decode("ascii") + + +def _mip_to_magma_like_rgb(mip: np.ndarray, size: int = 44) -> np.ndarray: + """Nearest-neighbor resize a 2D MIP to ``(size, size)`` and apply a high-contrast magma-like LUT.""" + arr = np.asarray(mip, dtype=np.float64) + if arr.size == 0: + return np.zeros((size, size, 3), dtype=np.uint8) + yi = np.linspace(0, arr.shape[0] - 1, size).astype(np.intp) + xi = np.linspace(0, arr.shape[1] - 1, size).astype(np.intp) + resized = arr[np.ix_(yi, xi)] + lo = float(np.min(resized)) + hi = float(np.percentile(resized, 99.5)) if resized.size > 1 else float(np.max(resized)) + if hi <= lo: + hi = lo + 1.0 + t = np.clip((resized - lo) / (hi - lo), 0.0, 1.0) + # Smooth 4-stop magma-like ramp: #0b0924 -> #6b1d5c -> #dc493a -> #f9e784 + r = np.clip(11.0 + 235.0 * (t**0.75), 0.0, 255.0).astype(np.uint8) + g = np.clip(9.0 + 222.0 * (t**1.65), 0.0, 255.0).astype(np.uint8) + b = np.clip(36.0 + 140.0 * np.sin(np.pi * np.clip(t * 0.85, 0.0, 1.0)) + 80.0 * (t**3), 0.0, 255.0).astype(np.uint8) + return np.stack([r, g, b], axis=-1) + + +def _stitch_three_mips_b64(mip_mu: np.ndarray, mip_chi: np.ndarray, mip_d: np.ndarray, tile: int = 40) -> str: + """Stitch ``(d, chi) | (mu, d) | (mu, chi)`` MIPs horizontally with 2-px dividers into one base64 PNG.""" + t1 = _mip_to_magma_like_rgb(mip_mu, size=tile) + t2 = _mip_to_magma_like_rgb(mip_chi, size=tile) + t3 = _mip_to_magma_like_rgb(mip_d, size=tile) + sep = np.full((tile, 2, 3), 30, dtype=np.uint8) + strip = np.concatenate([t1, sep, t2, sep, t3], axis=1) + return _encode_rgb_png_base64(strip) + + +def _read_csv(path: Path) -> list[dict[str, str]]: + if not path.exists() or path.stat().st_size == 0: + return [] + with path.open(newline="") as f: + return list(csv.DictReader(f)) + + +def _read_json(path: Path) -> Any: + if not path.exists(): + return None + try: + return json.loads(path.read_text()) + except (OSError, json.JSONDecodeError): + return None + + +def _collect_mip_thumbnails( + seg_dir: Path, + dataset_root: Path | None, + track_rows: list[dict[str, Any]], + priority_tids: list[int], + *, + max_tracks: int, +) -> dict[str, str]: + """Extract compact 3-view MIP strips keyed by ``'{track_id}:{scan_idx}'`` via lazy HDF5 ROI reads.""" + if not seg_dir.is_dir() or dataset_root is None or not dataset_root.is_dir(): + return {} + try: + scans_fs = discover_operando_scans(dataset_root) + except Exception: + return {} + if not scans_fs: + return {} + + scan_dirs = sorted(d for d in seg_dir.iterdir() if d.is_dir() and d.name.startswith("scan")) + scan_by_name = {s.scan_name: s for s in scans_fs} + selected = set(priority_tids[:max_tracks]) + wanted_by_scan: dict[int, list[dict[str, Any]]] = {} + for r in track_rows: + tid = int(float(r["track_id"])) + if tid in selected and "bbox_min_z" in r and "label" in r: + s_idx = int(float(r["scan_idx"])) + wanted_by_scan.setdefault(s_idx, []).append(r) + + thumbs: dict[str, str] = {} + with ExitStack() as stack: + for s_idx, obs_list in wanted_by_scan.items(): + if s_idx >= len(scan_dirs): + continue + sd = scan_dirs[s_idx] + lab_path = sd / "labels.npz" + sf = scan_by_name.get(sd.name) + if not lab_path.exists() or sf is None: + continue + labels = np.load(lab_path)["labels"] + try: + lazy_vol: LazyVolume = stack.enter_context(open_lazy_volume(sf.path)) + except (MissingH5DependencyError, KeyError, ValueError, OSError): + continue + if lazy_vol.shape != labels.shape: + continue + for obs in obs_list: + lid = int(float(obs["label"])) + tid = int(float(obs["track_id"])) + masked_cube, _ = crop_spot_cube(lazy_vol, labels, lid, obs, margin=2) + m_mu, m_chi, m_d = orthogonal_mips(masked_cube) + thumbs[f"{tid}:{s_idx}"] = _stitch_three_mips_b64(m_mu, m_chi, m_d, tile=38) + return thumbs + + +def build_explorer_payload( + artifact_dir: str | Path, + *, + dataset_root: str | Path | None = None, + max_mip_tracks: int = 16, +) -> dict[str, Any]: + """Assemble structured JSON payload for the interactive 4D explorer from pipeline/tracking outputs.""" + root = Path(artifact_dir) + trk_dir = root / "tracking" if (root / "tracking").is_dir() else root + evt_dir = root / "events" if (root / "events").is_dir() else trk_dir + seg_dir = root / "segmentation" if (root / "segmentation").is_dir() else root.parent / "segmentation" + + manifest = _read_json(root / "run_manifest.json") or {} + trk_summary = _read_json(trk_dir / "tracking_summary.json") or {} + evt_summary = _read_json(evt_dir / "events_summary.json") or {} + + ds_root: Path | None = None + if dataset_root is not None: + ds_root = resolve_dataset_root(str(dataset_root)) + elif manifest.get("dataset_root"): + cand = Path(str(manifest["dataset_root"])) + if cand.is_dir(): + ds_root = cand + + raw_tracks = _read_csv(evt_dir / "tracks.csv") or _read_csv(trk_dir / "tracks.csv") + raw_events = _read_csv(evt_dir / "events.csv") or _read_csv(trk_dir / "events.csv") + raw_precursors = _read_csv(evt_dir / "precursors.csv") or _read_csv(trk_dir / "precursors.csv") + raw_prec_obs = _read_csv(evt_dir / "precursor_observations.csv") + + track_rows: list[dict[str, Any]] = [] + for r in raw_tracks: + parsed: dict[str, Any] = {} + for k, v in r.items(): + if k in ("event", "lineage_role", "parent_track_ids"): + parsed[k] = v + elif k in ("track_id", "scan_idx", "spot_idx", "label", "voxel_count"): + parsed[k] = int(float(v)) if v != "" else 0 + else: + try: + parsed[k] = float(v) + except (TypeError, ValueError): + parsed[k] = v + track_rows.append(parsed) + + gks = compute_grain_kinematics(track_rows) if track_rows else [] + gk_by_tid = {g.track_id: g for g in gks} + + prec_obs_by_key: dict[tuple[int, int], dict[str, float]] = {} + for r in raw_prec_obs: + key = (int(float(r["track_id"])), int(float(r["scan_idx"]))) + prec_obs_by_key[key] = { + "score": float(r.get("precursor_score", 0.0)), + "anisotropy_term": float(r.get("anisotropy_term", 0.0)), + "spread_term": float(r.get("spread_term", 0.0)), + "roi_dispersion_term": float(r.get("roi_dispersion_term", 0.0)), + "subpeaks": int(float(r.get("roi_subpeak_count", 1))), + } + + events_list: list[dict[str, Any]] = [] + split_tids: set[int] = set() + merge_tids: set[int] = set() + for r in raw_events: + ptids = [int(x) for x in str(r.get("parent_track_ids", "")).split(";") if x.strip()] + ctids = [int(x) for x in str(r.get("child_track_ids", "")).split(";") if x.strip()] + etype = str(r.get("event_type", "")) + if etype == "split": + split_tids.update(ptids) + split_tids.update(ctids) + elif etype == "merge": + merge_tids.update(ptids) + merge_tids.update(ctids) + events_list.append( + { + "event_type": etype, + "parent_scan": int(float(r.get("scan_idx_from", r.get("parent_scan", 0)))), + "child_scan": int(float(r.get("scan_idx_to", r.get("child_scan", 1)))), + "parent_track_ids": ptids, + "child_track_ids": ctids, + "intensity_ratio": round(float(r.get("intensity_ratio", 1.0)), 3), + "centroid_distance": round(float(r.get("mean_distance", r.get("centroid_distance", 0.0))), 3), + "confidence": round(float(r.get("confidence", 0.0)), 3), + } + ) + + precursors_list: list[dict[str, Any]] = [] + prec_tids: set[int] = set() + for r in raw_precursors: + tid = int(float(r["track_id"])) + prec_tids.add(tid) + precursors_list.append( + { + "rank": int(float(r.get("rank", 0))), + "track_id": tid, + "onset_scan": int(float(r.get("onset_scan", 0))), + "peak_scan": int(float(r.get("peak_scan", 0))), + "persistence_scans": int(float(r.get("persistence_scans", 0))), + "peak_score": round(float(r.get("peak_score", 0.0)), 4), + "max_anisotropy": round(float(r.get("max_anisotropy", 1.0)), 3), + "max_subpeak_count": int(float(r.get("max_subpeak_count", 1))), + "confidence": round(float(r.get("confidence", 0.0)), 4), + "subsequent_split": str(r.get("subsequent_split", "")).lower() == "true", + } + ) + + by_tid: dict[int, list[dict[str, Any]]] = {} + for r in track_rows: + by_tid.setdefault(int(r["track_id"]), []).append(r) + + n_scans = int(trk_summary.get("n_scans") or evt_summary.get("n_scans") or 0) + if n_scans == 0 and track_rows: + n_scans = max(int(r["scan_idx"]) for r in track_rows) + 1 + + priority_tids = sorted( + by_tid.keys(), + key=lambda tid: ( + 0 if (tid in split_tids or tid in merge_tids or tid in prec_tids) else 1, + -len(by_tid[tid]), + -max(float(x.get("integrated_intensity", 0.0)) for x in by_tid[tid]), + tid, + ), + ) + thumbs = _collect_mip_thumbnails(seg_dir, ds_root, track_rows, priority_tids, max_tracks=max_mip_tracks) + + tracks_payload: list[dict[str, Any]] = [] + for tid in sorted(by_tid.keys(), key=lambda t: (float(by_tid[t][0]["centroid_d"]), t)): + obs_sorted = sorted(by_tid[tid], key=lambda x: int(x["scan_idx"])) + gk = gk_by_tid.get(tid) + scans = [int(x["scan_idx"]) for x in obs_sorted] + has_gap = any(scans[i + 1] - scans[i] > 1 for i in range(len(scans) - 1)) + is_full = n_scans > 0 and min(scans) == 0 and max(scans) >= n_scans - 1 + + obs_items: list[dict[str, Any]] = [] + for idx_o, o in enumerate(obs_sorted): + s_i = int(o["scan_idx"]) + strain_pct = float(gk.strain[idx_o] * 100.0) if gk is not None and idx_o < len(gk.strain) else 0.0 + miso = ( + float(gk.misorientation_total[idx_o]) + if gk is not None and idx_o < len(gk.misorientation_total) + else 0.0 + ) + aniso = float(gk.anisotropy[idx_o]) if gk is not None and idx_o < len(gk.anisotropy) else 1.0 + po = prec_obs_by_key.get((tid, s_i), {}) + obs_items.append( + { + "scan_idx": s_i, + "label": int(o.get("label", 0)), + "mu": round(float(o["centroid_mu"]), 4), + "chi": round(float(o["centroid_chi"]), 4), + "d": round(float(o["centroid_d"]), 4), + "intensity": round(float(o.get("integrated_intensity", 0.0)), 2), + "voxels": int(o.get("voxel_count", 0)), + "strain_pct": round(strain_pct, 4), + "misorientation": round(miso, 4), + "anisotropy": round(aniso, 3), + "precursor_score": round(float(po.get("score", 0.0)), 4), + "roi_dispersion_term": round(float(po.get("roi_dispersion_term", 0.0)), 4), + "subpeaks": int(po.get("subpeaks", 1)), + "mip_b64": thumbs.get(f"{tid}:{s_i}"), + } + ) + + tracks_payload.append( + { + "track_id": tid, + "is_full": is_full, + "has_gap": has_gap, + "is_split": tid in split_tids, + "is_merge": tid in merge_tids, + "is_precursor": tid in prec_tids, + "max_abs_strain_pct": round(max((abs(x["strain_pct"]) for x in obs_items), default=0.0), 4), + "max_precursor": round(max((x["precursor_score"] for x in obs_items), default=0.0), 4), + "observations": obs_items, + } + ) + + scan_names = ( + trk_summary.get("scan_names") or evt_summary.get("scan_names") or [f"scan{i + 1:04d}" for i in range(n_scans)] + ) + return { + "title": f"BraggTrack 4D Explorer — {Path(manifest.get('dataset_root') or root).name}", + "schema_version": "report.v1", + "n_scans": n_scans, + "scan_names": scan_names, + "calibrated_axes": bool(trk_summary.get("calibrated_axes", False)), + "backend": evt_summary.get("backend") or manifest.get("config", {}).get("backend") or "n/a", + "model": evt_summary.get("model") or manifest.get("config", {}).get("model") or "n/a", + "braggtrack_version": manifest.get("braggtrack_version", "0.3.0"), + "total_duration_sec": manifest.get("total_duration_sec"), + "kpis": { + "total_tracks": len(tracks_payload), + "full_length_tracks": sum(1 for t in tracks_payload if t["is_full"]), + "gap_closed_count": int(trk_summary.get("gap_closed_count", evt_summary.get("gap_closed_count", 0))), + "split_count": sum(1 for e in events_list if e["event_type"] == "split"), + "merge_count": sum(1 for e in events_list if e["event_type"] == "merge"), + "precursor_count": len(precursors_list), + }, + "tracks": tracks_payload, + "events": events_list, + "precursors": precursors_list, + } + + +_HTML_TEMPLATE = """ + + + + +__TITLE__ + + + +
+
+

BraggTrack 4D Explorer

+
+
+ +
+
+
+
+

+ 4D Trajectory & Lineage DAG + Click any track node to inspect +

+
+
+
+
+

+ Track Inspector + +

+
+
+
+
+
+
+

Split & Merge Lineage Events

+
+
+
+

Persistent Fracture Precursor Candidates

+
+
+
+ + + + +""" + + +def generate_html_report( + artifact_dir: str | Path, + out_html: str | Path | None = None, + *, + dataset_root: str | Path | None = None, + max_mip_tracks: int = 16, +) -> Path: + """Render a self-contained interactive HTML 4D explorer from a BraggTrack output directory.""" + root = Path(artifact_dir) + dest = Path(out_html) if out_html is not None else (root / "report.html") + dest.parent.mkdir(parents=True, exist_ok=True) + + payload = build_explorer_payload(root, dataset_root=dataset_root, max_mip_tracks=max_mip_tracks) + safe_json = json.dumps(payload).replace(" tuple[Any, Any]: + """Plot 3-panel kinematic evolution: lattice strain, angular misorientation, and intensity/anisotropy.""" + _, plt = _require_matplotlib() + + if kinematics_or_tracks and isinstance(kinematics_or_tracks[0], GrainKinematics): + gks: list[GrainKinematics] = list(kinematics_or_tracks) # type: ignore[arg-type] + else: + rows = [dict(r) for r in kinematics_or_tracks] # type: ignore[arg-type] + if rows and "strain" in rows[0] and "misorientation_total" in rows[0] and "relative_intensity" in rows[0]: + # Reconstruct GrainKinematics from kinematics.csv rows or compute from tracks.csv rows + gks = compute_grain_kinematics(rows) + else: + gks = compute_grain_kinematics(rows) + + fig, axes = plt.subplots(1, 3, figsize=(13.5, 4.2)) + if not gks: + for ax in axes: + apply_axis_style(ax) + fig.suptitle(title or "Per-Grain Kinematics Dashboard (empty)") + maybe_save(fig, save_path) + return fig, axes + + ranked = sorted(gks, key=lambda g: (-len(g.scan_indices), -float(g.integrated_intensity[0]), g.track_id))[ + :max_tracks + ] + + for idx, gk in enumerate(ranked): + color = OKABE_ITO[idx % len(OKABE_ITO)] + lbl = f"T{gk.track_id}" + scans = gk.scan_indices + axes[0].plot(scans, 100.0 * gk.strain, "o-", color=color, linewidth=1.7, markersize=4.5, label=lbl) + axes[1].plot(scans, gk.misorientation_total, "o-", color=color, linewidth=1.7, markersize=4.5, label=lbl) + axes[2].plot(scans, gk.anisotropy, "s-", color=color, linewidth=1.6, markersize=4.0, label=lbl) + + for ev in events or []: + etype = ev.get("event_type") if isinstance(ev, dict) else getattr(ev, "event_type", "") + raw_scan = ( + ev.get("scan_idx_to", ev.get("child_scan", 0)) + if isinstance(ev, dict) + else getattr(ev, "scan_idx_to", getattr(ev, "child_scan", 0)) + ) + cscan = int(float(raw_scan)) + ev_col = OKABE_ITO[1] if etype == "split" else OKABE_ITO[2] + for ax in axes: + ax.axvline(cscan - 0.5, linestyle=":", linewidth=1.2, color=ev_col, alpha=0.8) + + strain_label = ( + r"Lattice strain $\varepsilon = \Delta d / d_0$ (%)" + if calibrated + else r"Relative $d$-shift $\Delta d / d_0$ (%)" + ) + miso_label = ( + r"Misorientation $\sqrt{\Delta\mu^2 + \Delta\chi^2}$ (deg)" + if calibrated + else r"Angular shift $\sqrt{\Delta\mu^2 + \Delta\chi^2}$ (px)" + ) + + axes[0].axhline(0.0, color="#94A3B8", linewidth=0.8) + axes[0].set_title("Strain / d-Spacing Evolution", fontsize=10, fontweight="bold") + axes[0].set_ylabel(strain_label, fontsize=8.8) + + axes[1].set_title("Lattice Rotation / Misorientation", fontsize=10, fontweight="bold") + axes[1].set_ylabel(miso_label, fontsize=8.8) + + axes[2].set_title(r"3D Shape Anisotropy ($\lambda_1 / \lambda_3$)", fontsize=10, fontweight="bold") + axes[2].set_ylabel(r"Eigenvalue ratio $\lambda_1 / \lambda_3$", fontsize=8.8) + + for ax in axes: + ax.set_xlabel("Scan index", fontsize=9) + apply_axis_style(ax) + + if len(ranked) <= 10: + axes[0].legend(fontsize=7.5, ncol=2, frameon=True) + + fig.suptitle( + title or f"Operando Grain Kinematics ({'Calibrated Physical Units' if calibrated else 'Detector Units'})", + fontsize=11, + fontweight="bold", + y=1.02, + ) + fig.tight_layout() + maybe_save(fig, save_path) + return fig, axes diff --git a/braggtrack/viz/lineage.py b/braggtrack/viz/lineage.py new file mode 100644 index 0000000..4dff72a --- /dev/null +++ b/braggtrack/viz/lineage.py @@ -0,0 +1,216 @@ +"""Publication-grade 4D trajectory and split/merge lineage DAG visualization.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +import networkx as nx +import numpy as np + +from braggtrack.tracking.lifecycle import tracks_to_table + +from ._style import OKABE_ITO, _require_matplotlib, apply_axis_style, maybe_save + + +def _parse_int_list(val: Any) -> list[int]: + if val is None or val == "": + return [] + if isinstance(val, (list, tuple)): + return [int(x) for x in val] + return [int(tok) for tok in str(val).split(";") if tok.strip()] + + +def plot_lineage_dag( + tracks_or_graph: nx.DiGraph | list[dict[str, Any]], + *, + events: list[Any] | None = None, + max_tracks: int = 40, + title: str | None = None, + save_path: str | Path | None = None, +) -> tuple[Any, Any]: + """Plot a scan-layered 4D trajectory & lineage DAG highlighting splits, merges, and gap closures.""" + _, plt = _require_matplotlib() + + if isinstance(tracks_or_graph, nx.DiGraph): + rows = tracks_to_table(tracks_or_graph) + if events is None: + events = list(tracks_or_graph.graph.get("lineage_events", [])) + else: + rows = [dict(r) for r in tracks_or_graph] + + fig, ax = plt.subplots(figsize=(9.5, 5.2)) + if not rows: + ax.set_title(title or "4D Trajectory Lineage DAG (empty)") + apply_axis_style(ax) + maybe_save(fig, save_path) + return fig, ax + + by_track: dict[int, list[dict[str, Any]]] = {} + for r in rows: + by_track.setdefault(int(float(r["track_id"])), []).append(r) + for tid in by_track: + by_track[tid].sort(key=lambda r: int(float(r["scan_idx"]))) + + # Prioritize tracks involved in split/merge events, then longest & brightest tracks. + event_records: list[dict[str, Any]] = [] + involved_tids: set[int] = set() + for ev in events or []: + if isinstance(ev, dict): + etype = str(ev.get("event_type", "")) + pscan = int(float(ev.get("scan_idx_from", ev.get("parent_scan", 0)))) + cscan = int(float(ev.get("scan_idx_to", ev.get("child_scan", pscan + 1)))) + ptids = _parse_int_list(ev.get("parent_track_ids")) + ctids = _parse_int_list(ev.get("child_track_ids")) + else: + etype = str(getattr(ev, "event_type", "")) + pscan = int(getattr(ev, "scan_idx_from", getattr(ev, "parent_scan", 0))) + cscan = int(getattr(ev, "scan_idx_to", getattr(ev, "child_scan", pscan + 1))) + ptids = [int(x) for x in getattr(ev, "parent_track_ids", ())] + ctids = [int(x) for x in getattr(ev, "child_track_ids", ())] + event_records.append( + { + "event_type": etype, + "parent_scan": pscan, + "child_scan": cscan, + "parent_track_ids": ptids, + "child_track_ids": ctids, + } + ) + involved_tids.update(ptids) + involved_tids.update(ctids) + + ranked_tids = sorted( + by_track.keys(), + key=lambda tid: ( + 0 if tid in involved_tids else 1, + -len(by_track[tid]), + -max(float(r.get("integrated_intensity", 0.0)) for r in by_track[tid]), + tid, + ), + )[:max_tracks] + selected_set = set(ranked_tids) + + # Order vertical lanes by initial centroid_d so spatially nearby fragments sit adjacent. + ordered_tids = sorted(ranked_tids, key=lambda tid: (float(by_track[tid][0]["centroid_d"]), tid)) + lane_y = {tid: float(idx) for idx, tid in enumerate(ordered_tids)} + + node_xy: dict[tuple[int, int], tuple[float, float]] = {} + all_x: list[float] = [] + all_y: list[float] = [] + all_strain: list[float] = [] + + gap_labeled = False + cont_labeled = False + for tid in ordered_tids: + obs = by_track[tid] + y_val = lane_y[tid] + d0 = float(obs[0]["centroid_d"]) + scans = [int(float(r["scan_idx"])) for r in obs] + for r in obs: + s_idx = int(float(r["scan_idx"])) + d_cur = float(r["centroid_d"]) + strain_pct = 100.0 * (d_cur - d0) / d0 if abs(d0) > 1e-9 else 0.0 + node_xy[(tid, s_idx)] = (float(s_idx), y_val) + all_x.append(float(s_idx)) + all_y.append(y_val) + all_strain.append(strain_pct) + + for i in range(len(scans) - 1): + s0, s1 = scans[i], scans[i + 1] + if s1 - s0 > 1: + ax.plot( + [s0, s1], + [y_val, y_val], + linestyle="--", + linewidth=1.8, + color=OKABE_ITO[4], + label="Gap-closed bridge" if not gap_labeled else None, + zorder=2, + ) + gap_labeled = True + else: + ax.plot( + [s0, s1], + [y_val, y_val], + linestyle="-", + linewidth=1.8, + color="#64748B", + alpha=0.75, + label="Continuation" if not cont_labeled else None, + zorder=2, + ) + cont_labeled = True + + split_labeled = False + merge_labeled = False + for ev in event_records: + etype = ev["event_type"] + pscan = ev["parent_scan"] + cscan = ev["child_scan"] + for ptid in ev["parent_track_ids"]: + for ctid in ev["child_track_ids"]: + if ptid not in selected_set or ctid not in selected_set: + continue + p_xy = node_xy.get((ptid, pscan), (float(pscan), lane_y[ptid])) + c_xy = node_xy.get((ctid, cscan), (float(cscan), lane_y[ctid])) + color = OKABE_ITO[1] if etype == "split" else OKABE_ITO[2] + lbl = None + if etype == "split" and not split_labeled: + lbl = "1 -> 2+ Split" + split_labeled = True + elif etype == "merge" and not merge_labeled: + lbl = "2+ -> 1 Merge" + merge_labeled = True + ax.plot( + [p_xy[0], c_xy[0]], + [p_xy[1], c_xy[1]], + color=color, + linewidth=2.4, + alpha=0.92, + label=lbl, + zorder=3, + ) + ax.scatter( + [c_xy[0] if etype == "split" else p_xy[0]], + [c_xy[1] if etype == "split" else p_xy[1]], + marker="D" if etype == "split" else "s", + s=58, + color=color, + edgecolor="#FFFFFF", + linewidth=0.8, + zorder=5, + ) + + vmax = max(0.05, float(np.max(np.abs(all_strain)))) if all_strain else 0.1 + sc = ax.scatter( + all_x, + all_y, + c=all_strain, + cmap="coolwarm", + vmin=-vmax, + vmax=vmax, + s=42, + edgecolors="#1E293B", + linewidths=0.6, + zorder=4, + ) + cbar = fig.colorbar(sc, ax=ax, pad=0.02) + cbar.set_label(r"Relative $d$-shift $\Delta d / d_0$ (%)", fontsize=9) + + ax.set_yticks([lane_y[tid] for tid in ordered_tids]) + ax.set_yticklabels([f"T{tid}" for tid in ordered_tids], fontsize=8) + max_scan = int(max(all_x)) if all_x else 0 + ax.set_xticks(list(range(max_scan + 1))) + ax.set_xlabel("Scan index", fontsize=9.5) + ax.set_ylabel("Grain trajectory lane", fontsize=9.5) + ax.set_title( + title or f"4D Bragg Reflection Lineage DAG ({len(ordered_tids)} tracks)", fontsize=11, fontweight="bold" + ) + apply_axis_style(ax) + handles, labels_legend = ax.get_legend_handles_labels() + if handles: + ax.legend(loc="upper left", fontsize=8, frameon=True) + fig.tight_layout() + maybe_save(fig, save_path) + return fig, ax diff --git a/braggtrack/viz/mips.py b/braggtrack/viz/mips.py new file mode 100644 index 0000000..8328f37 --- /dev/null +++ b/braggtrack/viz/mips.py @@ -0,0 +1,104 @@ +"""Orthogonal 3-view MIP spot cards and full-scan projection overlays.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +import numpy as np + +from braggtrack.semantic.mips import crop_spot_cube, orthogonal_mips + +from ._style import _require_matplotlib, apply_axis_style, maybe_save + + +def plot_spot_mip_card( + volume: np.ndarray | Any, + labels: np.ndarray, + label_id: int, + bbox: dict[str, Any], + *, + margin: int = 3, + title: str | None = None, + save_path: str | Path | None = None, +) -> tuple[Any, Any]: + """Plot a 3-panel orthogonal MIP card ``(d, chi)``, ``(mu, d)``, ``(mu, chi)`` for one 3D reflection.""" + _, plt = _require_matplotlib() + masked_cube, mask = crop_spot_cube(volume, labels, int(label_id), bbox, margin=margin) + mip_mu, mip_chi, mip_d = orthogonal_mips(masked_cube) + mask_mu, mask_chi, mask_d = orthogonal_mips(mask) + + fig, axes = plt.subplots(1, 3, figsize=(10.5, 3.4)) + panels = [ + (mip_mu, mask_mu, r"$\mu$-collapsed $(d, \chi)$", r"$\chi$ (px)", r"$d$ (px)"), + (mip_chi, mask_chi, r"$\chi$-collapsed $(\mu, d)$", r"$d$ (px)", r"$\mu$ (frame)"), + (mip_d, mask_d, r"$d$-collapsed $(\mu, \chi)$", r"$\chi$ (px)", r"$\mu$ (frame)"), + ] + + for ax, (mip, msk, subtitle, xlabel, ylabel) in zip(axes, panels): + im = ax.imshow(mip, cmap="magma", origin="lower", aspect="auto") + if msk.shape[0] >= 2 and msk.shape[1] >= 2 and np.any(msk > 0) and np.any(msk == 0): + ax.contour(msk, levels=[0.5], colors=["#56B4E9"], linewidths=1.1) + ax.set_title(subtitle, fontsize=9.5, fontweight="bold") + ax.set_xlabel(xlabel, fontsize=8.5) + ax.set_ylabel(ylabel, fontsize=8.5) + fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04) + + vox = int(np.sum(mask > 0)) + tot_int = float(np.sum(masked_cube)) + header = title or f"Spot #{label_id} | {vox} voxels | I = {tot_int:.1f}" + fig.suptitle(header, fontsize=10.5, fontweight="bold", y=1.02) + fig.tight_layout() + maybe_save(fig, save_path) + return fig, axes + + +def plot_scan_projection_overlay( + volume: np.ndarray | Any, + labels: np.ndarray, + feature_rows: list[dict[str, Any]], + *, + max_labels: int = 25, + title: str | None = None, + save_path: str | Path | None = None, +) -> tuple[Any, Any]: + """Plot a full-scan ``(d, chi)`` MIP with instance contours and ranked spot IDs.""" + _, plt = _require_matplotlib() + vol_arr = volume[()] if not isinstance(volume, np.ndarray) else volume + mip_dc = np.max(np.asarray(vol_arr, dtype=np.float64), axis=0) + disp = np.log1p(np.maximum(0.0, mip_dc)) + fg_proj = np.max(labels > 0, axis=0).astype(np.float64) + + fig, ax = plt.subplots(figsize=(7.5, 6.0)) + im = ax.imshow(disp, cmap="inferno", origin="lower", aspect="auto") + if fg_proj.shape[0] >= 2 and fg_proj.shape[1] >= 2 and np.any(fg_proj > 0) and np.any(fg_proj == 0): + ax.contour(fg_proj, levels=[0.5], colors=["#56B4E9"], linewidths=0.8, alpha=0.8) + + ranked = sorted(feature_rows, key=lambda r: float(r.get("integrated_intensity", 0.0)), reverse=True)[:max_labels] + for row in ranked: + if "bbox_min_x" in row and "bbox_max_x" in row: + cx = 0.5 * (float(row["bbox_min_x"]) + float(row["bbox_max_x"])) + cy = 0.5 * (float(row["bbox_min_y"]) + float(row["bbox_max_y"])) + else: + cx = float(row["centroid_chi"]) + cy = float(row["centroid_d"]) + lid = int(float(row["label"])) + ax.plot(cx, cy, marker="+", color="#00E5FF", markersize=6, markeredgewidth=1.2) + ax.annotate( + f"#{lid}", + (cx, cy), + xytext=(4, 4), + textcoords="offset points", + fontsize=7.5, + color="#FFFFFF", + bbox={"boxstyle": "round,pad=0.15", "fc": "#111827", "ec": "none", "alpha": 0.65}, + ) + + ax.set_title(title or f"Detector Projection (log1p MIP) — {len(feature_rows)} segmented reflections", fontsize=10.5) + ax.set_xlabel(r"Detector $\chi$ / fast pixel", fontsize=9) + ax.set_ylabel(r"Detector $d$ / slow pixel", fontsize=9) + apply_axis_style(ax) + fig.colorbar(im, ax=ax, label="log(1 + max intensity)") + fig.tight_layout() + maybe_save(fig, save_path) + return fig, ax diff --git a/braggtrack/viz/precursors.py b/braggtrack/viz/precursors.py new file mode 100644 index 0000000..771fcad --- /dev/null +++ b/braggtrack/viz/precursors.py @@ -0,0 +1,149 @@ +"""Persistent 4D fracture precursor heatmap and component decomposition plots.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +import numpy as np + +from braggtrack.tracking.precursors import ObservationPrecursorScore, PrecursorCandidate + +from ._style import OKABE_ITO, _require_matplotlib, apply_axis_style, maybe_save + + +def _obs_to_dict(obs: ObservationPrecursorScore | dict[str, Any]) -> dict[str, Any]: + if isinstance(obs, dict): + return { + "track_id": int(float(obs["track_id"])), + "scan_idx": int(float(obs["scan_idx"])), + "anisotropy_term": float(obs.get("anisotropy_term", 0.0)), + "spread_term": float(obs.get("spread_term", 0.0)), + "roi_dispersion_term": float(obs.get("roi_dispersion_term", 0.0)), + "roi_subpeak_count": int(float(obs.get("roi_subpeak_count", 1))), + "precursor_score": float(obs.get("precursor_score", 0.0)), + } + return { + "track_id": obs.track_id, + "scan_idx": obs.scan_idx, + "anisotropy_term": obs.anisotropy_term, + "spread_term": obs.spread_term, + "roi_dispersion_term": obs.roi_dispersion_term, + "roi_subpeak_count": obs.roi_subpeak_count, + "precursor_score": obs.precursor_score, + } + + +def plot_precursor_timeline( + obs_scores: list[ObservationPrecursorScore] | list[dict[str, Any]], + *, + candidates: list[PrecursorCandidate] | list[dict[str, Any]] | None = None, + max_tracks: int = 15, + score_threshold: float = 0.40, + title: str | None = None, + save_path: str | Path | None = None, +) -> tuple[Any, Any]: + """Plot a track-by-scan fracture precursor heatmap and top-candidate component decomposition.""" + _, plt = _require_matplotlib() + rows = [_obs_to_dict(x) for x in obs_scores] + + fig, axes = plt.subplots(1, 2, figsize=(12.0, 4.4), gridspec_kw={"width_ratios": [1.15, 1.0]}) + if not rows: + for ax in axes: + apply_axis_style(ax) + fig.suptitle(title or "Fracture Precursor Timeline (no observations)") + maybe_save(fig, save_path) + return fig, axes + + by_track: dict[int, list[dict[str, Any]]] = {} + max_scan = 0 + for r in rows: + by_track.setdefault(r["track_id"], []).append(r) + if r["scan_idx"] > max_scan: + max_scan = r["scan_idx"] + + split_tids: set[int] = set() + top_tid: int | None = None + for idx_c, c in enumerate(candidates or []): + tid_c = int(float(c["track_id"])) if isinstance(c, dict) else int(c.track_id) + sub_split = ( + str(c.get("subsequent_split", "")).lower() == "true" if isinstance(c, dict) else bool(c.subsequent_split) + ) + if idx_c == 0: + top_tid = tid_c + if sub_split: + split_tids.add(tid_c) + + ranked_tids = sorted( + by_track.keys(), + key=lambda tid: (-max(x["precursor_score"] for x in by_track[tid]), tid), + )[:max_tracks] + if top_tid is None and ranked_tids: + top_tid = ranked_tids[0] + + mat = np.full((len(ranked_tids), max_scan + 1), np.nan, dtype=np.float64) + for r_i, tid in enumerate(ranked_tids): + for r in by_track[tid]: + mat[r_i, r["scan_idx"]] = r["precursor_score"] + + im = axes[0].imshow(mat, aspect="auto", cmap="YlOrRd", vmin=0.0, vmax=1.0, interpolation="nearest") + axes[0].set_yticks(list(range(len(ranked_tids)))) + axes[0].set_yticklabels( + [f"T{tid} *" if tid in split_tids else f"T{tid}" for tid in ranked_tids], + fontsize=8.5, + ) + axes[0].set_xticks(list(range(max_scan + 1))) + axes[0].set_xlabel("Scan index", fontsize=9) + axes[0].set_ylabel("Track ID (* = subsequent split)", fontsize=9) + axes[0].set_title("Precursor Score Heatmap", fontsize=10, fontweight="bold") + fig.colorbar(im, ax=axes[0], fraction=0.046, pad=0.04, label="Precursor score") + + # Right panel: component breakdown for top candidate + if top_tid is not None and top_tid in by_track: + top_obs = sorted(by_track[top_tid], key=lambda x: x["scan_idx"]) + scans = [x["scan_idx"] for x in top_obs] + axes[1].plot( + scans, + [x["anisotropy_term"] for x in top_obs], + "o--", + color=OKABE_ITO[0], + linewidth=1.4, + label="Shape anisotropy", + ) + axes[1].plot( + scans, + [x["spread_term"] for x in top_obs], + "s--", + color=OKABE_ITO[2], + linewidth=1.4, + label="Covariance broadening", + ) + axes[1].plot( + scans, + [x["roi_dispersion_term"] for x in top_obs], + "^--", + color=OKABE_ITO[3], + linewidth=1.4, + label="3D sub-peaks + DINO dispersion", + ) + axes[1].plot( + scans, + [x["precursor_score"] for x in top_obs], + "o-", + color=OKABE_ITO[1], + linewidth=2.2, + label=f"Composite score (T{top_tid})", + ) + axes[1].axhline(score_threshold, linestyle=":", color="#475569", linewidth=1.2, label="Threshold") + axes[1].set_ylim(-0.04, 1.06) + axes[1].set_xticks(list(range(max_scan + 1))) + axes[1].set_xlabel("Scan index", fontsize=9) + axes[1].set_ylabel("Normalized term [0, 1]", fontsize=9) + axes[1].set_title(f"Top Precursor Decomposition — Track T{top_tid}", fontsize=10, fontweight="bold") + axes[1].legend(fontsize=7.8, loc="best", frameon=True) + apply_axis_style(axes[1]) + + fig.suptitle(title or "Persistent 4D Fracture Precursor Analysis", fontsize=11, fontweight="bold", y=1.02) + fig.tight_layout() + maybe_save(fig, save_path) + return fig, axes diff --git a/docs/architecture.md b/docs/architecture.md index 7f9e002..c8efe27 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -6,17 +6,18 @@ This document describes how the repository is structured, how data flows through ```text BraggTrack/ -├── braggtrack/ # Installable Python package (v0.2.0) -│ ├── io/ # Discovery, ESRF-ID03 / NeXus HDF5 auto-discovery, AxisCalibration, validation -│ ├── segmentation/ # Classical 3D LoG+watershed, cross-scan threshold smoothing, experimental DINO segmenter, features +├── braggtrack/ # Installable Python package (v0.3.0) +│ ├── io/ # Discovery, LazyVolume streaming, AxisCalibration, DetectorGeometry, ImageD11 & NeXus export +│ ├── segmentation/ # Classical 3D LoG+watershed, chunked Otsu + threshold smoothing, experimental DINO segmenter │ ├── semantic/ # Orthogonal (mu, chi, d) MIPs + frozen ViT / patch encoders (DINOv2 default, DINOv3, mock) -│ ├── tracking/ # Costs, Hungarian assignment, kinematics, split/merge lineage DAG, fracture precursors -│ └── cli/ # Thin argparse entry points + reproducible run_pipeline orchestrator +│ ├── tracking/ # Costs, Hungarian assignment, multi-scan gap closing, kinematics, split/merge DAG, precursors +│ ├── viz/ # Publication plots (MIPs, Lineage DAG, Strain fans, Precursors) + interactive HTML 4D Explorer +│ └── cli/ # Thin argparse entry points (9 CLIs) + reproducible run_pipeline orchestrator ├── data/ │ └── sample_operando/ # Bundled ESRF-ID03 Ni-rich cathode operando scans (scan0001..scan0003) ├── notebooks/ # End-to-end demo and DINO vs. classical segmentation notebooks -├── docs/ # Architecture & coding practices -├── scripts/ # Acceptance gates, semantic ablation with bootstrap CIs, ci_report.py +├── docs/ # Architecture, quantitative benchmarks, figures, and coding practices +├── scripts/ # 9 acceptance gates, 5-scenario benchmark suite, semantic ablation, ci_report.py ├── tests/ # Unit and acceptance test suite └── artifacts/ # Generated outputs (gitignored) ``` @@ -25,11 +26,12 @@ BraggTrack/ | Layer | Responsibility | Key Types / Functions | Depends on | |---|---|---|---| -| **io** | Discover scans, auto-discover 3D HDF5 cubes, extract timestamps & `AxisCalibration`, validate sequences | `ScanVolumeMeta`, `AxisCalibration`, `load_primary_volume`, `BeamlineAdapter` | `numpy`, `h5py` | +| **io** | Discover scans, stream `LazyVolume` HDF5 slices & chunked Otsu histograms, calibrate `(mu, chi, d)` & `(2theta, eta, d, \|Q\|)`, export `ImageD11` `.flt` & NeXus `.nxs` | `LazyVolume`, `otsu_threshold_chunked`, `AxisCalibration`, `DetectorGeometry`, `export_imaged11_flt`, `export_nexus_process` | `numpy`, `h5py` | | **segmentation** | Multi-scan threshold smoothing, 3D LoG + `h`-maxima + watershed (or experimental DINO + HDBSCAN), physical/voxel feature table | `segment_classical`, `smooth_thresholds`, `segment_dino`, `extract_instance_table` | `numpy`, `scipy`, `scikit-image`, `scikit-learn` | -| **semantic** | Cropped spot cubes, orthogonal MIPs, multi-view global embeddings & dense patch-token grids | `crop_spot_cube`, `orthogonal_mips`, `make_multiview_encoder`, `make_patch_encoder` | `numpy`, optional `torch` + `transformers` | -| **tracking** | Vectorised geometry + semantic cost, Hungarian assignment, per-grain kinematics, `1 -> 2+` split & `2+ -> 1` merge lineage resolution, persistent fracture precursors | `PositionShapeCost`, `GeometrySemanticCost`, `build_tracks`, `compute_grain_kinematics`, `resolve_splits_and_merges`, `compute_fracture_precursors` | `numpy`, `scipy`, `networkx` | -| **cli** | Parse args/JSON config, orchestrate stages, write CSV/JSON/NPZ artifacts and SHA-256 `run_manifest.json` | `segment_dataset`, `embed_dataset`, `track_dataset`, `detect_events`, `run_pipeline` | All of the above | +| **semantic** | Lazy ROI spot cropping, orthogonal MIPs, multi-view global embeddings & dense patch-token grids | `crop_spot_cube`, `orthogonal_mips`, `make_multiview_encoder`, `make_patch_encoder` | `numpy`, optional `torch` + `transformers` | +| **tracking** | Vectorised geometry + semantic cost, Hungarian assignment, multi-scan gap closing (`max_gap`), per-grain kinematics, `1 -> 2+` split & `2+ -> 1` merge lineage, fracture precursors | `PositionShapeCost`, `GeometrySemanticCost`, `resolve_track_gaps`, `build_tracks`, `compute_grain_kinematics`, `resolve_splits_and_merges`, `compute_fracture_precursors` | `numpy`, `scipy`, `networkx` | +| **viz** | Publication figures and zero-CDN offline interactive HTML 4D Lineage & Strain Explorer | `plot_lineage_dag`, `plot_kinematics_dashboard`, `plot_precursor_timeline`, `plot_spot_mip_card`, `generate_html_report` | `numpy`, optional `matplotlib` (HTML explorer uses stdlib only) | +| **cli** | Parse args/JSON config, orchestrate stages, write CSV/JSON/NPZ/FLT/NXS/HTML artifacts and SHA-256 `run_manifest.json` | `segment_dataset`, `embed_dataset`, `track_dataset`, `detect_events`, `report_dataset`, `run_pipeline` | All of the above | **Rule of thumb:** keep **numeric kernels** and **typed data contracts** in subpackages; keep **CLI modules** as thin orchestration layers. @@ -38,25 +40,29 @@ BraggTrack/ ```mermaid flowchart LR subgraph inputs["Inputs"] - H5["HDF5 / NeXus 3D scans"] - CAL["AxisCalibration (auto or JSON)"] + H5["HDF5 / NeXus 3D scans (LazyVolume)"] + CAL["AxisCalibration & DetectorGeometry"] end subgraph seg["Segmentation"] - SEG["segment_dataset (smoothed Otsu + 3D watershed)"] + SEG["segment_dataset (chunked Otsu + 3D watershed)"] FEAT["features.csv + labels.npz"] end subgraph sem["Semantic"] - EMB["embed_dataset (MIPs + DINOv2 / mock)"] + EMB["embed_dataset (ROI MIPs + DINOv2 / mock)"] NPZ["embeddings.npz"] end - subgraph trk["Tracking & Kinematics"] - TRK["track_dataset (Hungarian + kinematics)"] - KIN["tracks.csv + kinematics.csv"] + subgraph trk["Tracking, Gap-Closing & Kinematics"] + TRK["track_dataset (Hungarian + max_gap + kinematics)"] + KIN["tracks.csv + kinematics.csv + .flt / .nxs"] end subgraph evt["Lineage & Precursors"] EVT["detect_events (splits, merges, ROI dispersion)"] OUT["events.csv + precursors.csv"] end + subgraph rep["Visualization"] + REP["report_dataset (braggtrack.viz)"] + HTML["report.html + figures/*.png"] + end MAN["run_manifest.json (SHA-256 + timings)"] H5 --> SEG @@ -65,19 +71,23 @@ flowchart LR H5 --> EMB FEAT --> EMB --> NPZ FEAT --> TRK + CAL --> TRK NPZ --> TRK TRK --> KIN H5 --> EVT FEAT --> EVT NPZ --> EVT EVT --> OUT + KIN --> REP + OUT --> REP --> HTML SEG --> MAN TRK --> MAN EVT --> MAN + REP --> MAN ``` - **Dataset root** is a directory containing `scan*` folders (defaults to bundled `data/sample_operando/` when present). -- **Physical coordinates vs. voxel indices:** `extract_instance_table(..., calibration=cal)` converts `centroid_mu`, `centroid_chi`, `centroid_d`, `cov_*`, and `eig_1..3` into physical reciprocal-space units while preserving integer voxel `bbox_*` indices so downstream 3D ROI cropping (`crop_spot_cube`) remains exact. +- **Physical coordinates vs. voxel indices:** `extract_instance_table(..., calibration=cal)` converts `centroid_mu`, `centroid_chi`, `centroid_d`, `cov_*`, and `eig_1..3` into physical reciprocal-space units while preserving integer voxel `bbox_*` indices so downstream 3D ROI cropping (`crop_spot_cube` over `LazyVolume`) remains exact. - **Artifacts** under `artifacts/` are reproducible build outputs and are never committed to Git. ## Extension points @@ -89,12 +99,12 @@ flowchart LR ## Performance notes -- Frame-to-frame Hungarian association builds its `(N, M)` cost matrix via vectorised `scipy.spatial.distance.cdist` and a single dense matrix multiplication (`A @ B.T`) for semantic cosine similarity. -- Cross-scan threshold stabilisation (`smooth_thresholds`) operates in $O(N \cdot W)$ on scalar per-scan Otsu thresholds without holding the entire 4D dataset in memory simultaneously during streaming workflows. +- `LazyVolume` streams `z`-slabs (`otsu_threshold_chunked`) in Pass 1 of `segment_dataset` and reads only tight 3D spot ROIs (`read_roi`) in `embed_dataset` and `detect_events`, avoiding full-volume `float64` allocations on multi-gigabyte detector stacks. +- Frame-to-frame Hungarian association and multi-scan gap closing (`resolve_track_gaps`) build cost matrices via vectorised `scipy.spatial.distance.cdist` and dense matrix multiplication (`A @ B.T`) for semantic cosine similarity. ## Configuration surfaces - **Environment variables:** - `BRAGGTRACK_DATA_ROOT`: Override default dataset root discovery. - `BRAGGTRACK_DINO_BACKEND`: Force `auto`, `mock`, or `torch` backend selection. -- **Pipeline JSON config:** Pass `--config pipeline.json` to `braggtrack-run` to declaratively configure backend, model ID (`DEFAULT_DINO_MODEL = "facebook/dinov2-small"` or DINOv3), calibration file, semantic weights (`cost_alpha`, `cost_beta`), and split/precursor thresholds. +- **Pipeline JSON config:** Pass `--config pipeline.json` to `braggtrack-run` to declaratively configure backend, model ID (`DEFAULT_DINO_MODEL = "facebook/dinov2-small"` or DINOv3), calibration/detector JSON files, `max_gap`, semantic weights (`cost_alpha`, `cost_beta`), split/precursor thresholds, `--report`, and `ImageD11` / NeXus export paths. diff --git a/docs/benchmarks.md b/docs/benchmarks.md new file mode 100644 index 0000000..d0b5d58 --- /dev/null +++ b/docs/benchmarks.md @@ -0,0 +1,115 @@ +# BraggTrack v0.3.0 Benchmarks & ESRF-ID03 Case Study + +This document reports reproducible multi-trial quantitative benchmarks for **BraggTrack v0.3.0**, comparing **Geometry-Only**, **Deterministic Mock-Hash** (`mock`), and **Pretrained Vision Transformer** (`torch` with ungated `facebook/dinov2-small`) tracking, gap-closing, and 4D chemomechanical fracture precursor scoring, followed by an end-to-end case study on bundled operando dark-field X-ray microscopy (DFXM) data from **ESRF ID03**. + +All synthetic benchmarks can be reproduced via: + +```bash +python scripts/benchmark_suite.py \ + --include-torch \ + --model facebook/dinov2-small \ + --trials 5 \ + --bootstrap-samples 500 \ + --output-json artifacts/benchmarks/benchmark_results.json \ + --output-figure docs/figures/benchmark_comparison.png +``` + +![BraggTrack 5-scenario benchmark comparison across Geometry-Only, Mock-Hash, and Pretrained DINOv2](figures/benchmark_comparison.png) + +--- + +## 1. Benchmark Methodology + +To isolate when pretrained multi-view morphological features genuinely outperform classical 3D centroid + covariance tracking—and to verify that gains come from learned visual structure rather than arbitrary feature dimensionality—`scripts/benchmark_suite.py` evaluates three backends under identical segmentation and Hungarian/Jaqaman solver configurations: + +1. **`geo` (Geometry-Only, $\alpha=1.0, \beta=0.0$):** Uses calibrated 3D reciprocal-space centroid displacement and log-eigenvalue shape distance (`Eigen-Shape`), with zero semantic weight. +2. **`mock` (Deterministic Hash Baseline, $\alpha=1.0, \beta=0.6$):** Appends `1152`-d `SHA-256` multi-view MIP vectors (`MockDinoEncoder`). Useful solely for deterministic offline CI plumbing; slight pixel changes completely decorrelate consecutive scan hashes. +3. **`torch` (Pretrained `facebook/dinov2-small`, $\alpha=1.0, \beta=0.6$):** Extracts `1152`-d L2-normalized multi-view orthogonal MIP embeddings (`3` projections $\times$ `384`-d ViT-S/14 features) and `16x16` spatial patch tokens for sub-spot precursor dispersion. + +### Scenarios Evaluated (`N = 5` trials, `500` bootstrap resamples for 95% CIs) + +| Scenario | Physical Beamline Regime | Primary Failure Mode Tested | +| :--- | :--- | :--- | +| **`crossing_morphology`** | Two sub-grains on an antipodal circle ($R = 4.2\text{ px}$) rotating $90.25^\circ$ between scans with orthogonal $+45^\circ$ vs $-45^\circ$ streak tilt (`3D` eigenvalues identical by symmetry) | Equidistant / near-degenerate 3D geometry causing catastrophic Hungarian ID swaps without 2D MIP orientation semantics | +| **`intensity_jitter`** | $\pm 45\%$ incident synchrotron beam-flux spikes + Poisson/Gaussian detector shot noise across 6 scans | Photometric invariance of L2-normalized ViT MIP embeddings vs pixel-hash fragility | +| **`mosaic_broadening`** | Progressive rocking-curve ($\mu$) mosaic broadening ($1.0\times \to 1.9\times$) under electrochemical cycling | Smooth morphological continuity ($\cos > 0.98$) as Bragg reflections broaden | +| **`beam_dropout_no_gap` vs `beam_dropout_gap2`** | Staggered 1-scan rocking-window dropouts across 4 grains over 6 scans (`max_gap=0` vs `max_gap=2`) | Track fragmentation and cross-grain jump hijacking vs Jaqaman diffusive gap-closing recovery | +| **`chemomechanical_fracture`** | 8-scan 4D grain evolution with persistent pre-split broadening + sub-peak bimodality (`scans 1-3`), `1 -> 2` split (`scan 3 -> 4`), `2 -> 1` merge (`scan 5 -> 6`), and isotropic control | Exact split/merge lineage recall and pre-fracture precursor score contrast against stable control grains | + +--- + +## 2. Quantitative Multi-Trial Results (`facebook/dinov2-small`) + +### 2.1 Tracking Identity, Gap-Closing & Embedding Stability + +| Scenario | Backend | Mean ID-Switch Rate (95% CI) | Fragmentation Ratio (95% CI) | Gap Closures | Cosine Stability $\cos(\mathbf{z}_t, \mathbf{z}_{t+1})$ | Elapsed (`5` trials, CPU) | +| :--- | :--- | :---: | :---: | :---: | :---: | :---: | +| **`crossing_morphology`** | `geo` | `0.2500` (`[0.2500, 0.2500]`) | `0.0000` (`[0.0000, 0.0000]`) | `0.0` | — | `0.51 s` | +| **`crossing_morphology`** | `mock` | `0.0000` (`[0.0000, 0.0000]`) | `0.0000` (`[0.0000, 0.0000]`) | `0.0` | `0.0160` | `0.50 s` | +| **`crossing_morphology`** | **`torch` (`dinov2-small`)** | **`0.0000` (`[0.0000, 0.0000]`)** | **`0.0000` (`[0.0000, 0.0000]`)** | `0.0` | **`0.9035`** | `43.80 s` | +| **`intensity_jitter`** | `geo` | `0.0000` (`[0.0000, 0.0000]`) | `0.0000` (`[0.0000, 0.0000]`) | `0.0` | — | `0.04 s` | +| **`intensity_jitter`** | `mock` | `0.0000` (`[0.0000, 0.0000]`) | `0.0000` (`[0.0000, 0.0000]`) | `0.0` | `0.0089` | `0.05 s` | +| **`intensity_jitter`** | **`torch` (`dinov2-small`)** | **`0.0000` (`[0.0000, 0.0000]`)** | **`0.0000` (`[0.0000, 0.0000]`)** | `0.0` | **`0.9908`** | `10.66 s` | +| **`mosaic_broadening`** | `geo` | `0.0000` (`[0.0000, 0.0000]`) | `0.0000` (`[0.0000, 0.0000]`) | `0.0` | — | `0.05 s` | +| **`mosaic_broadening`** | `mock` | `0.0000` (`[0.0000, 0.0000]`) | `0.0000` (`[0.0000, 0.0000]`) | `0.0` | `-0.0031` | `0.05 s` | +| **`mosaic_broadening`** | **`torch` (`dinov2-small`)** | **`0.0000` (`[0.0000, 0.0000]`)** | **`0.0000` (`[0.0000, 0.0000]`)** | `0.0` | **`0.9899`** | `10.85 s` | +| **`beam_dropout_no_gap` (`max_gap=0`)** | `geo` / `mock` / `torch` | `0.0833` (`[0.0833, 0.0833]`) | `0.5000` (`[0.5000, 0.5000]`) | `0.0` | `— / 0.0048 / 0.9879` | `0.07–17.83 s` | +| **`beam_dropout_gap2` (`max_gap=2`)** | `geo` | `0.0000` (`[0.0000, 0.0000]`) | `0.0000` (`[0.0000, 0.0000]`) | **`2.0`** | — | `0.07 s` | +| **`beam_dropout_gap2` (`max_gap=2`)** | `mock` | `0.0833` (`[0.0833, 0.0833]`) | `0.5000` (`[0.5000, 0.5000]`) | `0.0` | `0.0048` | `0.08 s` | +| **`beam_dropout_gap2` (`max_gap=2`)** | **`torch` (`dinov2-small`)** | **`0.0000` (`[0.0000, 0.0000]`)** | **`0.0000` (`[0.0000, 0.0000]`)** | **`2.0`** | **`0.9879`** | `17.88 s` | + +### 2.2 4D Chemomechanical Fracture & Precursor Benchmark + +| Scenario | Backend | `1 -> 2` Split Recall | `2 -> 1` Merge Recall | Top-1 Precursor Precision | Precursor Contrast $\Delta S$ vs Control (95% CI) | Elapsed (`5` trials, CPU) | +| :--- | :--- | :---: | :---: | :---: | :---: | :---: | +| **`chemomechanical_fracture`** | `geo` | `1.00` | `1.00` | `1.00` | `0.6449` (`[0.6448, 0.6450]`) | `0.13 s` | +| **`chemomechanical_fracture`** | `mock` | `1.00` | `1.00` | `1.00` | `0.5539` (`[0.5538, 0.5540]`) | `0.29 s` | +| **`chemomechanical_fracture`** | **`torch` (`dinov2-small`)** | **`1.00`** | **`1.00`** | **`1.00`** | **`0.5584` (`[0.5582, 0.5585]`)** | `74.82 s` | + +![4D chemomechanical fracture lineage DAG, persistent precursor contrast, and MIP evolution](figures/fracture_lineage_and_precursors.png) + +### Key Scientific Takeaways + +1. **Orientation-Sensitive Disambiguation (`crossing_morphology`):** When two grains have identical 3D eigenvalue magnitudes ($\lambda_1, \lambda_2, \lambda_3$) and rotate slightly past $90^\circ$ on a shared Debye-Scherrer / rocking locus, **Geometry-Only** suffers a deterministic `25.0%` ID-switch rate because 3D scalar eigenvalues discard 2D detector streak orientation (`+45 deg` vs `-45 deg`). **`facebook/dinov2-small`** preserves high multi-view morphological similarity (`0.9035`) along true trajectories and eliminates ID switches (`0.0%`). +2. **Real Pretrained Embeddings vs Mock Hash (`beam_dropout_gap2` & `intensity_jitter`):** While `MockDinoEncoder` produces pseudo-random zero-mean cosine similarities (`-0.003` to `0.016`) whenever shot noise Perturbs a single voxel—causing semantic gap-closing (`min_cosine_similarity=0.35`) to reject valid re-links (`0.0` gap closures, `50%` fragmentation)—pretrained **`facebook/dinov2-small`** maintains `0.988–0.991` cosine stability across `45%` flux spikes, progressive mosaic broadening, and multi-scan dropouts, recovering `100%` of dropped tracks (`0.0%` fragmentation, `2.0` gap closures). +3. **Early Precursor Contrast (`chemomechanical_fracture`):** Across `1 -> 2` grain splitting (`scan 3 -> 4`) and `2 -> 1` sub-grain coalescence (`scan 5 -> 6`), BraggTrack's multi-component precursor score flags the fracturing parent grain `3` scans before topological separation (`1.00` top-1 precision, `+0.56` to `+0.64` score contrast above isotropic control grains). + +--- + +## 3. ESRF-ID03 Operando DFXM Case Study (`data/sample_operando/`) + +We executed the complete **BraggTrack v0.3.0** pipeline with real **`facebook/dinov2-small`** embeddings, multi-scan gap closing (`--max-gap 1`), interactive HTML reporting (`--report`), `ImageD11` `.flt` export, and NeXus `NXprocess` HDF5 archival on the bundled 3-scan **ESRF-ID03** near-field PCO dataset (`3` scans $\times$ `100 x 250 x 250` `uint16` cubes, ~`20 MB` compressed HDF5): + +```bash +braggtrack-run data/sample_operando \ + --outdir artifacts/esrf_id03_dinov2 \ + --backend torch \ + --model facebook/dinov2-small \ + --max-gap 1 \ + --report \ + --export-nexus artifacts/esrf_id03_dinov2/esrf_id03.nxs \ + --export-imaged11 artifacts/esrf_id03_dinov2/esrf_id03.flt +``` + +### 3.1 CPU Stage-Timing Profile + +| Pipeline Stage | Wall-Clock Time (CPU) | Share of Run | Primary Workload | +| :--- | :---: | :---: | :--- | +| **`validate`** | `0.043 s` | `0.1%` | NeXus `/entry_0000/ESRF-ID03/pco_nf/data` discovery & SHA-256 verification | +| **`segment`** | `13.48 s` | `24.4%` | Chunked lazy Otsu pass (`LazyVolume`) + 3D LoG + `h`-maxima seeded watershed (`[18, 17, 15]` spots) | +| **`embed`** | `18.35 s` | `33.3%` | Lazy ROI cropping + `facebook/dinov2-small` 3-view MIP inference (`50` spots $\times$ `1152`-d) | +| **`track`** | `0.024 s` | `0.04%` | Geometry+semantic Hungarian matching + Jaqaman gap closing + 4D grain kinematics | +| **`events`** | `20.23 s` | `36.7%` | `1 -> 2` / `2 -> 1` lineage resolution + 3D sub-peak & `dinov2-small` patch-token dispersion | +| **`report` + exports** | `3.04 s` | `5.5%` | Self-contained `report.html`, publication PNGs, `esrf_id03.flt`, and `esrf_id03.nxs` | +| **Total** | **`55.17 s`** | **`100.0%`** | Full 3-scan operando DFXM workflow on CPU (no GPU required) | + +### 3.2 Detected Lineage Events & Persistent Precursor Candidates + +- **Split Candidates (`events.csv`):** + - **Event 1 (`scan 0 -> 1`):** Parent **Track `6`** (`s0_i5`) $\to$ Daughters **Track `32`** (`s1_i11`) & **Track `34`** (`s1_i9`), intensity partition ratio `1.434`, mean daughter separation `18.64 px`, **DINOv2 multi-view cosine similarity `0.7561`**. + - **Event 2 (`scan 1 -> 2`):** Parent **Track `21`** (`s1_i1`) $\to$ Daughters **Track `36`** (`s2_i1`) & **Track `44`** (`s2_i13`), intensity partition ratio `1.258`, mean daughter separation `20.11 px`, **DINOv2 multi-view cosine similarity `0.6837`**. +- **Top Persistent Precursor Tracks (`precursors.csv`, `min_persistence = 2` scans):** + 1. **Track `14`** (`rank 1`): Active across all `3` scans (`onset_scan=0`, `peak_scan=1`), `peak_score = 0.8789`, `mean_active_score = 0.7775`, `max_anisotropy = 5.45`, `max_spread_growth = +106%`, `confidence = 0.8555`. + 2. **Track `34`** (`rank 2`, split daughter of Track `6`): Active across `scans 1-2`, `peak_score = 0.9023`, extreme streak elongation (`max_anisotropy = 26.78`), `max_spread_growth = +129%`, `confidence = 0.8119`. + 3. **Track `27`** (`rank 3`): Active across `scans 1-2`, `peak_score = 0.6710`, `max_anisotropy = 16.00`, `confidence = 0.6534`. + 4. **Track `29`** (`rank 4`): Active across `scans 1-2`, `peak_score = 0.6668`, `max_anisotropy = 6.67`, `confidence = 0.6490`. diff --git a/docs/figures/benchmark_comparison.png b/docs/figures/benchmark_comparison.png new file mode 100644 index 0000000000000000000000000000000000000000..03a9b0cfa56a7192aa0f139a94f3ee70b0d987be GIT binary patch literal 182861 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 }EpxH%Gio~6v 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ʫ=a>Y0Z@#lff#!u-u&U!hHXgIHqv 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�&iECb^ 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®GoYl)@aX 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 literal 0 HcmV?d00001 diff --git a/notebooks/braggtrack_demo.ipynb b/notebooks/braggtrack_demo.ipynb index ef8edac..bbdcba6 100644 --- a/notebooks/braggtrack_demo.ipynb +++ b/notebooks/braggtrack_demo.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "id": "e65e834e", "metadata": {}, - "source": "# BraggTrack end-to-end demo\n\n[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BASE-Laboratory/BraggTrack/blob/main/notebooks/braggtrack_demo.ipynb)\n\nRuns the full BraggTrack v0.2 pipeline on the bundled `data/sample_operando/` ESRF-ID03 scans:\n\n1. **Discover & load** — find per-scan NeXus/HDF5 files and auto-discover 3D detector cubes (`load_primary_volume`).\n2. **Segment** — cross-scan smoothed Otsu → 3D LoG → h-maxima → seeded watershed → instance features.\n3. **Track (physics-only)** — Hungarian association over geometry cost with per-axis gating; build a lifecycle DAG.\n4. **Semantic descriptors** — orthogonal $(\\mu, \\chi, d)$ MIPs + frozen vision-transformer embeddings.\n5. **Geometry + semantic tracking** — compose $\\alpha \\cdot C_{\\text{geo}} + \\beta \\cdot (1 - \\cos)$.\n6. **$\\alpha / \\beta$ ablation** — sweep semantic weight across tracking metrics.\n7. **Near-overlap disambiguation** — synthetic crossing where semantics prevent an ID swap.\n8. **Per-grain kinematics, split/merge lineage & fracture precursors** — calibrated strain $\\Delta d / d_0$, `1 -> 2` grain cleavage, `2 -> 1` coalescence, and persistent precursor ranking.\n9. **Command-line & one-command pipeline (`braggtrack-run`)** — reproducible CLI equivalents.\n\nThis notebook uses the **mock** DINO backend by default so zero PyTorch / GPU weights are needed in CI. Set `BRAGGTRACK_DINO_BACKEND=torch` (with `pip install -e '.[torch]'`) to use ungated `facebook/dinov2-small`." + "source": "# BraggTrack end-to-end demo (v0.3)\n\n[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BASE-Laboratory/BraggTrack/blob/main/notebooks/braggtrack_demo.ipynb)\n\nRuns the full BraggTrack v0.3 pipeline on the bundled `data/sample_operando/` ESRF-ID03 scans:\n\n1. **Discover & stream** — find per-scan NeXus/HDF5 files, auto-discover 3D detector cubes, and stream chunked Otsu thresholds via `LazyVolume`.\n2. **Segment** — cross-scan smoothed Otsu → 3D LoG → h-maxima → seeded watershed → instance features.\n3. **Track (physics-only & gap closing)** — Hungarian association + multi-scan gap closing (`GapClosingConfig`).\n4. **Semantic descriptors** — orthogonal $(\\mu, \\chi, d)$ MIPs + frozen vision-transformer embeddings.\n5. **Geometry + semantic tracking** — compose $\\alpha \\cdot C_{\\text{geo}} + \\beta \\cdot (1 - \\cos)$.\n6. **$\\alpha / \\beta$ ablation** — sweep semantic weight across tracking metrics.\n7. **Near-overlap disambiguation** — synthetic crossing where semantics prevent an ID swap.\n8. **Per-grain kinematics, split/merge lineage & `braggtrack.viz` dashboards** — calibrated strain $\\Delta d / d_0$, `1 -> 2` grain cleavage, `2 -> 1` coalescence, persistent precursor ranking, and `DetectorGeometry` $(2\\theta, \\eta, d, |\\mathbf{Q}|)$ conversion.\n9. **Command-line & one-command pipeline (`braggtrack-run --report`)** — reproducible CLI equivalents.\n\nThis notebook uses the **mock** DINO backend by default so zero PyTorch / GPU weights are needed in CI. Set `BRAGGTRACK_DINO_BACKEND=torch` (with `pip install -e \".[torch]\"`) to use ungated `facebook/dinov2-small`." }, { "cell_type": "markdown", @@ -41,7 +41,7 @@ } }, "outputs": [], - "source": "%matplotlib inline\nimport copy\nfrom pathlib import Path\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nfrom matplotlib.colors import ListedColormap\n\nfrom braggtrack.io import (\n AxisCalibration,\n discover_operando_scans,\n discover_primary_volume_path,\n load_primary_volume,\n sample_operando_root,\n)\nfrom braggtrack.segmentation import (\n extract_instance_table,\n fill_holes_binary,\n flag_outlier_frames,\n label_projection_by_intensity,\n merge_nearby_labels,\n otsu_floor_from_mip,\n otsu_threshold,\n relabel_sequential,\n remove_small_objects,\n segment_classical,\n smooth_thresholds,\n)\nfrom braggtrack.semantic import (\n crop_spot_cube,\n make_multiview_encoder,\n make_patch_encoder,\n orthogonal_mips,\n)\nfrom braggtrack.tracking import (\n GeometrySemanticCost,\n PositionShapeCost,\n PrecursorConfig,\n SplitMergeConfig,\n TrackEvent,\n build_tracks,\n compute_fracture_precursors,\n compute_grain_kinematics,\n compute_tracking_metrics,\n events_to_table,\n generate_fracture_scenario,\n kinematics_to_table,\n precursors_to_table,\n tracks_to_table,\n)" + "source": "%matplotlib inline\nimport copy\nfrom pathlib import Path\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nfrom matplotlib.colors import ListedColormap\n\nfrom braggtrack.io import (\n AxisCalibration,\n DetectorGeometry,\n open_lazy_volume,\n otsu_threshold_chunked,\n discover_operando_scans,\n discover_primary_volume_path,\n load_primary_volume,\n sample_operando_root,\n)\nfrom braggtrack.segmentation import (\n extract_instance_table,\n fill_holes_binary,\n flag_outlier_frames,\n label_projection_by_intensity,\n merge_nearby_labels,\n otsu_floor_from_mip,\n otsu_threshold,\n relabel_sequential,\n remove_small_objects,\n segment_classical,\n smooth_thresholds,\n)\nfrom braggtrack.semantic import (\n crop_spot_cube,\n make_multiview_encoder,\n make_patch_encoder,\n orthogonal_mips,\n)\nfrom braggtrack.tracking import (\n GapClosingConfig,\n GeometrySemanticCost,\n PositionShapeCost,\n PrecursorConfig,\n SplitMergeConfig,\n TrackEvent,\n build_tracks,\n compute_fracture_precursors,\n compute_grain_kinematics,\n compute_tracking_metrics,\n events_to_table,\n generate_fracture_scenario,\n kinematics_to_table,\n precursors_to_table,\n tracks_to_table,\n)\nfrom braggtrack.viz import (\n plot_kinematics_dashboard,\n plot_lineage_dag,\n plot_precursor_timeline,\n)\n" }, { "cell_type": "markdown", @@ -728,11 +728,19 @@ "outputs": [], "source": "# 8b. 4D split/merge lineage + persistent fracture precursor ranking\nf_vols, f_labels, f_tables, f_expected = generate_fracture_scenario(n_scans=5, seed=42)\nG_frac = build_tracks(\n f_tables,\n cost_fn=PositionShapeCost(),\n split_merge_config=SplitMergeConfig(max_distance=20.0),\n)\nlineage_events = G_frac.graph[\"lineage_events\"]\nfrac_rows = tracks_to_table(G_frac)\ncandidates, obs_scores = compute_fracture_precursors(\n frac_rows,\n PrecursorConfig(score_threshold=0.35, min_persistence=2),\n volumes=f_vols,\n label_volumes=f_labels,\n patch_encoder=make_patch_encoder(\"mock\"),\n lineage_events=lineage_events,\n)\n\nprint(\"=== Detected Lineage Events (splits & merges) ===\")\nprint(pd.DataFrame(events_to_table(lineage_events))[[\n \"event_id\", \"event_type\", \"scan_idx_from\", \"scan_idx_to\",\n \"parent_track_ids\", \"child_track_ids\", \"intensity_ratio\", \"confidence\"\n]].to_string(index=False))\n\nprint(\"\\n=== Persistent Fracture Precursor Ranking ===\")\nprint(pd.DataFrame(precursors_to_table(candidates)).to_string(index=False))" }, + { + "cell_type": "code", + "id": "b730v001", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": "# 8c. Publication visualization (braggtrack.viz) + crystallographic (2theta, eta, d, |Q|) mapping\nfig_dag, _ = plot_lineage_dag(frac_rows, events=lineage_events, title=\"4D Split & Merge Lineage DAG\")\nplt.show()\n\nfig_prec, _ = plot_precursor_timeline(obs_scores, candidates=candidates, score_threshold=0.35)\nplt.show()\n\nfig_kin, _ = plot_kinematics_dashboard(gk_operando, calibrated=False, max_tracks=6)\nplt.show()\n\n# Lazy HDF5 streaming & transmission diffraction geometry (DetectorGeometry)\nwith open_lazy_volume(scans[0].path) as lv:\n chunked_otsu = otsu_threshold_chunked(lv, chunk_z=32)\ndet = DetectorGeometry(distance_mm=150.0, pixel_size_y_mm=0.075, pixel_size_x_mm=0.075,\n beam_center_y_px=20.0, beam_center_x_px=20.0, wavelength_angstrom=0.50)\ns0 = all_features[0][0]\nscat = det.spot_to_scattering(s0[\"centroid_mu\"], s0[\"centroid_d\"], s0[\"centroid_chi\"])\nprint(f\"Lazy chunked Otsu={chunked_otsu:.1f} | Spot #1: 2theta={scat['two_theta_deg']:.3f} deg, \"\n f\"eta={scat['eta_deg']:.2f} deg, d={scat['d_spacing_angstrom']:.4f} A, |Q|={scat['q_mag_inv_angstrom']:.4f} A^-1\")" + }, { "cell_type": "markdown", "id": "7e605de2", "metadata": {}, - "source": "## 9 — Reproducible command-line pipeline (`braggtrack-run`)\n\nEvery stage above is available via CLI entry points — or as a single end-to-end command (`braggtrack-run`) that validates inputs, segments with cross-scan threshold smoothing, embeds MIPs, tracks kinematics, resolves splits/merges & fracture precursors, and writes `run_manifest.json` with SHA-256 input checksums:\n\n```bash\n# One-command end-to-end pipeline\nbraggtrack-run --outdir artifacts/pipeline\n\n# Or stage-by-stage:\nbraggtrack-segment-dataset --outdir artifacts/segmentation\nbraggtrack-embed-dataset --segdir artifacts/segmentation --outdir artifacts/embedding --backend auto\nbraggtrack-track-dataset artifacts/segmentation \\\n --outdir artifacts/tracking \\\n --embedding-dir artifacts/embedding \\\n --cost-alpha 1.0 --cost-beta 0.25 --detect-events\nbraggtrack-events --segdir artifacts/segmentation --outdir artifacts/events\n\n# Semantic alpha/beta ablation with 95% bootstrap confidence intervals\npython scripts/ablation_semantic.py \\\n --indir artifacts/segmentation \\\n --embedding-dir artifacts/embedding \\\n --betas 0,0.25,0.5,1.0 --bootstrap-samples 100 \\\n --output artifacts/ablation/report.json\n\n# Full CI suite (unit tests + all 7 acceptance gates)\npython scripts/ci_report.py\n```" + "source": "## 9 — Reproducible command-line pipeline (`braggtrack-run`)\n\nEvery stage above is available via CLI entry points — or as a single end-to-end command (`braggtrack-run`) that validates inputs, segments with chunked Otsu + cross-scan threshold smoothing, embeds MIPs, tracks kinematics with `--max-gap`, resolves splits/merges & fracture precursors, exports `ImageD11` (`.flt`) / NeXus (`.nxs`), renders an offline interactive HTML 4D Explorer (`--report`), and writes `run_manifest.json` with SHA-256 input checksums:\n\n```bash\n# One-command end-to-end pipeline with interactive HTML explorer & NeXus/ImageD11 exports\nbraggtrack-run --outdir artifacts/pipeline --max-gap 1 --report \\\n --export-nexus artifacts/pipeline/results.nxs \\\n --export-imaged11 artifacts/pipeline/peaks.flt\n\n# Standalone interactive report & static publication figures\nbraggtrack-report artifacts/pipeline\n\n# Quantitative 5-scenario benchmark suite (add --include-torch for real DINOv2)\npython scripts/benchmark_suite.py --trials 5\n\n# Full CI suite (unit tests + all 9 acceptance gates)\npython scripts/ci_report.py\n```" } ], "metadata": { diff --git a/paper.bib b/paper.bib index b8e4710..6b37b89 100644 --- a/paper.bib +++ b/paper.bib @@ -25,7 +25,7 @@ @article{Hayashi2019 doi = {10.1126/science.aax9167} } -@article{Finegan2019, +@article{Finegan2017, author = {Finegan, Donal P. and Darcy, Eric and Keyser, Matt and Tjaden, Bernhard and Heenan, Thomas M. M. and Jervis, Rhodri and Bailey, Josh J. and Malik, Ruhul and @@ -181,3 +181,17 @@ @inproceedings{Hagberg2008 Millman, Jarrod}, address = {Pasadena, CA} } + +@article{Jaqaman2008, + author = {Jaqaman, Khuloud and Loerke, Dinah and Mettlen, Marcel + and Kuwata, Hirotaka and Grinstein, Sergio and + Schmid, Sandra L. and Danuser, Gaudenz}, + title = {Robust single-particle tracking in live-cell time-lapse + sequences}, + journal = {Nature Methods}, + volume = {5}, + number = {8}, + pages = {695--702}, + year = {2008}, + doi = {10.1038/nmeth.1237} +} diff --git a/paper.md b/paper.md index d59b023..1c56e8d 100644 --- a/paper.md +++ b/paper.md @@ -30,13 +30,17 @@ during *in situ* or *operando* experiments, BraggTrack segments individual Bragg reflections, extracts calibrated geometric and foundation vision features, and links observations across scans into a directed acyclic trajectory graph capturing births, continuations, terminations, `1 -> 2+` grain fracture splits, -and `2+ -> 1` coalescence merges. In addition, BraggTrack ranks persistent -pre-fracture precursor candidates across scans by combining 3D reflection -anisotropy, covariance broadening, internal sub-peak bimodality, and frozen +and `2+ -> 1` coalescence merges, as well as multi-scan gap closures across +transient beam dropouts. In addition, BraggTrack ranks persistent pre-fracture +precursor candidates across scans by combining 3D reflection anisotropy, +covariance broadening, internal sub-peak bimodality, and frozen vision-transformer patch-token dispersion. Designed for synchrotron NeXus/HDF5 -data, BraggTrack ships with bundled operando scans from ESRF beamline ID03, -eight CLI entry points including a single-command reproducible pipeline runner -(`braggtrack-run`), and interactive Jupyter notebooks runnable on Google Colab. +data, BraggTrack supports lazy HDF5 ROI streaming, crystallographic +$(2\theta, \eta, d, |\mathbf{Q}|)$ conversion with direct `ImageD11` (`.flt`) +and NeXus `NXprocess` HDF5 export, publication plotting and offline interactive +HTML 4D lineage reports (`braggtrack-report`), bundled operando scans from ESRF +beamline ID03, nine CLI entry points culminating in `braggtrack-run`, and +interactive Jupyter notebooks runnable on Google Colab. # Statement of Need @@ -49,7 +53,7 @@ In battery electrodes such as Ni-rich layered oxides, chemomechanical degradation manifests first as anisotropic intragranular strain broadening and sub-domain formation before culminating in particle microcracking — observable in reciprocal space as reflection broadening followed by `1 -> 2+` peak -splitting [@Finegan2019]. Quantifying per-grain lattice strain +splitting [@Finegan2017]. Quantifying per-grain lattice strain ($\varepsilon = \Delta d / d_0$), lattice rotation ($\Delta\mu$, $\Delta\chi$), and fracture lineage across long scan sequences is essential for linking local crystallography to macroscopic failure, as well as for solidification and @@ -62,36 +66,45 @@ scripts, or crystallographic indexing packages such as GrainSpotter evolving, splitting, and broadening 3D intensity distributions through time. Previously, researchers lacked an open-source, `pip`-installable toolkit combining stabilised 3D spot segmentation, foundation-model visual descriptors, -calibrated per-grain kinematics, and explicit split/merge fracture lineage in a -reproducible software architecture. +calibrated per-grain kinematics, explicit split/merge fracture lineage, and +beamline-ready crystallographic exports in a reproducible software architecture. BraggTrack addresses this need by separating beamline HDF5 ingestion and axis calibration, 3D instance segmentation, multi-view vision-transformer encoding, -Hungarian and topological lineage tracking, and fracture precursor scoring into -cleanly tested, modular layers. +Hungarian and topological lineage tracking, fracture precursor scoring, and +interactive visualization (`braggtrack.viz`) into cleanly tested, modular +layers. # Implementation -## Beamline ingestion and physical axis calibration +## Beamline ingestion, lazy HDF5 streaming, and crystallographic mapping BraggTrack discovers sequential `scan*` directories, inspects NeXus/HDF5 trees (including ESRF-ID03 LIMA detector hierarchies under `/entry_0000/...` and generic HDF5 layouts via automatic largest-3D numeric dataset discovery), and -validates timestamp monotonicity. An `AxisCalibration` transform converts raw -detector indices into physical reciprocal-space coordinates -$(\mu, \chi, d)$ via HDF5 axis metadata or JSON/CLI calibration parameters while -preserving integer voxel bounding boxes for lossless 3D region-of-interest (ROI) -cropping. This ensures crystallographic strain $\Delta d / d_0$ is invariant to -detector window cropping. +validates timestamp monotonicity. To handle gigabyte-scale detector stacks +without exhausting host memory, `LazyVolume` streams `z`-slabs for exact +two-pass global Otsu histogramming (`otsu_threshold_chunked`) and reads only +tight 3D spot bounding-box slices (`read_roi`) during semantic embedding and +precursor analysis. + +An `AxisCalibration` transform converts raw detector indices into physical +reciprocal-space coordinates $(\mu, \chi, d)$ while preserving integer voxel +bounding boxes for lossless 3D ROI cropping. Complementarily, +`DetectorGeometry` maps transmission-diffraction spot centroids into +crystallographic scattering angle $2\theta$, azimuth $\eta$, $d$-spacing +($\lambda = 2 d \sin\theta$), and reciprocal-lattice vectors $\mathbf{Q}$ +($\text{\AA}^{-1}$), exporting directly to `ImageD11` columnfiles (`.flt`) +[@Wright2023] and self-describing NeXus `NXprocess` HDF5 archives (`.nxs`). ## Stabilised 3D segmentation BraggTrack's primary segmentation pipeline processes 3D volumes in four stages: -1. **Stabilised foreground thresholding.** Per-scan Otsu thresholds [@Otsu1979] - on raw intensity histograms are smoothed across scans with a rolling median - (`smooth_thresholds`) and checked for median-absolute-deviation outliers, - eliminating spot-count jitter caused by transient beam fluctuations. +1. **Stabilised foreground thresholding.** Streaming per-scan Otsu thresholds + [@Otsu1979] on raw intensity histograms are smoothed across scans with a + rolling median (`smooth_thresholds`) and checked for median-absolute-deviation + outliers, eliminating spot-count jitter caused by transient beam fluctuations. 2. **3D LoG enhancement.** Gaussian smoothing followed by the negative discrete Laplacian highlights Bragg reflections as local maxima [@Lindeberg1998] @@ -110,44 +123,63 @@ BraggTrack's primary segmentation pipeline processes 3D volumes in four stages: ## Multi-view semantic descriptors -Each segmented 3D reflection is cropped, masked to its instance support, and -projected into three orthogonal maximum-intensity projections (MIPs) along -$\mu$, $\chi$, and $d$. By default, BraggTrack encodes these views using the -public, ungated DINOv2 vision transformer (`facebook/dinov2-small`) -[@Oquab2024] into an $L_2$-normalised 384-d descriptor, while also supporting -newer DINOv3 backbones (`facebook/dinov3-vitb16-pretrain-lvd1689m`) via dynamic -prefix/register token handling and a deterministic hash-based `mock` encoder for -zero-GPU continuous integration. +Each segmented 3D reflection is cropped via `LazyVolume`, masked to its instance +support, and projected into three orthogonal maximum-intensity projections +(MIPs) along $\mu$, $\chi$, and $d$. By default, BraggTrack encodes these views +using the public, ungated DINOv2 vision transformer (`facebook/dinov2-small`) +[@Oquab2024] into a concatenated $L_2$-normalised 1152-d descriptor, while also +supporting newer DINOv3 backbones (`facebook/dinov3-vitb16-pretrain-lvd1689m`) +via dynamic prefix/register token handling and a deterministic hash-based `mock` +encoder for zero-GPU continuous integration. -## Tracking, kinematics, and chemomechanical fracture events +## Tracking, gap closing, kinematics, and chemomechanical fracture events Frame-to-frame 1-to-1 association solves the gated Hungarian assignment problem [@Kuhn1955] over $\alpha \cdot C_{\text{geo}}(i, j) + \beta \cdot (1 - \cos(\mathbf{f}_i, \mathbf{f}_j))$, constructing a NetworkX [@Hagberg2008] -`DiGraph`. From each trajectory, `compute_grain_kinematics` extracts time-series -strain $\Delta d / d_0$, rocking/azimuthal misorientation, integrated intensity -and volume evolution, and 3D eigenvalue anisotropy. +`DiGraph`. Prior to topological event detection, `resolve_track_gaps` solves an +augmented multi-scan linear assignment problem [@Jaqaman2008] with diffusive +displacement scaling ($\Delta r^2 / \Delta t$) and semantic cosine gating to +reconnect reflections across transient beam dropouts (`--max-gap`) while +severing spurious cross-detector jumps. From each trajectory, +`compute_grain_kinematics` extracts time-series strain $\Delta d / d_0$, +rocking/azimuthal misorientation, integrated intensity and volume evolution, and +3D eigenvalue anisotropy. To capture grain fracture and coalescence, `resolve_splits_and_merges` augments -unmatched birth and termination nodes with explicit `1 -> 2+` split and -`2+ -> 1` merge edges gated by spatial proximity, integrated-intensity +remaining unmatched birth and termination nodes with explicit `1 -> 2+` split +and `2+ -> 1` merge edges gated by spatial proximity, integrated-intensity conservation ($I_{\text{children}} / I_{\text{parent}}$), and minimum fragment intensity share, assigning clean daughter track IDs so diverging post-fracture -strains are tracked independently. Complementarily, +strains are tracked independently (\autoref{fig:lineage}). Complementarily, `compute_fracture_precursors` scores pre-split intragranular degradation across contiguous scans (`min_persistence`) using 3D eigenvalue anisotropy, covariance trace growth, internal 3D sub-peak bimodality, and foreground DINO patch-token cosine dispersion. -## Reproducibility and deployment - -BraggTrack (`pip install braggtrack`) provides eight CLI commands, culminating -in `braggtrack-run`, which executes validation, segmentation, embedding, -tracking, kinematics, and event detection and writes a `run_manifest.json` -recording SHA-256 input checksums, configuration, software version, and per-stage -runtimes. Automated CI tests Python 3.10–3.12, enforces Ruff linting/formatting, -runs seven acceptance gates (`scripts/ci_report.py`), and executes the tutorial -notebook end-to-end on bundled ESRF-ID03 data. +![Four-dimensional chemomechanical fracture lineage, pre-split bimodal MIP evolution, persistent precursor decomposition (`facebook/dinov2-small`), and calibrated ESRF-ID03 Ni-rich cathode per-grain strain trajectories.\label{fig:lineage}](docs/figures/fracture_lineage_and_precursors.png) + +## Quantitative evaluation, visualization, and reproducibility + +Across controlled 4D benchmarks (`scripts/benchmark_suite.py`; +\autoref{fig:benchmarks}), multi-view `facebook/dinov2-small` descriptors +maintain $> 0.96$ adjacent-scan cosine similarity under shot noise, 45% beam-flux +jitter, and mosaic rocking-curve broadening (where byte-hash mocks collapse to +$\approx 0$), eliminate crossing ID switches between reflections with identical +3D covariance eigenvalues (`+45` vs. `-45` deg detector tilts), and recover +100% of staggered beam dropouts with `--max-gap 2`. + +![Quantitative 4D diffraction benchmark suite comparing Geometry-Only, Mock-Hash, and Real `facebook/dinov2-small` across crossing tilted reflections, flux/mosaic noise invariance, and staggered beam-dropout recovery.\label{fig:benchmarks}](docs/figures/benchmark_comparison.png) + +BraggTrack (`pip install braggtrack`) provides nine CLI commands, including +`braggtrack-report` (generating publication figures and a zero-CDN offline +interactive HTML 4D Lineage & Strain Explorer) and `braggtrack-run`, which +executes validation, segmentation, embedding, tracking, kinematics, event +detection, reporting, and `ImageD11`/NeXus export while writing a +`run_manifest.json` with SHA-256 input checksums and per-stage runtimes. +Automated CI tests Python 3.10–3.12, enforces Ruff linting/formatting, runs nine +acceptance gates (`scripts/ci_report.py`), and executes the tutorial notebook +end-to-end on bundled ESRF-ID03 data. # Acknowledgements diff --git a/pyproject.toml b/pyproject.toml index bff1ae3..128b6ae 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "braggtrack" -version = "0.2.0" +version = "0.3.0" description = "Semantic 4D kinematics and fracture tracking for operando diffraction." readme = "README.md" requires-python = ">=3.10" @@ -59,6 +59,7 @@ braggtrack-segment-dataset = "braggtrack.cli.segment_dataset:main" braggtrack-track-dataset = "braggtrack.cli.track_dataset:main" braggtrack-embed-dataset = "braggtrack.cli.embed_dataset:main" braggtrack-events = "braggtrack.cli.detect_events:main" +braggtrack-report = "braggtrack.cli.report_dataset:main" braggtrack-run = "braggtrack.cli.run_pipeline:main" [tool.setuptools.packages.find] diff --git a/scripts/benchmark_suite.py b/scripts/benchmark_suite.py new file mode 100644 index 0000000..df171dc --- /dev/null +++ b/scripts/benchmark_suite.py @@ -0,0 +1,477 @@ +#!/usr/bin/env python3 +"""Quantitative 5-scenario 4D diffraction benchmark suite (Geometry vs Mock vs Real DINOv2). + +Evaluates tracking continuity, ID-switch rates, multi-scan gap closing, and +chemomechanical fracture precursor sensitivity across synthetic 3D volume +sequences with realistic detector noise. +""" + +from __future__ import annotations + +import argparse +import json +import sys +import time +from pathlib import Path +from typing import Any + +import numpy as np + +REPO = Path(__file__).resolve().parents[1] +if str(REPO) not in sys.path: + sys.path.insert(0, str(REPO)) + +from braggtrack.segmentation.features import extract_instance_table +from braggtrack.semantic import ( + DEFAULT_DINO_MODEL, + crop_spot_cube, + make_multiview_encoder, + make_patch_encoder, + orthogonal_mips, +) +from braggtrack.tracking import ( + GapClosingConfig, + GeometrySemanticCost, + PositionShapeCost, + PrecursorConfig, + SplitMergeConfig, + build_tracks, + compute_fracture_precursors, + compute_tracking_metrics, + generate_fracture_scenario, + tracks_to_table, +) + + +def _add_tilted_blob( + vol: np.ndarray, + center: tuple[float, float, float], + sigma: tuple[float, float, float], + amp: float, + tilt_xy: float = 0.0, +) -> np.ndarray: + zz, yy, xx = np.indices(vol.shape, dtype=np.float64) + dz = zz - center[0] + dy = yy - center[1] + dx = xx - center[2] + c, s = np.cos(tilt_xy), np.sin(tilt_xy) + ry = c * dy - s * dx + rx = s * dy + c * dx + lobe = amp * np.exp(-0.5 * ((dz / sigma[0]) ** 2 + (ry / sigma[1]) ** 2 + (rx / sigma[2]) ** 2)) + vol += lobe + return lobe + + +def _embed_scan_tables( + volumes: list[np.ndarray], + label_volumes: list[np.ndarray], + scan_tables: list[list[dict[str, Any]]], + encoder: Any, +) -> list[list[dict[str, Any]]]: + out_tables: list[list[dict[str, Any]]] = [] + for vol, labs, table in zip(volumes, label_volumes, scan_tables): + rows_copy: list[dict[str, Any]] = [] + for row in table: + rc = dict(row) + if encoder is not None: + lid = int(rc["label"]) + masked, _ = crop_spot_cube(vol, labs, lid, rc, margin=3) + m_mu, m_chi, m_d = orthogonal_mips(masked) + rc["embedding"] = encoder.embed(m_mu, m_chi, m_d) + rows_copy.append(rc) + out_tables.append(rows_copy) + return out_tables + + +def _gen_crossing_morphology(seed: int) -> tuple[list[np.ndarray], list[np.ndarray], list[list[dict]], list[dict]]: + """Two reflections with orthogonal +45 deg vs -45 deg detector tilts (equal eigenvalues!) crossing paths. + + Spots sit on antipodal points (6.4 voxels apart -> zero 3D mask overlap, identical + eigenvalues eig_1..3) and rotate by 92 deg between scans 2 and 3: the swapped + (-88 deg) chord is slightly shorter than the true (+92 deg) chord (delta_geo ~ 2.9), + causing pure geometry to swap identities while multi-view DINOv2 preserves 0% ID switches. + """ + rng = np.random.default_rng(seed) + shape = (36, 64, 64) + angles_deg = [-40.0, -20.0, 0.0, 90.25, 110.0] + radius = 4.2 + vols, labs, tables, gt = [], [], [], [] + for t, ang_deg in enumerate(angles_deg): + vol = rng.normal(1.0, 0.25, size=shape).clip(0.0) + lab = np.zeros(shape, dtype=np.int32) + th1 = np.deg2rad(ang_deg) + th2 = th1 + np.pi + c1_use = ( + 18.0 + radius * np.sin(th1) + rng.normal(0, 0.005), + 32.0 + rng.normal(0, 0.005), + 32.0 + radius * np.cos(th1) + rng.normal(0, 0.005), + ) + c2_use = ( + 18.0 + radius * np.sin(th2) + rng.normal(0, 0.005), + 32.0 + rng.normal(0, 0.005), + 32.0 + radius * np.cos(th2) + rng.normal(0, 0.005), + ) + + b1 = _add_tilted_blob(vol, c1_use, (1.4, 5.2, 0.95), 95.0, tilt_xy=np.pi / 4.0) + lab[b1 >= 14.0] = 1 + b2 = _add_tilted_blob(vol, c2_use, (1.4, 5.2, 0.95), 95.0, tilt_xy=-np.pi / 4.0) + lab[(b2 >= 14.0) & (lab == 0)] = 2 + + tab = extract_instance_table(lab, vol) + for s_idx, r in enumerate(tab): + gt.append({"scan_idx": t, "spot_idx": s_idx, "true_id": int(r["label"])}) + vols.append(vol) + labs.append(lab) + tables.append(tab) + return vols, labs, tables, gt + + +def _gen_intensity_jitter(seed: int) -> tuple[list[np.ndarray], list[np.ndarray], list[list[dict]], list[dict]]: + """Close neighbor pair under 45% beam-flux attenuation spikes and shot noise.""" + rng = np.random.default_rng(seed) + shape = (18, 40, 40) + flux = [1.0, 0.55, 1.35, 0.60, 1.10] + vols, labs, tables, gt = [], [], [], [] + for t, f_scale in enumerate(flux): + vol = rng.normal(0.8, 0.3, size=shape).clip(0.0) + lab = np.zeros(shape, dtype=np.int32) + b1 = _add_tilted_blob(vol, (9.0, 16.0 + 0.4 * t, 17.0), (1.3, 2.6, 1.1), 80.0 * f_scale, tilt_xy=0.5) + lab[b1 >= 7.0 * f_scale] = 1 + b2 = _add_tilted_blob(vol, (9.0, 22.5 + 0.4 * t, 21.0), (1.3, 1.1, 2.6), 78.0 * f_scale, tilt_xy=-0.4) + lab[(b2 >= 7.0 * f_scale) & (lab == 0)] = 2 + tab = extract_instance_table(lab, vol) + for s_idx, r in enumerate(tab): + gt.append({"scan_idx": t, "spot_idx": s_idx, "true_id": int(r["label"])}) + vols.append(vol) + labs.append(lab) + tables.append(tab) + return vols, labs, tables, gt + + +def _gen_mosaic_broadening(seed: int) -> tuple[list[np.ndarray], list[np.ndarray], list[list[dict]], list[dict]]: + """Progressive intragranular rocking-curve broadening across 5 scans.""" + rng = np.random.default_rng(seed) + shape = (24, 40, 40) + vols, labs, tables, gt = [], [], [], [] + for t in range(5): + vol = rng.normal(0.8, 0.25, size=shape).clip(0.0) + lab = np.zeros(shape, dtype=np.int32) + sig_z = 1.1 + 0.35 * t + b1 = _add_tilted_blob(vol, (12.0, 14.0 + 0.6 * t, 15.0), (sig_z, 2.0, 1.2), 75.0, tilt_xy=0.3) + lab[b1 >= 6.5] = 1 + b2 = _add_tilted_blob(vol, (12.0, 27.0 - 0.3 * t, 26.0), (1.2, 1.5, 2.2), 75.0, tilt_xy=-0.6) + lab[(b2 >= 6.5) & (lab == 0)] = 2 + tab = extract_instance_table(lab, vol) + for s_idx, r in enumerate(tab): + gt.append({"scan_idx": t, "spot_idx": s_idx, "true_id": int(r["label"])}) + vols.append(vol) + labs.append(lab) + tables.append(tab) + return vols, labs, tables, gt + + +def _gen_beam_dropout(seed: int) -> tuple[list[np.ndarray], list[np.ndarray], list[list[dict]], list[dict]]: + """Three reflections across 6 scans with staggered 1-scan beam dropouts (scans 2 and 3).""" + rng = np.random.default_rng(seed) + shape = (18, 44, 44) + vols, labs, tables, gt = [], [], [], [] + specs = [ + (1, (9.0, 11.0, 12.0), (1.3, 2.2, 1.1), 0.3, {2}), # drops at scan 2 + (2, (9.0, 22.0, 24.0), (1.3, 1.1, 2.2), -0.4, {3}), # drops at scan 3 + (3, (9.0, 33.0, 15.0), (1.4, 1.5, 1.5), 0.0, set()), # continuous control + ] + for t in range(6): + vol = rng.normal(0.7, 0.25, size=shape).clip(0.0) + lab = np.zeros(shape, dtype=np.int32) + present_true_ids: list[int] = [] + next_lbl = 1 + for tid_true, base_c, sig, tilt, drop_scans in specs: + if t in drop_scans: + continue + center = (base_c[0], base_c[1] + 0.35 * t, base_c[2] + 0.2 * t) + b = _add_tilted_blob(vol, center, sig, 80.0, tilt_xy=tilt) + lab[(b >= 7.0) & (lab == 0)] = next_lbl + present_true_ids.append(tid_true) + next_lbl += 1 + tab = extract_instance_table(lab, vol) + for s_idx in range(len(tab)): + gt.append({"scan_idx": t, "spot_idx": s_idx, "true_id": present_true_ids[s_idx]}) + vols.append(vol) + labs.append(lab) + tables.append(tab) + return vols, labs, tables, gt + + +def _adjacent_cosine_stability(embedded_tables: list[list[dict[str, Any]]], gt: list[dict[str, int]]) -> float: + """Mean frame-to-frame cosine similarity along ground-truth trajectories.""" + gt_map = {(r["scan_idx"], r["spot_idx"]): r["true_id"] for r in gt} + by_true: dict[int, list[tuple[int, np.ndarray]]] = {} + for s_idx, rows in enumerate(embedded_tables): + for spot_idx, row in enumerate(rows): + emb = row.get("embedding") + tid = gt_map.get((s_idx, spot_idx)) + if emb is not None and tid is not None: + by_true.setdefault(tid, []).append((s_idx, np.asarray(emb, dtype=np.float64))) + sims: list[float] = [] + for obs in by_true.values(): + obs.sort(key=lambda x: x[0]) + for i in range(len(obs) - 1): + a, b = obs[i][1], obs[i + 1][1] + na, nb = np.linalg.norm(a), np.linalg.norm(b) + if na > 0 and nb > 0: + sims.append(float(np.dot(a, b) / (na * nb))) + return float(np.mean(sims)) if sims else 0.0 + + +def _ci95(vals: list[float]) -> list[float]: + if not vals: + return [0.0, 0.0] + arr = np.asarray(vals, dtype=np.float64) + if len(arr) == 1: + v = round(float(arr[0]), 4) + return [v, v] + rng = np.random.default_rng(12345) + boots = [float(np.mean(rng.choice(arr, size=len(arr), replace=True))) for _ in range(500)] + return [round(float(np.percentile(boots, 2.5)), 4), round(float(np.percentile(boots, 97.5)), 4)] + + +def run_suite( + backends: list[str], + *, + trials: int = 4, + model_name: str = DEFAULT_DINO_MODEL, +) -> dict[str, Any]: + encoders: dict[str, Any] = {} + patch_encoders: dict[str, Any] = {} + for b in backends: + if b == "geo": + encoders[b] = None + patch_encoders[b] = None + elif b == "mock": + encoders[b] = make_multiview_encoder("mock") + patch_encoders[b] = make_patch_encoder("mock") + elif b == "torch": + encoders[b] = make_multiview_encoder("torch", model_name=model_name) + patch_encoders[b] = make_patch_encoder("torch", model_name=model_name) + else: + raise ValueError(f"Unsupported backend: {b}") + + results: dict[str, dict[str, Any]] = {} + standard_scenarios = [ + ("crossing_morphology", _gen_crossing_morphology, 0), + ("intensity_jitter", _gen_intensity_jitter, 0), + ("mosaic_broadening", _gen_mosaic_broadening, 0), + ("beam_dropout_no_gap", _gen_beam_dropout, 0), + ("beam_dropout_gap2", _gen_beam_dropout, 2), + ] + + for scen_name, gen_fn, max_gap in standard_scenarios: + results[scen_name] = {} + for b in backends: + id_sw_rates: list[float] = [] + frag_ratios: list[float] = [] + cos_stabilities: list[float] = [] + gap_closures: list[float] = [] + t0 = time.perf_counter() + + for trial in range(trials): + vols, labs, tables, gt = gen_fn(100 + trial) + emb_tables = _embed_scan_tables(vols, labs, tables, encoders[b]) + geo = PositionShapeCost(position_weight=1.0, shape_weight=0.5) + # Weighted semantic cost disambiguates crossing morphologies when embeddings are meaningful + cost_fn = geo if b == "geo" else GeometrySemanticCost(geo, cost_alpha=1.0, cost_beta=25.0) + gap_cfg = ( + GapClosingConfig(max_gap=max_gap, max_cost=35.0, min_cosine_similarity=0.0 if b == "mock" else 0.5) + if max_gap > 0 + else None + ) + G = build_tracks(emb_tables, cost_fn=cost_fn, gap_closing_config=gap_cfg) + m = compute_tracking_metrics(G, n_scans=len(tables), ground_truth=gt) + id_sw_rates.append(float(m["id_switch_rate"])) + frag_ratios.append(float(m["fragmentation_ratio"])) + gap_closures.append(float(m["gap_closed_count"])) + if b != "geo": + cos_stabilities.append(_adjacent_cosine_stability(emb_tables, gt)) + + elapsed = round(time.perf_counter() - t0, 3) + results[scen_name][b] = { + "mean_id_switch_rate": round(float(np.mean(id_sw_rates)), 4), + "id_switch_rate_ci95": _ci95(id_sw_rates), + "mean_fragmentation_ratio": round(float(np.mean(frag_ratios)), 4), + "fragmentation_ratio_ci95": _ci95(frag_ratios), + "mean_gap_closed_count": round(float(np.mean(gap_closures)), 2), + "mean_cosine_stability": round(float(np.mean(cos_stabilities)), 4) if cos_stabilities else None, + "elapsed_sec": elapsed, + } + + # Scenario 5: Chemomechanical fracture (split + merge + persistent precursor contrast) + results["chemomechanical_fracture"] = {} + for b in backends: + precursor_contrasts: list[float] = [] + top_hit_rates: list[float] = [] + split_recalls: list[float] = [] + merge_recalls: list[float] = [] + t0 = time.perf_counter() + + for trial in range(trials): + vols, labs, tables, _ = generate_fracture_scenario(n_scans=5, seed=200 + trial) + emb_tables = _embed_scan_tables(vols, labs, tables, encoders[b]) + geo = PositionShapeCost() + cost_fn = geo if b == "geo" else GeometrySemanticCost(geo, cost_alpha=1.0, cost_beta=0.5) + G = build_tracks( + emb_tables, + cost_fn=cost_fn, + split_merge_config=SplitMergeConfig(max_distance=20.0), + ) + m = compute_tracking_metrics(G, n_scans=5) + split_recalls.append(1.0 if m["split_count"] == 1 else 0.0) + merge_recalls.append(1.0 if m["merge_count"] == 1 else 0.0) + + track_rows = tracks_to_table(G) + cands, obs_scores = compute_fracture_precursors( + track_rows, + PrecursorConfig(score_threshold=0.35, min_persistence=2), + volumes=vols, + label_volumes=labs, + patch_encoder=patch_encoders[b], + lineage_events=G.graph["lineage_events"], + ) + top_ok = 1.0 if (cands and cands[0].subsequent_split) else 0.0 + top_hit_rates.append(top_ok) + + # Contrast between fracturing grain precursor score and stable control grain + split_tids = {ev.parent_track_ids[0] for ev in G.graph["lineage_events"] if ev.event_type == "split"} + frac_scores = [o.precursor_score for o in obs_scores if o.track_id in split_tids and o.scan_idx < 2] + ctrl_scores = [ + o.precursor_score + for o in obs_scores + if o.track_id not in split_tids and o.scan_idx < 2 and o.roi_subpeak_count == 1 + ] + if frac_scores and ctrl_scores: + precursor_contrasts.append(float(np.mean(frac_scores) - np.mean(ctrl_scores))) + + results["chemomechanical_fracture"][b] = { + "split_detection_rate": round(float(np.mean(split_recalls)), 4), + "merge_detection_rate": round(float(np.mean(merge_recalls)), 4), + "top1_precursor_precision": round(float(np.mean(top_hit_rates)), 4), + "mean_precursor_contrast": round(float(np.mean(precursor_contrasts)), 4) if precursor_contrasts else 0.0, + "precursor_contrast_ci95": _ci95(precursor_contrasts), + "elapsed_sec": round(time.perf_counter() - t0, 3), + } + + return { + "schema_version": "benchmark_suite.v1", + "backends": backends, + "model": model_name if "torch" in backends else None, + "trials": trials, + "scenarios": results, + } + + +def _save_benchmark_figure(payload: dict[str, Any], out_path: Path) -> None: + import matplotlib + + matplotlib.use("Agg", force=False) + import matplotlib.pyplot as plt + + from braggtrack.viz._style import OKABE_ITO, apply_axis_style + + backends = payload["backends"] + scen = payload["scenarios"] + labels_map = {"geo": "Geometry-Only", "mock": "Mock-Hash", "torch": "Real DINOv2 (ViT-S/14)"} + colors_map = {"geo": "#64748B", "mock": OKABE_ITO[4], "torch": OKABE_ITO[0]} + + fig, axes = plt.subplots(1, 3, figsize=(13.2, 4.0)) + + # Panel A: Crossing ID-switch rate + xs = np.arange(len(backends)) + sw_vals = [scen["crossing_morphology"][b]["mean_id_switch_rate"] * 100.0 for b in backends] + axes[0].bar(xs, sw_vals, color=[colors_map.get(b, OKABE_ITO[0]) for b in backends], width=0.55) + axes[0].set_xticks(xs) + axes[0].set_xticklabels([labels_map.get(b, b) for b in backends], fontsize=8.5, rotation=12) + axes[0].set_ylabel("ID-Switch Rate (%)", fontsize=9) + axes[0].set_title("A. Crossing Tilted Reflections", fontsize=10, fontweight="bold") + for x_i, v in enumerate(sw_vals): + axes[0].text(x_i, v + 0.8, f"{v:.1f}%", ha="center", fontsize=8.5, fontweight="bold") + axes[0].set_ylim(0, max(sw_vals + [10.0]) * 1.25) + apply_axis_style(axes[0]) + + # Panel B: Descriptor Noise Stability (Adjacent Cosine Similarity) + sem_backends = [b for b in backends if b != "geo"] + if sem_backends: + w = 0.25 + s_names = ["crossing_morphology", "intensity_jitter", "mosaic_broadening"] + s_short = ["Crossing", "Flux Jitter", "Mosaic Spread"] + x_s = np.arange(len(s_names)) + for idx_b, b in enumerate(sem_backends): + vals = [scen[sn][b]["mean_cosine_stability"] or 0.0 for sn in s_names] + offset = (idx_b - 0.5 * (len(sem_backends) - 1)) * (w + 0.04) + axes[1].bar( + x_s + offset, + vals, + width=w, + color=colors_map.get(b, OKABE_ITO[2]), + label=labels_map.get(b, b), + ) + axes[1].set_xticks(x_s) + axes[1].set_xticklabels(s_short, fontsize=8.5) + axes[1].set_ylim(-0.15, 1.08) + axes[1].axhline(0.0, color="#94A3B8", linewidth=0.8) + axes[1].set_ylabel("Adjacent-Scan Cosine Similarity", fontsize=9) + axes[1].set_title("B. Descriptor Noise & Drift Invariance", fontsize=10, fontweight="bold") + axes[1].legend(fontsize=8, loc="lower right", frameon=True) + apply_axis_style(axes[1]) + + # Panel C: Beam-Dropout Fragmentation (No Gap vs max_gap=2) + ref_b = "torch" if "torch" in backends else backends[0] + frag_vals = [ + scen["beam_dropout_no_gap"][ref_b]["mean_fragmentation_ratio"] * 100.0, + scen["beam_dropout_gap2"][ref_b]["mean_fragmentation_ratio"] * 100.0, + ] + axes[2].bar([0, 1], frag_vals, color=["#EF4444", OKABE_ITO[2]], width=0.5) + axes[2].set_xticks([0, 1]) + axes[2].set_xticklabels(["max_gap = 0\n(Frame-by-Frame)", "max_gap = 2\n(Gap-Closing)"], fontsize=8.5) + axes[2].set_ylabel("Track Fragmentation Ratio (%)", fontsize=9) + axes[2].set_title("C. Staggered Beam-Dropout Recovery", fontsize=10, fontweight="bold") + for x_i, v in enumerate(frag_vals): + axes[2].text(x_i, v + 1.5, f"{v:.1f}%", ha="center", fontsize=8.5, fontweight="bold") + axes[2].set_ylim(0, max(frag_vals + [20.0]) * 1.25) + apply_axis_style(axes[2]) + + fig.suptitle( + "BraggTrack v0.3.0 Quantitative 4D Diffraction Benchmark Suite", fontsize=11.5, fontweight="bold", y=1.02 + ) + fig.tight_layout() + out_path.parent.mkdir(parents=True, exist_ok=True) + fig.savefig(out_path, dpi=200, bbox_inches="tight") + plt.close(fig) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--backends", default="geo,mock", help="Comma-separated backends from {geo,mock,torch}") + parser.add_argument("--include-torch", action="store_true", help="Append real DINOv2 torch backend") + parser.add_argument("--trials", type=int, default=4, help="Random-seed trials per scenario") + parser.add_argument("--model", default=DEFAULT_DINO_MODEL, help="HuggingFace model ID for torch backend") + parser.add_argument("--json-out", default=None, help="Optional path to write JSON benchmark report") + parser.add_argument("--plot-out", default=None, help="Optional path to write PNG/PDF benchmark summary figure") + args = parser.parse_args(argv) + + backends = [b.strip() for b in args.backends.split(",") if b.strip()] + if args.include_torch and "torch" not in backends: + backends.append("torch") + + payload = run_suite(backends, trials=max(1, args.trials), model_name=args.model) + if args.json_out: + out_j = Path(args.json_out) + out_j.parent.mkdir(parents=True, exist_ok=True) + out_j.write_text(json.dumps(payload, indent=2)) + if args.plot_out: + _save_benchmark_figure(payload, Path(args.plot_out)) + + print(json.dumps(payload, indent=2)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/check_report_and_export_acceptance.py b/scripts/check_report_and_export_acceptance.py new file mode 100644 index 0000000..02ed333 --- /dev/null +++ b/scripts/check_report_and_export_acceptance.py @@ -0,0 +1,223 @@ +"""Report, multi-scan gap-closing, and crystallographic export acceptance gate. + +Acceptance criteria: + 1. Multi-scan gap closing (--max-gap 2) reconnects transient 1-scan beam dropouts + with zero track fragmentation on a controlled dropout sequence. + 2. End-to-end pipeline (braggtrack-run --report --detector-json --export-imaged11 + --export-nexus) executes on bundled ESRF-ID03 operando data and emits: + - Interactive self-contained HTML explorer (report/report.html) + static PNGs + - ImageD11 columnfile (.flt) with physical (tth, eta, d_spacing) columns + - NeXus NXprocess HDF5 summary (.nxs) carrying tracks, kinematics, events, and precursors. +""" + +from __future__ import annotations + +import json +import subprocess +import sys +import tempfile +from pathlib import Path + +import h5py + +_REPO_ROOT = Path(__file__).resolve().parents[1] +if str(_REPO_ROOT) not in sys.path: + sys.path.insert(0, str(_REPO_ROOT)) + +from braggtrack.cli._utils import write_csv +from braggtrack.io import DetectorGeometry, read_imaged11_flt, resolve_dataset_root + +ACCEPTANCE_OUTDIR = Path("artifacts/report_export_acceptance") +DATASET_ROOT = resolve_dataset_root(None) + + +def _check_gap_closing_cli(failures: list[str]) -> dict[str, object]: + with tempfile.TemporaryDirectory() as tmp: + tmp_root = Path(tmp) + seg_dir = tmp_root / "seg" + trk_dir = tmp_root / "trk" + + # Two spots across 4 scans; spot 1 drops out at scan0002 (scan_idx=1) and reappears at scan0003 + scan_specs = [ + [(1, 10.0, 20.0, 30.0), (2, 10.0, 60.0, 60.0)], + [(1, 10.0, 60.2, 60.1)], + [(1, 10.1, 20.3, 30.2), (2, 10.0, 60.4, 60.2)], + [(1, 10.2, 20.5, 30.4), (2, 10.1, 60.6, 60.3)], + ] + for idx, specs in enumerate(scan_specs): + sdir = seg_dir / f"scan{idx + 1:04d}" + sdir.mkdir(parents=True, exist_ok=True) + rows = [ + { + "label": lbl, + "voxel_count": 20, + "integrated_intensity": 500.0, + "centroid_mu": mu, + "centroid_chi": chi, + "centroid_d": d, + "bbox_min_mu": int(mu) - 2, + "bbox_min_d": int(d) - 2, + "bbox_min_chi": int(chi) - 2, + "bbox_max_mu": int(mu) + 3, + "bbox_max_d": int(d) + 3, + "bbox_max_chi": int(chi) + 3, + "cov_00": 1.0, + "cov_01": 0.0, + "cov_02": 0.0, + "cov_11": 1.0, + "cov_12": 0.0, + "cov_22": 1.0, + "eig_1": 1.0, + "eig_2": 1.0, + "eig_3": 1.0, + } + for lbl, mu, chi, d in specs + ] + write_csv(sdir / "features.csv", rows) + + proc = subprocess.run( + [ + sys.executable, + "-m", + "braggtrack.cli.track_dataset", + str(seg_dir), + "--outdir", + str(trk_dir), + "--max-gap", + "2", + ], + check=False, + capture_output=True, + text=True, + ) + if proc.returncode != 0: + failures.append(f"track_dataset --max-gap 2 failed: {proc.stderr.strip() or proc.stdout.strip()}") + return {} + + summary = json.loads(proc.stdout) + if int(summary.get("gap_closed_count", 0)) != 1: + failures.append(f"Expected gap_closed_count==1, got {summary.get('gap_closed_count')}") + if float(summary.get("fragmentation_ratio", 1.0)) != 0.0: + failures.append( + f"Expected fragmentation_ratio==0.0 after gap closing, got {summary.get('fragmentation_ratio')}" + ) + return { + "gap_closed_count": summary.get("gap_closed_count"), + "total_tracks": summary.get("total_tracks"), + "fragmentation_ratio": summary.get("fragmentation_ratio"), + } + + +def _check_pipeline_report_and_exports(failures: list[str]) -> dict[str, object]: + ACCEPTANCE_OUTDIR.mkdir(parents=True, exist_ok=True) + det_json = ACCEPTANCE_OUTDIR / "detector_geometry.json" + flt_path = ACCEPTANCE_OUTDIR / "operando_peaks.flt" + nxs_path = ACCEPTANCE_OUTDIR / "operando_results.nxs" + + geom = DetectorGeometry( + distance_mm=150.0, + pixel_size_y_mm=0.075, + pixel_size_x_mm=0.075, + beam_center_y_px=20.0, + beam_center_x_px=20.0, + wavelength_angstrom=0.50, + omega_origin_deg=10.0, + omega_step_deg=0.05, + ) + geom.save_json(det_json) + + proc = subprocess.run( + [ + sys.executable, + "-m", + "braggtrack.cli.run_pipeline", + str(DATASET_ROOT), + "--outdir", + str(ACCEPTANCE_OUTDIR), + "--backend", + "mock", + "--max-gap", + "1", + "--detector-json", + str(det_json), + "--export-imaged11", + str(flt_path), + "--export-nexus", + str(nxs_path), + "--report", + ], + check=False, + capture_output=True, + text=True, + ) + if proc.returncode != 0: + failures.append(f"run_pipeline --report failed: {proc.stderr.strip() or proc.stdout.strip()}") + return {} + + html_path = ACCEPTANCE_OUTDIR / "report" / "report.html" + if not html_path.exists() or html_path.stat().st_size < 5_000: + failures.append(f"Missing or undersized HTML report: {html_path}") + else: + html_text = html_path.read_text(encoding="utf-8") + if "report.v1" not in html_text or "data:image/png;base64," not in html_text: + failures.append("report.html missing embedded report.v1 payload or base64 MIP thumbnails") + + fig_dir = ACCEPTANCE_OUTDIR / "report" / "figures" + expected_figs = ("lineage_dag.png", "kinematics_dashboard.png", "precursor_timeline.png") + for fname in expected_figs: + fpath = fig_dir / fname + if not fpath.exists() or fpath.stat().st_size < 1_000: + failures.append(f"Missing or empty report figure: {fpath}") + + if not flt_path.exists(): + failures.append(f"Missing ImageD11 export: {flt_path}") + flt_rows = [] + else: + flt_params, flt_rows = read_imaged11_flt(flt_path) + if "wavelength" not in flt_params: + failures.append("ImageD11 .flt header missing wavelength parameter") + if not flt_rows: + failures.append("ImageD11 .flt export contained 0 rows") + else: + for col in ("sc", "fc", "omega", "tth", "eta", "d_spacing", "track_id"): + if col not in flt_rows[0]: + failures.append(f"ImageD11 .flt missing column {col}") + if float(flt_rows[0].get("d_spacing", 0.0)) <= 0.0: + failures.append("ImageD11 .flt d_spacing must be positive when DetectorGeometry is provided") + + if not nxs_path.exists(): + failures.append(f"Missing NeXus HDF5 export: {nxs_path}") + else: + with h5py.File(nxs_path, "r") as h5: + if h5.attrs.get("NX_class") != "NXroot": + failures.append("NeXus root missing NX_class=NXroot") + if "/entry/braggtrack" not in h5: + failures.append("NeXus file missing /entry/braggtrack NXprocess group") + else: + grp = h5["/entry/braggtrack"] + for sub in ("tracks", "kinematics", "events", "precursors"): + if sub not in grp: + failures.append(f"NeXus /entry/braggtrack missing {sub} table group") + + return { + "html_report_bytes": html_path.stat().st_size if html_path.exists() else 0, + "flt_row_count": len(flt_rows), + "nexus_bytes": nxs_path.stat().st_size if nxs_path.exists() else 0, + } + + +def main() -> int: + failures: list[str] = [] + gap_report = _check_gap_closing_cli(failures) + export_report = _check_pipeline_report_and_exports(failures) + payload = { + "gap_closing": gap_report, + "report_and_exports": export_report, + "failures": failures, + } + print(json.dumps(payload, indent=2)) + return 0 if not failures else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/ci_report.py b/scripts/ci_report.py index 97ae603..3f78024 100644 --- a/scripts/ci_report.py +++ b/scripts/ci_report.py @@ -131,7 +131,12 @@ def main() -> int: ) evt_ok = evt_ok_cmd and isinstance(evt_payload, dict) and evt_payload.get("failures") == [] - all_ok = unit_ok and acc_ok and smoke_ok and seg_ok and trk_ok and emb_ok and dino_ok and evt_ok + rep_ok_cmd, rep_payload, _ = run_cmd_json( + [sys.executable, "scripts/check_report_and_export_acceptance.py"], "Report & Export Acceptance" + ) + rep_ok = rep_ok_cmd and isinstance(rep_payload, dict) and rep_payload.get("failures") == [] + + all_ok = unit_ok and acc_ok and smoke_ok and seg_ok and trk_ok and emb_ok and dino_ok and evt_ok and rep_ok print("\n=== Summary ===") print(f"unit_tests={'PASS' if unit_ok else 'FAIL'}") print(f"io_acceptance={'PASS' if acc_ok else 'FAIL'}") @@ -141,6 +146,7 @@ def main() -> int: print(f"embedding_acceptance={'PASS' if emb_ok else 'FAIL'}") print(f"dino_acceptance={'PASS' if dino_ok else 'FAIL'}") print(f"events_acceptance={'PASS' if evt_ok else 'FAIL'}") + print(f"report_and_export_acceptance={'PASS' if rep_ok else 'FAIL'}") print(f"overall={'PASS' if all_ok else 'FAIL'}") return 0 if all_ok else 1 diff --git a/scripts/generate_paper_figures.py b/scripts/generate_paper_figures.py new file mode 100644 index 0000000..3b874bc --- /dev/null +++ b/scripts/generate_paper_figures.py @@ -0,0 +1,261 @@ +#!/usr/bin/env python3 +"""Generate publication-grade composite figures for paper.md and README.md.""" + +from __future__ import annotations + +import argparse +import sys +from pathlib import Path + +import matplotlib +import numpy as np + +matplotlib.use("Agg", force=False) +import matplotlib.pyplot as plt # noqa: E402 + +REPO = Path(__file__).resolve().parents[1] +if str(REPO) not in sys.path: + sys.path.insert(0, str(REPO)) + +from braggtrack.io import AxisCalibration, discover_operando_scans, load_primary_volume, sample_operando_root # noqa: E402 +from braggtrack.segmentation import ( # noqa: E402 + extract_instance_table, + fill_holes_binary, + merge_nearby_labels, + otsu_threshold, + relabel_sequential, + remove_small_objects, + segment_classical, + smooth_thresholds, +) +from braggtrack.semantic import make_patch_encoder # noqa: E402 +from braggtrack.tracking import ( # noqa: E402 + PositionShapeCost, + PrecursorConfig, + SplitMergeConfig, + build_tracks, + compute_fracture_precursors, + compute_grain_kinematics, + events_to_table, + generate_fracture_scenario, + tracks_to_table, +) +from braggtrack.viz._style import OKABE_ITO, apply_axis_style # noqa: E402 + + +def build_fracture_and_operando_figure(out_path: Path, *, backend: str = "auto") -> None: + # 1. Synthetic 4D chemomechanical fracture + merge + persistent precursor decomposition + vols, labs, tables, _ = generate_fracture_scenario(n_scans=5, seed=42) + G_frac = build_tracks( + tables, + cost_fn=PositionShapeCost(), + split_merge_config=SplitMergeConfig(max_distance=20.0), + ) + events = G_frac.graph["lineage_events"] + ev_rows = events_to_table(events) + frac_rows = tracks_to_table(G_frac) + cands, obs_scores = compute_fracture_precursors( + frac_rows, + PrecursorConfig(score_threshold=0.35, min_persistence=2), + volumes=vols, + label_volumes=labs, + patch_encoder=make_patch_encoder(backend), + lineage_events=events, + ) + + # 2. Real ESRF-ID03 operando cathode sequence with physical calibration + cal = AxisCalibration( + mu_origin=12.0, + mu_step=0.02, + chi_origin=-2.5, + chi_step=0.015, + d_origin=2.065, + d_step=-0.00015, + calibrated=True, + ) + scans = discover_operando_scans(sample_operando_root()) + op_vols = [load_primary_volume(s.path) for s in scans] + sm_thr = smooth_thresholds([otsu_threshold(v.ravel()) for v in op_vols], window=5) + op_tables = [] + for v, thr in zip(op_vols, sm_thr): + res = segment_classical( + v, + threshold=float(thr), + blur_passes=1, + h_value=0.1, + min_seed_separation=2, + seed_peak_fraction=0.2, + seed_response_percentile=99.95, + ) + lb = remove_small_objects(res.labeled_volume, min_size=8) + lb = np.where(fill_holes_binary(lb > 0), lb, 0) + lb = relabel_sequential(merge_nearby_labels(lb, v, max_centroid_distance=15)) + op_tables.append(extract_instance_table(lb, v, calibration=cal)) + + G_op = build_tracks(op_tables, cost_fn=PositionShapeCost(gate_mu=2.0, gate_chi=2.0, gate_d=0.05)) + gks = compute_grain_kinematics(tracks_to_table(G_op)) + + fig, axes = plt.subplots(2, 2, figsize=(12.6, 8.2)) + ax_dag, ax_mip = axes[0] + ax_prec, ax_op = axes[1] + + # Panel A: 4D Lineage DAG (Split 1->2 & Merge 2->1) + by_track: dict[int, list[dict]] = {} + node_pos: dict[tuple[int, int], tuple[float, float]] = {} + for r in frac_rows: + tid = int(r["track_id"]) + sidx = int(r["scan_idx"]) + by_track.setdefault(tid, []).append(r) + node_pos[(tid, sidx)] = (float(sidx), float(r["centroid_d"])) + + for idx_t, (tid, obs) in enumerate(sorted(by_track.items())): + obs.sort(key=lambda x: int(x["scan_idx"])) + col = OKABE_ITO[idx_t % len(OKABE_ITO)] + xs = [int(x["scan_idx"]) for x in obs] + ys = [float(x["centroid_d"]) for x in obs] + ax_dag.plot(xs, ys, "o-", color=col, linewidth=2.0, markersize=6.5, label=f"T{tid}") + + for ev in ev_rows: + etype = ev["event_type"] + s_from, s_to = int(ev["scan_idx_from"]), int(ev["scan_idx_to"]) + pids = [int(p) for p in str(ev["parent_track_ids"]).split(";") if p] + cids = [int(c) for c in str(ev["child_track_ids"]).split(";") if c] + ecol = "#DC2626" if etype == "split" else "#059669" + ls = "--" if etype == "split" else "-." + for pid in pids: + for cid in cids: + if (pid, s_from) in node_pos and (cid, s_to) in node_pos: + x0, y0 = node_pos[(pid, s_from)] + x1, y1 = node_pos[(cid, s_to)] + ax_dag.plot([x0, x1], [y0, y1], linestyle=ls, color=ecol, linewidth=2.1) + ax_dag.annotate( + etype.upper(), + xy=((x0 + x1) / 2, (y0 + y1) / 2), + fontsize=7.5, + fontweight="bold", + color=ecol, + bbox={"boxstyle": "round,pad=0.18", "fc": "white", "ec": ecol, "alpha": 0.9}, + ) + ax_dag.set_title("A. 4D Trajectory Lineage DAG (1→2 Split & 2→1 Merge)", fontsize=10, fontweight="bold") + ax_dag.set_xlabel("Scan index", fontsize=9) + ax_dag.set_ylabel("Reciprocal-space position d (voxel)", fontsize=9) + ax_dag.legend(fontsize=7.5, ncol=3, loc="upper left", frameon=True) + apply_axis_style(ax_dag) + + # Panel B: Pre-split bimodal broadening vs post-split cleavage MIP strip + # Show scan 0 (incipient), scan 1 (bimodal precursor), scan 2 (cleaved daughters) + strip_imgs = [] + for s_i in (0, 1, 2): + # Crop region around the fracturing grain (d ~ 10..26, chi ~ 12..28) + mip_patch = vols[s_i].max(axis=0)[6:28, 10:30] + mip_norm = mip_patch / max(float(mip_patch.max()), 1e-6) + strip_imgs.append(mip_norm) + sep = np.ones((strip_imgs[0].shape[0], 2), dtype=np.float64) * 0.95 + montage = np.concatenate([strip_imgs[0], sep, strip_imgs[1], sep, strip_imgs[2]], axis=1) + im = ax_mip.imshow(montage, cmap="magma", origin="lower", aspect="auto", vmin=0.0, vmax=1.0) + w_p = strip_imgs[0].shape[1] + ax_mip.set_xticks([w_p * 0.5, w_p * 1.5 + 2, w_p * 2.5 + 4]) + ax_mip.set_xticklabels( + ["Scan 0\n(Incipient)", "Scan 1\n(Bimodal Precursor)", "Scan 2\n(1→2 Cleavage)"], fontsize=8.5 + ) + ax_mip.set_yticks([]) + ax_mip.set_title("B. Reciprocal-Space Reflection Broadening to Cleavage (μ-MIP)", fontsize=10, fontweight="bold") + fig.colorbar(im, ax=ax_mip, fraction=0.042, pad=0.03, label="Normalized intensity") + + # Panel C: Persistent Precursor Decomposition (Fracturing Grain vs Control) + top_tid = cands[0].track_id if cands else 0 + top_obs = sorted([o for o in obs_scores if o.track_id == top_tid], key=lambda o: o.scan_idx) + ctrl_tids = [ + tid + for tid in sorted({o.track_id for o in obs_scores}) + if tid != top_tid and len([o for o in obs_scores if o.track_id == tid]) == 5 + ] + ctrl_tid = ctrl_tids[0] if ctrl_tids else top_tid + ctrl_obs = sorted([o for o in obs_scores if o.track_id == ctrl_tid], key=lambda o: o.scan_idx) + + ax_prec.plot( + [o.scan_idx for o in top_obs], + [o.precursor_score for o in top_obs], + "o-", + color="#DC2626", + linewidth=2.3, + markersize=6.5, + label=f"Fracturing grain (T{top_tid} composite)", + ) + ax_prec.plot( + [o.scan_idx for o in top_obs], + [o.roi_dispersion_term for o in top_obs], + "^--", + color=OKABE_ITO[0], + linewidth=1.6, + label=f"T{top_tid} 3D sub-peak + DINO patch dispersion", + ) + ax_prec.plot( + [o.scan_idx for o in ctrl_obs], + [o.precursor_score for o in ctrl_obs], + "s-", + color="#64748B", + linewidth=1.8, + markersize=5.5, + label=f"Stable control grain (T{ctrl_tid})", + ) + ax_prec.axhline(0.35, linestyle=":", color="#475569", linewidth=1.2, label="Persistence threshold") + ax_prec.axvline(1.5, linestyle="--", color="#DC2626", alpha=0.65, linewidth=1.2, label="Cleavage onset") + ax_prec.set_ylim(-0.03, 1.05) + ax_prec.set_xticks(range(5)) + ax_prec.set_xlabel("Scan index", fontsize=9) + ax_prec.set_ylabel("Precursor score [0, 1]", fontsize=9) + ax_prec.set_title("C. Persistent Precursor Ranking vs. Control Grain", fontsize=10, fontweight="bold") + ax_prec.legend(fontsize=7.8, loc="upper right", frameon=True) + apply_axis_style(ax_prec) + + # Panel D: Bundled ESRF-ID03 Operando Multi-Scan Grain Kinematics + multi_gks = [g for g in gks if len(g.scan_indices) >= 2] + for idx_g, gk in enumerate(multi_gks[:6]): + col = OKABE_ITO[idx_g % len(OKABE_ITO)] + ax_op.plot( + gk.scan_indices, + 100.0 * gk.strain, + "o-", + color=col, + linewidth=1.9, + markersize=5.5, + label=f"ESRF T{gk.track_id} (I0={gk.integrated_intensity[0]:.0f})", + ) + ax_op.axhline(0.0, color="#94A3B8", linewidth=0.9) + ax_op.set_xticks([0, 1, 2]) + ax_op.set_xticklabels(["scan0001", "scan0002", "scan0003"], fontsize=8.5) + ax_op.set_xlabel("ESRF-ID03 Operando Scan", fontsize=9) + ax_op.set_ylabel(r"Calibrated lattice strain $\varepsilon = \Delta d / d_0$ (%)", fontsize=9) + ax_op.set_title("D. ESRF-ID03 Ni-Rich Cathode Per-Grain Strain Trajectories", fontsize=10, fontweight="bold") + ax_op.legend(fontsize=7.5, ncol=2, loc="best", frameon=True) + apply_axis_style(ax_op) + + fig.suptitle( + "BraggTrack: 4D Chemomechanical Fracture Lineage, Precursor Scoring & Operando Kinematics", + fontsize=11.5, + fontweight="bold", + y=1.01, + ) + fig.tight_layout() + out_path.parent.mkdir(parents=True, exist_ok=True) + fig.savefig(out_path, dpi=200, bbox_inches="tight") + plt.close(fig) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--out", + default="docs/figures/fracture_lineage_and_precursors.png", + help="Output PNG/PDF path", + ) + parser.add_argument("--backend", default="auto", choices=("auto", "mock", "torch")) + args = parser.parse_args(argv) + build_fracture_and_operando_figure(Path(args.out), backend=args.backend) + print(f"Saved {args.out}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/test_benchmark_suite.py b/tests/test_benchmark_suite.py new file mode 100644 index 0000000..ad45422 --- /dev/null +++ b/tests/test_benchmark_suite.py @@ -0,0 +1,69 @@ +from __future__ import annotations + +import json +import sys +import tempfile +import unittest +from pathlib import Path + +_REPO = Path(__file__).resolve().parents[1] +if str(_REPO) not in sys.path: + sys.path.insert(0, str(_REPO)) + +from scripts.benchmark_suite import main as benchmark_main # noqa: E402 +from scripts.benchmark_suite import run_suite # noqa: E402 + + +class BenchmarkSuiteTests(unittest.TestCase): + def test_run_suite_geo_and_mock_smoke(self) -> None: + payload = run_suite(["geo", "mock"], trials=1) + self.assertEqual(payload["schema_version"], "benchmark_suite.v1") + self.assertEqual(payload["backends"], ["geo", "mock"]) + scenarios = payload["scenarios"] + for expected in ( + "crossing_morphology", + "intensity_jitter", + "mosaic_broadening", + "beam_dropout_no_gap", + "beam_dropout_gap2", + "chemomechanical_fracture", + ): + self.assertIn(expected, scenarios) + self.assertIn("geo", scenarios[expected]) + self.assertIn("mock", scenarios[expected]) + + # Gap-closing recovers both staggered 1-scan dropouts on geometry backend + self.assertEqual(scenarios["beam_dropout_no_gap"]["geo"]["mean_gap_closed_count"], 0.0) + self.assertEqual(scenarios["beam_dropout_gap2"]["geo"]["mean_gap_closed_count"], 2.0) + self.assertLess( + scenarios["beam_dropout_gap2"]["geo"]["mean_fragmentation_ratio"], + scenarios["beam_dropout_no_gap"]["geo"]["mean_fragmentation_ratio"], + ) + + def test_cli_writes_json_and_plot(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + tmp_path = Path(tmp) + json_out = tmp_path / "bench.json" + plot_out = tmp_path / "bench.png" + rc = benchmark_main( + [ + "--backends", + "geo,mock", + "--trials", + "1", + "--json-out", + str(json_out), + "--plot-out", + str(plot_out), + ] + ) + self.assertEqual(rc, 0) + self.assertTrue(json_out.exists()) + self.assertTrue(plot_out.exists()) + self.assertGreater(plot_out.stat().st_size, 5_000) + parsed = json.loads(json_out.read_text()) + self.assertEqual(parsed["trials"], 1) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_gap_closing.py b/tests/test_gap_closing.py new file mode 100644 index 0000000..23d9017 --- /dev/null +++ b/tests/test_gap_closing.py @@ -0,0 +1,151 @@ +"""Unit tests for multi-scan gap closing (beam-dropout & rocking-clip recovery).""" + +from __future__ import annotations + +import unittest + +import numpy as np + +from braggtrack.tracking import ( + GapClosingConfig, + GeometrySemanticCost, + PositionShapeCost, + SplitMergeConfig, + build_tracks, + compute_tracking_metrics, + tracks_to_table, +) + + +def _spot( + label: int, + mu: float, + chi: float, + d: float, + intensity: float = 1000.0, + eig1: float = 2.0, + eig2: float = 1.5, + eig3: float = 1.2, + embedding: np.ndarray | None = None, +) -> dict: + row = { + "label": label, + "centroid_mu": mu, + "centroid_chi": chi, + "centroid_d": d, + "integrated_intensity": intensity, + "voxel_count": 25, + "eig_1": eig1, + "eig_2": eig2, + "eig_3": eig3, + } + if embedding is not None: + row["embedding"] = embedding + return row + + +class GapClosingTests(unittest.TestCase): + def test_one_scan_beam_dropout_reconnected(self) -> None: + """A reflection missing at scan 2 (0, 1, -, 3, 4) bridges into 1 end-to-end track.""" + scans = [ + [_spot(1, 10.0, 20.0, 30.0)], + [_spot(1, 10.0, 20.0, 31.0)], + [], # beam dropout at scan 2 + [_spot(1, 10.0, 20.0, 33.0)], + [_spot(1, 10.0, 20.0, 34.0)], + ] + + G_no_gap = build_tracks(scans) + m_no_gap = compute_tracking_metrics(G_no_gap, n_scans=5) + self.assertEqual(m_no_gap["total_tracks"], 2) + self.assertEqual(m_no_gap["gap_closed_count"], 0) + self.assertEqual(m_no_gap["fragmentation_ratio"], 1.0) + + G_gap = build_tracks(scans, gap_closing_config=GapClosingConfig(max_gap=2, max_cost=20.0)) + m_gap = compute_tracking_metrics(G_gap, n_scans=5) + self.assertEqual(m_gap["total_tracks"], 1) + self.assertEqual(m_gap["gap_closed_count"], 1) + self.assertEqual(m_gap["full_length_tracks"], 1) + self.assertEqual(m_gap["fragmentation_ratio"], 0.0) + + gap_edges = [(u, v, d) for u, v, d in G_gap.edges(data=True) if d.get("edge_type") == "gap_close"] + self.assertEqual(len(gap_edges), 1) + self.assertEqual(gap_edges[0][2]["gap_scans"], 1) + + def test_two_scan_dropout_respects_max_gap_limit(self) -> None: + """A 2-scan gap is ignored when max_gap=1 and bridged when max_gap=2.""" + scans = [ + [_spot(1, 5.0, 5.0, 10.0)], + [], + [], + [_spot(1, 5.0, 5.0, 11.5)], + ] + + G_g1 = build_tracks(scans, gap_closing_config=GapClosingConfig(max_gap=1, max_cost=20.0)) + self.assertEqual(compute_tracking_metrics(G_g1, n_scans=4)["total_tracks"], 2) + + G_g2 = build_tracks(scans, gap_closing_config=GapClosingConfig(max_gap=2, max_cost=20.0)) + m_g2 = compute_tracking_metrics(G_g2, n_scans=4) + self.assertEqual(m_g2["total_tracks"], 1) + self.assertEqual(m_g2["gap_closed_count"], 1) + + def test_chained_multi_dropouts_preserve_single_track_id(self) -> None: + """Repeated dropouts (0 -> 2 -> 4) propagate the initial track_id chronologically.""" + scans = [ + [_spot(1, 12.0, 15.0, 20.0)], + [], + [_spot(1, 12.0, 15.0, 21.0)], + [], + [_spot(1, 12.0, 15.0, 22.0)], + ] + G = build_tracks(scans, gap_closing_config=GapClosingConfig(max_gap=1, max_cost=20.0)) + rows = tracks_to_table(G) + self.assertEqual({r["track_id"] for r in rows}, {1}) + self.assertEqual(compute_tracking_metrics(G, n_scans=5)["gap_closed_count"], 2) + + def test_semantic_cosine_gate_blocks_impostor_and_severs_stray_jump(self) -> None: + """Semantic embeddings block dissimilar gap matches and sever stray intermediate noise jumps.""" + e_grain = np.array([1.0, 0.0, 0.0], dtype=np.float64) + e_noise = np.array([0.0, 1.0, 0.0], dtype=np.float64) + + # Grain 1 at (10, 10, 10) drops out at scan 1 while a distant noise spot appears at (80, 80, 80). + scans = [ + [_spot(1, 10.0, 10.0, 10.0, embedding=e_grain)], + [_spot(1, 80.0, 80.0, 80.0, embedding=e_noise)], + [_spot(1, 10.0, 10.0, 10.5, embedding=e_grain)], + ] + cost_fn = GeometrySemanticCost(PositionShapeCost(), cost_alpha=1.0, cost_beta=2.0) + G = build_tracks( + scans, + cost_fn=cost_fn, + gap_closing_config=GapClosingConfig(max_gap=1, max_cost=15.0, min_cosine_similarity=0.8), + ) + m = compute_tracking_metrics(G, n_scans=3) + self.assertEqual(m["gap_closed_count"], 1) + self.assertEqual(m["total_tracks"], 2) # Grain 1 (scans 0, 2) + isolated noise (scan 1) + + def test_gap_closing_composes_cleanly_before_split_resolution(self) -> None: + """A track that recovers from a 1-scan dropout and later splits 1->2 resolves both events.""" + scans = [ + [_spot(1, 20.0, 20.0, 20.0, intensity=1000.0)], + [], # dropout at scan 1 + [_spot(1, 20.0, 20.0, 20.5, intensity=1000.0)], + [ + _spot(1, 20.0, 18.0, 21.0, intensity=520.0), + _spot(2, 20.0, 22.0, 21.0, intensity=480.0), + ], + ] + G = build_tracks( + scans, + gap_closing_config=GapClosingConfig(max_gap=1, max_cost=20.0), + split_merge_config=SplitMergeConfig(max_distance=15.0), + ) + m = compute_tracking_metrics(G, n_scans=4) + self.assertEqual(m["gap_closed_count"], 1) + self.assertEqual(m["split_count"], 1) + ev = G.graph["lineage_events"][0] + self.assertEqual(ev.parent_track_ids, (1,)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_lazy_and_export.py b/tests/test_lazy_and_export.py new file mode 100644 index 0000000..daa4752 --- /dev/null +++ b/tests/test_lazy_and_export.py @@ -0,0 +1,199 @@ +"""Unit tests for LazyVolume ROI streaming, chunked Otsu, crystallography, and ImageD11/NeXus exports.""" + +from __future__ import annotations + +import json +import math +import tempfile +import unittest +from pathlib import Path + +import h5py +import numpy as np + +from braggtrack.cli import track_dataset +from braggtrack.cli._utils import write_csv +from braggtrack.io import ( + AxisCalibration, + DetectorGeometry, + LazyVolume, + annotate_crystallographic_columns, + export_imaged11_flt, + export_nexus_process, + open_lazy_volume, + otsu_threshold_chunked, + read_imaged11_flt, +) +from braggtrack.segmentation import otsu_threshold +from braggtrack.semantic import crop_spot_cube + + +class LazyAndExportTests(unittest.TestCase): + def test_lazy_volume_roi_and_chunked_otsu_parity(self) -> None: + rng = np.random.default_rng(42) + vol = (rng.exponential(scale=2.0, size=(20, 32, 28)) * 10.0).astype(np.float32) + vol[6:10, 12:18, 10:15] += 250.0 + + labels = np.zeros_like(vol, dtype=np.int32) + labels[6:10, 12:18, 10:15] = 1 + bbox = { + "bbox_min_z": 6, + "bbox_max_z": 9, + "bbox_min_y": 12, + "bbox_max_y": 17, + "bbox_min_x": 10, + "bbox_max_x": 14, + } + + with tempfile.TemporaryDirectory() as tmp: + h5_path = Path(tmp) / "test_vol.h5" + with h5py.File(h5_path, "w") as h5: + h5.create_dataset("/entry_0000/ESRF-ID03/pco_nf/data", data=vol, chunks=(5, 16, 14)) + + with open_lazy_volume(h5_path) as lazy: + self.assertEqual(lazy.shape, vol.shape) + self.assertEqual(lazy.dataset_path, "/entry_0000/ESRF-ID03/pco_nf/data") + + roi_lazy, mask_lazy = crop_spot_cube(lazy, labels, 1, bbox, margin=2) + roi_dense, mask_dense = crop_spot_cube(vol.astype(np.float64), labels, 1, bbox, margin=2) + np.testing.assert_allclose(roi_lazy, roi_dense) + np.testing.assert_array_equal(mask_lazy, mask_dense) + + thr_chunked = otsu_threshold_chunked(lazy, chunk_z=5) + thr_dense = otsu_threshold(vol) + self.assertAlmostEqual(thr_chunked, thr_dense, places=5) + + # Constant-volume edge case + const_lazy = LazyVolume.from_array(np.full((4, 4, 4), 7.5)) + self.assertEqual(otsu_threshold_chunked(const_lazy), 7.5) + + def test_detector_geometry_bragg_law_identities(self) -> None: + geom = DetectorGeometry( + distance_mm=100.0, + pixel_size_y_mm=0.1, + pixel_size_x_mm=0.1, + beam_center_y_px=500.0, + beam_center_x_px=500.0, + wavelength_angstrom=0.5, + omega_origin_deg=-10.0, + omega_step_deg=0.5, + ) + # Offset by dx = 30 mm, dy = 40 mm => r = 50 mm at L = 100 mm => tan(2theta) = 0.5 + scat = geom.spot_to_scattering(z_idx=20.0, y_px=900.0, x_px=800.0) + expected_tth = math.degrees(math.atan2(50.0, 100.0)) + expected_d = 0.5 / (2.0 * math.sin(0.5 * math.radians(expected_tth))) + expected_q = (2.0 * math.pi) / expected_d + + self.assertAlmostEqual(scat["omega_deg"], 0.0, places=5) + self.assertAlmostEqual(scat["two_theta_deg"], expected_tth, places=5) + self.assertAlmostEqual(scat["d_spacing_angstrom"], expected_d, places=5) + self.assertAlmostEqual(scat["q_mag_inv_angstrom"], expected_q, places=5) + + # Verify rotational invariance of |Q| across arbitrary omega + scat_rot = geom.spot_to_scattering(z_idx=73.0, y_px=900.0, x_px=800.0) + self.assertAlmostEqual(scat_rot["q_mag_inv_angstrom"], expected_q, places=5) + + # Verify calibration inversion parity + cal = AxisCalibration( + mu_origin=-10.0, mu_step=0.5, chi_origin=0.0, chi_step=0.02, d_origin=1.0, d_step=0.01, calibrated=True + ) + mu_phys, chi_phys, d_phys = cal.voxel_to_physical(20.0, 900.0, 800.0) + annotated = annotate_crystallographic_columns( + [{"centroid_mu": mu_phys, "centroid_chi": chi_phys, "centroid_d": d_phys}], + geom, + calibration=cal, + ) + self.assertAlmostEqual(annotated[0]["d_spacing_angstrom"], expected_d, places=5) + + def test_imaged11_and_nexus_exports_via_cli(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + seg_dir = root / "seg" + for s_idx in range(3): + sd = seg_dir / f"scan{s_idx + 1:04d}" + sd.mkdir(parents=True) + write_csv( + sd / "features.csv", + [ + { + "label": 1, + "voxel_count": 30, + "integrated_intensity": 1200.0 + 10.0 * s_idx, + "centroid_mu": 5.0, + "centroid_chi": 620.0, + "centroid_d": 580.0 + 0.5 * s_idx, + "eig_1": 2.0, + "eig_2": 1.4, + "eig_3": 1.1, + "bbox_min_z": 3, + "bbox_max_z": 7, + "bbox_min_y": 577, + "bbox_max_y": 583, + "bbox_min_x": 617, + "bbox_max_x": 623, + } + ], + ) + (sd / "summary.json").write_text(json.dumps({"calibration": {"calibrated": False}})) + + geom_path = root / "detector.json" + geom_path.write_text( + json.dumps( + { + "distance_mm": 120.0, + "pixel_size_y_mm": 0.075, + "pixel_size_x_mm": 0.075, + "beam_center_y_px": 512.0, + "beam_center_x_px": 512.0, + "wavelength_angstrom": 0.31, + "omega_origin_deg": 0.0, + "omega_step_deg": 0.1, + } + ) + ) + flt_path = root / "peaks.flt" + nxs_path = root / "results.nxs" + trk_dir = root / "tracking" + + rc = track_dataset.main( + [ + str(seg_dir), + "--outdir", + str(trk_dir), + "--detect-events", + "--detector-json", + str(geom_path), + "--export-imaged11", + str(flt_path), + "--export-nexus", + str(nxs_path), + ] + ) + self.assertEqual(rc, 0) + + hdr, flt_rows = read_imaged11_flt(flt_path) + self.assertEqual(len(flt_rows), 3) + self.assertAlmostEqual(float(hdr["wavelength"]), 0.31, places=5) + self.assertTrue(all(r["tth"] > 0.0 and r["d_spacing"] > 0.0 for r in flt_rows)) + + with h5py.File(nxs_path, "r") as h5: + self.assertEqual(h5.attrs["NX_class"], "NXroot") + self.assertEqual(h5["/entry"].attrs["NX_class"], "NXentry") + self.assertEqual(h5["/entry/braggtrack"].attrs["NX_class"], "NXprocess") + self.assertEqual(int(h5["/entry/braggtrack/tracks"].attrs["row_count"]), 3) + self.assertIn("two_theta_deg", h5["/entry/braggtrack/tracks"]) + self.assertIn("strain", h5["/entry/braggtrack/kinematics"]) + self.assertIn("delta_d", h5["/entry/braggtrack/kinematics"]) + + # Direct export helper check + nxs_direct = export_nexus_process(trk_dir, root / "direct.nxs") + self.assertTrue(nxs_direct.exists()) + flt_direct = export_imaged11_flt( + [{"centroid_mu": 5.0, "centroid_chi": 620.0, "centroid_d": 580.0, "integrated_intensity": 500.0}], + root / "direct.flt", + ) + self.assertTrue(flt_direct.exists()) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_report_and_export_acceptance.py b/tests/test_report_and_export_acceptance.py new file mode 100644 index 0000000..5095a03 --- /dev/null +++ b/tests/test_report_and_export_acceptance.py @@ -0,0 +1,26 @@ +from __future__ import annotations + +import json +import subprocess +import sys +import unittest + + +class ReportAndExportAcceptanceTests(unittest.TestCase): + def test_report_and_export_acceptance_passes(self) -> None: + proc = subprocess.run( + [sys.executable, "scripts/check_report_and_export_acceptance.py"], + check=False, + capture_output=True, + text=True, + ) + self.assertEqual(proc.returncode, 0, msg=proc.stdout + proc.stderr) + payload = json.loads(proc.stdout) + self.assertEqual(payload["failures"], []) + self.assertEqual(payload["gap_closing"]["gap_closed_count"], 1) + self.assertGreater(payload["report_and_exports"]["html_report_bytes"], 5_000) + self.assertGreater(payload["report_and_exports"]["flt_row_count"], 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_segmentation_dino.py b/tests/test_segmentation_dino.py index 7a65857..3dfc843 100644 --- a/tests/test_segmentation_dino.py +++ b/tests/test_segmentation_dino.py @@ -146,6 +146,30 @@ def test_labels_are_nonnegative(self) -> None: result = segment_dino(volume, backend="mock") self.assertTrue(np.all(result.labeled_volume >= 0)) + def test_resized_vit_grid_alignment(self) -> None: + """Simulate ViT 224x224 image resizing (16x16 tokens) on non-multiple slice shapes.""" + from unittest.mock import patch + + class _ResizedViTEncoder: + patch_size = 14 + feature_dim = 16 + + def extract_patch_features(self, image: np.ndarray) -> np.ndarray: + rng = np.random.default_rng(int(np.sum(image > 5.0))) + grid = rng.standard_normal((16, 16, 16)).astype(np.float32) + grid[10:15, 10:15, :] += 8.0 + norms = np.linalg.norm(grid, axis=-1, keepdims=True) + 1e-8 + return grid / norms + + volume = np.zeros((4, 250, 250), dtype=np.float64) + volume[1:3, 180:240, 180:240] = 25.0 + with patch("braggtrack.semantic.dino.make_patch_encoder", return_value=_ResizedViTEncoder()): + result = segment_dino(volume, backend="mock", min_cluster_size=2, min_samples=1) + self.assertEqual(result.labeled_volume.shape, (4, 250, 250)) + self.assertGreaterEqual(result.component_count, 1) + # Ensure spots near the far corner (> 16 * 14 = 224) receive foreground labels via proportional upsampling + self.assertGreater(int(np.count_nonzero(result.labeled_volume[1:3, 225:240, 225:240])), 0) + if __name__ == "__main__": unittest.main() diff --git a/tests/test_viz_and_report.py b/tests/test_viz_and_report.py new file mode 100644 index 0000000..ad45488 --- /dev/null +++ b/tests/test_viz_and_report.py @@ -0,0 +1,134 @@ +"""Unit and CLI tests for braggtrack.viz plotting functions and braggtrack-report HTML explorer.""" + +from __future__ import annotations + +import json +import tempfile +import unittest +from pathlib import Path + +import h5py +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import numpy as np + +from braggtrack.cli import report_dataset, run_pipeline +from braggtrack.tracking import ( + PrecursorConfig, + SplitMergeConfig, + build_tracks, + compute_fracture_precursors, + compute_grain_kinematics, + generate_fracture_scenario, + tracks_to_table, +) +from braggtrack.viz import ( + generate_html_report, + plot_kinematics_dashboard, + plot_lineage_dag, + plot_precursor_timeline, + plot_scan_projection_overlay, + plot_spot_mip_card, +) + + +class VizAndReportTests(unittest.TestCase): + def test_all_matplotlib_plots_render_and_save(self) -> None: + volumes, label_volumes, scan_tables, _ = generate_fracture_scenario() + G = build_tracks(scan_tables, split_merge_config=SplitMergeConfig(max_distance=20.0)) + track_rows = tracks_to_table(G) + gks = compute_grain_kinematics(track_rows) + candidates, obs_scores = compute_fracture_precursors( + track_rows, + PrecursorConfig(score_threshold=0.35, min_persistence=2), + volumes=volumes, + label_volumes=label_volumes, + lineage_events=G.graph["lineage_events"], + ) + + with tempfile.TemporaryDirectory() as tmp: + out = Path(tmp) + fig1, _ = plot_lineage_dag(G, save_path=out / "dag.png") + plt.close(fig1) + self.assertTrue((out / "dag.png").stat().st_size > 1000) + + fig2, _ = plot_kinematics_dashboard( + gks, events=G.graph["lineage_events"], calibrated=True, save_path=out / "kin.png" + ) + plt.close(fig2) + self.assertTrue((out / "kin.png").stat().st_size > 1000) + + fig3, _ = plot_precursor_timeline(obs_scores, candidates=candidates, save_path=out / "prec.png") + plt.close(fig3) + self.assertTrue((out / "prec.png").stat().st_size > 1000) + + spot0 = scan_tables[0][0] + fig4, _ = plot_spot_mip_card( + volumes[0], label_volumes[0], int(spot0["label"]), spot0, save_path=out / "mip.png" + ) + plt.close(fig4) + self.assertTrue((out / "mip.png").stat().st_size > 1000) + + fig5, _ = plot_scan_projection_overlay( + volumes[0], label_volumes[0], scan_tables[0], save_path=out / "proj.png" + ) + plt.close(fig5) + self.assertTrue((out / "proj.png").stat().st_size > 1000) + + def test_pipeline_with_report_and_exports(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + base = Path(tmp) + ds = base / "operando" + for i in range(3): + sdir = ds / f"scan{i + 1:04d}" + sdir.mkdir(parents=True) + vol = np.zeros((16, 28, 28), dtype=np.float32) + vol[5:10, 10 + i : 15 + i, 12:17] = 180.0 + with h5py.File(sdir / "pco_nf.h5", "w") as h5: + entry = h5.create_group("entry_0000") + entry.attrs["NX_class"] = "NXentry" + entry.create_dataset("start_time", data=f"2026-05-16T10:0{i}:00Z") + h5.create_dataset("/entry_0000/ESRF-ID03/pco_nf/data", data=vol) + + out_dir = base / "pipeline_out" + nxs_out = base / "summary.nxs" + flt_out = base / "peaks.flt" + rc = run_pipeline.main( + [ + str(ds), + "--outdir", + str(out_dir), + "--backend", + "mock", + "--report", + "--export-nexus", + str(nxs_out), + "--export-imaged11", + str(flt_out), + ] + ) + self.assertEqual(rc, 0) + html_file = out_dir / "report" / "report.html" + self.assertTrue(html_file.exists()) + html_text = html_file.read_text(encoding="utf-8") + self.assertIn("BraggTrack 4D Explorer", html_text) + self.assertIn("data:image/png;base64,", html_text) + self.assertTrue((out_dir / "report" / "figures" / "lineage_dag.png").exists()) + self.assertTrue(nxs_out.exists()) + self.assertTrue(flt_out.exists()) + + manifest = json.loads((out_dir / "run_manifest.json").read_text()) + self.assertIn("report", manifest["stage_timings_sec"]) + self.assertIsNotNone(manifest["artifacts"]["html_report"]) + + # Standalone report CLI smoke check + standalone_html = generate_html_report(out_dir, base / "standalone.html", dataset_root=ds) + self.assertTrue(standalone_html.exists()) + rc_rep = report_dataset.main([str(out_dir), "--outdir", str(base / "rep2"), "--no-figures"]) + self.assertEqual(rc_rep, 0) + + +if __name__ == "__main__": + unittest.main()