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 à :
1 Parent
a25690363d
révision
6f2445c8a9
12 fichiers modifiés
+1786
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1 @@
|
||||
target/
|
||||
Générée
+193
@@ -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"
|
||||
@@ -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"
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
@@ -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;
|
||||
@@ -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())
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur