insar-rs 0.2.0__tar.gz

insar_rs-0.2.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: insar-rs
+Version: 0.2.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: Operating System :: OS Independent
+Requires-Dist: numpy>=1.23
+Summary: Python bindings for the insar-rs InSAR time-series (SBAS) engine written in Rust
+Keywords: insar,sar,sbas,deformation,remote-sensing,sentinel-1
+Author-email: Francisco Parra <gran.huja@gmail.com>
+License: MIT OR Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/franciscoparrao/insar-rs/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/franciscoparrao/insar-rs
+
+# insar-rs (Python)
+
+Bindings Python del motor SBAS de [insar-rs](../..) (Rust). Inversión de series
+temporales InSAR rápida, consumible desde numpy.
+
+## Instalar (desarrollo)
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install maturin numpy
+cd crates/python
+maturin develop --release
+```
+
+## Uso
+
+```python
+import insar_rs, numpy as np
+
+# End-to-end desde interferogramas ISCE (.unw desenrollados). Referencia
+# automáticamente al píxel de máxima coherencia media.
+vel, vel_std, series, coherence, epochs = insar_rs.sbas_from_isce(
+    "merged/interferograms", baselines_dir="baselines")
+# vel: (filas, cols) m/año ; vel_std: (filas, cols) m/año (error estándar)
+# series: (épocas, filas, cols) m
+# coherence: (filas, cols) coherencia temporal [0,1] (máscara de calidad)
+# epochs: ['YYYY-MM-DD', ...]
+
+# O sobre arrays propios de fase desenrollada (n_pares, filas, cols) en radianes:
+ts  = insar_rs.invert_sbas(phase, refs, secs, epoch_days, wavelength_m=0.0555)
+vel = insar_rs.estimate_velocity(ts, epoch_days)
+
+# Persistent Scatterers:
+da  = insar_rs.amplitude_dispersion(amp_stack)  # (n_épocas, filas, cols) -> (filas, cols)
+
+# Descomposición LOS asc+desc -> (Up, East); geometría escalar o por píxel:
+up, east = insar_rs.decompose_asc_desc(los_asc, 39.0, 349.0, los_desc, 39.0, 191.0)
+up, east = insar_rs.decompose_per_pixel([los_asc, los_desc], [inc_asc, inc_desc], [head_asc, head_desc])
+
+# Descriptores por píxel para ML (dict de arrays, esquema determinista):
+features = insar_rs.extract_features(series, epoch_days)  # {"velocity": ..., "acceleration": ..., ...}
+
+# Deramp (plano/cuadrática) y corrección de saltos 2π por cierre de fase:
+flat = insar_rs.remove_ramp(vel, "linear")
+corrected_phase, n_corrected, n_uncorrected = insar_rs.correct_unwrap_errors(phase, refs, secs)
+```
+
+Convenciones: NoData = NaN; desplazamiento LOS `d = −λ/(4π)·φ`; serie relativa a
+la primera época. Validado contra MintPy (ver `../../docs/validation.md`).
+

insar_rs-0.2.0/README.md

@@ -0,0 +1,49 @@
+# insar-rs (Python)
+
+Bindings Python del motor SBAS de [insar-rs](../..) (Rust). Inversión de series
+temporales InSAR rápida, consumible desde numpy.
+
+## Instalar (desarrollo)
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install maturin numpy
+cd crates/python
+maturin develop --release
+```
+
+## Uso
+
+```python
+import insar_rs, numpy as np
+
+# End-to-end desde interferogramas ISCE (.unw desenrollados). Referencia
+# automáticamente al píxel de máxima coherencia media.
+vel, vel_std, series, coherence, epochs = insar_rs.sbas_from_isce(
+    "merged/interferograms", baselines_dir="baselines")
+# vel: (filas, cols) m/año ; vel_std: (filas, cols) m/año (error estándar)
+# series: (épocas, filas, cols) m
+# coherence: (filas, cols) coherencia temporal [0,1] (máscara de calidad)
+# epochs: ['YYYY-MM-DD', ...]
+
+# O sobre arrays propios de fase desenrollada (n_pares, filas, cols) en radianes:
+ts  = insar_rs.invert_sbas(phase, refs, secs, epoch_days, wavelength_m=0.0555)
+vel = insar_rs.estimate_velocity(ts, epoch_days)
+
+# Persistent Scatterers:
+da  = insar_rs.amplitude_dispersion(amp_stack)  # (n_épocas, filas, cols) -> (filas, cols)
+
+# Descomposición LOS asc+desc -> (Up, East); geometría escalar o por píxel:
+up, east = insar_rs.decompose_asc_desc(los_asc, 39.0, 349.0, los_desc, 39.0, 191.0)
+up, east = insar_rs.decompose_per_pixel([los_asc, los_desc], [inc_asc, inc_desc], [head_asc, head_desc])
+
+# Descriptores por píxel para ML (dict de arrays, esquema determinista):
+features = insar_rs.extract_features(series, epoch_days)  # {"velocity": ..., "acceleration": ..., ...}
+
+# Deramp (plano/cuadrática) y corrección de saltos 2π por cierre de fase:
+flat = insar_rs.remove_ramp(vel, "linear")
+corrected_phase, n_corrected, n_uncorrected = insar_rs.correct_unwrap_errors(phase, refs, secs)
+```
+
+Convenciones: NoData = NaN; desplazamiento LOS `d = −λ/(4π)·φ`; serie relativa a
+la primera época. Validado contra MintPy (ver `../../docs/validation.md`).

insar_rs-0.2.0/geostat-rs/Cargo.toml

@@ -0,0 +1,30 @@
+[workspace]
+resolver = "3"
+members = [
+    "crates/geostat-core",
+    "crates/geostat-cli",
+    "crates/geostat-python",
+    "crates/geostat-wasm",
+]
+
+[workspace.package]
+version = "0.8.0"
+edition = "2024"
+license = "MIT OR Apache-2.0"
+authors = ["Francisco Parra-O."]
+repository = "https://github.com/franciscoparrao/geostat-rs"
+rust-version = "1.88"
+
+[workspace.dependencies]
+ndarray = "0.16"
+rayon = "1.10"
+thiserror = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+anyhow = "1"
+clap = { version = "4", features = ["derive"] }
+csv = "1.3"
+
+[profile.release]
+lto = true
+codegen-units = 1

insar_rs-0.2.0/geostat-rs/crates/geostat-core/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "geostat-core"
+description = "Geostatistics engine: variography, kriging and sequential Gaussian simulation"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+keywords = ["geostatistics", "kriging", "variogram", "simulation", "spatial"]
+categories = ["science", "mathematics"]
+readme = "README.md"
+
+[features]
+default = ["parallel"]
+# Parallel execution via rayon. Disable for single-threaded targets (wasm32).
+parallel = ["dep:rayon"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[dependencies]
+ndarray = { workspace = true }
+rayon = { workspace = true, optional = true }
+thiserror = { workspace = true }
+serde = { workspace = true }
+
+[lib]
+bench = false
+
+[dev-dependencies]
+criterion = "0.5"
+proptest = "1"
+
+[[bench]]
+name = "engine"
+harness = false

insar_rs-0.2.0/geostat-rs/crates/geostat-core/README.md

@@ -0,0 +1,354 @@
+# geostat-rs
+
+[![CI](https://github.com/franciscoparrao/geostat-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/franciscoparrao/geostat-rs/actions/workflows/ci.yml)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](#license)
+
+Geostatistics engine in pure Rust: variography, kriging and sequential
+Gaussian/indicator simulation, plus a scalable Vecchia approximation for
+large point sets. A modern, single-binary take on the GSLIB / gstat
+feature set, with deterministic stochastic simulation and parallel
+prediction out of the box, validated against gstat at machine precision.
+
+Not yet published to crates.io/PyPI — build from source (see below).
+
+## Crates
+
+| Crate | Description |
+|---|---|
+| `geostat-core` | Library: no I/O, no heavy dependencies. `parallel` feature (rayon, default on) — disable for wasm32. |
+| `geostat-cli` | `geostat` command-line tool: CSV in, CSV/JSON out. |
+| `geostat-python` | Python module `geostat_rs` (PyO3, abi3 ≥ 3.9). Build with maturin. |
+| `geostat-wasm` | WebAssembly bindings (wasm-bindgen); demo in `examples/wasm-demo/`. |
+
+## Features (v0.7)
+
+- **2-D and 3-D** — the engine is generic over dimension (`PointSet<2>` /
+  `PointSet<3>`); variography, kriging, CV and SGS all run in 3-D through
+  the same validated code paths.
+- **Experimental variograms** — omnidirectional, directional (azimuth +
+  dip cone in 3-D, gstat/GSLIB convention) and cross-variograms.
+- **Theoretical models** — spherical, exponential, Gaussian, Matérn with
+  **continuous ν** (Bessel-quadrature evaluation; ν = 3/2, 5/2 also have
+  closed forms), circular, stable (power-exponential), hole-effect and
+  wave (cardinal-sine), and **Power** (IRF-0, unbounded, kriged directly in
+  semivariogram form). Nested multi-structure models plus nugget, with
+  geometric anisotropy per structure — full 3-D rotation
+  (azimuth/dip/rake, GSLIB `setrot`) and zonal anisotropy.
+- **Model fitting** — weighted least squares via Nelder–Mead
+  (log-parametrized, multi-start), with selectable weight schemes
+  (`N_j/h_j²` gstat default, `N_j`, Cressie `N_j/γ(h_j)²`, OLS); automatic
+  best-family selection; multi-structure nesting; joint `ν`/`α` fitting for
+  Matérn/stable; geometric-anisotropy auto-fit; N-variable-capable LMC
+  prediction (2-variable iterated Goulard–Voltz fit) with PSD projection.
+- **Kriging** — simple, ordinary, universal (polynomial drift) and
+  **external drift** (KED); **ordinary co-kriging** (collocated or
+  **heterotopic**) and **collocated cokriging** (MM1/MM2, Journel 1999)
+  under a linear model of coregionalization; **block kriging** and **block
+  co-kriging** with explicit discretization; **lognormal kriging**
+  (unbiased back-transform); **median/ordinary indicator kriging** (local
+  ccdf, E-type estimate, conditional variance), with **Markov-Bayes**
+  calibration of soft secondary data (core-only); **regression kriging** (a
+  trend fitted separately — built-in OLS or any
+  external/ML model — plus kriging of its residuals); per-datum
+  **measurement error** (gstat `Err`); octant search (GSLIB `noct`) and
+  `min_neighbors` (`ndmin`); **anisotropic (rotated-ellipsoid) search**
+  (GSLIB `kt3d` `sang`/`sanis`, `--search-azimuth`/`--search-ratio` in the
+  CLI, `search_azimuth=`/`search_ratio=` in Python) instead of the
+  gstat/GSLIB-default Euclidean neighborhood; kd-tree moving neighborhoods;
+  parallel over targets; variance maps.
+- **Vecchia approximation** — for point sets too large for exact kriging:
+  O(n log n) maxmin ordering, likelihood-based maximum-likelihood/REML
+  fitting (including external-drift REML and joint Matérn-`ν` MLE),
+  Guinness (2018) likelihood grouping, and joint prediction (Katzfuss &
+  Guinness 2021) that stays consistent across targets as `m` grows.
+- **Simulation** — conditional sequential **Gaussian** simulation
+  (normal-score transform, GSLIB-style tail extrapolation, cell
+  declustering + weighted normal scores, multiple-grid path, separate
+  data/simulated-node neighbor quotas), sequential **indicator** simulation
+  (ccdf with order-relation corrections), and **truncated Gaussian
+  simulation** (TGS) for ordered categorical/facies data (thresholds from
+  global category proportions via the inverse-normal CDF; GSLIB `tgsim`-
+  equivalent — full plurigaussian simulation, with a flexible 2-D
+  truncation rule for non-ordered facies, is not implemented), all with a
+  deterministic, platform-independent RNG (xoshiro256++) and incremental
+  bucket-grid neighbor search: same seed, same realizations, anywhere.
+- **Mathematical interpolators** — inverse-distance weighting and
+  k-nearest-neighbor averaging (k = 1 is nearest-neighbor / Voronoi), as
+  assumption-light baselines for fair method comparison.
+- **Method comparison** — a leave-one-out harness that ranks ordinary
+  kriging, IDW, k-NN and NN by VEcv on the same data (`geostat compare` /
+  `compare_methods`), in the spirit of Li (2021): no method dominates, so
+  compare by predictive accuracy.
+- **Hyperparameter tuning by accuracy** — choose the IDW power, the k-NN `k`
+  or the kriging neighborhood size by maximizing leave-one-out VEcv
+  (`geostat tune` / `tune_idw_power`, `tune_knn_k`, `tune_kriging_neighbors`),
+  i.e. by predictive accuracy rather than by a model fit.
+- **GeoPackage I/O** — read point feature layers straight from an OGC
+  `.gpkg` and write kriging results back to one (pure Rust via bundled
+  SQLite — no GDAL): any CLI subcommand that only needs x/y/value accepts a
+  `.gpkg` input (drift/error/detrend covariate columns and 3-D mode still
+  require a CSV — they fail with a clear error on `.gpkg` for now),
+  `geostat gpkg-info` lists its layers, and `geostat krige -o out.gpkg`
+  writes a point layer (prediction + variance) — or, with `--raster`, a
+  single-band **2D-gridded-coverage** raster (16-bit PNG tile, values
+  preserved via scale/offset) — with a recorded CRS, readable by QGIS/GDAL.
+- **Validation** — leave-one-out, k-fold and **spatial block**
+  cross-validation, with error measures (ME, MAE, MSE, RMSE, MSDR),
+  scale-free relative measures (RME, RMAE, RRMSE), predictive-accuracy
+  measures **VEcv** (Li 2016) and **E₁** (Legates–McCabe), and
+  **Deutsch (1997) accuracy plots** for checking whether kriging variances
+  are well calibrated, with or without external drift.
+- **Benchmarks** — criterion suite (`cargo bench -p geostat-core`);
+  proptest property tests and `cargo-fuzz` targets for parser robustness.
+- **Bindings** — Python (`import geostat_rs`: variography, kriging, CV,
+  SGS, SIS, IK, all with 3-D variants; zero-copy numpy outputs, GIL
+  released during computation, `.pyi` type stubs) and WebAssembly (browser
+  demo in `examples/wasm-demo/`).
+
+## Build
+
+```sh
+cargo build --release         # binary at target/release/geostat
+cargo test --workspace        # unit + integration tests
+```
+
+## CLI quickstart
+
+Input is a CSV with named columns (defaults: `x`, `y`, `z`).
+
+```sh
+# 1. Experimental variogram + automatic model fit
+geostat variogram -i meuse.csv --value-col zinc \
+    --fit best --model-out model.json -o vario.csv
+
+# 2. Leave-one-out cross-validation of the fitted model
+geostat cv -i meuse.csv --value-col zinc -m model.json --max-neighbors 32
+
+# 3. Ordinary kriging onto a 100x100 grid (+ kriging variance)
+geostat krige -i meuse.csv --value-col zinc -m model.json \
+    --nx 100 --ny 100 --max-neighbors 32 -o kriged.csv
+
+# 4. Conditional SGS, 100 realizations, reproducible
+geostat sgs -i meuse.csv --value-col zinc \
+    --nx 100 --ny 100 -n 100 --seed 42 -o sims.csv
+
+# 5. Kriging with external drift (covariates in data and targets CSVs)
+geostat krige -i meuse.csv --value-col lzinc -m model.json \
+    --drift-cols sdist --targets grid_with_sdist.csv -o ked.csv
+
+# 6. Ordinary co-kriging with a collocated secondary variable
+geostat cokrige -i meuse.csv --value-col lzinc --secondary-col llead \
+    --nx 100 --ny 100 -o cokriged.csv     # LMC auto-fitted (or --lmc lmc.json)
+
+# 7. Sequential indicator simulation at the quartiles
+geostat sis -i meuse.csv --value-col zinc --quantiles 0.25,0.5,0.75 \
+    --nx 100 --ny 100 -n 50 --seed 42 -o sis.csv
+
+# 8. Indicator kriging: local ccdf, E-type estimate, conditional variance
+geostat ik -i meuse.csv --value-col zinc --quantiles 0.25,0.5,0.75 \
+    --nx 100 --ny 100 -o ik.csv
+
+# 9. 3-D ordinary kriging (z column + explicit targets CSV with x,y,z)
+geostat krige -i drillholes.csv --z-col z --value-col grade -m model3d.json \
+    --targets blocks.csv -o kriged3d.csv
+
+# 10. Heterotopic co-kriging (secondary at its own locations; needs --lmc)
+geostat cokrige -i primary.csv --value-col lzinc --secondary-col llead \
+    --secondary-input secondary.csv --lmc lmc.json \
+    --nx 100 --ny 100 -o cokriged.csv
+
+# 11. Regression kriging: OLS trend on covariates + kriging of residuals
+#     (residual variogram fitted automatically; targets carry the covariates)
+geostat rk -i meuse.csv --value-col lzinc --covar-cols sdist \
+    --targets grid_with_sdist.csv -o rk.csv
+
+# 12. Compare methods (OK / IDW / k-NN / NN) by leave-one-out VEcv
+geostat compare -i meuse.csv --value-col zinc --max-neighbors 32 --knn-k 8
+
+# 13. Tune a hyperparameter by leave-one-out VEcv (idw | knn | ok)
+geostat tune -i meuse.csv --value-col zinc --method idw
+
+# 14. GeoPackage I/O: read points from a .gpkg, write kriging to one
+geostat gpkg-info -i meuse.gpkg                            # list layers
+geostat cv -i meuse.gpkg --value-col lzinc -m model.json   # any subcommand reads .gpkg
+geostat krige -i meuse.gpkg --value-col lzinc -m model.json \
+    --nx 100 --ny 100 --srs 28992 -o kriged.gpkg           # write a .gpkg point layer
+geostat krige -i meuse.gpkg --value-col lzinc -m model.json \
+    --nx 200 --ny 200 --srs 28992 --raster -o kriged.gpkg  # write a single-band raster
+
+# 15. Vecchia: scalable ML covariance fitting + prediction for large n
+#     (O(n log n) plan; --trend for REML under a spatial trend)
+geostat variogram -i drillholes.csv --value-col grade \
+    --mle --cond 20 --model-out model_ml.json
+geostat krige -i drillholes.csv --value-col grade -m model_ml.json \
+    --vecchia 20 --nx 200 --ny 200 -o kriged_vecchia.csv
+
+# 16. Spatial block CV + Deutsch accuracy plot (honest error under autocorrelation)
+geostat cv -i meuse.csv --value-col zinc -m model.json --blocks 4,4 --accuracy
+
+# 17. Collocated cokriging (MM1): one secondary value per target (e.g. a
+#     raster sampled with gpkg-sample), no cross-variogram needed
+geostat collocated-cokrige -i meuse.csv --value-col lzinc --secondary-col llead \
+    -m model.json --targets grid_with_secondary.csv --target-secondary-col llead \
+    -o collocated.csv
+
+# 18. Truncated Gaussian simulation: ordered facies from global proportions
+#     (--value-col holds integer category codes; model is of the
+#     underlying standard-Gaussian field, not auto-fitted)
+geostat tgs -i drillholes.csv --value-col facies -m facies_model.json \
+    --nx 100 --ny 100 -n 50 --seed 42 -o facies_sims.csv
+```
+
+Other useful flags: `--azimuth/--dip/--tolerance` (directional variograms,
+dip for 3-D), `--method simple|ordinary|universal --degree 2` (kriging
+flavor), `--block w,h --block-discr nx,ny` (block kriging),
+`--bbox xmin,ymin,xmax,ymax --res <cell>` (grid control).
+
+A fitted model is plain JSON and can be edited by hand:
+
+```json
+{
+  "nugget": 0.05,
+  "structures": [{ "kind": "spherical", "sill": 0.59, "range": 897.0 }]
+}
+```
+
+## Library quickstart
+
+```rust
+use geostat_core::{
+    experimental_variogram, fit_best, Kriging, KrigingConfig, ModelKind,
+    PointSet, VariogramConfig,
+};
+
+let data = PointSet::from_xyz(&x, &y, &z)?;
+let ev = experimental_variogram(&data, &VariogramConfig {
+    n_lags: 15, max_dist: 1500.0, direction: None,
+})?;
+let fit = fit_best(&ev, &ModelKind::ALL)?;
+let kriging = Kriging::new(&data, &fit.model, KrigingConfig::default())?;
+let est = kriging.predict([179_000.0, 330_000.0])?;
+println!("prediction {} ± {}", est.value, est.variance.sqrt());
+```
+
+## Validation against gstat
+
+Every deterministic method is cross-checked against **gstat** (R) at
+machine precision on the Meuse and Walker Lake datasets; SGS is validated
+distributionally. The full harness and result tables live in
+[`validation/`](validation/README.md) — variography, OK/UK/SK/KED/co-kriging
+(collocated and heterotopic), block kriging, 3-D kriging/CV and indicator
+kriging, plus the SGS ensemble check.
+
+Conventions intentionally match gstat where it matters: semivariance
+estimator, `N_j/h_j²` fit weights, azimuth measured clockwise from north,
+right-closed lag bins, nugget-free within-block covariance. The Matérn
+parameterization is Rasmussen & Williams (`√(2ν)h/ρ` scaling), so ranges
+are comparable across families.
+
+## Roadmap
+
+- v0.1: ✅ variography, OK/UK/SK kriging, LOO CV, SGS. Validated against
+  gstat at machine precision (Meuse, Walker Lake) — see `validation/`.
+- v0.2: ✅ co-kriging (LMC), KED, SIS, model anisotropy, kd-tree/bucket
+  neighbor search, criterion benchmarks. KED/anisotropy/co-kriging also
+  validated against gstat at machine precision.
+- v0.3: ✅ Python bindings (PyO3, bit-identical with the CLI), WASM
+  bindings + browser demo, block kriging (validated vs gstat at machine
+  precision, including the nugget-free C̄(B,B) convention).
+- v0.4: ✅ 3-D support (const-generic core), heterotopic co-kriging,
+  standalone indicator kriging — all validated against gstat at machine
+  precision; 3-D and IK exposed in the Python bindings.
+- v0.5: ✅ lognormal (trans-Gaussian) kriging and block co-kriging.
+  Block co-kriging matches gstat to machine precision; simple lognormal
+  kriging matches gstat's SK back-transform to ~1e-9 (ordinary follows the
+  Journel & Huijbregts formula).
+- v0.6: ✅ VEcv/E₁ and relative error measures in cross-validation (parity
+  with Li's spm::pred.acc); ✅ regression kriging (separate trend + residual
+  kriging), the bridge to an ML trend engine; ✅ IDW/k-NN/NN baselines + a
+  VEcv method-comparison harness; ✅ hyperparameter tuning by predictive
+  accuracy (IDW power, k-NN k, kriging neighborhood); ✅ GeoPackage I/O
+  (point reading + point-layer writing + single-band raster /
+  2D-gridded-coverage output).
+- v0.7: ✅ Vecchia approximation (O(n log n) plan, MLE/REML, Guinness
+  grouping, joint prediction) for large point sets; ✅ Matérn with
+  continuous ν, plus circular/stable/hole/wave/Power families, full 3-D
+  rotation and zonal anisotropy; ✅ cell declustering + weighted normal
+  scores; ✅ GSLIB tail extrapolation for SGS/SIS/IK back-transforms;
+  ✅ median/ordinary indicator kriging, collocated cokriging (MM1/MM2) and
+  Markov-Bayes soft-data calibration; ✅ per-datum measurement error,
+  octant search; ✅ spatial block CV and Deutsch accuracy plots;
+  ✅ public `Covariance` trait, zero-copy numpy bindings, proptest/fuzz
+  coverage. See `docs/AUDIT-2026-07.md` and `docs/AUDIT-2026-07-v2.md` for
+  the full audit trail behind this release.
+- ML+geostatistics hybrids: regression kriging accepts an external trend, so
+  an ML model supplies the mean and geostat-rs kriges the residuals. See
+  `examples/hybrid_smelt_rk.py` for an RFOK-style hybrid built entirely from
+  the author's Rust engines — a Smelt random-forest trend + residual kriging
+  here — scored by VEcv.
+- Next: paper draft (Mathematical Geosciences); publish to crates.io/PyPI.
+
+## Python quickstart
+
+```sh
+pip install maturin
+maturin develop -m crates/geostat-python/Cargo.toml --release
+```
+
+```python
+import geostat_rs as gs
+
+# 2-D
+model = gs.fit_variogram(x, y, vals, n_lags=15, max_dist=1500.0)
+pred, var = gs.krige_grid(x, y, vals, model, bbox=(0, 0, 100, 100),
+                          nx=50, ny=50, max_neighbors=32)
+sims = gs.sgs(x, y, vals, model_ns, bbox=(0, 0, 100, 100), nx=50, ny=50,
+              n_realizations=100, seed=42)
+
+# Truncated Gaussian simulation: ordered facies from global proportions
+# (facies_model is of the underlying standard-Gaussian field, sill ~ 1,
+# not auto-fitted; proportions estimated from `facies` frequency if omitted)
+facies_sims = gs.tgs(x, y, facies, facies_model, bbox=(0, 0, 100, 100),
+                      nx=50, ny=50, n_realizations=50, seed=42)
+
+# 3-D (drillhole-style data)
+m3 = gs.fit_variogram_3d(x, y, z, grade, n_lags=12, max_dist=200.0)
+pred, var = gs.krige_3d(x, y, z, grade, m3, bx, by, bz, max_neighbors=24)
+
+# Indicator kriging → local ccdf + E-type estimate
+ik = gs.indicator_kriging(x, y, vals, cutoffs, tx, ty)
+ik["ccdf"], ik["e_type"], ik["cond_var"]
+
+# Regression kriging: OLS trend on covariates + residual kriging.
+# (Or pass trend_at_data / trend_at_targets from any external/ML model.)
+rk = gs.regression_kriging(x, y, vals, covars, tx, ty, target_covars)
+rk["prediction"], rk["variance"], rk["trend_coef"]
+
+# Ordinary co-kriging with a correlated secondary (auto-fitted LMC;
+# collocated or heterotopic; `ridge` stabilizes the system).
+pred, var = gs.co_kriging(px, py, pv, sx, sy, sv, tx, ty)
+
+# Collocated cokriging (MM1/MM2): one secondary value per target instead
+# of a fitted cross-variogram -- the practical fit for an exhaustively
+# sampled secondary (raster/seismic). `collocated_stats` estimates
+# rho12/sigma1/sigma2 from collocated sample pairs when you don't already
+# know the population values.
+rho12, sigma1, sigma2 = gs.collocated_stats(pv, sv_at_primary)
+pred, var = gs.collocated_cokriging(px, py, pv, model, tx, ty, secondary_at_targets,
+                                     mean1=pv.mean(), mean2=sv_at_primary.mean(),
+                                     rho12=rho12, sigma1=sigma1, sigma2=sigma2)
+
+# Baselines + method comparison by leave-one-out VEcv.
+idw_pred = gs.idw(x, y, vals, tx, ty, power=2.0, max_neighbors=16)
+ranking = gs.compare_methods(x, y, vals, max_neighbors=32, knn_k=8)
+# {"ordinary_kriging": {"rmse":..., "vecv":...}, "idw": {...}, ...}
+
+# Tune a hyperparameter by predictive accuracy (VEcv).
+best = gs.tune_idw_power(x, y, vals)          # {"best":..., "best_vecv":..., "trace":[...]}
+gs.tune_knn_k(x, y, vals); gs.tune_kriging_neighbors(x, y, vals)
+```
+
+## License
+
+Dual-licensed under [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-APACHE), at
+your option.

insar_rs-0.2.0/geostat-rs/crates/geostat-core/benches/engine.rs

@@ -0,0 +1,79 @@
+//! Criterion benchmarks for the core engine: variography, kriging and
+//! sequential Gaussian simulation on synthetic data.
+
+use criterion::{Criterion, criterion_group, criterion_main};
+use std::hint::black_box;
+
+use geostat_core::{
+    Grid2D, Kriging, KrigingConfig, ModelKind, PointSet, Rng, SgsConfig, Structure,
+    VariogramConfig, VariogramModel, experimental_variogram, sequential_gaussian_simulation,
+};
+
+fn synthetic(n: usize, seed: u64) -> PointSet {
+    let mut rng = Rng::new(seed);
+    let mut coords = Vec::with_capacity(n);
+    let mut values = Vec::with_capacity(n);
+    for _ in 0..n {
+        let x = rng.uniform() * 1000.0;
+        let y = rng.uniform() * 1000.0;
+        coords.push([x, y]);
+        values.push((x / 150.0).sin() + (y / 200.0).cos() + 0.1 * rng.normal());
+    }
+    PointSet::new(coords, values).unwrap()
+}
+
+fn model() -> VariogramModel {
+    VariogramModel::new(0.02, vec![Structure::new(ModelKind::Spherical, 1.0, 300.0)]).unwrap()
+}
+
+fn bench_variogram(c: &mut Criterion) {
+    let data = synthetic(2000, 1);
+    let cfg = VariogramConfig {
+        n_lags: 15,
+        max_dist: 500.0,
+        direction: None,
+    };
+    c.bench_function("variogram_2k_points", |b| {
+        b.iter(|| experimental_variogram(black_box(&data), black_box(&cfg)).unwrap())
+    });
+}
+
+fn bench_kriging(c: &mut Criterion) {
+    let data = synthetic(1000, 2);
+    let m = model();
+    let grid = Grid2D::from_bbox([0.0, 0.0], [1000.0, 1000.0], 50, 50).unwrap();
+    // `KrigingConfig` is `#[non_exhaustive]`: build from `Default::default()`
+    // and assign fields.
+    let mut cfg = KrigingConfig::default();
+    cfg.max_neighbors = Some(32);
+    c.bench_function("ok_2500_cells_1k_data_k32", |b| {
+        b.iter(|| {
+            let k = Kriging::new(black_box(&data), &m, cfg.clone()).unwrap();
+            black_box(k.predict_grid(&grid))
+        })
+    });
+}
+
+fn bench_sgs(c: &mut Criterion) {
+    let data = synthetic(300, 3);
+    let m = model();
+    let grid = Grid2D::from_bbox([0.0, 0.0], [1000.0, 1000.0], 50, 50).unwrap();
+    // `SgsConfig` is `#[non_exhaustive]`: build from `Default::default()`
+    // and assign fields.
+    let mut cfg = SgsConfig::default();
+    cfg.n_realizations = 1;
+    cfg.seed = 42;
+    cfg.max_neighbors = 16;
+    cfg.search_radius = None;
+    let mut group = c.benchmark_group("sgs");
+    group.sample_size(10);
+    group.bench_function("sgs_2500_cells_1_realization_k16", |b| {
+        b.iter(|| {
+            black_box(sequential_gaussian_simulation(black_box(&data), &m, &grid, &cfg).unwrap())
+        })
+    });
+    group.finish();
+}
+
+criterion_group!(benches, bench_variogram, bench_kriging, bench_sgs);
+criterion_main!(benches);

insar_rs-0.2.0/geostat-rs/crates/geostat-core/examples/plan_bench.rs

@@ -0,0 +1,20 @@
+//! Quick scaling check of vecchia_plan after the O(n log n) rewrite.
+use geostat_core::rng::Rng;
+use geostat_core::vecchia::vecchia_plan;
+use std::time::Instant;
+
+fn main() {
+    for &n in &[10_000usize, 50_000, 100_000, 200_000] {
+        let mut rng = Rng::new(42);
+        let coords: Vec<[f64; 2]> = (0..n)
+            .map(|_| [rng.uniform() * 1000.0, rng.uniform() * 1000.0])
+            .collect();
+        let t = Instant::now();
+        let plan = vecchia_plan(&coords, 20, None).unwrap();
+        println!(
+            "n = {n:>7}: plan built in {:>8.2?} (order len {})",
+            t.elapsed(),
+            plan.order.len()
+        );
+    }
+}