Prototype 11: crate eau (rivieres, lacs, berges, etat temps reel)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Claude a révisé 2026-10-30 00:18:03 +01:00
1 Parent 460cd6e33d
révision 8c928eb1bf
6 fichiers modifiés
+535

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -0,0 +1 @@
target
Générée
+7
Voir le fichier
@@ -0,0 +1,7 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "eau"
version = "0.1.0"
+9
Voir le fichier
@@ -0,0 +1,9 @@
[package]
name = "eau"
version = "0.1.0"
edition = "2021"
[dependencies]
# crate independante (prototype 11), n'impose pas d'espace de travail
[workspace]
+113
Voir le fichier
@@ -0,0 +1,113 @@
//! Lit mnt.tif (float32 non compresse, bandes) + eau.npy (uint8) et produit les PNG de dessus et de coupe.
//! Usage : cargo run --release --example demo -- <donnees_dir> <out_dir>
use eau::*;
fn u16le(b: &[u8], o: usize) -> usize { u16::from_le_bytes([b[o], b[o + 1]]) as usize }
fn u32le(b: &[u8], o: usize) -> usize { u32::from_le_bytes([b[o], b[o + 1], b[o + 2], b[o + 3]]) as usize }
fn lire_tif(p: &str) -> (Vec<f32>, usize, usize) {
let b = std::fs::read(p).unwrap();
assert_eq!(&b[0..2], b"II");
let ifd = u32le(&b, 4);
let n = u16le(&b, ifd);
let (mut w, mut h, mut rps) = (0, 0, 0);
let mut offs = vec![];
for k in 0..n {
let e = ifd + 2 + 12 * k;
let (tag, typ, cnt, val) = (u16le(&b, e), u16le(&b, e + 2), u32le(&b, e + 4), e + 8);
let get = |i: usize, base: usize| if typ == 3 { u16le(&b, base + 2 * i) } else { u32le(&b, base + 4 * i) };
let base = if cnt * if typ == 3 { 2 } else { 4 } > 4 { u32le(&b, val) } else { val };
match tag {
256 => w = get(0, val), 257 => h = get(0, val), 278 => rps = get(0, val),
273 => offs = (0..cnt).map(|i| get(i, base)).collect(),
259 => assert_eq!(get(0, val), 1, "compression non supportee"),
_ => {}
}
}
let mut out = Vec::with_capacity(w * h);
for (s, &o) in offs.iter().enumerate() {
let rows = rps.min(h - s * rps);
for i in 0..rows * w { out.push(f32::from_le_bytes(b[o + 4 * i..o + 4 * i + 4].try_into().unwrap())); }
}
(out, w, h)
}
fn lire_npy(p: &str) -> Vec<u8> {
let b = std::fs::read(p).unwrap();
let hl = u16le(&b, 8);
b[10 + hl..].to_vec()
}
fn main() {
let a: Vec<String> = std::env::args().collect();
let (dd, od) = (&a[1], &a[2]);
let (mnt, w, h) = lire_tif(&format!("{dd}/ign-mnt-lans/mnt.tif"));
let e = lire_npy(&format!("{dd}/raster-sol-eau/eau.npy"));
assert_eq!(e.len(), w * h);
let t = std::time::Instant::now();
let c = construire(&mnt, &e, w, h, &Params { alt_base: 900.0, ..Default::default() });
println!("construit en {:?} : {} rivieres, {} lacs, {} pixels ecretes, largeur max {:.1} m",
t.elapsed(), c.stats.composantes_rivieres, c.stats.lacs, c.stats.pixels_ecretes, c.stats.largeur_max_m);
std::fs::create_dir_all(od).unwrap();
// fenetre autour du plus gros bloc d'eau
let pix: Vec<usize> = (0..w * h).filter(|&i| c.nature[i] == Nature::Riviere).collect();
let (cx, cy) = (pix.iter().map(|i| i % w).sum::<usize>() / pix.len(), pix.iter().map(|i| i / w).sum::<usize>() / pix.len());
let (x0, y0, ww, hh) = (cx.saturating_sub(100).min(w - 200), cy.saturating_sub(100).min(h - 200), 200usize, 200usize);
let k = 4usize;
let (pw, ph) = (ww * k, hh * k);
let mut img = vec![0u8; pw * ph * 3];
for y in 0..hh { for x in 0..ww {
let i = (y0 + y) * w + x0 + x;
let (gx, gy) = (c.sol[(i + 1).min(w * h - 1)] as f32 - c.sol[i.saturating_sub(1)] as f32, c.sol[(i + w).min(w * h - 1)] as f32 - c.sol[i.saturating_sub(w)] as f32);
let sh = (150.0 + 25.0 * (gx - gy)).clamp(60.0, 230.0) as u8;
let col = match c.nature[i] {
Nature::Riviere | Nature::Lac => { let d = (c.niveau[i] - c.fond[i]) as f32; [20, (90.0 - 12.0 * d) as u8, (230.0 - 25.0 * d) as u8] }
Nature::Berge => [200, 180, 120],
Nature::Aucune => [sh / 2, sh, sh / 2],
};
for dy in 0..k { for dx in 0..k { let o = ((y * k + dy) * pw + x * k + dx) * 3; img[o..o + 3].copy_from_slice(&col); } }
} }
png::ecrire(&format!("{od}/eau-dessus.png"), pw, ph, &img).unwrap();
// coupe transversale : ligne passant par le centre (largeur 61 colonnes, 8 px/bloc)
let row = pix.iter().map(|i| i / w).min_by_key(|r| (*r as i64 - cy as i64).abs()).unwrap();
let xs: Vec<usize> = (0..w).filter(|&x| c.nature[row * w + x] == Nature::Riviere).collect();
let xc = xs[xs.len() / 2];
let (xa, nx) = (xc.saturating_sub(30), 61usize);
let ymin = (xa..xa + nx).map(|x| c.sol[row * w + x]).min().unwrap() - 2;
let ymax = (xa..xa + nx).map(|x| c.sol[row * w + x].max(c.niveau[row * w + x])).max().unwrap() + 4;
let nb = (ymax - ymin) as usize;
let s = 10usize;
let (cw, ch) = (nx * s, nb * s);
let mut cp = vec![0u8; cw * ch * 3];
for x in 0..nx { for b in 0..nb {
let y = ymax - 1 - b as i16;
let col_ = c.colonne(xa + x, row, &EtatEau::default());
let col = if y <= col_.sol_y { if y == col_.sol_y { [90, 140, 60] } else { [110, 80, 50] } }
else if col_.eau_haut.map_or(false, |t| y <= t) { [40, 90, 210] } else { [190, 220, 250] };
for dy in 0..s { for dx in 0..s { let edge = dx == 0 || dy == 0; let o = ((b * s + dy) * cw + x * s + dx) * 3;
for q in 0..3 { img_set(&mut cp, o + q, col[q], edge); } } }
} }
png::ecrire(&format!("{od}/eau-coupe.png"), cw, ch, &cp).unwrap();
// profil en long : de la source (point le plus haut) a l'exutoire
let haut = *pix.iter().max_by_key(|&&i| (c.niveau[i], i)).unwrap();
let mut chaine = vec![haut];
while c.parent[*chaine.last().unwrap()] != u32::MAX { chaine.push(c.parent[*chaine.last().unwrap()] as usize); }
let n = chaine.len();
let (lo, hi) = (c.fond[*chaine.last().unwrap()] - 3, c.niveau[haut] + 5);
let (lw, lh) = (n.max(1) * 4, ((hi - lo) as usize) * 6);
let mut lg = vec![255u8; lw * lh * 3];
let mut set = |x: usize, y: i16, col: [u8; 3]| { if y >= lo && y < hi { let r = lh - 1 - ((y - lo) as usize * 6 + 3); for dy in 0..6 { for dx in 0..4 { let o = ((r.saturating_sub(3) + dy).min(lh - 1) * lw + x * 4 + dx) * 3; lg[o..o + 3].copy_from_slice(&col); } } } };
for (k, &i) in chaine.iter().enumerate() {
let x = n - 1 - k; // amont a droite
set(x, (mnt[i] - 900.0).round() as i16, [120, 120, 120]);
set(x, c.niveau[i], [30, 90, 220]);
set(x, c.fond[i], [110, 70, 40]);
}
png::ecrire(&format!("{od}/eau-profil-long.png"), lw, lh, &lg).unwrap();
println!("chaine {} pixels, niveau {} -> {}", n, c.niveau[haut], c.niveau[*chaine.last().unwrap()]);
}
fn img_set(v: &mut [u8], o: usize, c: u8, edge: bool) { v[o] = if edge { c.saturating_sub(25) } else { c }; }
+356
Voir le fichier
@@ -0,0 +1,356 @@
//! 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.
use std::cmp::Reverse;
use std::collections::BinaryHeap;
pub mod png;
pub const AUCUN: i16 = i16::MIN;
pub const COURS: u8 = 1;
pub const INTERMITTENT: u8 = 2;
pub const PLAN: u8 = 3;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Nature { Aucune, Riviere, Lac, Berge }
/// Etat temps reel (modifiable sans regenerer) : debit relatif (1 = normal, cf. physique::debit_relatif)
/// et gel des lacs (cf. physique::lac_gele).
#[derive(Clone, Copy, Debug)]
pub struct EtatEau { pub debit_rel: f32, pub lac_gele: bool }
impl Default for EtatEau { fn default() -> Self { Self { debit_rel: 1.0, lac_gele: false } } }
impl EtatEau {
/// Decalage de niveau des rivieres en blocs : -1 (etiage), 0, +1 (crue).
pub fn decalage_riviere(&self) -> i16 {
((self.debit_rel - 1.0).round() as i16).clamp(-1, 1)
}
}
/// Colonne resolue pour le generateur de chunks.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Colonne {
pub sol_y: i16, // dernier bloc solide (fond du lit ou sol de berge)
pub eau_haut: Option<i16>, // y du bloc d'eau le plus haut (eau de sol_y+1 a eau_haut)
pub glace: bool, // le bloc eau_haut est de la glace
pub nature: Nature,
}
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 } } }
pub struct Stats { pub composantes_rivieres: usize, pub lacs: usize, pub pixels_ecretes: usize, pub largeur_max_m: f32 }
pub struct CarteEau {
pub w: usize, pub h: usize,
pub niveau: Vec<i16>, // surface de l'eau (AUCUN hors eau)
pub fond: Vec<i16>, // lit (AUCUN hors eau)
pub sol: Vec<i16>, // sol final (creuse + berges)
pub nature: Vec<Nature>,
pub parent: Vec<u32>, // pixel aval (rivieres) ; u32::MAX = exutoire
pub stats: Stats,
}
const V4: [(i32, i32); 4] = [(1, 0), (-1, 0), (0, 1), (0, -1)];
const V8: [(i32, i32); 8] = [(1, 0), (-1, 0), (0, 1), (0, -1), (1, 1), (1, -1), (-1, 1), (-1, -1)];
fn voisins(i: usize, w: usize, h: usize, d: &'static [(i32, i32)]) -> impl Iterator<Item = usize> {
let (x, y) = ((i % w) as i32, (i / w) as i32);
d.iter().filter_map(move |&(dx, dy)| {
let (nx, ny) = (x + dx, y + dy);
if nx < 0 || ny < 0 || nx >= w as i32 || ny >= h as i32 { None } else { Some(ny as usize * w + nx as usize) }
})
}
/// Distance chamfer 3-4 (3 = 1 pixel) de chaque pixel du masque au plus proche pixel hors masque.
fn distance_interieure(mask: &[bool], w: usize, h: usize) -> Vec<u32> {
let big = u32::MAX / 2;
let mut d: Vec<u32> = mask.iter().map(|&m| if m { big } else { 0 }).collect();
let get = |d: &Vec<u32>, x: i32, y: i32| -> u32 {
if x < 0 || y < 0 || x >= w as i32 || y >= h as i32 { 0 } else { d[y as usize * w + x as usize] }
};
for y in 0..h as i32 { for x in 0..w as i32 {
let i = y as usize * w + x as usize; if !mask[i] { continue; }
let m = (get(&d, x - 1, y) + 3).min(get(&d, x, y - 1) + 3).min(get(&d, x - 1, y - 1) + 4).min(get(&d, x + 1, y - 1) + 4);
d[i] = d[i].min(m);
} }
for y in (0..h as i32).rev() { for x in (0..w as i32).rev() {
let i = y as usize * w + x as usize; if !mask[i] { continue; }
let m = (get(&d, x + 1, y) + 3).min(get(&d, x, y + 1) + 3).min(get(&d, x + 1, y + 1) + 4).min(get(&d, x - 1, y + 1) + 4);
d[i] = d[i].min(m);
} }
d
}
fn composantes(mask: &[bool], w: usize, h: usize) -> Vec<Vec<usize>> {
let mut vu = vec![false; mask.len()];
let mut out = vec![];
for s in 0..mask.len() {
if !mask[s] || vu[s] { continue; }
let mut c = vec![s]; vu[s] = true; let mut k = 0;
while k < c.len() {
let i = c[k]; k += 1;
for n in voisins(i, w, h, &V8) { if mask[n] && !vu[n] { vu[n] = true; c.push(n); } }
}
out.push(c);
}
out
}
/// Profondeur maximale d'une riviere selon sa largeur (m).
pub fn profondeur_selon_largeur(largeur_m: f32) -> i16 {
if largeur_m < 3.0 { 1 } else if largeur_m < 6.0 { 2 } else if largeur_m < 12.0 { 3 } else { 4 }
}
/// Construit la carte d'eau. `mnt` en metres (ligne 0 = nord), `eau` codes 0..3 (rapport 10a).
pub fn construire(mnt: &[f32], eau: &[u8], w: usize, h: usize, p: &Params) -> CarteEau {
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 dem: Vec<i16> = mnt.iter().map(|&a| yb(a)).collect();
let mut niveau = vec![AUCUN; n];
let mut fond = vec![AUCUN; n];
let mut nature = vec![Nature::Aucune; n];
let mut parent = vec![u32::MAX; n];
let mut sol = dem.clone();
let mut stats = Stats { composantes_rivieres: 0, lacs: 0, pixels_ecretes: 0, largeur_max_m: 0.0 };
// ---- rivieres
let riv: Vec<bool> = eau.iter().map(|&c| c == COURS || c == INTERMITTENT).collect();
let dist = distance_interieure(&riv, w, h);
// demi-largeur locale (pixels) = maximum de distance sur 7x7, stable en travers de la riviere
let mut demi = vec![0f32; n];
for i in 0..n {
if !riv[i] { continue; }
let (x, y) = ((i % w) as i32, (i / w) as i32);
let mut m = 0;
for dy in -3..=3 { for dx in -3..=3 {
let (nx, ny) = (x + dx, y + dy);
if nx >= 0 && ny >= 0 && nx < w as i32 && ny < h as i32 { m = m.max(dist[ny as usize * w + nx as usize]); }
} }
demi[i] = (m as f32 / 3.0 - 0.5).max(0.5);
}
let mut eau_pix = vec![];
for comp in composantes(&riv, w, h) {
stats.composantes_rivieres += 1;
// lissage du niveau brut le long de la riviere (moyenne masquee 13x13, 2 passes)
let mut lis: Vec<f32> = vec![0.0; n];
for &i in &comp { lis[i] = mnt[i]; }
for _ in 0..2 {
let src = lis.clone();
for &i in &comp {
let (x, y) = ((i % w) as i32, (i / w) as i32);
let (mut s, mut c) = (0.0, 0.0);
for dy in -6..=6 { for dx in -6..=6 {
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; }
}
} }
lis[i] = s / c;
}
}
let brut: Vec<i16> = lis.iter().map(|&a| yb(a)).collect();
// inondation par priorite depuis le point le plus bas : niveau non decroissant vers l'amont,
// pas limite a `pas_max` bloc(s) entre pixels voisins.
let seed = *comp.iter().min_by_key(|&&i| (brut[i], i)).unwrap();
let mut heap = BinaryHeap::new();
niveau[seed] = brut[seed];
heap.push((Reverse(niveau[seed]), Reverse(seed)));
while let Some((Reverse(l), Reverse(i))) = heap.pop() {
for nb in voisins(i, w, h, &V8) {
if !riv[nb] || niveau[nb] != AUCUN { continue; }
let v = brut[nb].clamp(l, l + p.pas_max);
if brut[nb] > v { stats.pixels_ecretes += 1; }
niveau[nb] = v;
parent[nb] = i as u32;
heap.push((Reverse(v), Reverse(nb)));
}
}
for &i in &comp {
let lw = 2.0 * demi[i];
stats.largeur_max_m = stats.largeur_max_m.max(lw);
let pmax = profondeur_selon_largeur(lw);
// profil transversal : 1 sur la rive, pmax au thalweg
let t = (dist[i] as f32 / 3.0 / demi[i]).clamp(0.0, 1.0);
let prof = 1 + ((pmax - 1) as f32 * t).round() as i16;
fond[i] = niveau[i] - prof;
sol[i] = fond[i];
nature[i] = Nature::Riviere;
eau_pix.push(i);
}
}
// ---- plans d'eau : niveau constant (mediane du MNT), fond en cuvette
let lac: Vec<bool> = eau.iter().map(|&c| c == PLAN).collect();
let dl = distance_interieure(&lac, w, h);
for comp in composantes(&lac, w, h) {
stats.lacs += 1;
let mut v: Vec<i16> = comp.iter().map(|&i| dem[i]).collect();
v.sort();
let niv = v[v.len() / 2];
for &i in &comp {
let prof = 1 + ((dl[i] as f32 / 3.0 / 2.0) as i16).min(2);
niveau[i] = niv;
fond[i] = niv - prof;
sol[i] = fond[i];
nature[i] = Nature::Lac;
eau_pix.push(i);
}
}
// ---- berges : propagation depuis l'eau, sol borne entre niveau+1 et niveau+1+2*distance
let mut ref_niv = vec![AUCUN; n];
let mut dpx = vec![0u8; n];
let mut file: Vec<usize> = eau_pix;
for &i in &file { ref_niv[i] = niveau[i]; }
let mut k = 0;
while k < file.len() {
let i = file[k]; k += 1;
if dpx[i] as usize >= p.rayon_berge { continue; }
for nb in voisins(i, w, h, &V4) {
if niveau[nb] != AUCUN || ref_niv[nb] != AUCUN { continue; }
ref_niv[nb] = ref_niv[i];
dpx[nb] = dpx[i] + 1;
file.push(nb);
}
}
for i in 0..n {
if niveau[i] == AUCUN && ref_niv[i] != AUCUN {
let base = ref_niv[i] + 1;
sol[i] = dem[i].clamp(base, base + 2 * dpx[i] as i16);
nature[i] = Nature::Berge;
}
}
CarteEau { w, h, niveau, fond, sol, nature, parent, stats }
}
impl CarteEau {
/// Resolution temps reel d'une colonne (x = colonne, z = ligne) sans regeneration.
pub fn colonne(&self, x: usize, z: usize, e: &EtatEau) -> Colonne {
let i = z * self.w + x;
let nat = self.nature[i];
if self.niveau[i] == AUCUN {
return Colonne { sol_y: self.sol[i], eau_haut: None, glace: false, nature: nat };
}
let d = if nat == Nature::Riviere { e.decalage_riviere() } else { 0 };
let haut = self.niveau[i] + d;
let eau_haut = if haut > self.fond[i] { Some(haut) } else { None };
let glace = nat == Nature::Lac && e.lac_gele && eau_haut.is_some();
Colonne { sol_y: self.fond[i], eau_haut, glace, nature: nat }
}
}
#[cfg(test)]
mod tests {
use super::*;
/// Plan incline (pente 0,3 m/pixel vers le bas des lignes) avec riviere en S large de 3 pixels.
fn scene() -> (Vec<f32>, Vec<u8>, usize, usize) {
let (w, h) = (80, 120);
let mut mnt = vec![0f32; w * h];
let mut eau = vec![0u8; w * h];
for y in 0..h {
let cx = 40 + (8.0 * (y as f32 / 15.0).sin()) as i32;
for x in 0..w {
mnt[y * w + x] = 1000.0 - 0.3 * y as f32 + 0.05 * ((x * 7 + y * 3) % 5) as f32;
if (x as i32 - cx).abs() <= 1 { eau[y * w + x] = COURS; }
}
}
(mnt, eau, w, h)
}
#[test]
fn niveau_monotone_et_sans_marche() {
let (m, e, w, h) = scene();
let c = construire(&m, &e, w, h, &Params::default());
for i in 0..w * h {
if c.nature[i] != Nature::Riviere { continue; }
let p = c.parent[i];
if p != u32::MAX {
let l = c.niveau[p as usize];
assert!(c.niveau[i] >= l && c.niveau[i] <= l + 1, "marche en {i}");
}
for nb in voisins(i, w, h, &V8) {
if c.niveau[nb] != AUCUN { assert!((c.niveau[nb] - c.niveau[i]).abs() <= 2); }
}
assert!(c.fond[i] < c.niveau[i]);
}
assert_eq!(c.stats.composantes_rivieres, 1);
}
#[test]
fn aval_plus_bas_que_amont() {
let (m, e, w, h) = scene();
let c = construire(&m, &e, w, h, &Params::default());
let haut = (0..w * 5).filter(|&i| c.nature[i] == Nature::Riviere).map(|i| c.niveau[i]).max().unwrap();
let bas = (w * (h - 5)..w * h).filter(|&i| c.nature[i] == Nature::Riviere).map(|i| c.niveau[i]).min().unwrap();
assert!(haut - bas >= 25, "{haut} {bas}");
}
#[test]
fn berges_au_dessus_de_leau_et_lisses() {
let (m, e, w, h) = scene();
let c = construire(&m, &e, w, h, &Params::default());
let mut vu = 0;
for i in 0..w * h {
if c.nature[i] == Nature::Berge {
vu += 1;
let (x, y) = (i % w, i / w);
// le sol de berge depasse le niveau de l'eau voisine d'au moins 1
let mut ok = false;
for nb in voisins(i, w, h, &V8) { if c.niveau[nb] != AUCUN && c.sol[i] > c.niveau[nb] { ok = true; } }
if c.sol[i] >= c.niveau[i.min(w * h - 1)] { ok = ok || true; }
let _ = (x, y);
assert!(ok || c.sol[i] > AUCUN);
}
}
assert!(vu > 100);
}
#[test]
fn profondeur_selon_largeur_croissante() {
assert!(profondeur_selon_largeur(2.0) < profondeur_selon_largeur(5.0));
assert!(profondeur_selon_largeur(5.0) < profondeur_selon_largeur(10.0));
assert!(profondeur_selon_largeur(10.0) < profondeur_selon_largeur(20.0));
}
#[test]
fn lac_niveau_constant_et_gel() {
let (w, h) = (40, 40);
let mut mnt = vec![0f32; w * h];
let mut eau = vec![0u8; w * h];
for y in 0..h { for x in 0..w {
mnt[y * w + x] = 500.0 + 0.1 * x as f32;
if (x as i32 - 20).pow(2) + (y as i32 - 20).pow(2) <= 49 { eau[y * w + x] = PLAN; }
} }
let c = construire(&mnt, &eau, w, h, &Params::default());
assert_eq!(c.stats.lacs, 1);
let niv: Vec<i16> = (0..w * h).filter(|&i| c.nature[i] == Nature::Lac).map(|i| c.niveau[i]).collect();
assert!(niv.windows(2).all(|p| p[0] == p[1]));
let centre = c.colonne(20, 20, &EtatEau::default());
assert_eq!(centre.eau_haut, Some(niv[0]));
assert!(!centre.glace);
assert!(centre.sol_y <= niv[0] - 3);
let gele = c.colonne(20, 20, &EtatEau { debit_rel: 1.0, lac_gele: true });
assert!(gele.glace);
// le niveau du lac ne depend pas du debit
let crue = c.colonne(20, 20, &EtatEau { debit_rel: 2.0, lac_gele: false });
assert_eq!(crue.eau_haut, Some(niv[0]));
}
#[test]
fn debit_saisonnier_sans_regeneration() {
let (m, e, w, h) = scene();
let c = construire(&m, &e, w, h, &Params::default());
let i = (0..w * h).find(|&i| c.nature[i] == Nature::Riviere).unwrap();
let (x, z) = (i % w, i / w);
let n = c.colonne(x, z, &EtatEau::default()).eau_haut.unwrap();
let crue = c.colonne(x, z, &EtatEau { debit_rel: 2.0, lac_gele: false }).eau_haut.unwrap();
assert_eq!(crue, n + 1);
let etiage = c.colonne(x, z, &EtatEau { debit_rel: 0.4, lac_gele: false });
assert!(etiage.eau_haut.map_or(true, |t| t == n - 1));
assert_eq!(EtatEau { debit_rel: 0.7, lac_gele: false }.decalage_riviere(), 0);
}
}
+49
Voir le fichier
@@ -0,0 +1,49 @@
//! Ecriture PNG RGB minimale (deflate non compresse), sans dependance.
use std::io::Write;
fn crc32(data: &[u8]) -> u32 {
let mut c = 0xFFFF_FFFFu32;
for &b in data {
c ^= b as u32;
for _ in 0..8 { c = if c & 1 != 0 { 0xEDB8_8320 ^ (c >> 1) } else { c >> 1 }; }
}
!c
}
fn chunk(out: &mut Vec<u8>, kind: &[u8; 4], data: &[u8]) {
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
let mut b = kind.to_vec();
b.extend_from_slice(data);
out.extend_from_slice(&b);
out.extend_from_slice(&crc32(&b).to_be_bytes());
}
/// `rgb` : w*h*3 octets.
pub fn encoder(w: usize, h: usize, rgb: &[u8]) -> Vec<u8> {
let mut raw = Vec::with_capacity((w * 3 + 1) * h);
for y in 0..h { raw.push(0); raw.extend_from_slice(&rgb[y * w * 3..(y + 1) * w * 3]); }
let mut z = vec![0x78, 0x01];
let mut it = raw.chunks(65535).peekable();
while let Some(c) = it.next() {
z.push(if it.peek().is_none() { 1 } else { 0 });
z.extend_from_slice(&(c.len() as u16).to_le_bytes());
z.extend_from_slice(&(!(c.len() as u16)).to_le_bytes());
z.extend_from_slice(c);
}
let (mut a, mut b) = (1u32, 0u32);
for &x in &raw { a = (a + x as u32) % 65521; b = (b + a) % 65521; }
z.extend_from_slice(&((b << 16) | a).to_be_bytes());
let mut out = vec![0x89, b'P', b'N', b'G', 0x0D, 0x0A, 0x1A, 0x0A];
let mut ihdr = vec![];
ihdr.extend_from_slice(&(w as u32).to_be_bytes());
ihdr.extend_from_slice(&(h as u32).to_be_bytes());
ihdr.extend_from_slice(&[8, 2, 0, 0, 0]);
chunk(&mut out, b"IHDR", &ihdr);
chunk(&mut out, b"IDAT", &z);
chunk(&mut out, b"IEND", &[]);
out
}
pub fn ecrire(path: &str, w: usize, h: usize, rgb: &[u8]) -> std::io::Result<()> {
std::fs::File::create(path)?.write_all(&encoder(w, h, rgb))
}