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>
Cette révision appartient à :
1 Parent
6f2445c8a9
révision
e9e26ebb2e
7 fichiers modifiés
+633
-1
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,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 <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 {
|
||||
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<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 ..."),
|
||||
}
|
||||
}
|
||||
@@ -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