From 32d381e63793a5da4dc88d2fa61dd6ca4adeeea8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= Date: Sat, 31 Oct 2026 11:45:22 +0100 Subject: [PATCH] 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 --- proc-relief/src/erosion.rs | 57 ++++++++++++++++++++++++++++ proc-relief/src/params.rs | 3 ++ proc-relief/src/relief.rs | 9 +++++ proc-relief/src/tuile.rs | 22 +++++++++++ proc-relief/tests/generateur.rs | 66 +++++++++++++++++++++++++++++++++ 5 files changed, 157 insertions(+) diff --git a/proc-relief/src/erosion.rs b/proc-relief/src/erosion.rs index c2a6066..a502bcf 100644 --- a/proc-relief/src/erosion.rs +++ b/proc-relief/src/erosion.rs @@ -151,3 +151,60 @@ pub fn accumulation_d8(h: &[f32], n: usize) -> Vec { } 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> = 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 +} diff --git a/proc-relief/src/params.rs b/proc-relief/src/params.rs index e8857c1..22fd460 100644 --- a/proc-relief/src/params.rs +++ b/proc-relief/src/params.rs @@ -38,6 +38,7 @@ pub fn params_initiaux(b: BiomeRelief) -> ParamsRelief { incision: None, glaciaire: None, erosion: ero(20_000, 10, 35.0), + combler_cuvettes: true, }; match b { // 400-2400 m, falaises étagées (Urgonien / Tithonique), hauts plateaux lapiazés @@ -89,6 +90,8 @@ pub fn params_initiaux(b: BiomeRelief) -> ParamsRelief { dolines: Some(Dolines { densite_km2: 25.0, rayon_m: 40.0, profondeur_m: 12.0 }), incision: Some(Incision { largeur_m: 400.0, profondeur_m: 350.0, echelle_m: 12000.0, raideur_parois: 6.0 }), erosion: ero(12_000, 15, 38.0), + // les dolines doivent rester + combler_cuvettes: false, ..base.clone() }, // 400-1500 m, plateaux entaillés de canyons à parois verticales diff --git a/proc-relief/src/relief.rs b/proc-relief/src/relief.rs index 9fd7f18..a35ad16 100644 --- a/proc-relief/src/relief.rs +++ b/proc-relief/src/relief.rs @@ -25,6 +25,15 @@ pub struct ParamsRelief { pub incision: Option, pub glaciaire: Option, 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)] diff --git a/proc-relief/src/tuile.rs b/proc-relief/src/tuile.rs index c0cb8d4..a9254e5 100644 --- a/proc-relief/src/tuile.rs +++ b/proc-relief/src/tuile.rs @@ -25,6 +25,8 @@ pub const PAS_EROSION: f64 = 2.0; /// Côté de la grille d'érosion élargie : (512 + 2·128) / 2. pub const N_EXT: usize = ((TAILLE_M + 2.0 * MARGE_M) / PAS_EROSION) as usize; /// Demi-largeur de la bande de raccord (32 m au total). +/// Pente minimale (m par maille de 2 m) imposée dans les cuvettes comblées. +pub const EPSILON_COMBLEMENT: f32 = 0.005; pub const DEMI_BANDE_M: f64 = 16.0; /// Résultat de l'érosion d'une tuile élargie (pas de 2 m). @@ -156,6 +158,23 @@ impl Generateur { e } + /// Vrai si le comblement des cuvettes s'applique à cette tuile : poids des biomes + /// qui le demandent > 0,5 (les dolines du karst le désactivent). + fn combler_tuile(&self, id: TileId) -> bool { + let (cx, cz) = ((id.tx as f64 + 0.5) * TAILLE_M, (id.tz as f64 + 0.5) * TAILLE_M); + let w = self.monde.poids(cx, cz); + let (mut oui, mut tot) = (0.0f32, 0.0f32); + for &(b, p) in &w.b { + if p > 0.0 { + tot += p; + if self.params[b.index()].combler_cuvettes { + oui += p; + } + } + } + oui > 0.5 * tot + } + /// Calcule (sans cache) l'érosion de la tuile élargie. pub fn eroder_tuile(&self, id: TileId) -> TuileErodee { let n = N_EXT; @@ -175,6 +194,9 @@ impl Generateur { let graine = sous_graine(hash2(self.seed, id.tx as i64, id.tz as i64), 9); erosion::hydraulique(&mut h, n, &e, graine); erosion::thermique(&mut h, n, PAS_EROSION as f32, e.iterations_therm, e.angle_talus_deg); + if self.combler_tuile(id) { + erosion::combler_cuvettes(&mut h, n, EPSILON_COMBLEMENT, 0.0); + } let accumulation = erosion::accumulation_d8(&h, n); let delta = h.iter().zip(&brut).map(|(a, b)| a - b).collect(); TuileErodee { id, delta, accumulation } diff --git a/proc-relief/tests/generateur.rs b/proc-relief/tests/generateur.rs index 3d64706..acb286c 100644 --- a/proc-relief/tests/generateur.rs +++ b/proc-relief/tests/generateur.rs @@ -124,3 +124,69 @@ fn params_serde_aller_retour() { assert_eq!(p, q); } } + +/// Nombre de cellules strictement plus basses que leurs 8 voisines (hors bord). +fn puits(h: &[f32], n: usize) -> usize { + let mut k = 0; + for z in 1..n - 1 { + for x in 1..n - 1 { + let c = h[z * n + x]; + if (-1i32..=1).all(|dz| (-1i32..=1).all(|dx| (dx == 0 && dz == 0) || h[(z as i32 + dz) as usize * n + (x as i32 + dx) as usize] > c)) { + k += 1; + } + } + } + k +} + +#[test] +fn comblement_supprime_les_puits_et_respecte_la_mer() { + let n = 40; + let mut h: Vec = (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"); +}