Comparer les révisions
4
Révisions
master
...
biomes-reels
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
1aa76fcb0a | |||
|
|
0918b335db | |||
|
|
32d381e637 | |||
|
|
e9e26ebb2e | |||
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1,2 @@
|
||||
target/
|
||||
*.avant-*
|
||||
Générée
+34
@@ -86,6 +86,12 @@ 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"
|
||||
@@ -143,6 +149,7 @@ dependencies = [
|
||||
"rt-core",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"signature",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -224,6 +231,16 @@ dependencies = [
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "signature"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"rt-core",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"tiff",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "simd-adler32"
|
||||
version = "0.3.10"
|
||||
@@ -241,12 +258,29 @@ dependencies = [
|
||||
"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"
|
||||
|
||||
@@ -13,6 +13,7 @@ rayon = "1.10"
|
||||
|
||||
[dev-dependencies]
|
||||
png = "0.17"
|
||||
signature = { path = "../signature" }
|
||||
|
||||
[profile.release]
|
||||
debug = false
|
||||
|
||||
@@ -0,0 +1,554 @@
|
||||
//! Atlas multi-sites des 8 biomes : score du generateur contre les signatures reelles + calage (rapport 27, reprise du rapport 23).
|
||||
//!
|
||||
//! usage :
|
||||
//! atlas_calage score <donnees/atlas> <dossier_params> <sortie.json> [dossier_f32]
|
||||
//! atlas_calage caler <donnees/atlas> <params_in> <params_out> <biome_id> <evals>
|
||||
//! `biome_id` = bocage | cote_rocheuse | fjord | glaciaire | gorges | karst | plaine | prealpes.
|
||||
//! Les sites sont lus dans `<atlas>/multipays/sites.json` (role "score" : entre dans la moyenne et le tau ; "temoin" : 5 m ou GLO-30, hors score).
|
||||
//!
|
||||
//! Score (cadrage 20, section 8) : x = RMS(gen - moyenne des sites) / tau par sous-groupe, score du sous-groupe = exp(-x^2).
|
||||
//! tau = max(etendue ENTRE sites, etendue intra-site moyenne), plancher 10 % de la norme et 0,02.
|
||||
//! Groupes : hypso 0,20 ; pentes 0,20 ; spectre 0,20 ; drainage 0,15 ; formes (falaises, vallees) 0,15 ; cuvettes 0,10 (critere dedie contre les cuvettes fermees).
|
||||
//! Sols/etages non mesures (poids 0, comme au rapport 23). Acceptation : score >= 0,75, aucun groupe < 0,4, cuvettes >= 0,5, ecart type graines < 0,05,
|
||||
//! et controle de forme respecte (cote_rocheuse : mer et trait de cote ; glaciaire : relief et auge). Mer (cote_rocheuse, fjord) : generateur ramene a max(h, 0).
|
||||
use proc_relief::*;
|
||||
use rayon::prelude::*;
|
||||
use serde_json::{json, Value};
|
||||
use signature::{mesurer, MetaSource, Raster, Signature};
|
||||
use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
const BIOMES: [(&str, &str, BiomeRelief); 8] = [
|
||||
("collines-bocage", "bocage", BiomeRelief::Bocage),
|
||||
("cote-rocheuse", "cote_rocheuse", BiomeRelief::CoteRocheuse),
|
||||
("fjord", "fjord", BiomeRelief::Fjord),
|
||||
("gorges", "gorges", BiomeRelief::Gorges),
|
||||
("haute-montagne-glaciaire", "glaciaire", BiomeRelief::Glaciaire),
|
||||
("plaine-alluviale", "plaine", BiomeRelief::Plaine),
|
||||
("plateau-karstique", "karst", BiomeRelief::Karst),
|
||||
("prealpes-calcaires", "prealpes", BiomeRelief::Prealpes),
|
||||
];
|
||||
const GROUPES: [(&str, f64, &[&str]); 6] = [
|
||||
("hypso", 0.20, &["hypsometrie", "relief_total"]),
|
||||
("pentes", 0.20, &["pentes", "exposition", "courbure"]),
|
||||
("spectre", 0.20, &["spectre", "hurst", "rugosite"]),
|
||||
("drainage", 0.15, &["drainage"]),
|
||||
("formes", 0.15, &["falaises", "vallees"]),
|
||||
// groupe special : evalue par `score_cuvettes`
|
||||
("cuvettes", 0.10, &[]),
|
||||
];
|
||||
const PAS: f64 = 2.5;
|
||||
const X0: f64 = 512.0 * 40.0;
|
||||
|
||||
/// Biomes dont la tuile reelle contient la mer (eau = 0 m) : le generateur est ramene a max(h, 0) avant mesure.
|
||||
fn mer(id: &str) -> bool {
|
||||
id == "cote_rocheuse" || id == "fjord"
|
||||
}
|
||||
|
||||
type Vecs = BTreeMap<String, Vec<f32>>;
|
||||
fn vecs(s: &Signature) -> Vecs {
|
||||
s.groupes().into_iter().map(|(n, v)| (n.to_string(), v)).collect()
|
||||
}
|
||||
fn rms(a: &[f32], b: &[f32]) -> f32 {
|
||||
let n = a.len().min(b.len()).max(1);
|
||||
(a.iter().zip(b).map(|(x, y)| (x - y) * (x - y)).sum::<f32>() / n as f32).sqrt()
|
||||
}
|
||||
|
||||
/// Un site reel : ses 4 quadrants (signatures) et ses mesures de forme.
|
||||
struct SiteRef {
|
||||
id: String,
|
||||
pays: String,
|
||||
role: String,
|
||||
regs: Vec<Signature>,
|
||||
forme: BTreeMap<String, f64>,
|
||||
ref_site: Option<Box<Ref>>,
|
||||
}
|
||||
/// Reference multi-sites. moy = moyenne des moyennes de site ; tau = max(etendue entre sites, etendue intra-site moyenne).
|
||||
struct Ref {
|
||||
moy: Vecs,
|
||||
tau: BTreeMap<String, f32>,
|
||||
sigs: Vec<Signature>,
|
||||
sites: Vec<SiteRef>,
|
||||
cuv_hi: f32,
|
||||
cuv_lo: f32,
|
||||
relief_moy: f32,
|
||||
fen_forme: BTreeMap<String, (f64, f64)>,
|
||||
}
|
||||
fn moyenne_vecs(vs: &[&Vecs]) -> Vecs {
|
||||
let mut moy = Vecs::new();
|
||||
for k in vs[0].keys() {
|
||||
let n = vs[0][k].len();
|
||||
moy.insert(k.clone(), (0..n).map(|i| vs.iter().map(|v| v[k][i]).sum::<f32>() / vs.len() as f32).collect());
|
||||
}
|
||||
moy
|
||||
}
|
||||
/// Un seul jeu de regions (regles du rapport 23) : sert au score contre chaque site pris isolement.
|
||||
fn construire_ref(regs: &[Signature]) -> Ref {
|
||||
let vs: Vec<Vecs> = regs.iter().map(vecs).collect();
|
||||
let (mut moy, mut tau) = (Vecs::new(), BTreeMap::new());
|
||||
for k in vs[0].keys() {
|
||||
let n = vs[0][k].len();
|
||||
let m: Vec<f32> = (0..n).map(|i| vs.iter().map(|v| v[k][i]).sum::<f32>() / vs.len() as f32).collect();
|
||||
let etendue: Vec<f32> = (0..n)
|
||||
.map(|i| {
|
||||
let (lo, hi) = vs.iter().fold((f32::MAX, f32::MIN), |a, v| (a.0.min(v[k][i]), a.1.max(v[k][i])));
|
||||
hi - lo
|
||||
})
|
||||
.collect();
|
||||
let t = (etendue.iter().map(|e| e * e).sum::<f32>() / n as f32).sqrt();
|
||||
let norme = (m.iter().map(|e| e * e).sum::<f32>() / n as f32).sqrt();
|
||||
tau.insert(k.clone(), t.max(0.10 * norme).max(0.02));
|
||||
moy.insert(k.clone(), m);
|
||||
}
|
||||
let cuv: Vec<f32> = regs.iter().map(|s| s.part_cuvettes).collect();
|
||||
Ref {
|
||||
moy,
|
||||
tau,
|
||||
sigs: regs.to_vec(),
|
||||
sites: vec![],
|
||||
cuv_hi: cuv.iter().cloned().fold(0.0, f32::max),
|
||||
cuv_lo: cuv.iter().sum::<f32>() / cuv.len() as f32,
|
||||
relief_moy: regs.iter().map(|s| s.relief_m).sum::<f32>() / regs.len() as f32,
|
||||
fen_forme: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
fn construire_ref_multi(mut sites: Vec<SiteRef>) -> Ref {
|
||||
let sc: Vec<usize> = (0..sites.len()).filter(|&i| sites[i].role == "score").collect();
|
||||
let par_site: Vec<Vec<Vecs>> = sc.iter().map(|&i| sites[i].regs.iter().map(vecs).collect()).collect();
|
||||
let moy_site: Vec<Vecs> = par_site.iter().map(|q| moyenne_vecs(&q.iter().collect::<Vec<_>>())).collect();
|
||||
let moy = moyenne_vecs(&moy_site.iter().collect::<Vec<_>>());
|
||||
let mut tau = BTreeMap::new();
|
||||
for k in moy.keys() {
|
||||
let n = moy[k].len();
|
||||
let et: Vec<f32> = (0..n)
|
||||
.map(|i| {
|
||||
let (lo, hi) = moy_site.iter().fold((f32::MAX, f32::MIN), |a, v| (a.0.min(v[k][i]), a.1.max(v[k][i])));
|
||||
let inter = hi - lo;
|
||||
let intra = par_site
|
||||
.iter()
|
||||
.map(|q| {
|
||||
let (l, h) = q.iter().fold((f32::MAX, f32::MIN), |a, v| (a.0.min(v[k][i]), a.1.max(v[k][i])));
|
||||
h - l
|
||||
})
|
||||
.sum::<f32>()
|
||||
/ par_site.len() as f32;
|
||||
inter.max(intra)
|
||||
})
|
||||
.collect();
|
||||
let t = (et.iter().map(|e| e * e).sum::<f32>() / n as f32).sqrt();
|
||||
let norme = (moy[k].iter().map(|e| e * e).sum::<f32>() / n as f32).sqrt();
|
||||
tau.insert(k.clone(), t.max(0.10 * norme).max(0.02));
|
||||
}
|
||||
let sigs: Vec<Signature> = sc.iter().flat_map(|&i| sites[i].regs.clone()).collect();
|
||||
let cuv_hi = sigs.iter().map(|s| s.part_cuvettes).fold(0.0, f32::max);
|
||||
let cuv_lo = sc.iter().map(|&i| sites[i].regs.iter().map(|s| s.part_cuvettes).sum::<f32>() / 4.0).fold(f32::MAX, f32::min);
|
||||
let relief_moy = sigs.iter().map(|s| s.relief_m).sum::<f32>() / sigs.len() as f32;
|
||||
// fenetres de forme : [0,75 x min, 1,35 x max] des moyennes de site (relief : plus serre, 0,8 / 1,25)
|
||||
let mut fen = BTreeMap::new();
|
||||
if let Some(&i0) = sc.first() {
|
||||
for k in sites[i0].forme.keys() {
|
||||
let v: Vec<f64> = sc.iter().map(|&i| sites[i].forme[k]).collect();
|
||||
let (lo, hi) = v.iter().fold((f64::MAX, f64::MIN), |a, x| (a.0.min(*x), a.1.max(*x)));
|
||||
let (fl, fh) = if k == "relief_m" { (0.8, 1.25) } else { (0.75, 1.35) };
|
||||
fen.insert(k.clone(), (lo * fl, hi * fh));
|
||||
}
|
||||
}
|
||||
for s in sites.iter_mut() {
|
||||
s.ref_site = Some(Box::new(construire_ref(&s.regs)));
|
||||
}
|
||||
Ref { moy, tau, sigs, sites, cuv_hi, cuv_lo, relief_moy, fen_forme: fen }
|
||||
}
|
||||
struct Score {
|
||||
total: f64,
|
||||
groupes: BTreeMap<String, f64>,
|
||||
x: BTreeMap<String, f64>,
|
||||
}
|
||||
/// Cuvettes fermees : 1 si la part de cuvettes reste entre un plancher (la moitie du site le moins creuse)
|
||||
/// et un plafond (1,5 x le pire quadrant reel, au moins 0,08 % de la surface) ; decroit en gaussienne au-dela.
|
||||
fn score_cuvettes(g: f32, r: &Ref) -> f64 {
|
||||
let cap = (1.5 * r.cuv_hi).max(0.0008);
|
||||
let plancher = 0.5 * r.cuv_lo;
|
||||
let exces = ((g - cap).max(0.0) / cap) as f64 + ((plancher - g).max(0.0) / plancher.max(1e-6)) as f64;
|
||||
(-exces * exces).exp()
|
||||
}
|
||||
fn score(s: &Signature, r: &Ref) -> Score {
|
||||
let v = vecs(s);
|
||||
let mut x = BTreeMap::new();
|
||||
let mut sc = BTreeMap::new();
|
||||
for (k, vk) in &v {
|
||||
if let Some(m) = r.moy.get(k) {
|
||||
x.insert(k.clone(), (rms(vk, m) / r.tau[k]) as f64);
|
||||
sc.insert(k.clone(), (-(x[k]).powi(2)).exp());
|
||||
}
|
||||
}
|
||||
let (mut tot, mut den) = (0.0, 0.0);
|
||||
let mut groupes = BTreeMap::new();
|
||||
for (g, w, subs) in GROUPES {
|
||||
let m = if g == "cuvettes" { score_cuvettes(s.part_cuvettes, r) } else { subs.iter().filter_map(|s| sc.get(*s)).sum::<f64>() / subs.len() as f64 };
|
||||
groupes.insert(g.to_string(), m);
|
||||
tot += w * m;
|
||||
den += w;
|
||||
}
|
||||
Score { total: tot / den, groupes, x }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- controles de forme (rapport 27)
|
||||
/// Mesures de forme sur une fenetre de hauteurs (m) : cote/mer pour cote_rocheuse et fjord, relief + auge pour glaciaire.
|
||||
fn formes(id: &str, h: &[f32], w: usize, pas: f32) -> BTreeMap<String, f64> {
|
||||
let n = h.len();
|
||||
let mut out = BTreeMap::new();
|
||||
let (mn, mx) = h.iter().fold((f32::MAX, f32::MIN), |a, v| (a.0.min(*v), a.1.max(*v)));
|
||||
out.insert("relief_m".to_string(), (mx - mn) as f64);
|
||||
let hh = n / w;
|
||||
if id == "cote_rocheuse" || id == "fjord" {
|
||||
let sea = |i: usize| h[i] <= 0.5;
|
||||
let nm = (0..n).filter(|&i| sea(i)).count();
|
||||
let mut tr = 0usize;
|
||||
for j in 0..hh {
|
||||
for i in 0..w {
|
||||
let k = j * w + i;
|
||||
if i + 1 < w && sea(k) != sea(k + 1) {
|
||||
tr += 1
|
||||
}
|
||||
if j + 1 < hh && sea(k) != sea(k + w) {
|
||||
tr += 1
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut terre: Vec<f32> = h.iter().cloned().filter(|v| *v > 0.5).collect();
|
||||
terre.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
out.insert("part_mer".to_string(), nm as f64 / n as f64);
|
||||
out.insert("trait_cote_km_par_km2".to_string(), tr as f64 * 1000.0 / (n as f64 * pas as f64));
|
||||
out.insert("terre_p95_m".to_string(), if terre.is_empty() { 0.0 } else { terre[((terre.len() as f64 * 0.95) as usize).min(terre.len() - 1)] as f64 });
|
||||
}
|
||||
if id == "glaciaire" {
|
||||
let (mut paroi, mut bas, mut bas_plat) = (0usize, 0usize, 0usize);
|
||||
for j in 1..hh - 1 {
|
||||
for i in 1..w - 1 {
|
||||
let k = j * w + i;
|
||||
let gx = (h[k + 1] - h[k - 1]) / (2.0 * pas);
|
||||
let gz = (h[k + w] - h[k - w]) / (2.0 * pas);
|
||||
let sl = (gx * gx + gz * gz).sqrt().atan().to_degrees();
|
||||
if sl > 35.0 {
|
||||
paroi += 1
|
||||
}
|
||||
if h[k] < mn + 0.3 * (mx - mn) {
|
||||
bas += 1;
|
||||
if sl < 10.0 {
|
||||
bas_plat += 1
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let m = ((hh - 2) * (w - 2)) as f64;
|
||||
out.insert("part_paroi_35deg".to_string(), paroi as f64 / m);
|
||||
out.insert("fond_plat_part".to_string(), if bas == 0 { 0.0 } else { bas_plat as f64 / bas as f64 });
|
||||
}
|
||||
out
|
||||
}
|
||||
/// Formes qui gatent l'acceptation (fjord : information seulement).
|
||||
fn forme_gate(id: &str) -> bool {
|
||||
id == "cote_rocheuse" || id == "glaciaire"
|
||||
}
|
||||
fn moyenne_formes(v: &[BTreeMap<String, f64>]) -> BTreeMap<String, f64> {
|
||||
v[0].keys().map(|k| (k.clone(), v.iter().map(|m| m[k]).sum::<f64>() / v.len() as f64)).collect()
|
||||
}
|
||||
/// Violations (textes) et ecart relatif total (plafonne a 1) par rapport aux fenetres de reference.
|
||||
fn controle_forme(id: &str, gen: &BTreeMap<String, f64>, r: &Ref) -> (Vec<String>, f64) {
|
||||
let (mut viol, mut ecart) = (vec![], 0.0);
|
||||
for (k, (lo, hi)) in &r.fen_forme {
|
||||
if k == "relief_m" && id == "fjord" {
|
||||
continue;
|
||||
}
|
||||
let g = gen[k];
|
||||
if g < *lo || g > *hi {
|
||||
viol.push(format!("{k} = {g:.3} hors [{lo:.3} ; {hi:.3}]"));
|
||||
ecart += if g < *lo { (lo - g) / lo.max(1e-9) } else { (g - hi) / hi.max(1e-9) };
|
||||
}
|
||||
}
|
||||
if id == "cote_rocheuse" && (gen["part_mer"] < 0.03 || gen["trait_cote_km_par_km2"] <= 0.0) {
|
||||
viol.push("pas de mer / pas de trait de cote".to_string());
|
||||
ecart += 1.0;
|
||||
}
|
||||
(viol, ecart.min(1.0))
|
||||
}
|
||||
|
||||
fn charger_ref(atlas: &str, dir: &str, idb: &str) -> Ref {
|
||||
let lst: Value = serde_json::from_str(&std::fs::read_to_string(format!("{atlas}/multipays/sites.json")).unwrap()).unwrap();
|
||||
let mut sites = vec![];
|
||||
for s in lst[dir].as_array().unwrap() {
|
||||
let id = s["id"].as_str().unwrap().to_string();
|
||||
let regs: Vec<Signature> = (1..=4)
|
||||
.map(|i| Signature::from_json(&std::fs::read_to_string(format!("{atlas}/multipays/signatures/{dir}/{id}/q{i}.json")).unwrap()).unwrap())
|
||||
.collect();
|
||||
let role = s["role"].as_str().unwrap().to_string();
|
||||
let mut forme = BTreeMap::new();
|
||||
if role == "score" {
|
||||
let mut fq = vec![];
|
||||
for i in 1..=4 {
|
||||
let rr = signature::lire_geotiff(&format!("{atlas}/multipays/brut/{dir}/{id}/q{i}.tif")).unwrap();
|
||||
fq.push(formes(idb, &rr.z, rr.w, s["pas_m"].as_f64().unwrap() as f32));
|
||||
}
|
||||
forme = moyenne_formes(&fq);
|
||||
}
|
||||
sites.push(SiteRef { id, pays: s["pays"].as_str().unwrap().to_string(), role, regs, forme, ref_site: None });
|
||||
}
|
||||
construire_ref_multi(sites)
|
||||
}
|
||||
fn charger_params(dp: &str, id: &str) -> ParamsRelief {
|
||||
// chargeur public de la crate ; un fichier absent est une erreur ici (le calage ne doit pas se rabattre en silence sur table_initiale)
|
||||
let b = BIOMES.iter().find(|e| e.1 == id).expect("biome inconnu").2;
|
||||
assert!(std::path::Path::new(&format!("{dp}/{id}.json")).exists(), "paramètres absents : {dp}/{id}.json");
|
||||
charger_params_biome(std::path::Path::new(dp), b).unwrap_or_else(|e| panic!("{e}"))
|
||||
}
|
||||
fn generateur(seed: u64, b: BiomeRelief, p: &ParamsRelief) -> Generateur {
|
||||
let mut t = table_initiale();
|
||||
t[b.index()] = p.clone();
|
||||
Generateur::new(seed, Arc::new(BiomeUnique(b)), t)
|
||||
}
|
||||
fn fenetre(g: &Generateur, x0: f64, z0: f64, n: usize, clamp: bool) -> Vec<f32> {
|
||||
(0..n * n)
|
||||
.into_par_iter()
|
||||
.map(|i| {
|
||||
let h = g.hauteur(x0 + (i % n) as f64 * PAS, z0 + (i / n) as f64 * PAS);
|
||||
if clamp { h.max(0.0) } else { h }
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn sig_fenetre(h: &[f32], w: usize) -> Signature {
|
||||
mesurer(&Raster::new(w, h.len() / w, PAS as f32, h.to_vec()), None, &MetaSource::default())
|
||||
}
|
||||
fn quadrants(h: &[f32], n: usize) -> Vec<Vec<f32>> {
|
||||
let m = n / 2;
|
||||
let mut out = vec![];
|
||||
for (r0, c0) in [(0, 0), (0, m), (m, 0), (m, m)] {
|
||||
let mut q = Vec::with_capacity(m * m);
|
||||
for r in 0..m {
|
||||
q.extend_from_slice(&h[(r0 + r) * n + c0..(r0 + r) * n + c0 + m]);
|
||||
}
|
||||
out.push(q);
|
||||
}
|
||||
out
|
||||
}
|
||||
fn moyenne_scores(ss: &[Score]) -> (f64, BTreeMap<String, f64>) {
|
||||
let n = ss.len() as f64;
|
||||
let mut g = BTreeMap::new();
|
||||
for s in ss {
|
||||
for (k, v) in &s.groupes {
|
||||
*g.entry(k.clone()).or_insert(0.0) += v / n;
|
||||
}
|
||||
}
|
||||
(ss.iter().map(|s| s.total).sum::<f64>() / n, g)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- score final
|
||||
fn cmd_score(a: &[String]) {
|
||||
let (atlas, dp, out) = (&a[0], &a[1], &a[2]);
|
||||
let dirf32 = a.get(3);
|
||||
let seeds = [20261030u64, 7, 99];
|
||||
let mut res = vec![];
|
||||
println!("biome\tscore\tecart_seeds\tmin_groupe\tcuvettes\tforme\tcontrole\tgroupes");
|
||||
for (dir, id, b) in BIOMES {
|
||||
let r = charger_ref(atlas, dir, id);
|
||||
let p = charger_params(dp, id);
|
||||
let n = 2000usize;
|
||||
let (mut par_seed, mut tous, mut fq_all, mut cuv) = (vec![], vec![], vec![], vec![]);
|
||||
for (k, &seed) in seeds.iter().enumerate() {
|
||||
let g = generateur(seed, b, &p);
|
||||
let h = fenetre(&g, X0, X0, n, mer(id));
|
||||
if k == 0 {
|
||||
if let Some(d) = dirf32 {
|
||||
std::fs::create_dir_all(d).unwrap();
|
||||
let bytes: Vec<u8> = h.iter().flat_map(|v| v.to_le_bytes()).collect();
|
||||
std::fs::write(format!("{d}/{dir}.f32"), bytes).unwrap();
|
||||
}
|
||||
}
|
||||
let qs = quadrants(&h, n);
|
||||
let sigs: Vec<Signature> = qs.iter().map(|q| sig_fenetre(q, n / 2)).collect();
|
||||
cuv.extend(sigs.iter().map(|s| s.part_cuvettes as f64));
|
||||
let sc: Vec<Score> = sigs.iter().map(|s| score(s, &r)).collect();
|
||||
fq_all.extend(qs.iter().map(|q| formes(id, q, n / 2, PAS as f32)));
|
||||
let (m, g) = moyenne_scores(&sc);
|
||||
par_seed.push(m);
|
||||
tous.push((m, g, sc));
|
||||
}
|
||||
let moy = par_seed.iter().sum::<f64>() / par_seed.len() as f64;
|
||||
let ec = (par_seed.iter().map(|s| (s - moy).powi(2)).sum::<f64>() / par_seed.len() as f64).sqrt();
|
||||
let gm: BTreeMap<String, f64> = tous[0].1.keys().map(|k| (k.clone(), tous.iter().map(|t| t.1[k]).sum::<f64>() / tous.len() as f64)).collect();
|
||||
let xm: BTreeMap<String, f64> = tous[0].2[0].x.keys().map(|k| (k.clone(), tous.iter().flat_map(|t| t.2.iter()).map(|s| s.x[k]).sum::<f64>() / 12.0)).collect();
|
||||
let min_g = gm.values().cloned().fold(f64::MAX, f64::min);
|
||||
// plafond : chaque quadrant reel (sites du score) note contre la reference
|
||||
let plafond = r.sigs.iter().map(|s| score(s, &r).total).sum::<f64>() / r.sigs.len() as f64;
|
||||
// score contre chaque site pris isolement (le generateur doit rester plausible pour chacun) et accord de chaque site avec la reference
|
||||
let mut par_site = serde_json::Map::new();
|
||||
let gens: Vec<Signature> = vec![]; // (les signatures generees ne sont pas conservees : recalcul ci-dessous a partir de la graine 0)
|
||||
let _ = gens;
|
||||
let hh = fenetre(&generateur(seeds[0], b, &p), X0, X0, n, mer(id));
|
||||
let sgen: Vec<Signature> = quadrants(&hh, n).iter().map(|q| sig_fenetre(q, n / 2)).collect();
|
||||
for s in &r.sites {
|
||||
let rs = s.ref_site.as_ref().unwrap();
|
||||
let sg = sgen.iter().map(|g| score(g, rs).total).sum::<f64>() / 4.0;
|
||||
let sref = s.regs.iter().map(|q| score(q, &r).total).sum::<f64>() / 4.0;
|
||||
par_site.insert(s.id.clone(), json!({"pays": s.pays, "role": s.role, "score_gen_contre_ce_site_seul": sg, "accord_site_reel_avec_reference": sref}));
|
||||
}
|
||||
// formes
|
||||
let fgen = moyenne_formes(&fq_all);
|
||||
let (viol, _) = controle_forme(id, &fgen, &r);
|
||||
let forme_ok = !forme_gate(id) || viol.is_empty();
|
||||
let cuv_m = cuv.iter().sum::<f64>() / cuv.len() as f64;
|
||||
let cuv_s = gm["cuvettes"];
|
||||
let nb_score = r.sites.iter().filter(|s| s.role == "score").count();
|
||||
let accepte = moy >= 0.75 && min_g >= 0.4 && ec < 0.05 && cuv_s >= 0.5 && forme_ok && nb_score >= 2;
|
||||
let controle = if forme_ok { moy } else { moy.min(0.74) };
|
||||
println!("{dir}\t{moy:.3}\t{ec:.3}\t{min_g:.3}\t{cuv_s:.2}\t{}\t{controle:.3}\t{}", if forme_gate(id) { if forme_ok { "ok" } else { "ECHEC" } } else { "info" }, gm.iter().map(|(k, v)| format!("{k} {v:.2}")).collect::<Vec<_>>().join(", "));
|
||||
res.push(json!({"biome": dir, "id": id, "score": moy, "score_controle": controle, "ecart_type_graines": ec, "scores_par_graine": par_seed, "graines": seeds,
|
||||
"groupes": gm, "min_groupe": min_g, "x_moyen_sous_groupes": xm, "plafond_reel_quadrants": plafond,
|
||||
"par_site": par_site, "nb_sites_score": nb_score,
|
||||
"cuvettes": {"part_gen_moyenne": cuv_m, "plafond": (1.5 * r.cuv_hi).max(0.0008), "plancher": 0.5 * r.cuv_lo, "score": cuv_s},
|
||||
"formes": {"gate": forme_gate(id), "gen": fgen, "fenetres_reference": r.fen_forme, "reference_par_site": r.sites.iter().filter(|s| s.role == "score").map(|s| (s.id.clone(), s.forme.clone())).collect::<BTreeMap<_, _>>(), "violations": viol, "ok": forme_ok},
|
||||
"accepte": accepte}));
|
||||
}
|
||||
std::fs::write(out, serde_json::to_string_pretty(&res).unwrap()).unwrap();
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- calage
|
||||
struct Rng(u64);
|
||||
impl Rng {
|
||||
fn u(&mut self) -> f64 {
|
||||
self.0 ^= self.0 << 13;
|
||||
self.0 ^= self.0 >> 7;
|
||||
self.0 ^= self.0 << 17;
|
||||
(self.0 >> 11) as f64 / (1u64 << 53) as f64
|
||||
}
|
||||
fn n(&mut self) -> f64 {
|
||||
let (a, b) = (self.u().max(1e-12), self.u());
|
||||
(-2.0 * a.ln()).sqrt() * (6.283185307 * b).cos()
|
||||
}
|
||||
}
|
||||
const FIXES: [&str; 4] = ["octaves", "lacunarite", "courbe_hypso", "base_m"];
|
||||
fn chemins(v: &Value, pre: &str, out: &mut Vec<String>) {
|
||||
if let Value::Object(o) = v {
|
||||
for (k, x) in o {
|
||||
let c = if pre.is_empty() { k.clone() } else { format!("{pre}/{k}") };
|
||||
match x {
|
||||
Value::Number(_) if !FIXES.contains(&k.as_str()) => out.push(c),
|
||||
Value::Object(_) => chemins(x, &c, out),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
fn acces<'a>(v: &'a mut Value, c: &str) -> &'a mut Value {
|
||||
c.split('/').fold(v, |a, k| a.get_mut(k).unwrap())
|
||||
}
|
||||
fn perturber(p: &ParamsRelief, rng: &mut Rng, sigma: f64) -> ParamsRelief {
|
||||
let mut v = serde_json::to_value(p).unwrap();
|
||||
let mut ch = vec![];
|
||||
chemins(&v, "", &mut ch);
|
||||
let force = (rng.u() * ch.len() as f64) as usize;
|
||||
for (i, c) in ch.iter().enumerate() {
|
||||
if i != force && rng.u() > 0.3 {
|
||||
continue;
|
||||
}
|
||||
let nom = c.rsplit('/').next().unwrap().to_string();
|
||||
let cur = acces(&mut v, c).as_f64().unwrap();
|
||||
let mut nv = if cur == 0.0 { 0.0 } else { cur * (sigma * rng.n()).exp() };
|
||||
let (lo, hi) = match nom.as_str() {
|
||||
"ridge" | "raideur" | "melange" | "fond_plat" | "douceur" | "seuil" => (0.0, 1.0),
|
||||
"gain" => (0.25, 0.8),
|
||||
"angle_talus_deg" => (25.0, 60.0),
|
||||
"amplitude_m" => (3.0, 6000.0),
|
||||
"iterations_hydro" => (0.0, 40000.0),
|
||||
"iterations_therm" => (0.0, 60.0),
|
||||
"rapport" => (1.0, 5.0),
|
||||
"angle_deg" => (-1e9, 1e9),
|
||||
_ => (0.0, 1e9),
|
||||
};
|
||||
nv = nv.clamp(lo, hi);
|
||||
*acces(&mut v, c) = if nom.starts_with("iterations") { json!(nv.round() as u64) } else { json!(nv) };
|
||||
}
|
||||
serde_json::from_value(v).unwrap_or_else(|_| p.clone())
|
||||
}
|
||||
/// Objectif du calage : score + 0,3 x pire groupe - penalite de forme (0,4 x ecart relatif, pour les biomes a controle de forme).
|
||||
fn evaluer(id: &str, b: BiomeRelief, p: &ParamsRelief, r: &Ref) -> (f64, Score, f64) {
|
||||
// 2 fenetres de 2,5 km, graine de calage 11 (differente des graines de controle)
|
||||
let g = generateur(11, b, p);
|
||||
let (mut sc, mut fq) = (vec![], vec![]);
|
||||
for (dx, dz) in [(0.0, 0.0), (7000.0, 3000.0)] {
|
||||
let h = fenetre(&g, X0 + dx, X0 + dz, 1000, mer(id));
|
||||
sc.push(score(&sig_fenetre(&h, 1000), r));
|
||||
fq.push(formes(id, &h, 1000, PAS as f32));
|
||||
}
|
||||
let (m, gm) = moyenne_scores(&sc);
|
||||
let min_g = gm.values().cloned().fold(f64::MAX, f64::min);
|
||||
let pen = if forme_gate(id) { controle_forme(id, &moyenne_formes(&fq), r).1 } else { 0.0 };
|
||||
(m + 0.3 * min_g - 0.4 * pen, Score { total: m, groupes: gm, x: BTreeMap::new() }, pen)
|
||||
}
|
||||
fn cmd_caler(a: &[String]) {
|
||||
let (atlas, pin, pout, id, evals) = (&a[0], &a[1], &a[2], &a[3], a[4].parse::<usize>().unwrap());
|
||||
let (dir, _, b) = *BIOMES.iter().find(|e| e.1 == id).expect("biome inconnu");
|
||||
let r = charger_ref(atlas, dir, id);
|
||||
let mut p = charger_params(pin, id);
|
||||
// 6e argument : decalage de graine du tirage ; 7e = "garder" : repart des params d'entree sans refaire l'etape analytique (affinage)
|
||||
let decal: u64 = a.get(5).and_then(|v| v.parse().ok()).unwrap_or(0);
|
||||
let garder = a.get(6).map(|v| v == "garder").unwrap_or(false);
|
||||
// etape analytique (regle d'inversion du cadrage, 4.2) : amplitude = relief reel moyen, courbe = hypsometrie reelle moyenne (moyenne des sites)
|
||||
let hy = r.moy["hypsometrie"].clone();
|
||||
let rel = r.relief_moy;
|
||||
let mut h_i: Vec<f32> = (0..11).map(|i| hy[i] * rel).collect();
|
||||
if !garder { p.amplitude_m = rel; }
|
||||
if garder {
|
||||
} else if mer(id) {
|
||||
// mer : les quantiles a 0 m sont de l'eau. On leur donne un fond negatif (profondeur d) ; la mesure clampe a 0 comme le reel.
|
||||
let d = if id == "fjord" { 150.0f32 } else { 40.0 };
|
||||
let is = (0..11).rev().find(|&i| h_i[i] <= 0.5);
|
||||
if let Some(is) = is.filter(|&i| i >= 1) {
|
||||
for i in 0..=is {
|
||||
h_i[i] = -d * (1.0 - i as f32 / is as f32);
|
||||
}
|
||||
p.base_m = -d;
|
||||
p.amplitude_m = rel + d;
|
||||
for i in 0..11 {
|
||||
p.courbe_hypso[i] = (h_i[i] + d) / (rel + d);
|
||||
}
|
||||
} else {
|
||||
for i in 0..11 {
|
||||
p.courbe_hypso[i] = hy[i];
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for i in 0..11 {
|
||||
p.courbe_hypso[i] = hy[i];
|
||||
}
|
||||
}
|
||||
let (mut best, sb, pen) = evaluer(id, b, &p, &r);
|
||||
println!("{id} analytique : obj {best:.3} score {:.3} pen_forme {pen:.2} groupes {:?}", sb.total, sb.groupes);
|
||||
let mut rng = Rng(0x9E3779B97F4A7C15 ^ (id.len() as u64 * 7919) ^ decal.wrapping_mul(0x2545F4914F6CDD1D));
|
||||
let (mut sigma, mut sans) = (0.35, 0);
|
||||
for e in 0..evals {
|
||||
let q = perturber(&p, &mut rng, sigma);
|
||||
let (o, s, pn) = evaluer(id, b, &q, &r);
|
||||
if o > best {
|
||||
best = o;
|
||||
p = q;
|
||||
sans = 0;
|
||||
println!("{id} eval {e}: obj {o:.3} score {:.3} pen {pn:.2} groupes {}", s.total, s.groupes.iter().map(|(k, v)| format!("{k} {v:.2}")).collect::<Vec<_>>().join(" "));
|
||||
} else {
|
||||
sans += 1;
|
||||
if sans % 8 == 0 {
|
||||
sigma = (sigma * 0.8_f64).max(0.08);
|
||||
}
|
||||
}
|
||||
}
|
||||
std::fs::create_dir_all(pout).unwrap();
|
||||
std::fs::write(format!("{pout}/{id}.json"), serde_json::to_string_pretty(&p).unwrap()).unwrap();
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().skip(1).collect();
|
||||
match a.first().map(|s| s.as_str()) {
|
||||
Some("score") => cmd_score(&a[1..]),
|
||||
Some("caler") => cmd_caler(&a[1..]),
|
||||
_ => eprintln!("usage: atlas_calage score|caler ..."),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
//! Chargeur des paramètres calés : `<dossier>/<biome>.json` (format = `ParamsRelief` sérialisé).
|
||||
//!
|
||||
//! Règle : fichier absent → repli sur `params_initiaux` (jamais d'erreur) ; fichier
|
||||
//! présent mais illisible ou invalide → `Err` (on ne masque pas un JSON cassé).
|
||||
|
||||
use std::fmt;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::params::params_initiaux;
|
||||
use crate::relief::ParamsRelief;
|
||||
use crate::types::BiomeRelief;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum ErreurParams {
|
||||
Lecture { fichier: PathBuf, cause: std::io::Error },
|
||||
Json { fichier: PathBuf, cause: serde_json::Error },
|
||||
}
|
||||
|
||||
impl fmt::Display for ErreurParams {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Lecture { fichier, cause } => write!(f, "lecture de {} impossible : {cause}", fichier.display()),
|
||||
Self::Json { fichier, cause } => write!(f, "JSON invalide dans {} : {cause}", fichier.display()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for ErreurParams {}
|
||||
|
||||
/// Charge `<dossier>/<biome.id()>.json`. Repli sur `params_initiaux(biome)` si le fichier n'existe pas.
|
||||
pub fn charger_params_biome(dossier: &Path, biome: BiomeRelief) -> Result<ParamsRelief, ErreurParams> {
|
||||
let fichier = dossier.join(format!("{}.json", biome.id()));
|
||||
let texte = match std::fs::read_to_string(&fichier) {
|
||||
Ok(t) => t,
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(params_initiaux(biome)),
|
||||
Err(cause) => return Err(ErreurParams::Lecture { fichier, cause }),
|
||||
};
|
||||
serde_json::from_str(&texte).map_err(|cause| ErreurParams::Json { fichier, cause })
|
||||
}
|
||||
|
||||
/// Charge les 9 biomes du dossier, dans l'ordre de `BiomeRelief::TOUS` (= indexation de
|
||||
/// `Generateur::new`). Un biome sans fichier reprend `params_initiaux`.
|
||||
pub fn charger_table(dossier: &Path) -> Result<Vec<ParamsRelief>, ErreurParams> {
|
||||
BiomeRelief::TOUS.iter().map(|&b| charger_params_biome(dossier, b)).collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn dossier_temp(nom: &str) -> PathBuf {
|
||||
let d = std::env::temp_dir().join(format!("proc-relief-{nom}-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&d);
|
||||
std::fs::create_dir_all(&d).unwrap();
|
||||
d
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fichier_present_absent_et_invalide() {
|
||||
let d = dossier_temp("charge");
|
||||
let mut p = params_initiaux(BiomeRelief::Bocage);
|
||||
p.amplitude_m = 123.5;
|
||||
std::fs::write(d.join("bocage.json"), serde_json::to_string(&p).unwrap()).unwrap();
|
||||
// présent
|
||||
assert_eq!(charger_params_biome(&d, BiomeRelief::Bocage).unwrap(), p);
|
||||
// absent : repli
|
||||
assert_eq!(charger_params_biome(&d, BiomeRelief::Fjord).unwrap(), params_initiaux(BiomeRelief::Fjord));
|
||||
// table entière : 9 entrées, bocage chargé, le reste initial
|
||||
let t = charger_table(&d).unwrap();
|
||||
assert_eq!(t.len(), 9);
|
||||
assert_eq!(t[BiomeRelief::Bocage.index()].amplitude_m, 123.5);
|
||||
assert_eq!(t[BiomeRelief::Karst.index()], params_initiaux(BiomeRelief::Karst));
|
||||
// invalide : erreur, pas de repli silencieux
|
||||
std::fs::write(d.join("plaine.json"), "{ pas du json").unwrap();
|
||||
assert!(matches!(charger_params_biome(&d, BiomeRelief::Plaine), Err(ErreurParams::Json { .. })));
|
||||
assert!(charger_table(&d).is_err());
|
||||
let _ = std::fs::remove_dir_all(&d);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ancien_json_sans_comblement_reste_lisible() {
|
||||
let mut v = serde_json::to_value(params_initiaux(BiomeRelief::Plaine)).unwrap();
|
||||
v.as_object_mut().unwrap().remove("combler_cuvettes");
|
||||
let p: ParamsRelief = serde_json::from_value(v).unwrap();
|
||||
assert!(p.combler_cuvettes);
|
||||
}
|
||||
}
|
||||
@@ -151,3 +151,60 @@ pub fn accumulation_d8(h: &[f32], n: usize) -> Vec<f32> {
|
||||
}
|
||||
acc
|
||||
}
|
||||
|
||||
/// Comble les cuvettes fermées (priority-flood D8 avec pente epsilon).
|
||||
///
|
||||
/// Les sorties de l'eau sont les cellules du bord de la grille et les cellules à
|
||||
/// `h <= niveau_mer` (mer : elle draine). Toute autre cellule est relevée au moins à
|
||||
/// `h_voisin_aval + epsilon`, de sorte que chaque cellule a un chemin strictement
|
||||
/// descendant vers une sortie. Les cellules déjà drainées ne bougent pas.
|
||||
/// Retourne le nombre de cellules relevées.
|
||||
pub fn combler_cuvettes(h: &mut [f32], n: usize, epsilon: f32, niveau_mer: f32) -> usize {
|
||||
use std::cmp::Reverse;
|
||||
use std::collections::BinaryHeap;
|
||||
// clé de tas : hauteur ordonnée en entier (total_cmp) pour un ordre déterministe
|
||||
#[inline]
|
||||
fn cle(v: f32) -> i32 {
|
||||
let b = v.to_bits() as i32;
|
||||
if b < 0 { b ^ i32::MAX } else { b }
|
||||
}
|
||||
let mut vu = vec![false; n * n];
|
||||
let mut tas: BinaryHeap<Reverse<(i32, u32)>> = BinaryHeap::new();
|
||||
for z in 0..n {
|
||||
for x in 0..n {
|
||||
let c = z * n + x;
|
||||
if x == 0 || z == 0 || x == n - 1 || z == n - 1 || h[c] <= niveau_mer {
|
||||
vu[c] = true;
|
||||
tas.push(Reverse((cle(h[c]), c as u32)));
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut releves = 0;
|
||||
while let Some(Reverse((_, c))) = tas.pop() {
|
||||
let c = c as usize;
|
||||
let (x, z) = ((c % n) as i32, (c / n) as i32);
|
||||
for dz in -1..=1 {
|
||||
for dx in -1..=1 {
|
||||
if dx == 0 && dz == 0 {
|
||||
continue;
|
||||
}
|
||||
let (xx, zz) = (x + dx, z + dz);
|
||||
if xx < 0 || zz < 0 || xx >= n as i32 || zz >= n as i32 {
|
||||
continue;
|
||||
}
|
||||
let j = zz as usize * n + xx as usize;
|
||||
if vu[j] {
|
||||
continue;
|
||||
}
|
||||
vu[j] = true;
|
||||
let mini = h[c] + epsilon;
|
||||
if h[j] < mini {
|
||||
h[j] = mini;
|
||||
releves += 1;
|
||||
}
|
||||
tas.push(Reverse((cle(h[j]), j as u32)));
|
||||
}
|
||||
}
|
||||
}
|
||||
releves
|
||||
}
|
||||
@@ -6,6 +6,7 @@
|
||||
//! `Send + Sync`.
|
||||
|
||||
pub mod bruit;
|
||||
pub mod charge;
|
||||
pub mod erosion;
|
||||
pub mod params;
|
||||
pub mod relief;
|
||||
@@ -13,6 +14,7 @@ pub mod tuile;
|
||||
pub mod types;
|
||||
|
||||
pub use bruit::{fbm, ridged, warp, Bruit2, Simplex};
|
||||
pub use charge::{charger_params_biome, charger_table, ErreurParams};
|
||||
pub use params::{params_initiaux, table_initiale};
|
||||
pub use relief::*;
|
||||
pub use tuile::{generer_tuile, Generateur, TileCache, TuileErodee, TuileRelief};
|
||||
|
||||
@@ -38,6 +38,7 @@ pub fn params_initiaux(b: BiomeRelief) -> ParamsRelief {
|
||||
incision: None,
|
||||
glaciaire: None,
|
||||
erosion: ero(20_000, 10, 35.0),
|
||||
combler_cuvettes: true,
|
||||
};
|
||||
match b {
|
||||
// 400-2400 m, falaises étagées (Urgonien / Tithonique), hauts plateaux lapiazés
|
||||
@@ -89,6 +90,8 @@ pub fn params_initiaux(b: BiomeRelief) -> ParamsRelief {
|
||||
dolines: Some(Dolines { densite_km2: 25.0, rayon_m: 40.0, profondeur_m: 12.0 }),
|
||||
incision: Some(Incision { largeur_m: 400.0, profondeur_m: 350.0, echelle_m: 12000.0, raideur_parois: 6.0 }),
|
||||
erosion: ero(12_000, 15, 38.0),
|
||||
// les dolines doivent rester
|
||||
combler_cuvettes: false,
|
||||
..base.clone()
|
||||
},
|
||||
// 400-1500 m, plateaux entaillés de canyons à parois verticales
|
||||
|
||||
@@ -25,6 +25,15 @@ pub struct ParamsRelief {
|
||||
pub incision: Option<Incision>,
|
||||
pub glaciaire: Option<Glaciaire>,
|
||||
pub erosion: ParamsErosion,
|
||||
/// Comble les cuvettes fermées à la fin de l'érosion d'une tuile (priority-flood D8).
|
||||
/// Actif par défaut (corrige un défaut du générateur) ; `false` pour garder les
|
||||
/// dolines du karst. Absent des anciens JSON : valeur `true`.
|
||||
#[serde(default = "vrai")]
|
||||
pub combler_cuvettes: bool,
|
||||
}
|
||||
|
||||
fn vrai() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
|
||||
|
||||
@@ -25,6 +25,8 @@ pub const PAS_EROSION: f64 = 2.0;
|
||||
/// Côté de la grille d'érosion élargie : (512 + 2·128) / 2.
|
||||
pub const N_EXT: usize = ((TAILLE_M + 2.0 * MARGE_M) / PAS_EROSION) as usize;
|
||||
/// Demi-largeur de la bande de raccord (32 m au total).
|
||||
/// Pente minimale (m par maille de 2 m) imposée dans les cuvettes comblées.
|
||||
pub const EPSILON_COMBLEMENT: f32 = 0.005;
|
||||
pub const DEMI_BANDE_M: f64 = 16.0;
|
||||
|
||||
/// Résultat de l'érosion d'une tuile élargie (pas de 2 m).
|
||||
@@ -156,6 +158,23 @@ impl Generateur {
|
||||
e
|
||||
}
|
||||
|
||||
/// Vrai si le comblement des cuvettes s'applique à cette tuile : poids des biomes
|
||||
/// qui le demandent > 0,5 (les dolines du karst le désactivent).
|
||||
fn combler_tuile(&self, id: TileId) -> bool {
|
||||
let (cx, cz) = ((id.tx as f64 + 0.5) * TAILLE_M, (id.tz as f64 + 0.5) * TAILLE_M);
|
||||
let w = self.monde.poids(cx, cz);
|
||||
let (mut oui, mut tot) = (0.0f32, 0.0f32);
|
||||
for &(b, p) in &w.b {
|
||||
if p > 0.0 {
|
||||
tot += p;
|
||||
if self.params[b.index()].combler_cuvettes {
|
||||
oui += p;
|
||||
}
|
||||
}
|
||||
}
|
||||
oui > 0.5 * tot
|
||||
}
|
||||
|
||||
/// Calcule (sans cache) l'érosion de la tuile élargie.
|
||||
pub fn eroder_tuile(&self, id: TileId) -> TuileErodee {
|
||||
let n = N_EXT;
|
||||
@@ -175,6 +194,9 @@ impl Generateur {
|
||||
let graine = sous_graine(hash2(self.seed, id.tx as i64, id.tz as i64), 9);
|
||||
erosion::hydraulique(&mut h, n, &e, graine);
|
||||
erosion::thermique(&mut h, n, PAS_EROSION as f32, e.iterations_therm, e.angle_talus_deg);
|
||||
if self.combler_tuile(id) {
|
||||
erosion::combler_cuvettes(&mut h, n, EPSILON_COMBLEMENT, 0.0);
|
||||
}
|
||||
let accumulation = erosion::accumulation_d8(&h, n);
|
||||
let delta = h.iter().zip(&brut).map(|(a, b)| a - b).collect();
|
||||
TuileErodee { id, delta, accumulation }
|
||||
|
||||
@@ -124,3 +124,69 @@ fn params_serde_aller_retour() {
|
||||
assert_eq!(p, q);
|
||||
}
|
||||
}
|
||||
|
||||
/// Nombre de cellules strictement plus basses que leurs 8 voisines (hors bord).
|
||||
fn puits(h: &[f32], n: usize) -> usize {
|
||||
let mut k = 0;
|
||||
for z in 1..n - 1 {
|
||||
for x in 1..n - 1 {
|
||||
let c = h[z * n + x];
|
||||
if (-1i32..=1).all(|dz| (-1i32..=1).all(|dx| (dx == 0 && dz == 0) || h[(z as i32 + dz) as usize * n + (x as i32 + dx) as usize] > c)) {
|
||||
k += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
k
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn comblement_supprime_les_puits_et_respecte_la_mer() {
|
||||
let n = 40;
|
||||
let mut h: Vec<f32> = (0..n * n).map(|i| 50.0 + ((i % n) as f32) * 0.5).collect();
|
||||
h[20 * n + 20] = 10.0; // puits
|
||||
h[21 * n + 20] = 12.0;
|
||||
assert!(puits(&h, n) >= 1);
|
||||
let r = erosion::combler_cuvettes(&mut h, n, 0.005, 0.0);
|
||||
assert!(r >= 2);
|
||||
assert_eq!(puits(&h, n), 0);
|
||||
// une cellule déjà drainée ne bouge pas
|
||||
assert_eq!(h[5 * n + 30], 50.0 + 15.0);
|
||||
// bassin sous le niveau de la mer relié à rien : la mer draine, rien n'est relevé
|
||||
let mut m = vec![20.0f32; n * n];
|
||||
for z in 10..30 {
|
||||
for x in 10..30 {
|
||||
m[z * n + x] = -30.0;
|
||||
}
|
||||
}
|
||||
let avant = m.clone();
|
||||
erosion::combler_cuvettes(&mut m, n, 0.005, 0.0);
|
||||
// la mer n'est pas relevée ; le plat reçoit seulement la pente epsilon
|
||||
assert!(m.iter().zip(&avant).all(|(a, b)| if *b < 0.0 { a == b } else { (a - b).abs() < 0.3 }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn comblement_actif_par_defaut_et_desactive_pour_le_karst() {
|
||||
assert!(params_initiaux(BiomeRelief::Prealpes).combler_cuvettes);
|
||||
assert!(!params_initiaux(BiomeRelief::Karst).combler_cuvettes);
|
||||
// sans comblement le karst garde des puits à 2 m ; avec, la tuile érodée n'en a plus
|
||||
let t = table_initiale();
|
||||
let ki = BiomeRelief::Karst.index();
|
||||
let avec_dolines = |flag: bool| {
|
||||
let mut t2 = t.clone();
|
||||
t2[ki].combler_cuvettes = flag;
|
||||
let g = Generateur::new(5, Arc::new(BiomeUnique(BiomeRelief::Karst)), t2);
|
||||
let e = g.erodee(TileId { tx: 2, tz: 2 });
|
||||
let n = tuile::N_EXT;
|
||||
let mut h = vec![0.0f32; n * n];
|
||||
let (ox, oz) = (2.0 * 512.0 - 128.0, 2.0 * 512.0 - 128.0);
|
||||
for j in 0..n {
|
||||
for i in 0..n {
|
||||
h[j * n + i] = g.brut(ox + i as f64 * 2.0, oz + j as f64 * 2.0, 4.0) + e.delta[j * n + i];
|
||||
}
|
||||
}
|
||||
puits(&h, n)
|
||||
};
|
||||
let (sans, avec) = (avec_dolines(false), avec_dolines(true));
|
||||
assert!(sans > 0, "le karst doit avoir des cuvettes sans comblement");
|
||||
assert_eq!(avec, 0, "comblement actif : plus aucun puits");
|
||||
}
|
||||
@@ -12,3 +12,7 @@ tiff = "0.9"
|
||||
[[bin]]
|
||||
name = "signer"
|
||||
path = "src/bin/signer.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "atlas"
|
||||
path = "src/bin/atlas.rs"
|
||||
@@ -0,0 +1,8 @@
|
||||
//! atlas <sortie.json> <sig1.json> [sig2.json ...] : archétype (SignatureCible) à partir de signatures mesurées.
|
||||
use signature::{archetype, Signature};
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().skip(1).collect();
|
||||
if a.len() < 2 { eprintln!("usage: atlas <sortie.json> <sig.json>..."); std::process::exit(2) }
|
||||
let sigs: Vec<Signature> = a[1..].iter().map(|f| Signature::from_json(&std::fs::read_to_string(f).unwrap()).unwrap()).collect();
|
||||
std::fs::write(&a[0], serde_json::to_string_pretty(&archetype(&sigs)).unwrap()).unwrap();
|
||||
}
|
||||
@@ -4,10 +4,12 @@ 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 pas: Option<f32> = None;
|
||||
let mut i = 0;
|
||||
while i < a.len() {
|
||||
match a[i].as_str() {
|
||||
"-o" => { out = a[i + 1].clone(); i += 1 }
|
||||
"--pas" => { pas = a[i + 1].parse().ok(); 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 }
|
||||
@@ -16,7 +18,37 @@ fn main() {
|
||||
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 mut mnt = lire_geotiff(&fich[0]).unwrap_or_else(|e| { eprintln!("{e}"); std::process::exit(1) });
|
||||
// Les tuiles de donnees/biomes/ n'ont pas de geotag : le pas vient de --pas ou du JSON voisin (pas_m, sinon pas_m_approx).
|
||||
let jpath = std::path::Path::new(&fich[0]).with_extension("json");
|
||||
let mut pas_xy: Option<(f32, f32)> = pas.map(|p| (p, p));
|
||||
if pas_xy.is_none() {
|
||||
if let Ok(t) = std::fs::read_to_string(&jpath) {
|
||||
if let Ok(v) = serde_json::from_str::<serde_json::Value>(&t) {
|
||||
let a = v.get("pas_m").or_else(|| v.get("pas_m_approx")).and_then(|a| a.as_array());
|
||||
if let Some(a) = a { if a.len() == 2 { pas_xy = Some((a[0].as_f64().unwrap_or(1.0) as f32, a[1].as_f64().unwrap_or(1.0) as f32)); } }
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some((px, py)) = pas_xy {
|
||||
if (px - py).abs() > 0.01 * py {
|
||||
// pas anisotrope (degres) : reechantillonnage lineaire des colonnes a un pas carre = py
|
||||
let nw = ((mnt.w as f32 * px / py).round() as usize).max(8);
|
||||
let mut z = vec![f32::NAN; nw * mnt.h];
|
||||
for r in 0..mnt.h {
|
||||
for c in 0..nw {
|
||||
let x = (c as f32 + 0.5) * py / px - 0.5;
|
||||
let (i0, t) = (x.floor().max(0.0), (x - x.floor()).clamp(0.0, 1.0));
|
||||
let (i0, i1) = ((i0 as usize).min(mnt.w - 1), ((i0 as usize) + 1).min(mnt.w - 1));
|
||||
let (a, b) = (mnt.z[r * mnt.w + i0], mnt.z[r * mnt.w + i1]);
|
||||
z[r * nw + c] = a + (b - a) * t;
|
||||
}
|
||||
}
|
||||
mnt = signature::Raster::new(nw, mnt.h, py, z);
|
||||
} else {
|
||||
mnt.pas_m = py;
|
||||
}
|
||||
}
|
||||
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();
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur