Comparer les révisions

...
4 Révisions
Auteur SHA1 Message Date

2026-10-31

Théo GastineletClaude Sonnet 5.5 1aa76fcb0a atlas_calage: lit les parametres via le chargeur public de proc-relief
Un fichier absent reste une erreur pour le calage (pas de repli silencieux).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 12:24:32 +01:00
Théo GastineletClaude Sonnet 5.5 0918b335db proc-relief: chargeur JSON des parametres (charger_params_biome, charger_table)
Repli sur params_initiaux si le fichier manque ; erreur si le JSON est invalide.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 11:45:22 +01:00
Théo GastineletClaude Sonnet 5.5 32d381e637 proc-relief: comblement des cuvettes fermees (priority-flood D8) en fin d'erosion de tuile
Actif par defaut (corrige les puits fermes du generateur, rapport 27) ;
champ serde combler_cuvettes (defaut true, anciens JSON compatibles),
false pour le karst afin de garder les dolines. La mer (h <= 0) et les
bords de la grille elargie servent d'exutoires : le raccord entre tuiles
(poids trapezes sur delta) est inchange.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 11:45:22 +01:00
Théo GastineletClaude Opus 5.5 e9e26ebb2e atlas multi-pays: binaire atlas, signer etendu, exemple atlas_calage (score + calage, cuvettes, gates cote/glaciaire)
Travail de l agent 4 bis (rapport 27), commite apres coup.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 11:41:08 +01:00
14 fichiers modifiés avec 882 ajouts et 1 suppressions

Aucun fichier ne correspond à votre recherche

+2
Voir le fichier
@@ -0,0 +1,2 @@
target/
*.avant-*
+34
Voir le fichier
@@ -86,6 +86,12 @@ version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
[[package]]
name = "jpeg-decoder"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07"
[[package]] [[package]]
name = "memchr" name = "memchr"
version = "2.8.3" version = "2.8.3"
@@ -143,6 +149,7 @@ dependencies = [
"rt-core", "rt-core",
"serde", "serde",
"serde_json", "serde_json",
"signature",
] ]
[[package]] [[package]]
@@ -224,6 +231,16 @@ dependencies = [
"zmij", "zmij",
] ]
[[package]]
name = "signature"
version = "0.1.0"
dependencies = [
"rt-core",
"serde",
"serde_json",
"tiff",
]
[[package]] [[package]]
name = "simd-adler32" name = "simd-adler32"
version = "0.3.10" version = "0.3.10"
@@ -241,12 +258,29 @@ dependencies = [
"unicode-ident", "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]] [[package]]
name = "unicode-ident" name = "unicode-ident"
version = "1.0.27" version = "1.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
[[package]]
name = "weezl"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
[[package]] [[package]]
name = "zlib-rs" name = "zlib-rs"
version = "0.6.8" version = "0.6.8"
+1
Voir le fichier
@@ -13,6 +13,7 @@ rayon = "1.10"
[dev-dependencies] [dev-dependencies]
png = "0.17" png = "0.17"
signature = { path = "../signature" }
[profile.release] [profile.release]
debug = false debug = false
+554
Voir le fichier
@@ -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 ..."),
}
}
+87
Voir le fichier
@@ -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);
}
}
+57
Voir le fichier
@@ -151,3 +151,60 @@ pub fn accumulation_d8(h: &[f32], n: usize) -> Vec<f32> {
} }
acc 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
}
+2
Voir le fichier
@@ -6,6 +6,7 @@
//! `Send + Sync`. //! `Send + Sync`.
pub mod bruit; pub mod bruit;
pub mod charge;
pub mod erosion; pub mod erosion;
pub mod params; pub mod params;
pub mod relief; pub mod relief;
@@ -13,6 +14,7 @@ pub mod tuile;
pub mod types; pub mod types;
pub use bruit::{fbm, ridged, warp, Bruit2, Simplex}; 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 params::{params_initiaux, table_initiale};
pub use relief::*; pub use relief::*;
pub use tuile::{generer_tuile, Generateur, TileCache, TuileErodee, TuileRelief}; pub use tuile::{generer_tuile, Generateur, TileCache, TuileErodee, TuileRelief};
+3
Voir le fichier
@@ -38,6 +38,7 @@ pub fn params_initiaux(b: BiomeRelief) -> ParamsRelief {
incision: None, incision: None,
glaciaire: None, glaciaire: None,
erosion: ero(20_000, 10, 35.0), erosion: ero(20_000, 10, 35.0),
combler_cuvettes: true,
}; };
match b { match b {
// 400-2400 m, falaises étagées (Urgonien / Tithonique), hauts plateaux lapiazés // 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 }), 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 }), 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), erosion: ero(12_000, 15, 38.0),
// les dolines doivent rester
combler_cuvettes: false,
..base.clone() ..base.clone()
}, },
// 400-1500 m, plateaux entaillés de canyons à parois verticales // 400-1500 m, plateaux entaillés de canyons à parois verticales
+9
Voir le fichier
@@ -25,6 +25,15 @@ pub struct ParamsRelief {
pub incision: Option<Incision>, pub incision: Option<Incision>,
pub glaciaire: Option<Glaciaire>, pub glaciaire: Option<Glaciaire>,
pub erosion: ParamsErosion, 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)] #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+22
Voir le fichier
@@ -25,6 +25,8 @@ pub const PAS_EROSION: f64 = 2.0;
/// Côté de la grille d'érosion élargie : (512 + 2·128) / 2. /// 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; 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). /// 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; pub const DEMI_BANDE_M: f64 = 16.0;
/// Résultat de l'érosion d'une tuile élargie (pas de 2 m). /// Résultat de l'érosion d'une tuile élargie (pas de 2 m).
@@ -156,6 +158,23 @@ impl Generateur {
e 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. /// Calcule (sans cache) l'érosion de la tuile élargie.
pub fn eroder_tuile(&self, id: TileId) -> TuileErodee { pub fn eroder_tuile(&self, id: TileId) -> TuileErodee {
let n = N_EXT; 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); let graine = sous_graine(hash2(self.seed, id.tx as i64, id.tz as i64), 9);
erosion::hydraulique(&mut h, n, &e, graine); erosion::hydraulique(&mut h, n, &e, graine);
erosion::thermique(&mut h, n, PAS_EROSION as f32, e.iterations_therm, e.angle_talus_deg); 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 accumulation = erosion::accumulation_d8(&h, n);
let delta = h.iter().zip(&brut).map(|(a, b)| a - b).collect(); let delta = h.iter().zip(&brut).map(|(a, b)| a - b).collect();
TuileErodee { id, delta, accumulation } TuileErodee { id, delta, accumulation }
+66
Voir le fichier
@@ -124,3 +124,69 @@ fn params_serde_aller_retour() {
assert_eq!(p, q); 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");
}
+4
Voir le fichier
@@ -12,3 +12,7 @@ tiff = "0.9"
[[bin]] [[bin]]
name = "signer" name = "signer"
path = "src/bin/signer.rs" path = "src/bin/signer.rs"
[[bin]]
name = "atlas"
path = "src/bin/atlas.rs"
+8
Voir le fichier
@@ -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();
}
+33 -1
Voir le fichier
@@ -4,10 +4,12 @@ use signature::{lire_geotiff, mesurer, MetaSource};
fn main() { fn main() {
let a: Vec<String> = std::env::args().skip(1).collect(); 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 fich, mut out, mut meta) = (vec![], "sig.json".to_string(), MetaSource::default());
let mut pas: Option<f32> = None;
let mut i = 0; let mut i = 0;
while i < a.len() { while i < a.len() {
match a[i].as_str() { match a[i].as_str() {
"-o" => { out = a[i + 1].clone(); i += 1 } "-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 } "--pays" => { meta.pays = a[i + 1].clone(); i += 1 }
"--jeu" => { meta.jeu = 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 } "--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; i += 1;
} }
if fich.is_empty() { eprintln!("usage: signer <mnt.tif> [occ.tif] -o sig.json"); std::process::exit(2) } 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 occ = fich.get(1).map(|f| lire_geotiff(f).unwrap());
let s = mesurer(&mnt, occ.as_ref(), &meta); let s = mesurer(&mnt, occ.as_ref(), &meta);
std::fs::write(&out, s.to_json()).unwrap(); std::fs::write(&out, s.to_json()).unwrap();