diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..248f8cc --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +target/ +*.avant-* diff --git a/proc-relief/Cargo.lock b/proc-relief/Cargo.lock index 5d2d23a..1bda743 100644 --- a/proc-relief/Cargo.lock +++ b/proc-relief/Cargo.lock @@ -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" diff --git a/proc-relief/Cargo.toml b/proc-relief/Cargo.toml index e5ace0d..13c02ab 100644 --- a/proc-relief/Cargo.toml +++ b/proc-relief/Cargo.toml @@ -13,6 +13,7 @@ rayon = "1.10" [dev-dependencies] png = "0.17" +signature = { path = "../signature" } [profile.release] debug = false diff --git a/proc-relief/examples/atlas_calage.rs b/proc-relief/examples/atlas_calage.rs new file mode 100644 index 0000000..d03b364 --- /dev/null +++ b/proc-relief/examples/atlas_calage.rs @@ -0,0 +1,551 @@ +//! Atlas multi-sites des 8 biomes : score du generateur contre les signatures reelles + calage (rapport 27, reprise du rapport 23). +//! +//! usage : +//! atlas_calage score [dossier_f32] +//! atlas_calage caler +//! `biome_id` = bocage | cote_rocheuse | fjord | glaciaire | gorges | karst | plaine | prealpes. +//! Les sites sont lus dans `/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>; +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::() / 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, + forme: BTreeMap, + ref_site: Option>, +} +/// Reference multi-sites. moy = moyenne des moyennes de site ; tau = max(etendue entre sites, etendue intra-site moyenne). +struct Ref { + moy: Vecs, + tau: BTreeMap, + sigs: Vec, + sites: Vec, + cuv_hi: f32, + cuv_lo: f32, + relief_moy: f32, + fen_forme: BTreeMap, +} +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::() / 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 = 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 = (0..n).map(|i| vs.iter().map(|v| v[k][i]).sum::() / vs.len() as f32).collect(); + let etendue: Vec = (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::() / n as f32).sqrt(); + let norme = (m.iter().map(|e| e * e).sum::() / n as f32).sqrt(); + tau.insert(k.clone(), t.max(0.10 * norme).max(0.02)); + moy.insert(k.clone(), m); + } + let cuv: Vec = 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::() / cuv.len() as f32, + relief_moy: regs.iter().map(|s| s.relief_m).sum::() / regs.len() as f32, + fen_forme: BTreeMap::new(), + } +} +fn construire_ref_multi(mut sites: Vec) -> Ref { + let sc: Vec = (0..sites.len()).filter(|&i| sites[i].role == "score").collect(); + let par_site: Vec> = sc.iter().map(|&i| sites[i].regs.iter().map(vecs).collect()).collect(); + let moy_site: Vec = par_site.iter().map(|q| moyenne_vecs(&q.iter().collect::>())).collect(); + let moy = moyenne_vecs(&moy_site.iter().collect::>()); + let mut tau = BTreeMap::new(); + for k in moy.keys() { + let n = moy[k].len(); + let et: Vec = (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::() + / par_site.len() as f32; + inter.max(intra) + }) + .collect(); + let t = (et.iter().map(|e| e * e).sum::() / n as f32).sqrt(); + let norme = (moy[k].iter().map(|e| e * e).sum::() / n as f32).sqrt(); + tau.insert(k.clone(), t.max(0.10 * norme).max(0.02)); + } + let sigs: Vec = 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::() / 4.0).fold(f32::MAX, f32::min); + let relief_moy = sigs.iter().map(|s| s.relief_m).sum::() / 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 = 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, + x: BTreeMap, +} +/// 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::() / 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 { + 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 = 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]) -> BTreeMap { + v[0].keys().map(|k| (k.clone(), v.iter().map(|m| m[k]).sum::() / 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, r: &Ref) -> (Vec, 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 = (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 { + serde_json::from_str(&std::fs::read_to_string(format!("{dp}/{id}.json")).unwrap()).unwrap() +} +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 { + (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> { + 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) { + 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::() / 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 = 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 = qs.iter().map(|q| sig_fenetre(q, n / 2)).collect(); + cuv.extend(sigs.iter().map(|s| s.part_cuvettes as f64)); + let sc: Vec = 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::() / par_seed.len() as f64; + let ec = (par_seed.iter().map(|s| (s - moy).powi(2)).sum::() / par_seed.len() as f64).sqrt(); + let gm: BTreeMap = tous[0].1.keys().map(|k| (k.clone(), tous.iter().map(|t| t.1[k]).sum::() / tous.len() as f64)).collect(); + let xm: BTreeMap = tous[0].2[0].x.keys().map(|k| (k.clone(), tous.iter().flat_map(|t| t.2.iter()).map(|s| s.x[k]).sum::() / 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::() / 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 = 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 = 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::() / 4.0; + let sref = s.regs.iter().map(|q| score(q, &r).total).sum::() / 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::() / 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::>().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::>(), "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) { + 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::().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 = (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::>().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 = 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 ..."), + } +} diff --git a/signature/Cargo.toml b/signature/Cargo.toml index f71ed81..dda74fa 100644 --- a/signature/Cargo.toml +++ b/signature/Cargo.toml @@ -12,3 +12,7 @@ tiff = "0.9" [[bin]] name = "signer" path = "src/bin/signer.rs" + +[[bin]] +name = "atlas" +path = "src/bin/atlas.rs" diff --git a/signature/src/bin/atlas.rs b/signature/src/bin/atlas.rs new file mode 100644 index 0000000..40729ec --- /dev/null +++ b/signature/src/bin/atlas.rs @@ -0,0 +1,8 @@ +//! atlas [sig2.json ...] : archétype (SignatureCible) à partir de signatures mesurées. +use signature::{archetype, Signature}; +fn main() { + let a: Vec = std::env::args().skip(1).collect(); + if a.len() < 2 { eprintln!("usage: atlas ..."); std::process::exit(2) } + let sigs: Vec = 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(); +} diff --git a/signature/src/bin/signer.rs b/signature/src/bin/signer.rs index 3d2c0cd..7c574a0 100644 --- a/signature/src/bin/signer.rs +++ b/signature/src/bin/signer.rs @@ -4,10 +4,12 @@ use signature::{lire_geotiff, mesurer, MetaSource}; fn main() { let a: Vec = std::env::args().skip(1).collect(); let (mut fich, mut out, mut meta) = (vec![], "sig.json".to_string(), MetaSource::default()); + let mut pas: Option = 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 [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::(&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();