From 6f2445c8a95b0f2fffe85eebdea66e4945791ba3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= Date: Fri, 30 Oct 2026 09:19:18 +0100 Subject: [PATCH] signature: crate de mesure de signatures de relief (cadrage 20), CLI signer, 13 tests Co-Authored-By: Claude Sonnet 5.5 --- signature/.gitignore | 1 + signature/Cargo.lock | 193 ++++++++++ signature/Cargo.toml | 14 + signature/exemples/sig-lans.json | 109 ++++++ signature/exemples/sig-moucherotte.json | 109 ++++++ signature/exemples/sig-veymont.json | 109 ++++++ signature/src/bin/signer.rs | 24 ++ signature/src/drainage.rs | 260 +++++++++++++ signature/src/grid.rs | 112 ++++++ signature/src/lib.rs | 486 ++++++++++++++++++++++++ signature/src/spectre.rs | 189 +++++++++ signature/src/tests.rs | 180 +++++++++ 12 files changed, 1786 insertions(+) create mode 100644 signature/.gitignore create mode 100644 signature/Cargo.lock create mode 100644 signature/Cargo.toml create mode 100644 signature/exemples/sig-lans.json create mode 100644 signature/exemples/sig-moucherotte.json create mode 100644 signature/exemples/sig-veymont.json create mode 100644 signature/src/bin/signer.rs create mode 100644 signature/src/drainage.rs create mode 100644 signature/src/grid.rs create mode 100644 signature/src/lib.rs create mode 100644 signature/src/spectre.rs create mode 100644 signature/src/tests.rs diff --git a/signature/.gitignore b/signature/.gitignore new file mode 100644 index 0000000..2f7896d --- /dev/null +++ b/signature/.gitignore @@ -0,0 +1 @@ +target/ diff --git a/signature/Cargo.lock b/signature/Cargo.lock new file mode 100644 index 0000000..940191a --- /dev/null +++ b/signature/Cargo.lock @@ -0,0 +1,193 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "crc32fast" +version = "1.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ba106e844045ddc02c20768ac4b0b7cb45f2cc2ecbd833ac9f5dacb183c2055" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "flate2" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb" +dependencies = [ + "crc32fast", + "miniz_oxide", + "zlib-rs", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "jpeg-decoder" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "miniz_oxide" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rt-core" +version = "0.1.0" +dependencies = [ + "serde", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "signature" +version = "0.1.0" +dependencies = [ + "rt-core", + "serde", + "serde_json", + "tiff", +] + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "syn" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tiff" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba1310fcea54c6a9a4fd1aad794ecc02c31682f6bfbecdf460bf19533eed1e3e" +dependencies = [ + "flate2", + "jpeg-decoder", + "weezl", +] + +[[package]] +name = "unicode-ident" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" + +[[package]] +name = "weezl" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88" + +[[package]] +name = "zlib-rs" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/signature/Cargo.toml b/signature/Cargo.toml new file mode 100644 index 0000000..f71ed81 --- /dev/null +++ b/signature/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "signature" +version = "0.1.0" +edition = "2021" + +[dependencies] +serde = { version = "1", features = ["derive"] } +serde_json = "1" +rt-core = { path = "../relief/rt-core" } +tiff = "0.9" + +[[bin]] +name = "signer" +path = "src/bin/signer.rs" diff --git a/signature/exemples/sig-lans.json b/signature/exemples/sig-lans.json new file mode 100644 index 0000000..8f75413 --- /dev/null +++ b/signature/exemples/sig-lans.json @@ -0,0 +1,109 @@ +{ + "biome": "Plaine", + "source": { + "pays": "FR", + "jeu": "IGN MNT 1m", + "resolution_native_m": 1.0, + "emprise_wgs84": [ + 0.0, + 0.0, + 0.0, + 0.0 + ] + }, + "hypso": [ + 0.0, + 0.22797222, + 0.38574243, + 0.43164158, + 0.46645787, + 0.5041744, + 0.54755175, + 0.59671104, + 0.65184855, + 0.7034403, + 1.0 + ], + "relief_m": 69.026855, + "integrale_hypso": 0.49394932, + "pente_hist": [ + 0.702889, + 0.136445, + 0.073289, + 0.036344, + 0.019088, + 0.012028, + 0.008251, + 0.00553, + 0.003632, + 0.001977, + 0.000408, + 0.000117, + 0.000002, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + "pente_p50": 2.5075362, + "pente_p90": 13.88878, + "spectre": [ + 2.7635741, + 3.5918581, + 2.589854, + 3.3694582, + 4.4420958, + 6.472939, + 8.477331, + 9.885767, + 10.164427, + 0.0, + 0.0, + 0.0 + ], + "hurst": 0.26081333, + "rugosite": [ + 0.15592065, + 0.5179223, + 3.0692508, + 8.671927, + 0.0, + 0.0 + ], + "densite_drainage": 1.6898772, + "rapport_bifurcation": 4.0, + "part_cuvettes": 0.0, + "densite_dolines": 0.0, + "sinuosite_rivieres": 1.037635, + "sinuosite_cote": null, + "part_falaises": 0.000002, + "hauteur_falaise_p90": 3.9591064, + "profil_vallee": 14.193795, + "profondeur_incision_p90": 24.228027, + "aspect_hist": [ + 0.28794956, + 0.058335505, + 0.07713693, + 0.005791987, + 0.13829212, + 0.10892277, + 0.26567447, + 0.057896685 + ], + "courbure": [ + -0.015924573, + 0.0160124, + -0.25341737, + 0.25317383 + ], + "etages": [ + 0.0, + 1.0090389, + 0.0, + 0.0, + 0.0 + ], + "sols": [], + "roche": "Calcaire" +} \ No newline at end of file diff --git a/signature/exemples/sig-moucherotte.json b/signature/exemples/sig-moucherotte.json new file mode 100644 index 0000000..898b4fa --- /dev/null +++ b/signature/exemples/sig-moucherotte.json @@ -0,0 +1,109 @@ +{ + "biome": "Plaine", + "source": { + "pays": "FR", + "jeu": "IGN MNT 1m", + "resolution_native_m": 1.0, + "emprise_wgs84": [ + 0.0, + 0.0, + 0.0, + 0.0 + ] + }, + "hypso": [ + 0.0, + 0.3191762, + 0.40579098, + 0.48213738, + 0.559021, + 0.6378699, + 0.7075592, + 0.77621776, + 0.8484186, + 0.9100995, + 1.0 + ], + "relief_m": 528.52625, + "integrale_hypso": 0.62235, + "pente_hist": [ + 0.243204, + 0.026916, + 0.02812, + 0.027309, + 0.029164, + 0.034728, + 0.044328, + 0.058253, + 0.084361, + 0.098725, + 0.112332, + 0.101103, + 0.056272, + 0.022298, + 0.016959, + 0.013565, + 0.002363, + 0.0 + ], + "pente_p50": 40.554688, + "pente_p90": 60.69843, + "spectre": [ + 4.116311, + 3.82816, + 4.17954, + 3.4508412, + 5.37676, + 7.498788, + 9.346751, + 10.278832, + 11.274576, + 0.0, + 0.0, + 0.0 + ], + "hurst": 0.23671591, + "rugosite": [ + 1.0258555, + 2.9034488, + 20.714037, + 105.72383, + 0.0, + 0.0 + ], + "densite_drainage": 0.03724264, + "rapport_bifurcation": 0.0, + "part_cuvettes": 0.0, + "densite_dolines": 0.0, + "sinuosite_rivieres": 1.0532218, + "sinuosite_cote": null, + "part_falaises": 0.111457, + "hauteur_falaise_p90": 5.8256474, + "profil_vallee": 6.6574845, + "profondeur_incision_p90": 28.839722, + "aspect_hist": [ + 0.081372835, + 0.08092115, + 0.25355285, + 0.050145585, + 0.054422576, + 0.046161827, + 0.39230162, + 0.041121542 + ], + "courbure": [ + -0.253061, + 0.2540877, + -2.6562974, + 2.6584473 + ], + "etages": [ + 0.0, + 0.28102088, + 0.724908, + 0.0, + 0.0 + ], + "sols": [], + "roche": "Calcaire" +} \ No newline at end of file diff --git a/signature/exemples/sig-veymont.json b/signature/exemples/sig-veymont.json new file mode 100644 index 0000000..819aa84 --- /dev/null +++ b/signature/exemples/sig-veymont.json @@ -0,0 +1,109 @@ +{ + "biome": "Plaine", + "source": { + "pays": "FR", + "jeu": "IGN MNT 1m", + "resolution_native_m": 1.0, + "emprise_wgs84": [ + 0.0, + 0.0, + 0.0, + 0.0 + ] + }, + "hypso": [ + 0.0, + 0.21377002, + 0.35500073, + 0.5108559, + 0.6083892, + 0.664409, + 0.7248776, + 0.78705335, + 0.84562266, + 0.90166235, + 1.0 + ], + "relief_m": 663.0261, + "integrale_hypso": 0.61363304, + "pente_hist": [ + 0.246104, + 0.025161, + 0.030845, + 0.030305, + 0.026873, + 0.027436, + 0.039749, + 0.072187, + 0.104636, + 0.0595, + 0.080429, + 0.089759, + 0.067558, + 0.040182, + 0.032883, + 0.025679, + 0.000714, + 0.0 + ], + "pente_p50": 40.057808, + "pente_p90": 64.944786, + "spectre": [ + 4.753812, + 4.795022, + 4.7909484, + 4.463878, + 5.7082534, + 8.159717, + 10.217932, + 11.88829, + 12.935914, + 0.0, + 0.0, + 0.0 + ], + "hurst": 0.20955274, + "rugosite": [ + 1.1119206, + 2.8817124, + 21.024687, + 124.267365, + 0.0, + 0.0 + ], + "densite_drainage": 0.016828427, + "rapport_bifurcation": 0.0, + "part_cuvettes": 0.0, + "densite_dolines": 0.0, + "sinuosite_rivieres": 1.2082107, + "sinuosite_cote": null, + "part_falaises": 0.167016, + "hauteur_falaise_p90": 6.1541014, + "profil_vallee": 0.0, + "profondeur_incision_p90": 0.0, + "aspect_hist": [ + 0.09251519, + 0.067644574, + 0.3771151, + 0.05326388, + 0.06546261, + 0.031945407, + 0.28666952, + 0.025383709 + ], + "courbure": [ + -0.27087885, + 0.27193, + -2.9675293, + 2.9707975 + ], + "etages": [ + 0.0, + 0.0, + 0.98675245, + 0.02255469, + 0.0 + ], + "sols": [], + "roche": "Calcaire" +} \ No newline at end of file diff --git a/signature/src/bin/signer.rs b/signature/src/bin/signer.rs new file mode 100644 index 0000000..3d2c0cd --- /dev/null +++ b/signature/src/bin/signer.rs @@ -0,0 +1,24 @@ +//! signer [occ.tif] -o sig.json [--biome Karst] [--pays FR] [--jeu RGE] +use rt_core::proc::BiomeRelief; +use signature::{lire_geotiff, mesurer, MetaSource}; +fn main() { + let a: Vec = std::env::args().skip(1).collect(); + let (mut fich, mut out, mut meta) = (vec![], "sig.json".to_string(), MetaSource::default()); + let mut i = 0; + while i < a.len() { + match a[i].as_str() { + "-o" => { out = a[i + 1].clone(); i += 1 } + "--pays" => { meta.pays = a[i + 1].clone(); i += 1 } + "--jeu" => { meta.jeu = a[i + 1].clone(); i += 1 } + "--biome" => { meta.biome = serde_json::from_str(&format!("\"{}\"", a[i + 1])).unwrap_or(BiomeRelief::Plaine); i += 1 } + f => fich.push(f.to_string()), + } + i += 1; + } + if fich.is_empty() { eprintln!("usage: signer [occ.tif] -o sig.json"); std::process::exit(2) } + let mnt = lire_geotiff(&fich[0]).unwrap_or_else(|e| { eprintln!("{e}"); std::process::exit(1) }); + let occ = fich.get(1).map(|f| lire_geotiff(f).unwrap()); + let s = mesurer(&mnt, occ.as_ref(), &meta); + std::fs::write(&out, s.to_json()).unwrap(); + println!("{out}: relief {:.0} m, pente p50 {:.1} deg, hurst {:.2}, drainage {:.1} km/km2", s.relief_m, s.pente_p50, s.hurst, s.densite_drainage); +} diff --git a/signature/src/drainage.rs b/signature/src/drainage.rs new file mode 100644 index 0000000..bd09c5f --- /dev/null +++ b/signature/src/drainage.rs @@ -0,0 +1,260 @@ +//! Hydrologie simulée : comblement des cuvettes (priority-flood), D8, accumulation, Strahler, +//! sinuosité, cuvettes, profils de vallée. +use crate::Raster; +use std::cmp::Reverse; +use std::collections::BinaryHeap; + +const DX: [i32; 8] = [1, 1, 0, -1, -1, -1, 0, 1]; +const DY: [i32; 8] = [0, 1, 1, 1, 0, -1, -1, -1]; + +#[derive(PartialEq)] +struct F(f64); +impl Eq for F {} +impl PartialOrd for F { + fn partial_cmp(&self, o: &Self) -> Option { + Some(self.cmp(o)) + } +} +impl Ord for F { + fn cmp(&self, o: &Self) -> std::cmp::Ordering { + self.0.partial_cmp(&o.0).unwrap() + } +} + +#[derive(Debug, Default, Clone)] +pub struct Hydro { + pub densite_drainage: f32, + pub rapport_bifurcation: f32, + pub strahler_max: u32, + pub sinuosite_rivieres: f32, + pub part_cuvettes: f32, + pub densite_dolines: f32, + pub profil_vallee: f32, + pub profondeur_incision_p90: f32, +} + +fn p90(mut v: Vec) -> f32 { + if v.is_empty() { + return 0.0; + } + v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v[((v.len() - 1) as f32 * 0.9) as usize] +} + +pub fn analyse(g: &Raster, seuil_aire_m2: f32, profondeur_cuvette_m: f32) -> Hydro { + let (w, h) = (g.w, g.h); + let n = w * h; + // Priority-flood avec epsilon : surface sans cuvette. + let mut zf: Vec = g.z.iter().map(|v| *v as f64).collect(); + let mut seen = vec![false; n]; + let mut heap = BinaryHeap::new(); + for y in 0..h { + for x in 0..w { + if x == 0 || y == 0 || x == w - 1 || y == h - 1 { + seen[y * w + x] = true; + heap.push(Reverse((F(zf[y * w + x]), y * w + x))); + } + } + } + let eps = 1e-5; + while let Some(Reverse((F(zc), c))) = heap.pop() { + let (cx, cy) = ((c % w) as i32, (c / w) as i32); + for d in 0..8 { + let (nx, ny) = (cx + DX[d], cy + DY[d]); + if nx < 0 || ny < 0 || nx >= w as i32 || ny >= h as i32 { + continue; + } + let ni = ny as usize * w + nx as usize; + if seen[ni] { + continue; + } + seen[ni] = true; + if zf[ni] <= zc { + zf[ni] = zc + eps; + } + heap.push(Reverse((F(zf[ni]), ni))); + } + } + // Cuvettes fermées plus profondes que le seuil (comblé - brut), composantes 8-connexes. + let prof = |i: usize| zf[i] - g.z[i] as f64; + let mut vu = vec![false; n]; + let (mut cells_cuv, mut dolines) = (0usize, 0usize); + for s in 0..n { + if vu[s] || prof(s) <= profondeur_cuvette_m as f64 { + continue; + } + dolines += 1; + let mut pile = vec![s]; + vu[s] = true; + while let Some(c) = pile.pop() { + cells_cuv += 1; + let (cx, cy) = ((c % w) as i32, (c / w) as i32); + for d in 0..8 { + let (nx, ny) = (cx + DX[d], cy + DY[d]); + if nx < 0 || ny < 0 || nx >= w as i32 || ny >= h as i32 { + continue; + } + let ni = ny as usize * w + nx as usize; + if !vu[ni] && prof(ni) > profondeur_cuvette_m as f64 { + vu[ni] = true; + pile.push(ni); + } + } + } + } + // D8 : plus forte pente ; None aux cellules de bord (exutoires). + let mut recv: Vec> = vec![None; n]; + for y in 1..h - 1 { + for x in 1..w - 1 { + let c = y * w + x; + let mut best = 0.0; + for d in 0..8 { + let ni = (y as i32 + DY[d]) as usize * w + (x as i32 + DX[d]) as usize; + let dist = if d % 2 == 0 { 1.0 } else { std::f64::consts::SQRT_2 }; + let s = (zf[c] - zf[ni]) / dist; + if s > best { + best = s; + recv[c] = Some(ni); + } + } + } + } + let mut order: Vec = (0..n).collect(); + order.sort_by(|a, b| zf[*b].partial_cmp(&zf[*a]).unwrap()); + let mut acc = vec![1u32; n]; + for &c in &order { + if let Some(r) = recv[c] { + acc[r] += acc[c]; + } + } + let cell_area = (g.pas_m * g.pas_m) as f64; + let thr = (seuil_aire_m2 as f64 / cell_area).ceil().max(1.0) as u32; + let chan: Vec = acc.iter().map(|a| *a >= thr).collect(); + let seglen = |c: usize, r: usize| -> f64 { + let diag = (c % w != r % w) && (c / w != r / w); + g.pas_m as f64 * if diag { std::f64::consts::SQRT_2 } else { 1.0 } + }; + // Strahler. + let mut inflow = vec![0u32; n]; + let (mut maxin, mut cntmax, mut ord) = (vec![0u32; n], vec![0u32; n], vec![0u32; n]); + let mut nstreams: Vec = vec![0; 32]; + for &c in &order { + if !chan[c] { + continue; + } + ord[c] = if cntmax[c] >= 2 { maxin[c] + 1 } else { maxin[c].max(1) }; + // Début d'un cours d'ordre i : source (i=1) ou confluence qui monte l'ordre. + if (ord[c] == 1 && maxin[c] == 0) || (cntmax[c] >= 2) { + nstreams[(ord[c] as usize).min(31)] += 1; + } + if let Some(r) = recv[c] { + if chan[r] { + inflow[r] += 1; + if ord[c] > maxin[r] { + maxin[r] = ord[c]; + cntmax[r] = 1; + } else if ord[c] == maxin[r] { + cntmax[r] += 1; + } + } + } + } + let smax = ord.iter().copied().max().unwrap_or(0); + let mut total = 0.0; + for c in 0..n { + if let (true, Some(r)) = (chan[c], recv[c]) { + total += seglen(c, r); + } + } + let bifurc = if smax >= 2 { + let r: Vec = (1..smax as usize).filter(|i| nstreams[i + 1] > 0).map(|i| nstreams[i] as f32 / nstreams[i + 1] as f32).collect(); + if r.is_empty() { 0.0 } else { r.iter().sum::() / r.len() as f32 } + } else { + 0.0 + }; + // Sinuosité sur les tronçons d'ordre >= 3 (>= max ordre disponible sinon). + let omin = 3.min(smax.max(1)); + let (mut path_sum, mut straight_sum) = (0.0, 0.0); + for c in 0..n { + if !chan[c] || ord[c] < omin || (inflow[c] == 1 && ord[c] >= omin && recv_prev_same(c, &recv, &chan, &ord, omin, n, w) ) { + continue; + } + let (mut cur, mut path, mut steps) = (c, 0.0, 0); + while let Some(r) = recv[cur] { + if !chan[r] || ord[r] < omin { + break; + } + path += seglen(cur, r); + cur = r; + steps += 1; + if inflow[cur] != 1 { + break; + } + } + if steps >= 5 { + let (dx, dy) = ((cur % w) as f64 - (c % w) as f64, (cur / w) as f64 - (c / w) as f64); + path_sum += path; + straight_sum += (dx * dx + dy * dy).sqrt() * g.pas_m as f64; + } + } + // Profils transverses le long des chenaux d'ordre >= 4 (>= ordre max sinon). + let vmin = 4.min(smax.max(1)); + let win = ((300.0 / g.pas_m) as i32).clamp(3, 400); + let (mut ratios, mut depths) = (vec![], vec![]); + for c in (0..n).filter(|c| chan[*c] && ord[*c] >= vmin && c % 3 == 0) { + let Some(r) = recv[c] else { continue }; + let (fx, fy) = ((r % w) as f64 - (c % w) as f64, (r / w) as f64 - (c / w) as f64); + let l = (fx * fx + fy * fy).sqrt(); + let (px, py) = (-fy / l, fx / l); + let (cx, cy) = ((c % w) as f64, (c / w) as f64); + let sample = |t: f64| -> Option { + let (x, y) = ((cx + px * t).round(), (cy + py * t).round()); + if x < 0.0 || y < 0.0 || x >= w as f64 || y >= h as f64 { None } else { Some(g.z[y as usize * w + x as usize] as f64 - g.z[c] as f64) } + }; + let side = |sgn: f64| -> Option> { + let v: Vec = (1..=win).map_while(|k| sample(sgn * k as f64)).collect(); + if v.len() as i32 == win { Some(v) } else { None } + }; + let (Some(a), Some(b)) = (side(1.0), side(-1.0)) else { continue }; + let ma = a.iter().cloned().fold(0.0, f64::max); + let mb = b.iter().cloned().fold(0.0, f64::max); + let d = ma.min(mb); + if d < 2.0 { + continue; + } + let first = |v: &Vec| v.iter().position(|z| *z >= d / 2.0).map(|k| k as f64 + 1.0); + if let (Some(ka), Some(kb)) = (first(&a), first(&b)) { + ratios.push(((ka + kb) * g.pas_m as f64 / d) as f32); + depths.push(d as f32); + } + } + ratios.sort_by(|a, b| a.partial_cmp(b).unwrap()); + let area_km2 = n as f64 * cell_area / 1e6; + Hydro { + densite_drainage: (total / 1000.0 / area_km2) as f32, + rapport_bifurcation: bifurc, + strahler_max: smax, + sinuosite_rivieres: if straight_sum > 0.0 { (path_sum / straight_sum) as f32 } else { 0.0 }, + part_cuvettes: cells_cuv as f32 / n as f32, + densite_dolines: (dolines as f64 / area_km2) as f32, + profil_vallee: if ratios.is_empty() { 0.0 } else { ratios[ratios.len() / 2] }, + profondeur_incision_p90: p90(depths), + } +} + +/// Vrai si `c` est au milieu d'un bief (reçoit exactement un affluent d'ordre >= omin) : il n'est pas un début de bief. +fn recv_prev_same(c: usize, recv: &[Option], chan: &[bool], ord: &[u32], omin: u32, n: usize, w: usize) -> bool { + let (cx, cy) = ((c % w) as i32, (c / w) as i32); + let _ = n; + for d in 0..8 { + let (nx, ny) = (cx + DX[d], cy + DY[d]); + if nx < 0 || ny < 0 { + continue; + } + let ni = ny as usize * w + nx as usize; + if ni < recv.len() && chan[ni] && ord[ni] >= omin && recv[ni] == Some(c) { + return true; + } + } + false +} diff --git a/signature/src/grid.rs b/signature/src/grid.rs new file mode 100644 index 0000000..51e1c7d --- /dev/null +++ b/signature/src/grid.rs @@ -0,0 +1,112 @@ +//! Grille d'altitudes (f32, mètres) et utilitaires de rééchantillonnage. +#[derive(Clone, Debug)] +pub struct Raster { + pub w: usize, + pub h: usize, + /// Taille d'une cellule en mètres. + pub pas_m: f32, + /// Ligne par ligne, nord en premier. Les valeurs non finies sont traitées comme « sans donnée ». + pub z: Vec, +} + +impl Raster { + pub fn new(w: usize, h: usize, pas_m: f32, z: Vec) -> Raster { + assert_eq!(w * h, z.len(), "taille de grille incohérente"); + Raster { w, h, pas_m, z } + } + pub fn from_fn(w: usize, h: usize, pas_m: f32, f: impl Fn(f32, f32) -> f32) -> Raster { + let mut z = Vec::with_capacity(w * h); + for y in 0..h { + for x in 0..w { + z.push(f(x as f32 * pas_m, y as f32 * pas_m)); + } + } + Raster { w, h, pas_m, z } + } + #[inline] + pub fn at(&self, x: usize, y: usize) -> f32 { + self.z[y * self.w + x] + } + /// Moyenne par blocs de `k`×`k` (réduction de résolution). Ignore les valeurs non finies. + pub fn coarsen(&self, k: usize) -> Raster { + if k <= 1 { + return self.clone(); + } + let (nw, nh) = (self.w / k, self.h / k); + let mut z = Vec::with_capacity(nw * nh); + for by in 0..nh { + for bx in 0..nw { + let (mut s, mut n) = (0.0f64, 0u32); + for dy in 0..k { + for dx in 0..k { + let v = self.at(bx * k + dx, by * k + dy); + if v.is_finite() { + s += v as f64; + n += 1; + } + } + } + z.push(if n > 0 { (s / n as f64) as f32 } else { f32::NAN }); + } + } + Raster { w: nw, h: nh, pas_m: self.pas_m * k as f32, z } + } + pub fn crop(&self, x0: usize, y0: usize, w: usize, h: usize) -> Raster { + let mut z = Vec::with_capacity(w * h); + for y in y0..y0 + h { + z.extend_from_slice(&self.z[y * self.w + x0..y * self.w + x0 + w]); + } + Raster { w, h, pas_m: self.pas_m, z } + } + /// Remplace les trous par la moyenne globale (simple, suffisant pour des tuiles quasi complètes). + pub fn filled(&self) -> Raster { + let (s, n) = self.z.iter().filter(|v| v.is_finite()).fold((0.0f64, 0usize), |a, v| (a.0 + *v as f64, a.1 + 1)); + let m = if n > 0 { (s / n as f64) as f32 } else { 0.0 }; + Raster { z: self.z.iter().map(|v| if v.is_finite() { *v } else { m }).collect(), ..self.clone() } + } +} + +/// Lecture d'un .npy float32 2D (C-order, little-endian), version 1.0/2.0. +#[allow(clippy::chunks_exact_with_constant_chunk_size)] +pub fn read_npy_f32(bytes: &[u8]) -> Result<(usize, usize, Vec), String> { + if bytes.len() < 10 || &bytes[..6] != b"\x93NUMPY" { + return Err("pas un fichier .npy".into()); + } + let (hlen, off) = if bytes[6] == 1 { (u16::from_le_bytes([bytes[8], bytes[9]]) as usize, 10) } else { (u32::from_le_bytes([bytes[8], bytes[9], bytes[10], bytes[11]]) as usize, 12) }; + let hdr = std::str::from_utf8(&bytes[off..off + hlen]).map_err(|e| e.to_string())?; + if !hdr.contains(" = sh.split(',').filter_map(|s| s.trim().parse().ok()).collect(); + if d.len() != 2 { + return Err("grille 2D attendue".into()); + } + let data = &bytes[off + hlen..]; + if data.len() < d[0] * d[1] * 4 { + return Err("données tronquées".into()); + } + let z = data.chunks_exact(4).take(d[0] * d[1]).map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]])).collect(); + Ok((d[1], d[0], z)) +} + +/// Lit un GeoTIFF mono-bande (f32/u8/u16/i16...) ; pas lu dans ModelPixelScale (tag 33550), 1 m sinon. +/// Valeurs <= -9000 (nodata) -> NaN. +pub fn lire_geotiff(path: &str) -> Result { + use tiff::decoder::{Decoder, DecodingResult}; + use tiff::tags::Tag; + let f = std::fs::File::open(path).map_err(|e| format!("{path}: {e}"))?; + let mut d = Decoder::new(std::io::BufReader::new(f)).map_err(|e| e.to_string())?; + let (w, h) = d.dimensions().map_err(|e| e.to_string())?; + let pas = d.get_tag_f64_vec(Tag::Unknown(33550)).ok().and_then(|v| v.first().copied()).unwrap_or(1.0) as f32; + let z: Vec = match d.read_image().map_err(|e| e.to_string())? { + DecodingResult::F32(v) => v, + DecodingResult::F64(v) => v.into_iter().map(|x| x as f32).collect(), + DecodingResult::U8(v) => v.into_iter().map(|x| x as f32).collect(), + DecodingResult::U16(v) => v.into_iter().map(|x| x as f32).collect(), + DecodingResult::I16(v) => v.into_iter().map(|x| x as f32).collect(), + _ => return Err("type de pixel non supporté".into()), + }; + let z = z.into_iter().map(|v| if v <= -9000.0 { f32::NAN } else { v }).collect(); + Ok(Raster::new(w as usize, h as usize, pas, z)) +} diff --git a/signature/src/lib.rs b/signature/src/lib.rs new file mode 100644 index 0000000..b36c7b6 --- /dev/null +++ b/signature/src/lib.rs @@ -0,0 +1,486 @@ +//! Signature morphométrique d'un relief et distance de ressemblance (rapport 20, § 3). +//! +//! Indépendant de Pumpkin. Unités physiques (m, degrés, km/km²). Le MNT est ramené au pas +//! `Params::pas_travail_m` (1 m par défaut) : une grille plus fine est réduite par moyenne de +//! blocs, une grille plus grossière (5, 25 m) est gardée telle quelle et sa résolution native est +//! consignée dans `source`. +//! +//! Extension : ajouter un champ à `Signature`, le calculer dans `mesurer_raster`, puis l'exposer +//! dans `Signature::groupes` (valeurs normalisées ~0..1) pour qu'il entre dans `distance`. +//! `archetype` moyenne tous les champs numériques automatiquement (via JSON). +#![forbid(unsafe_code)] +pub mod drainage; +pub mod grid; +pub mod spectre; +use rt_core::proc::{BiomeRelief, ClasseSol, Roche}; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +pub use grid::{lire_geotiff, Raster}; + +/// Métadonnées fournies par l'appelant (meta.json de l'agent 2). +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct MetaSource { + pub biome: BiomeRelief, + pub pays: String, + pub jeu: String, + /// [ouest, sud, est, nord] en WGS84. + pub emprise_wgs84: [f64; 4], + pub roche_dominante: Roche, + /// Part des conifères dans la classe « arbres » de WorldCover [À VÉRIFIER]. + pub part_coniferes: f32, + /// Altitudes basses des étages montagnard, subalpin, alpin, nival (m) [À VÉRIFIER : valeurs alpines]. + pub limites_etages_m: [f32; 4], +} +impl Default for MetaSource { + fn default() -> Self { + MetaSource { biome: BiomeRelief::Plaine, pays: String::new(), jeu: String::new(), emprise_wgs84: [0.0; 4], roche_dominante: Roche::Calcaire, part_coniferes: 0.5, limites_etages_m: [800.0, 1600.0, 2300.0, 3000.0] } + } +} +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct SourceMnt { + pub pays: String, + pub jeu: String, + pub resolution_native_m: f32, + pub emprise_wgs84: [f64; 4], +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Params { + /// Pas de travail (m). 1.0 d'après le cadrage. + pub pas_travail_m: f32, + /// Marge retirée sur chaque bord (m), ignorée si elle mangerait plus de la moitié de l'emprise. + pub marge_m: f32, + /// σ gaussiens (m) des résidus de rugosité (approximés par un filtre boîte de même variance). + pub sigmas_m: [f32; 6], + /// Aire amont minimale d'un chenal (m²) : 0,05 km². + pub seuil_chenal_m2: f32, + pub profondeur_cuvette_m: f32, + pub pente_falaise_deg: f32, +} +impl Default for Params { + fn default() -> Self { + Params { pas_travail_m: 1.0, marge_m: 250.0, sigmas_m: [4.0, 16.0, 64.0, 256.0, 1024.0, 2048.0], seuil_chenal_m2: 50_000.0, profondeur_cuvette_m: 2.0, pente_falaise_deg: 60.0 } + } +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Signature { + pub biome: BiomeRelief, + pub source: SourceMnt, + pub hypso: [f32; 11], + pub relief_m: f32, + pub integrale_hypso: f32, + pub pente_hist: [f32; 18], + pub pente_p50: f32, + pub pente_p90: f32, + /// log10 de la puissance moyenne par octave de longueur d'onde (2-4 m ... 4096-8192 m), 0 si hors portée. + pub spectre: [f32; 12], + pub hurst: f32, + /// Écart type (m) des résidus pour σ = 4, 16, 64, 256, 1024, 2048 m ; 0 si la fenêtre dépasse l'emprise. + pub rugosite: [f32; 6], + pub densite_drainage: f32, + pub rapport_bifurcation: f32, + pub part_cuvettes: f32, + pub densite_dolines: f32, + /// 0 si aucun tronçon mesurable. + pub sinuosite_rivieres: f32, + pub sinuosite_cote: Option, + pub part_falaises: f32, + pub hauteur_falaise_p90: f32, + pub profil_vallee: f32, + pub profondeur_incision_p90: f32, + pub aspect_hist: [f32; 8], + /// [plan p10, plan p90, profil p10, profil p90] (1/m, Zevenbergen-Thorne). + pub courbure: [f32; 4], + /// Collinéen, montagnard, subalpin, alpin, nival. + pub etages: [f32; 5], + pub sols: Vec<(ClasseSol, f32)>, + pub roche: Roche, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct SignatureCible { + pub moyenne: Signature, + pub tol: Signature, + pub regions: Vec, +} + +fn pct(sorted: &[f32], q: f32) -> f32 { + if sorted.is_empty() { + return 0.0; + } + let p = q * (sorted.len() - 1) as f32; + let (i, f) = (p.floor() as usize, p - p.floor()); + sorted[i] * (1.0 - f) + sorted[(i + 1).min(sorted.len() - 1)] * f +} +fn tri(mut v: Vec) -> Vec { + v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v +} + +/// Gradient de Horn : (dz/dx est, dz/dy nord), m/m. +fn horn(g: &Raster, x: usize, y: usize) -> (f32, f32) { + let px = |dx: i32, dy: i32| g.at((x as i32 + dx).clamp(0, g.w as i32 - 1) as usize, (y as i32 + dy).clamp(0, g.h as i32 - 1) as usize); + let gx = ((px(1, -1) + 2.0 * px(1, 0) + px(1, 1)) - (px(-1, -1) + 2.0 * px(-1, 0) + px(-1, 1))) / (8.0 * g.pas_m); + let gs = ((px(-1, 1) + 2.0 * px(0, 1) + px(1, 1)) - (px(-1, -1) + 2.0 * px(0, -1) + px(1, -1))) / (8.0 * g.pas_m); + (gx, -gs) +} + +fn sigma_residus(g: &Raster, r: usize) -> f32 { + let (w, h) = (g.w, g.h); + if 2 * r + 1 > w.min(h) { + return 0.0; + } + let mut ii = vec![0.0f64; (w + 1) * (h + 1)]; + for y in 0..h { + let mut row = 0.0; + for x in 0..w { + row += g.at(x, y) as f64; + ii[(y + 1) * (w + 1) + x + 1] = ii[y * (w + 1) + x + 1] + row; + } + } + let (mut s, mut s2) = (0.0f64, 0.0f64); + for y in 0..h { + let (y0, y1) = (y.saturating_sub(r), (y + r + 1).min(h)); + for x in 0..w { + let (x0, x1) = (x.saturating_sub(r), (x + r + 1).min(w)); + let sum = ii[y1 * (w + 1) + x1] - ii[y0 * (w + 1) + x1] - ii[y1 * (w + 1) + x0] + ii[y0 * (w + 1) + x0]; + let res = g.at(x, y) as f64 - sum / ((x1 - x0) * (y1 - y0)) as f64; + s += res; + s2 += res * res; + } + } + let n = (w * h) as f64; + ((s2 / n) - (s / n) * (s / n)).max(0.0).sqrt() as f32 +} + +fn code_sol(code: u8, meta: &MetaSource, pente_deg: f32) -> Option { + Some(match code { + 10 => if meta.part_coniferes >= 0.5 { ClasseSol::Coniferes } else { ClasseSol::Feuillus }, + 20 => ClasseSol::Lande, + 30 | 100 => ClasseSol::Prairie, + 40 => ClasseSol::Culture, + 60 => if pente_deg > 35.0 { ClasseSol::RocheNue } else { ClasseSol::Eboulis }, + 70 => ClasseSol::Glace, + 80 | 90 | 95 => ClasseSol::Eau, + _ => return None, + }) +} + +/// Mesure un MNT (pas natif quelconque) ; `occ` = occupation du sol ESA WorldCover (codes) optionnelle. +pub fn mesurer(mnt: &Raster, occ: Option<&Raster>, meta: &MetaSource) -> Signature { + mesurer_params(mnt, occ, meta, &Params::default()) +} + +pub fn mesurer_params(mnt: &Raster, occ: Option<&Raster>, meta: &MetaSource, p: &Params) -> Signature { + let k = (p.pas_travail_m / mnt.pas_m).round().max(1.0) as usize; + let mut g = mnt.coarsen(k).filled(); + let m = (p.marge_m / g.pas_m) as usize; + if m > 0 && g.w.min(g.h) > 4 * m { + g = g.crop(m, m, g.w - 2 * m, g.h - 2 * m); + } + let mut s = mesurer_raster(&g, meta, p); + s.source.resolution_native_m = mnt.pas_m; + if let Some(o) = occ { + let (mut cnt, mut tot) = (BTreeMap::::new(), 0.0); + for y in 0..g.h { + for x in 0..g.w { + let (ox, oy) = ((((x + m) as f32) * g.pas_m / o.pas_m) as usize, (((y + m) as f32) * g.pas_m / o.pas_m) as usize); + if ox >= o.w || oy >= o.h { + continue; + } + let (gx, gy) = horn(&g, x, y); + let deg = (gx * gx + gy * gy).sqrt().atan().to_degrees(); + if let Some(c) = code_sol(o.at(ox, oy) as u8, meta, deg) { + *cnt.entry(c as u8).or_default() += 1.0; + tot += 1.0; + } + } + } + const TOUTES: [ClasseSol; 10] = [ClasseSol::Feuillus, ClasseSol::Coniferes, ClasseSol::Prairie, ClasseSol::Culture, ClasseSol::RocheNue, ClasseSol::Eboulis, ClasseSol::Glace, ClasseSol::Eau, ClasseSol::Lande, ClasseSol::Sable]; + s.sols = TOUTES.iter().filter_map(|c| cnt.get(&(*c as u8)).map(|n| (*c, n / tot))).collect(); + } + s +} + +/// Même calcul appliqué à un monde généré (hauteurs en mètres, `w` colonnes, pas `pas_m`). +pub fn mesurer_hauteurs(h: &[f32], w: usize, pas_m: f32) -> Signature { + let g = Raster::new(w, h.len() / w, pas_m, h.to_vec()); + mesurer_raster(&g, &MetaSource::default(), &Params { marge_m: 0.0, ..Params::default() }) +} + +pub fn mesurer_raster(g: &Raster, meta: &MetaSource, p: &Params) -> Signature { + let (w, h) = (g.w, g.h); + assert!(w >= 8 && h >= 8, "grille trop petite"); + let n = (w * h) as f32; + // Hypsométrie + let zs = tri(g.z.clone()); + let (zmin, zmax) = (zs[0], zs[zs.len() - 1]); + let relief = zmax - zmin; + let mut hypso = [0.0; 11]; + for (i, v) in hypso.iter_mut().enumerate() { + *v = if relief > 0.0 { (pct(&zs, i as f32 / 10.0) - zmin) / relief } else { 0.0 }; + } + let integrale = if relief > 0.0 { g.z.iter().map(|z| (z - zmin) / relief).sum::() / n } else { 0.0 }; + // Pentes, exposition, falaises + let (mut ph, mut pentes, mut aspect) = ([0u32; 18], Vec::with_capacity(w * h), [0.0f64; 8]); + let mut falaise = vec![false; w * h]; + for y in 0..h { + for x in 0..w { + let (gx, gn) = horn(g, x, y); + let deg = (gx * gx + gn * gn).sqrt().atan().to_degrees(); + ph[((deg / 5.0) as usize).min(17)] += 1; + pentes.push(deg); + falaise[y * w + x] = deg > p.pente_falaise_deg; + if deg > 0.01 { + let az = (-gx).atan2(-gn).to_degrees().rem_euclid(360.0); + aspect[(((az + 22.5) / 45.0) as usize) % 8] += deg as f64; + } + } + } + let pentes = tri(pentes); + let asum: f64 = aspect.iter().sum::().max(1e-9); + let mut aspect_hist = [0.0; 8]; + for i in 0..8 { + aspect_hist[i] = (aspect[i] / asum) as f32; + } + let mut pente_hist = [0.0; 18]; + for i in 0..18 { + pente_hist[i] = ph[i] as f32 / n; + } + // Falaises : composantes connexes, hauteur = dénivelé de la bande. + let (mut vu, mut hauteurs, mut nf) = (vec![false; w * h], vec![], 0usize); + for s in 0..w * h { + if !falaise[s] { + continue; + } + nf += 1; + if vu[s] { + continue; + } + vu[s] = true; + let (mut pile, mut lo, mut hi) = (vec![s], f32::MAX, f32::MIN); + while let Some(c) = pile.pop() { + lo = lo.min(g.z[c]); + hi = hi.max(g.z[c]); + let (cx, cy) = ((c % w) as i32, (c / w) as i32); + for dy in -1..=1 { + for dx in -1..=1 { + let (nx, ny) = (cx + dx, cy + dy); + if nx < 0 || ny < 0 || nx >= w as i32 || ny >= h as i32 { + continue; + } + let ni = ny as usize * w + nx as usize; + if falaise[ni] && !vu[ni] { + vu[ni] = true; + pile.push(ni); + } + } + } + } + hauteurs.push(hi - lo); + } + let hauteur_falaise_p90 = pct(&tri(hauteurs), 0.9); + // Courbures de Zevenbergen-Thorne + let (mut plan, mut prof) = (vec![], vec![]); + let l = g.pas_m; + for y in 1..h - 1 { + for x in 1..w - 1 { + let z = |dx: i32, dy: i32| g.at((x as i32 + dx) as usize, (y as i32 + dy) as usize); + let (z1, z2, z3, z4, z5, z6, z7, z8, z9) = (z(-1, -1), z(0, -1), z(1, -1), z(-1, 0), z(0, 0), z(1, 0), z(-1, 1), z(0, 1), z(1, 1)); + let d = ((z4 + z6) / 2.0 - z5) / (l * l); + let e = ((z2 + z8) / 2.0 - z5) / (l * l); + let f = (-z1 + z3 + z7 - z9) / (4.0 * l * l); + let gg = (-z4 + z6) / (2.0 * l); + let hh = (z2 - z8) / (2.0 * l); + let q = gg * gg + hh * hh; + if q > 1e-8 { + prof.push(-2.0 * (d * gg * gg + e * hh * hh + f * gg * hh) / q); + plan.push(2.0 * (d * hh * hh + e * gg * gg - f * gg * hh) / q); + } else { + prof.push(0.0); + plan.push(0.0); + } + } + } + let (plan, prof) = (tri(plan), tri(prof)); + let courbure = [pct(&plan, 0.1), pct(&plan, 0.9), pct(&prof, 0.1), pct(&prof, 0.9)]; + // Rugosité multi-échelle, spectre + let mut rugosite = [0.0; 6]; + for (i, s) in p.sigmas_m.iter().enumerate() { + let r = (s * 3f32.sqrt() / g.pas_m).round().max(1.0) as usize; + rugosite[i] = sigma_residus(g, r); + } + let (spectre_o, hurst) = spectre::spectre_et_hurst(g); + let hy = drainage::analyse(g, p.seuil_chenal_m2, p.profondeur_cuvette_m); + // Étages + let mut etages = [0.0; 5]; + for z in &g.z { + let i = p.etage(*z, meta); + etages[i] += 1.0 / n; + } + Signature { + biome: meta.biome, + source: SourceMnt { pays: meta.pays.clone(), jeu: meta.jeu.clone(), resolution_native_m: g.pas_m, emprise_wgs84: meta.emprise_wgs84 }, + hypso, + relief_m: relief, + integrale_hypso: integrale, + pente_hist, + pente_p50: pct(&pentes, 0.5), + pente_p90: pct(&pentes, 0.9), + spectre: spectre_o, + hurst, + rugosite, + densite_drainage: hy.densite_drainage, + rapport_bifurcation: hy.rapport_bifurcation, + part_cuvettes: hy.part_cuvettes, + densite_dolines: hy.densite_dolines, + sinuosite_rivieres: hy.sinuosite_rivieres, + sinuosite_cote: None, // [À VÉRIFIER] non mesurée : demande l'isoligne 0 (biomes côtiers, agent 4) + part_falaises: nf as f32 / n, + hauteur_falaise_p90, + profil_vallee: hy.profil_vallee, + profondeur_incision_p90: hy.profondeur_incision_p90, + aspect_hist, + courbure, + etages, + sols: vec![], + roche: meta.roche_dominante, + } +} + +impl Params { + fn etage(&self, z: f32, meta: &MetaSource) -> usize { + let l = meta.limites_etages_m; + (z >= l[0]) as usize + (z >= l[1]) as usize + (z >= l[2]) as usize + (z >= l[3]) as usize + } +} + +impl Signature { + pub fn to_json(&self) -> String { + serde_json::to_string_pretty(self).unwrap() + } + pub fn from_json(s: &str) -> Result { + serde_json::from_str(s) + } + + /// Groupes de descripteurs normalisés (~0..1) servant à `distance`. + pub fn groupes(&self) -> Vec<(&'static str, Vec)> { + let mut sl: Vec = self.pente_hist.iter().map(|f| f.sqrt()).collect(); + sl.extend([self.pente_p50 / 45.0, self.pente_p90 / 45.0]); + let sp = self.spectre.iter().map(|v| v / 8.0).collect(); + let ru = self.rugosite.iter().zip(&self.sigmas_ref()).map(|(r, s)| (2.0 * r / s).min(1.0)).collect(); + let mut hy = self.hypso.to_vec(); + hy.push(self.integrale_hypso); + vec![ + ("hypsometrie", hy), + ("relief_total", vec![(1.0 + self.relief_m).log10() / 3.0]), + ("pentes", sl), + ("spectre", sp), + ("hurst", vec![self.hurst]), + ("rugosite", ru), + ("drainage", vec![(self.densite_drainage / 20.0).min(1.0), (self.rapport_bifurcation / 6.0).min(1.0), (self.sinuosite_rivieres - 1.0).clamp(0.0, 1.0)]), + ("cuvettes", vec![self.part_cuvettes.sqrt(), (self.densite_dolines / 100.0).min(1.0)]), + ("falaises", vec![self.part_falaises.sqrt(), (self.hauteur_falaise_p90 / 100.0).min(1.0)]), + ("vallees", vec![(self.profil_vallee / 20.0).min(1.0), (self.profondeur_incision_p90 / 300.0).min(1.0)]), + ("exposition", self.aspect_hist.iter().map(|f| f.sqrt()).collect()), + ("courbure", self.courbure.iter().map(|c| (c * 20.0).clamp(-1.0, 1.0)).collect()), + ("etages", self.etages.to_vec()), + ("sols", [ClasseSol::Feuillus, ClasseSol::Coniferes, ClasseSol::Prairie, ClasseSol::Culture, ClasseSol::RocheNue, ClasseSol::Eboulis, ClasseSol::Glace, ClasseSol::Eau, ClasseSol::Lande, ClasseSol::Sable].iter().map(|c| self.sols.iter().find(|s| s.0 == *c).map_or(0.0, |s| s.1)).collect()), + ] + } + fn sigmas_ref(&self) -> [f32; 6] { + Params::default().sigmas_m + } +} + +/// Poids par groupe (1.0 si absent). +#[derive(Clone, Debug, Serialize, Deserialize, Default)] +pub struct Poids(pub BTreeMap); +impl Poids { + pub fn get(&self, g: &str) -> f32 { + *self.0.get(g).unwrap_or(&1.0) + } +} + +/// Distance pondérée (0 = identiques) : moyenne pondérée des écarts RMS par groupe. +pub fn distance_avec(a: &Signature, b: &Signature, w: &Poids) -> f32 { + let (ga, gb) = (a.groupes(), b.groupes()); + let (mut num, mut den) = (0.0, 0.0); + for ((name, va), (_, vb)) in ga.iter().zip(&gb) { + let n = va.len().min(vb.len()).max(1); + let ms: f32 = va.iter().zip(vb).map(|(x, y)| (x - y) * (x - y)).sum::() / n as f32; + let wt = w.get(name); + num += wt * ms.sqrt(); + den += wt; + } + if den > 0.0 { num / den } else { 0.0 } +} +pub fn distance(a: &Signature, b: &Signature) -> f32 { + distance_avec(a, b, &Poids::default()) +} + +fn moyenne_json(vals: &[serde_json::Value]) -> (serde_json::Value, serde_json::Value) { + use serde_json::Value; + match &vals[0] { + Value::Number(_) => { + let v: Vec = vals.iter().filter_map(|x| x.as_f64()).collect(); + let m = v.iter().sum::() / v.len() as f64; + let tol = v.iter().cloned().fold(f64::MIN, f64::max) - v.iter().cloned().fold(f64::MAX, f64::min); + (m.into(), tol.into()) + } + Value::Array(a) if a.iter().all(|x| x.is_number()) => { + let (mut ms, mut ts) = (vec![], vec![]); + for i in 0..a.len() { + let col: Vec = vals.iter().filter_map(|v| v.get(i).cloned()).collect(); + let (m, t) = moyenne_json(&col); + ms.push(m); + ts.push(t); + } + (Value::Array(ms), Value::Array(ts)) + } + Value::Object(o) => { + let (mut m, mut t) = (serde_json::Map::new(), serde_json::Map::new()); + for k in o.keys() { + let col: Vec = vals.iter().filter_map(|v| v.get(k).cloned()).collect(); + let (a, b) = moyenne_json(&col); + m.insert(k.clone(), a); + t.insert(k.clone(), b); + } + (Value::Object(m), Value::Object(t)) + } + other => (other.clone(), Value::Null), + } +} + +/// Archétype : moyenne champ par champ des régions ; `tol` = étendue (max - min) entre régions. +/// Les champs non numériques (biome, source, roche) viennent de la première région ; `sols` est moyenné par classe. +pub fn archetype(sigs: &[Signature]) -> SignatureCible { + assert!(!sigs.is_empty()); + let js: Vec = sigs.iter().map(|s| serde_json::to_value(s).unwrap()).collect(); + let (mut m, mut t) = moyenne_json(&js); + for (j, v) in [(&mut m, true), (&mut t, false)] { + let mut par: BTreeMap> = BTreeMap::new(); + for s in sigs { + for c in 0..10u8 { + let x = s.sols.iter().find(|e| e.0 as u8 == c).map_or(0.0, |e| e.1); + par.entry(c).or_default().push(x); + } + } + let toutes = [ClasseSol::Feuillus, ClasseSol::Coniferes, ClasseSol::Prairie, ClasseSol::Culture, ClasseSol::RocheNue, ClasseSol::Eboulis, ClasseSol::Glace, ClasseSol::Eau, ClasseSol::Lande, ClasseSol::Sable]; + let sols: Vec<(ClasseSol, f32)> = toutes.iter().map(|c| { + let x = &par[&(*c as u8)]; + (*c, if v { x.iter().sum::() / x.len() as f32 } else { x.iter().cloned().fold(f32::MIN, f32::max) - x.iter().cloned().fold(f32::MAX, f32::min) }) + }).filter(|e| e.1 > 0.0 || !v).collect(); + j["sols"] = serde_json::to_value(sols).unwrap(); + } + t["biome"] = js[0]["biome"].clone(); + t["source"] = js[0]["source"].clone(); + t["roche"] = js[0]["roche"].clone(); + t["sinuosite_cote"] = serde_json::Value::Null; + m["sinuosite_cote"] = serde_json::Value::Null; + SignatureCible { moyenne: serde_json::from_value(m).unwrap(), tol: serde_json::from_value(t).unwrap(), regions: sigs.to_vec() } +} + +#[cfg(test)] +mod tests; diff --git a/signature/src/spectre.rs b/signature/src/spectre.rs new file mode 100644 index 0000000..9d85b65 --- /dev/null +++ b/signature/src/spectre.rs @@ -0,0 +1,189 @@ +//! Spectre de puissance radial (FFT 2D radix-2, fenêtre de Hann) : octaves et exposant de Hurst. +use crate::Raster; + +fn fft(re: &mut [f64], im: &mut [f64]) { + let n = re.len(); + let mut j = 0; + for i in 1..n { + let mut bit = n >> 1; + while j & bit != 0 { + j ^= bit; + bit >>= 1; + } + j ^= bit; + if i < j { + re.swap(i, j); + im.swap(i, j); + } + } + let mut len = 2; + while len <= n { + let ang = -2.0 * std::f64::consts::PI / len as f64; + let (wr, wi) = (ang.cos(), ang.sin()); + for s in (0..n).step_by(len) { + let (mut cr, mut ci) = (1.0, 0.0); + for k in 0..len / 2 { + let (a, b) = (s + k, s + k + len / 2); + let (tr, ti) = (re[b] * cr - im[b] * ci, re[b] * ci + im[b] * cr); + re[b] = re[a] - tr; + im[b] = im[a] - ti; + re[a] += tr; + im[a] += ti; + let nr = cr * wr - ci * wi; + ci = cr * wi + ci * wr; + cr = nr; + } + } + len <<= 1; + } +} + +/// Puissance moyenne par anneau entier r=1..N/2 (cycles par fenêtre) ; `n` = côté (puissance de 2), `pas` en m. +#[allow(clippy::needless_range_loop)] +pub fn anneaux(g: &Raster, nmax: usize) -> (usize, Vec) { + let mut n = 1; + while n * 2 <= g.w.min(g.h).min(nmax) { + n *= 2; + } + let (x0, y0) = ((g.w - n) / 2, (g.h - n) / 2); + // retrait du plan moyen (régression) + let nn = (n * n) as f64; + let (mut sz, mut sx, mut sy) = (0.0, 0.0, 0.0); + let c = (n as f64 - 1.0) / 2.0; + for y in 0..n { + for x in 0..n { + let z = g.at(x0 + x, y0 + y) as f64; + sz += z; + sx += z * (x as f64 - c); + sy += z * (y as f64 - c); + } + } + let var = (n as f64 * n as f64 - 1.0) / 12.0 * nn; + let (mz, ax, ay) = (sz / nn, sx / var, sy / var); + let mut re = vec![0.0; n * n]; + let mut im = vec![0.0; n * n]; + let hann = |i: usize| 0.5 - 0.5 * (2.0 * std::f64::consts::PI * (i as f64 + 0.5) / n as f64).cos(); + for y in 0..n { + for x in 0..n { + let z = g.at(x0 + x, y0 + y) as f64 - mz - ax * (x as f64 - c) - ay * (y as f64 - c); + re[y * n + x] = z * hann(x) * hann(y); + } + } + for y in 0..n { + fft(&mut re[y * n..(y + 1) * n], &mut im[y * n..(y + 1) * n]); + } + let (mut cr, mut ci) = (vec![0.0; n], vec![0.0; n]); + for x in 0..n { + for y in 0..n { + cr[y] = re[y * n + x]; + ci[y] = im[y * n + x]; + } + fft(&mut cr, &mut ci); + for y in 0..n { + re[y * n + x] = cr[y]; + im[y * n + x] = ci[y]; + } + } + let half = n / 2; + let (mut sum, mut cnt) = (vec![0.0; half + 1], vec![0u32; half + 1]); + for ky in 0..n { + for kx in 0..n { + let fx = if kx > half { kx as f64 - n as f64 } else { kx as f64 }; + let fy = if ky > half { ky as f64 - n as f64 } else { ky as f64 }; + let r = (fx * fx + fy * fy).sqrt().round() as usize; + if r >= 1 && r <= half { + sum[r] += re[ky * n + kx].powi(2) + im[ky * n + kx].powi(2); + cnt[r] += 1; + } + } + } + (n, (0..=half).map(|r| if cnt[r] > 0 { sum[r] / cnt[r] as f64 } else { 0.0 }).collect()) +} + +/// (spectre[12] en log10 de puissance par octave de longueur d'onde, hurst). +/// Octave k : longueurs d'onde de 2·2^k à 2·2^(k+1) m (k=0 : 2-4 m ... k=11 : 4096-8192 m). 0.0 si hors de portée. +#[allow(clippy::needless_range_loop)] +pub fn spectre_et_hurst(g: &Raster) -> ([f32; 12], f32) { + let (n, p) = anneaux(g, 2048); + let mut out = [0.0f32; 12]; + if n < 8 { + return (out, 0.0); + } + let l = n as f64 * g.pas_m as f64; // côté physique + for (k, o) in out.iter_mut().enumerate() { + let (lmin, lmax) = (2.0 * 2f64.powi(k as i32), 4.0 * 2f64.powi(k as i32)); + let (mut s, mut c) = (0.0, 0); + for r in 1..p.len() { + let lam = l / r as f64; + if lam >= lmin && lam < lmax && p[r] > 0.0 { + s += p[r]; + c += 1; + } + } + if c > 0 { + *o = (s / c as f64).log10() as f32; + } + } + // Hurst : P(k) ∝ k^-(2H+2) ; régression log-log sur les anneaux 2..N/4, en pondérant de façon égale par octave. + let (mut xs, mut ys) = (vec![], vec![]); + for r in 2..=(n / 4).max(3).min(p.len() - 1) { + if p[r] > 0.0 { + xs.push((r as f64).log10()); + ys.push(p[r].log10()); + } + } + if xs.len() < 3 { + return (out, 0.0); + } + let m = xs.len() as f64; + let (mx, my) = (xs.iter().sum::() / m, ys.iter().sum::() / m); + let slope = xs.iter().zip(&ys).map(|(x, y)| (x - mx) * (y - my)).sum::() / xs.iter().map(|x| (x - mx).powi(2)).sum::(); + let h = ((-slope - 2.0) / 2.0).clamp(0.0, 1.0); + (out, h as f32) +} + +/// Synthèse spectrale d'un fBm de Hurst `h` (côté `n` puissance de 2), utile aux tests et au calage. +pub fn fbm_spectral(n: usize, pas_m: f32, h: f64, seed: u64) -> Raster { + let mut s = seed.wrapping_mul(0x9E3779B97F4A7C15) | 1; + let mut rnd = || { + s ^= s << 13; + s ^= s >> 7; + s ^= s << 17; + (s >> 11) as f64 / (1u64 << 53) as f64 + }; + let (mut re, mut im) = (vec![0.0; n * n], vec![0.0; n * n]); + for ky in 0..n { + for kx in 0..n { + let fx = if kx > n / 2 { kx as f64 - n as f64 } else { kx as f64 }; + let fy = if ky > n / 2 { ky as f64 - n as f64 } else { ky as f64 }; + let k = (fx * fx + fy * fy).sqrt(); + if k == 0.0 { + continue; + } + let amp = k.powf(-(h + 1.0)); + let ph = 2.0 * std::f64::consts::PI * rnd(); + re[ky * n + kx] = amp * ph.cos(); + im[ky * n + kx] = amp * ph.sin(); + } + } + // FFT inverse via conjugaison ; on garde la partie réelle (équivaut à symétriser). + for v in im.iter_mut() { + *v = -*v; + } + for y in 0..n { + fft(&mut re[y * n..(y + 1) * n], &mut im[y * n..(y + 1) * n]); + } + let (mut cr, mut ci) = (vec![0.0; n], vec![0.0; n]); + for x in 0..n { + for y in 0..n { + cr[y] = re[y * n + x]; + ci[y] = im[y * n + x]; + } + fft(&mut cr, &mut ci); + for y in 0..n { + re[y * n + x] = cr[y]; + } + } + let mx = re.iter().fold(0.0f64, |a, v| a.max(v.abs())); + Raster::new(n, n, pas_m, re.iter().map(|v| (v / mx * 500.0) as f32).collect()) +} diff --git a/signature/src/tests.rs b/signature/src/tests.rs new file mode 100644 index 0000000..929de2e --- /dev/null +++ b/signature/src/tests.rs @@ -0,0 +1,180 @@ +use super::*; +use crate::spectre::fbm_spectral; + +fn noise(x: f32, y: f32, seed: u32) -> f32 { + let mut h = ((x as i64 * 73856093) ^ (y as i64 * 19349663) ^ (seed as i64 * 83492791)) as u64; + h = h.wrapping_mul(0x9E3779B97F4A7C15); + ((h >> 40) as f32) / (1u64 << 24) as f32 +} +fn lisse(x: f32, y: f32, lam: f32, seed: u32) -> f32 { + let (u, v) = (x / lam, y / lam); + let (i, j) = (u.floor(), v.floor()); + let (fu, fv) = ((u - i) * (u - i) * (3.0 - 2.0 * (u - i)), (v - j) * (v - j) * (3.0 - 2.0 * (v - j))); + let a = noise(i, j, seed) * (1.0 - fu) + noise(i + 1.0, j, seed) * fu; + let b = noise(i, j + 1.0, seed) * (1.0 - fu) + noise(i + 1.0, j + 1.0, seed) * fu; + a * (1.0 - fv) + b * fv +} +fn fbm(x: f32, y: f32, amp: f32, seed: u32) -> f32 { + (0..4).map(|o| amp * 0.5f32.powi(o) * lisse(x, y, 400.0 / 2f32.powi(o), seed + o as u32)).sum() +} +fn sans_marge() -> Params { + Params { marge_m: 0.0, ..Params::default() } +} +fn mes(g: &Raster, p: &Params) -> Signature { + mesurer_params(g, None, &MetaSource::default(), p) +} + +#[test] +fn plan_incline_pente_unique() { + let t = 30f32.to_radians().tan(); + let s = mes(&Raster::from_fn(200, 200, 10.0, |x, _| 1000.0 + x * t), &Params { pas_travail_m: 10.0, ..sans_marge() }); + assert!((s.pente_p50 - 30.0).abs() < 0.3 && (s.pente_p90 - 30.0).abs() < 0.3); + assert!(s.pente_hist[5] + s.pente_hist[6] > 0.97, "{:?}", s.pente_hist); + assert_eq!(s.part_falaises, 0.0); + // La descente va à l'ouest : tout le poids dans le secteur O (index 6). + assert!(s.aspect_hist[6] > 0.99); + assert!(s.courbure.iter().all(|c| c.abs() < 1e-4)); + let t = 65f32.to_radians().tan(); + let s = mes(&Raster::from_fn(100, 100, 10.0, |x, _| x * t), &Params { pas_travail_m: 10.0, ..sans_marge() }); + assert!(s.part_falaises > 0.95); +} + +#[test] +fn cone_hypsometrie_theorique() { + // z = H (1 - r/R) tronqué à 0 dans un carré de côté 2R : fraction sous t = 1 - sqrt(4(1-q)/pi)... inversé. + let r = 500.0; + let s = mes(&Raster::from_fn(101, 101, 10.0, |x, y| (1.0 - ((x - r).powi(2) + (y - r).powi(2)).sqrt() / r).max(0.0) * 800.0), &Params { pas_travail_m: 10.0, ..sans_marge() }); + assert!((s.relief_m - 800.0).abs() < 1.0); + // médiane : 1 - sqrt(2/pi) = 0.2021 + assert!((s.hypso[5] - 0.2021).abs() < 0.03, "{}", s.hypso[5]); + // hypsométrie convexe (beaucoup de surface basse) : HI faible + assert!(s.integrale_hypso < 0.3, "{}", s.integrale_hypso); + // pente du cône : atan(800/500) = 58 deg + assert!((s.pente_p50 - 58.0).abs() < 3.0, "{}", s.pente_p50); + // exposition uniforme + for b in &s.aspect_hist { + assert!((b - 0.125).abs() < 0.03, "{:?}", s.aspect_hist); + } +} + +#[test] +fn fbm_recupere_hurst() { + for h in [0.3, 0.5, 0.8] { + let g = fbm_spectral(512, 1.0, h, 42); + let s = mes(&g, &sans_marge()); + assert!((s.hurst as f64 - h).abs() < 0.1, "H={h} mesuré {}", s.hurst); + } +} + +#[test] +fn sinusoide_pic_spectral() { + // longueur d'onde 64 m -> octave k=5 (64-128 m) + let s = mes(&Raster::from_fn(256, 256, 1.0, |x, y| 10.0 * (2.0 * std::f32::consts::PI * x / 64.0).sin() + 0.01 * (y * 0.37).sin()), &sans_marge()); + let (imax, _) = s.spectre.iter().enumerate().fold((0, f32::MIN), |a, (i, v)| if *v > a.1 { (i, *v) } else { a }); + assert_eq!(imax, 5, "{:?}", s.spectre); +} + +#[test] +fn plat() { + let s = mes(&Raster::from_fn(100, 100, 10.0, |_, _| 500.0), &Params { pas_travail_m: 10.0, ..sans_marge() }); + assert_eq!(s.relief_m, 0.0); + assert_eq!(s.pente_p90, 0.0); +} + +#[test] +fn rugosite_croissante() { + let p = Params { pas_travail_m: 10.0, sigmas_m: [10.0, 30.0, 100.0, 300.0, 1000.0, 2000.0], ..sans_marge() }; + let calme = mes(&Raster::from_fn(200, 200, 10.0, |x, y| fbm(x, y, 20.0, 1)), &p); + let fort = mes(&Raster::from_fn(200, 200, 10.0, |x, y| fbm(x, y, 400.0, 1)), &p); + for i in 0..4 { + assert!(fort.rugosite[i] > calme.rugosite[i]); + } + assert!(fort.pente_p50 > calme.pente_p50); +} + +#[test] +fn drainage_vallee_et_ordres() { + let g = Raster::from_fn(100, 100, 10.0, |x, y| 0.4 * (x - 500.0).abs() + 0.1 * (1000.0 - y)); + let s = mes(&g, &Params { pas_travail_m: 10.0, seuil_chenal_m2: 10_000.0, ..sans_marge() }); + assert!(s.densite_drainage > 0.5, "{}", s.densite_drainage); + assert!(s.sinuosite_rivieres < 1.1); + let g = Raster::from_fn(250, 250, 10.0, |x, y| fbm(x, y, 600.0, 7) + 0.2 * (2500.0 - y)); + let s = mes(&g, &Params { pas_travail_m: 10.0, seuil_chenal_m2: 5000.0, ..sans_marge() }); + assert!(s.rapport_bifurcation > 1.0, "{}", s.rapport_bifurcation); +} + +#[test] +fn cuvettes_detectees() { + // plan incliné avec un trou carré de 10 m de profondeur + let g = Raster::from_fn(100, 100, 5.0, |x, y| 100.0 + 0.1 * x - if (200.0..300.0).contains(&x) && (200.0..300.0).contains(&y) { 10.0 } else { 0.0 }); + let s = mes(&g, &Params { pas_travail_m: 5.0, ..sans_marge() }); + assert!(s.part_cuvettes > 0.03, "{}", s.part_cuvettes); + assert!(s.densite_dolines > 1.0); +} + +#[test] +fn resolutions_differentes() { + let f = |x: f32, y: f32| 1000.0 + fbm(x, y, 300.0, 3) + 0.15 * x; + let mk = |pas: f32| { + let n = (3000.0 / pas) as usize; + mes(&Raster::from_fn(n, n, pas, f), &Params { pas_travail_m: 10.0, ..sans_marge() }) + }; + let (a, b, c, d) = (mk(2.0), mk(5.0), mk(10.0), mk(30.0)); + assert!(distance(&a, &c) < 0.05 && distance(&b, &c) < 0.05, "{} {}", distance(&a, &c), distance(&b, &c)); + assert_eq!(a.source.resolution_native_m, 2.0); + let autre = mes(&Raster::from_fn(300, 300, 10.0, |x, y| 1000.0 + fbm(x, y, 900.0, 9) + 0.9 * (x - 1500.0).abs()), &Params { pas_travail_m: 10.0, ..sans_marge() }); + assert!(distance(&d, &c) < distance(&autre, &c)); +} + +#[test] +fn distance_et_json() { + let p = Params { pas_travail_m: 10.0, ..sans_marge() }; + let a = mes(&Raster::from_fn(150, 150, 10.0, |x, y| fbm(x, y, 100.0, 1)), &p); + let b = mes(&Raster::from_fn(150, 150, 10.0, |x, y| fbm(x, y, 900.0, 2)), &p); + assert_eq!(distance(&a, &a), 0.0); + assert!((distance(&a, &b) - distance(&b, &a)).abs() < 1e-6); + assert!(distance(&a, &b) > 0.03); + let a2 = Signature::from_json(&a.to_json()).unwrap(); + assert_eq!(distance(&a, &a2), 0.0); + let mut w = Poids::default(); + for (g, _) in a.groupes() { + w.0.insert(g.into(), 0.0); + } + assert_eq!(distance_avec(&a, &b, &w), 0.0); +} + +#[test] +fn archetype_moyenne() { + let p = Params { pas_travail_m: 10.0, ..sans_marge() }; + let a = mes(&Raster::from_fn(150, 150, 10.0, |x, y| fbm(x, y, 100.0, 1)), &p); + let b = mes(&Raster::from_fn(150, 150, 10.0, |x, y| fbm(x, y, 900.0, 2)), &p); + let c = archetype(&[a.clone(), b.clone()]); + assert!((c.moyenne.relief_m - (a.relief_m + b.relief_m) / 2.0).abs() < 1e-2); + assert!((c.tol.relief_m - (a.relief_m - b.relief_m).abs()).abs() < 1e-2); + assert_eq!(c.regions.len(), 2); +} + +#[test] +fn sols_worldcover() { + let mnt = Raster::from_fn(200, 200, 10.0, |x, _| x * 0.1); + let occ = Raster::from_fn(200, 200, 10.0, |x, _| if x < 1000.0 { 30.0 } else { 80.0 }); + let s = mesurer_params(&mnt, Some(&occ), &MetaSource::default(), &Params { pas_travail_m: 10.0, ..sans_marge() }); + let pr = s.sols.iter().find(|e| e.0 == ClasseSol::Prairie).unwrap().1; + assert!((pr - 0.5).abs() < 0.02); +} + +#[test] +fn npy() { + let mut v = b"\x93NUMPY\x01\x00".to_vec(); + let hdr = "{'descr': '