From 7acda01811437eae0ad7f88d8c1fb82a26635903 Mon Sep 17 00:00:00 2001 From: Theo Date: Fri, 30 Oct 2026 00:23:56 +0100 Subject: [PATCH] eau: lissage sans melange des composantes voisines, y en floor Co-Authored-By: Claude Sonnet 5.5 --- eau/examples/altitude.rs | 40 ++++++++++++++++++++++++++++++++++++++++ eau/src/lib.rs | 26 ++++++++++++++++++++++---- 2 files changed, 62 insertions(+), 4 deletions(-) create mode 100644 eau/examples/altitude.rs diff --git a/eau/examples/altitude.rs b/eau/examples/altitude.rs new file mode 100644 index 0000000..fd72263 --- /dev/null +++ b/eau/examples/altitude.rs @@ -0,0 +1,40 @@ +//! Validation sur tuile d'altitude : trace une riviere fictive par plus forte descente depuis le sommet. +//! cargo run --release --example altitude -- +use eau::*; +fn main() { + let a: Vec = std::env::args().collect(); + let b = std::fs::read(&a[1]).unwrap(); + let hl = u16::from_le_bytes([b[8], b[9]]) as usize; + let z: Vec = b[10 + hl..].chunks_exact(4).map(|c| f32::from_le_bytes(c.try_into().unwrap())).collect(); + let n = 1000usize; + let mut e = vec![0u8; n * n]; + let (mut p, mut v) = (0usize, f32::MIN); + for (i, &h) in z.iter().enumerate() { if h > v { v = h; p = i; } } + let (mut r, mut c) = (p / n, p % n); + let mut len = 0; + loop { + for dr in 0..3usize { for dc in 0..3usize { if r + dr < n && c + dc < n { e[(r + dr) * n + c + dc] = 1; } } } + len += 1; + let mut best = (z[r * n + c], r, c); + for dr in -4i32..=4 { for dc in -4i32..=4 { if dr.abs() < 3 && dc.abs() < 3 { continue; } + let (rr, cc) = (r as i32 + dr, c as i32 + dc); + if rr < 0 || cc < 0 || rr >= n as i32 - 3 || cc >= n as i32 - 3 { continue; } + let h = z[rr as usize * n + cc as usize]; + if h < best.0 { best = (h, rr as usize, cc as usize); } + } } + if best.1 == r && best.2 == c || len > 5000 { break; } + r = best.1; c = best.2; + } + let t = std::time::Instant::now(); + let m = construire(&z, &e, n, n, &Params { alt_base: 1000.0, rayon_berge: 3, pas_max: 1 }); + let mut viol = 0; let mut max_niv = i16::MIN; let mut min_niv = i16::MAX; let mut sous_sol = 0; + for i in 0..n * n { + if m.niveau[i] != AUCUN { + max_niv = max_niv.max(m.niveau[i]); min_niv = min_niv.min(m.niveau[i]); + if m.fond[i] > m.niveau[i] { sous_sol += 1; } + let pa = m.parent[i]; + if pa != u32::MAX && m.niveau[pa as usize] > m.niveau[i] { viol += 1; } + } + } + println!("trace {len} px, {} ms, stats {:?}, niveau {min_niv}..{max_niv}, remontees aval {viol}, fond>niveau {sous_sol}", t.elapsed().as_millis(), m.stats); +} diff --git a/eau/src/lib.rs b/eau/src/lib.rs index f5a2633..daa7498 100644 --- a/eau/src/lib.rs +++ b/eau/src/lib.rs @@ -1,5 +1,5 @@ //! Prototype 11 : eau (rivieres creusees, niveaux en blocs, plans d'eau, berges). -//! 1 bloc = 1 m vertical ; y_bloc = round(altitude - alt_base). Aucune dependance. +//! 1 bloc = 1 m vertical ; y_bloc = floor(altitude - alt_base), comme rt-core::alt_to_y. Aucune dependance. use std::cmp::Reverse; use std::collections::BinaryHeap; @@ -38,6 +38,7 @@ pub struct Colonne { pub struct Params { pub alt_base: f32, pub rayon_berge: usize, pub pas_max: i16 } impl Default for Params { fn default() -> Self { Self { alt_base: 0.0, rayon_berge: 3, pas_max: 1 } } } +#[derive(Clone, Debug)] pub struct Stats { pub composantes_rivieres: usize, pub lacs: usize, pub pixels_ecretes: usize, pub largeur_max_m: f32 } pub struct CarteEau { @@ -106,7 +107,7 @@ pub fn construire(mnt: &[f32], eau: &[u8], w: usize, h: usize, p: &Params) -> Ca assert_eq!(mnt.len(), w * h); assert_eq!(eau.len(), w * h); let n = w * h; - let yb = |a: f32| -> i16 { (a - p.alt_base).round() as i16 }; + let yb = |a: f32| -> i16 { (a - p.alt_base).floor() as i16 }; let dem: Vec = mnt.iter().map(|&a| yb(a)).collect(); let mut niveau = vec![AUCUN; n]; let mut fond = vec![AUCUN; n]; @@ -135,7 +136,8 @@ pub fn construire(mnt: &[f32], eau: &[u8], w: usize, h: usize, p: &Params) -> Ca stats.composantes_rivieres += 1; // lissage du niveau brut le long de la riviere (moyenne masquee 13x13, 2 passes) let mut lis: Vec = vec![0.0; n]; - for &i in &comp { lis[i] = mnt[i]; } + let mut dans = vec![false; n]; // la moyenne ne doit pas melanger les composantes voisines + for &i in &comp { lis[i] = mnt[i]; dans[i] = true; } for _ in 0..2 { let src = lis.clone(); for &i in &comp { @@ -145,7 +147,7 @@ pub fn construire(mnt: &[f32], eau: &[u8], w: usize, h: usize, p: &Params) -> Ca let (nx, ny) = (x + dx, y + dy); if nx >= 0 && ny >= 0 && nx < w as i32 && ny < h as i32 { let j = ny as usize * w + nx as usize; - if riv[j] { s += src[j]; c += 1.0; } + if dans[j] { s += src[j]; c += 1.0; } } } } lis[i] = s / c; @@ -353,4 +355,20 @@ mod tests { assert!(etiage.eau_haut.map_or(true, |t| t == n - 1)); assert_eq!(EtatEau { debit_rel: 0.7, lac_gele: false }.decalage_riviere(), 0); } + + #[test] + fn composantes_voisines_independantes() { + // deux ruisseaux a 4 px d'ecart, l'un a 100 m, l'autre a 900 m : pas de melange des niveaux + let (w, h) = (30usize, 12usize); + let mut mnt = vec![0.0f32; w * h]; + let mut e = vec![0u8; w * h]; + for r in 0..h { for c in 0..w { + let haut = c >= 15; + mnt[r * w + c] = if haut { 900.0 } else { 100.0 }; + if c == 13 || c == 17 { e[r * w + c] = COURS; } + } } + let m = construire(&mnt, &e, w, h, &Params { alt_base: 0.0, rayon_berge: 2, pas_max: 1 }); + assert_eq!(m.niveau[5 * w + 13], 100); + assert_eq!(m.niveau[5 * w + 17], 900); + } }