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>
Cette révision appartient à :
1 Parent
e9e26ebb2e
révision
32d381e637
5 fichiers modifiés
+157
Aucun fichier ne correspond à votre recherche
@@ -151,3 +151,60 @@ pub fn accumulation_d8(h: &[f32], n: usize) -> Vec<f32> {
|
||||
}
|
||||
acc
|
||||
}
|
||||
|
||||
/// Comble les cuvettes fermées (priority-flood D8 avec pente epsilon).
|
||||
///
|
||||
/// Les sorties de l'eau sont les cellules du bord de la grille et les cellules à
|
||||
/// `h <= niveau_mer` (mer : elle draine). Toute autre cellule est relevée au moins à
|
||||
/// `h_voisin_aval + epsilon`, de sorte que chaque cellule a un chemin strictement
|
||||
/// descendant vers une sortie. Les cellules déjà drainées ne bougent pas.
|
||||
/// Retourne le nombre de cellules relevées.
|
||||
pub fn combler_cuvettes(h: &mut [f32], n: usize, epsilon: f32, niveau_mer: f32) -> usize {
|
||||
use std::cmp::Reverse;
|
||||
use std::collections::BinaryHeap;
|
||||
// clé de tas : hauteur ordonnée en entier (total_cmp) pour un ordre déterministe
|
||||
#[inline]
|
||||
fn cle(v: f32) -> i32 {
|
||||
let b = v.to_bits() as i32;
|
||||
if b < 0 { b ^ i32::MAX } else { b }
|
||||
}
|
||||
let mut vu = vec![false; n * n];
|
||||
let mut tas: BinaryHeap<Reverse<(i32, u32)>> = BinaryHeap::new();
|
||||
for z in 0..n {
|
||||
for x in 0..n {
|
||||
let c = z * n + x;
|
||||
if x == 0 || z == 0 || x == n - 1 || z == n - 1 || h[c] <= niveau_mer {
|
||||
vu[c] = true;
|
||||
tas.push(Reverse((cle(h[c]), c as u32)));
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut releves = 0;
|
||||
while let Some(Reverse((_, c))) = tas.pop() {
|
||||
let c = c as usize;
|
||||
let (x, z) = ((c % n) as i32, (c / n) as i32);
|
||||
for dz in -1..=1 {
|
||||
for dx in -1..=1 {
|
||||
if dx == 0 && dz == 0 {
|
||||
continue;
|
||||
}
|
||||
let (xx, zz) = (x + dx, z + dz);
|
||||
if xx < 0 || zz < 0 || xx >= n as i32 || zz >= n as i32 {
|
||||
continue;
|
||||
}
|
||||
let j = zz as usize * n + xx as usize;
|
||||
if vu[j] {
|
||||
continue;
|
||||
}
|
||||
vu[j] = true;
|
||||
let mini = h[c] + epsilon;
|
||||
if h[j] < mini {
|
||||
h[j] = mini;
|
||||
releves += 1;
|
||||
}
|
||||
tas.push(Reverse((cle(h[j]), j as u32)));
|
||||
}
|
||||
}
|
||||
}
|
||||
releves
|
||||
}
|
||||
@@ -38,6 +38,7 @@ pub fn params_initiaux(b: BiomeRelief) -> ParamsRelief {
|
||||
incision: None,
|
||||
glaciaire: None,
|
||||
erosion: ero(20_000, 10, 35.0),
|
||||
combler_cuvettes: true,
|
||||
};
|
||||
match b {
|
||||
// 400-2400 m, falaises étagées (Urgonien / Tithonique), hauts plateaux lapiazés
|
||||
@@ -89,6 +90,8 @@ pub fn params_initiaux(b: BiomeRelief) -> ParamsRelief {
|
||||
dolines: Some(Dolines { densite_km2: 25.0, rayon_m: 40.0, profondeur_m: 12.0 }),
|
||||
incision: Some(Incision { largeur_m: 400.0, profondeur_m: 350.0, echelle_m: 12000.0, raideur_parois: 6.0 }),
|
||||
erosion: ero(12_000, 15, 38.0),
|
||||
// les dolines doivent rester
|
||||
combler_cuvettes: false,
|
||||
..base.clone()
|
||||
},
|
||||
// 400-1500 m, plateaux entaillés de canyons à parois verticales
|
||||
|
||||
@@ -25,6 +25,15 @@ pub struct ParamsRelief {
|
||||
pub incision: Option<Incision>,
|
||||
pub glaciaire: Option<Glaciaire>,
|
||||
pub erosion: ParamsErosion,
|
||||
/// Comble les cuvettes fermées à la fin de l'érosion d'une tuile (priority-flood D8).
|
||||
/// Actif par défaut (corrige un défaut du générateur) ; `false` pour garder les
|
||||
/// dolines du karst. Absent des anciens JSON : valeur `true`.
|
||||
#[serde(default = "vrai")]
|
||||
pub combler_cuvettes: bool,
|
||||
}
|
||||
|
||||
fn vrai() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
|
||||
|
||||
@@ -25,6 +25,8 @@ pub const PAS_EROSION: f64 = 2.0;
|
||||
/// Côté de la grille d'érosion élargie : (512 + 2·128) / 2.
|
||||
pub const N_EXT: usize = ((TAILLE_M + 2.0 * MARGE_M) / PAS_EROSION) as usize;
|
||||
/// Demi-largeur de la bande de raccord (32 m au total).
|
||||
/// Pente minimale (m par maille de 2 m) imposée dans les cuvettes comblées.
|
||||
pub const EPSILON_COMBLEMENT: f32 = 0.005;
|
||||
pub const DEMI_BANDE_M: f64 = 16.0;
|
||||
|
||||
/// Résultat de l'érosion d'une tuile élargie (pas de 2 m).
|
||||
@@ -156,6 +158,23 @@ impl Generateur {
|
||||
e
|
||||
}
|
||||
|
||||
/// Vrai si le comblement des cuvettes s'applique à cette tuile : poids des biomes
|
||||
/// qui le demandent > 0,5 (les dolines du karst le désactivent).
|
||||
fn combler_tuile(&self, id: TileId) -> bool {
|
||||
let (cx, cz) = ((id.tx as f64 + 0.5) * TAILLE_M, (id.tz as f64 + 0.5) * TAILLE_M);
|
||||
let w = self.monde.poids(cx, cz);
|
||||
let (mut oui, mut tot) = (0.0f32, 0.0f32);
|
||||
for &(b, p) in &w.b {
|
||||
if p > 0.0 {
|
||||
tot += p;
|
||||
if self.params[b.index()].combler_cuvettes {
|
||||
oui += p;
|
||||
}
|
||||
}
|
||||
}
|
||||
oui > 0.5 * tot
|
||||
}
|
||||
|
||||
/// Calcule (sans cache) l'érosion de la tuile élargie.
|
||||
pub fn eroder_tuile(&self, id: TileId) -> TuileErodee {
|
||||
let n = N_EXT;
|
||||
@@ -175,6 +194,9 @@ impl Generateur {
|
||||
let graine = sous_graine(hash2(self.seed, id.tx as i64, id.tz as i64), 9);
|
||||
erosion::hydraulique(&mut h, n, &e, graine);
|
||||
erosion::thermique(&mut h, n, PAS_EROSION as f32, e.iterations_therm, e.angle_talus_deg);
|
||||
if self.combler_tuile(id) {
|
||||
erosion::combler_cuvettes(&mut h, n, EPSILON_COMBLEMENT, 0.0);
|
||||
}
|
||||
let accumulation = erosion::accumulation_d8(&h, n);
|
||||
let delta = h.iter().zip(&brut).map(|(a, b)| a - b).collect();
|
||||
TuileErodee { id, delta, accumulation }
|
||||
|
||||
@@ -124,3 +124,69 @@ fn params_serde_aller_retour() {
|
||||
assert_eq!(p, q);
|
||||
}
|
||||
}
|
||||
|
||||
/// Nombre de cellules strictement plus basses que leurs 8 voisines (hors bord).
|
||||
fn puits(h: &[f32], n: usize) -> usize {
|
||||
let mut k = 0;
|
||||
for z in 1..n - 1 {
|
||||
for x in 1..n - 1 {
|
||||
let c = h[z * n + x];
|
||||
if (-1i32..=1).all(|dz| (-1i32..=1).all(|dx| (dx == 0 && dz == 0) || h[(z as i32 + dz) as usize * n + (x as i32 + dx) as usize] > c)) {
|
||||
k += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
k
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn comblement_supprime_les_puits_et_respecte_la_mer() {
|
||||
let n = 40;
|
||||
let mut h: Vec<f32> = (0..n * n).map(|i| 50.0 + ((i % n) as f32) * 0.5).collect();
|
||||
h[20 * n + 20] = 10.0; // puits
|
||||
h[21 * n + 20] = 12.0;
|
||||
assert!(puits(&h, n) >= 1);
|
||||
let r = erosion::combler_cuvettes(&mut h, n, 0.005, 0.0);
|
||||
assert!(r >= 2);
|
||||
assert_eq!(puits(&h, n), 0);
|
||||
// une cellule déjà drainée ne bouge pas
|
||||
assert_eq!(h[5 * n + 30], 50.0 + 15.0);
|
||||
// bassin sous le niveau de la mer relié à rien : la mer draine, rien n'est relevé
|
||||
let mut m = vec![20.0f32; n * n];
|
||||
for z in 10..30 {
|
||||
for x in 10..30 {
|
||||
m[z * n + x] = -30.0;
|
||||
}
|
||||
}
|
||||
let avant = m.clone();
|
||||
erosion::combler_cuvettes(&mut m, n, 0.005, 0.0);
|
||||
// la mer n'est pas relevée ; le plat reçoit seulement la pente epsilon
|
||||
assert!(m.iter().zip(&avant).all(|(a, b)| if *b < 0.0 { a == b } else { (a - b).abs() < 0.3 }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn comblement_actif_par_defaut_et_desactive_pour_le_karst() {
|
||||
assert!(params_initiaux(BiomeRelief::Prealpes).combler_cuvettes);
|
||||
assert!(!params_initiaux(BiomeRelief::Karst).combler_cuvettes);
|
||||
// sans comblement le karst garde des puits à 2 m ; avec, la tuile érodée n'en a plus
|
||||
let t = table_initiale();
|
||||
let ki = BiomeRelief::Karst.index();
|
||||
let avec_dolines = |flag: bool| {
|
||||
let mut t2 = t.clone();
|
||||
t2[ki].combler_cuvettes = flag;
|
||||
let g = Generateur::new(5, Arc::new(BiomeUnique(BiomeRelief::Karst)), t2);
|
||||
let e = g.erodee(TileId { tx: 2, tz: 2 });
|
||||
let n = tuile::N_EXT;
|
||||
let mut h = vec![0.0f32; n * n];
|
||||
let (ox, oz) = (2.0 * 512.0 - 128.0, 2.0 * 512.0 - 128.0);
|
||||
for j in 0..n {
|
||||
for i in 0..n {
|
||||
h[j * n + i] = g.brut(ox + i as f64 * 2.0, oz + j as f64 * 2.0, 4.0) + e.delta[j * n + i];
|
||||
}
|
||||
}
|
||||
puits(&h, n)
|
||||
};
|
||||
let (sans, avec) = (avec_dolines(false), avec_dolines(true));
|
||||
assert!(sans > 0, "le karst doit avoir des cuvettes sans comblement");
|
||||
assert_eq!(avec, 0, "comblement actif : plus aucun puits");
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur