signature: crate de mesure de signatures de relief (cadrage 20), CLI signer, 13 tests

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Sonnet 5.5 a révisé 2026-10-30 09:19:18 +01:00
1 Parent a25690363d
révision 6f2445c8a9
12 fichiers modifiés
+1786

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -0,0 +1 @@
target/
+193
Voir le fichier
@@ -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"
+14
Voir le fichier
@@ -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"
+109
Voir le fichier
@@ -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"
}
+109
Voir le fichier
@@ -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"
}
+109
Voir le fichier
@@ -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"
}
+24
Voir le fichier
@@ -0,0 +1,24 @@
//! signer <mnt.tif> [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<String> = 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 <mnt.tif> [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);
}
+260
Voir le fichier
@@ -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<std::cmp::Ordering> {
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>) -> 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<f64> = 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<Option<usize>> = 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<usize> = (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<bool> = 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<u32> = 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<f32> = (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::<f32>() / 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<f64> {
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<Vec<f64>> {
let v: Vec<f64> = (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<f64>| 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<usize>], 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
}
+112
Voir le fichier
@@ -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<f32>,
}
impl Raster {
pub fn new(w: usize, h: usize, pas_m: f32, z: Vec<f32>) -> 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<f32>), 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("<f4") || hdr.contains("True") {
return Err(format!("npy non supporté (attendu <f4, C-order): {hdr}"));
}
let sh = hdr.split("'shape': (").nth(1).ok_or("shape absente")?.split(')').next().unwrap();
let d: Vec<usize> = 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<Raster, String> {
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<f32> = 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))
}
+486
Voir le fichier
@@ -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<f32>,
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<Signature>,
}
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<f32>) -> Vec<f32> {
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<ClasseSol> {
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::<u8, f32>::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::<f32>() / 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::<f64>().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<Signature, serde_json::Error> {
serde_json::from_str(s)
}
/// Groupes de descripteurs normalisés (~0..1) servant à `distance`.
pub fn groupes(&self) -> Vec<(&'static str, Vec<f32>)> {
let mut sl: Vec<f32> = 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<String, f32>);
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::<f32>() / 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<f64> = vals.iter().filter_map(|x| x.as_f64()).collect();
let m = v.iter().sum::<f64>() / 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<Value> = 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<Value> = 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<serde_json::Value> = 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<u8, Vec<f32>> = 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::<f32>() / 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;
+189
Voir le fichier
@@ -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<f64>) {
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::<f64>() / m, ys.iter().sum::<f64>() / m);
let slope = xs.iter().zip(&ys).map(|(x, y)| (x - mx) * (y - my)).sum::<f64>() / xs.iter().map(|x| (x - mx).powi(2)).sum::<f64>();
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())
}
+180
Voir le fichier
@@ -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': '<f4', 'fortran_order': False, 'shape': (2, 3), }";
let pad = 64 - (10 + hdr.len() + 1) % 64;
let hdr = format!("{hdr}{}\n", " ".repeat(pad));
v.extend((hdr.len() as u16).to_le_bytes());
v.extend(hdr.bytes());
for i in 0..6 {
v.extend((i as f32).to_le_bytes());
}
let (w, h, z) = grid::read_npy_f32(&v).unwrap();
assert_eq!((w, h), (3, 2));
assert_eq!(z[5], 5.0);
}