diff --git a/biomes/examples/arbres_mnh.rs b/biomes/examples/arbres_mnh.rs new file mode 100644 index 0000000..30ab600 --- /dev/null +++ b/biomes/examples/arbres_mnh.rs @@ -0,0 +1,45 @@ +//! Arbres reels de Lans depuis le MNH. Usage : +//! cargo run --release --example arbres_mnh -- +use biomes::*; +use std::io::{BufWriter, Read}; +fn npy(path: &str) -> Vec { + let mut b = Vec::new(); + std::fs::File::open(path).unwrap().read_to_end(&mut b).unwrap(); + let hl = u16::from_le_bytes([b[8], b[9]]) as usize; + b[10 + hl..].to_vec() +} +fn f32s(b: &[u8]) -> Vec { b.chunks_exact(4).map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]])).collect() } +fn main() { + let a: Vec = std::env::args().collect(); + let n = 1000usize; + let z = f32s(&npy(&a[1])); + let mnh = f32s(&npy(&a[2])); + let rd = |k: &str| npy(&format!("{}/{}.npy", a[3], k)); + let (sol, eau, routes, bati) = (rd("sol"), rd("eau"), rd("routes"), rd("bati")); + let g = |r: isize, c: isize| z[r.clamp(0, n as isize - 1) as usize * n + c.clamp(0, n as isize - 1) as usize]; + let col = |x: i32, zz: i32| { + let (r, c) = (zz as isize, x as isize); + let dx = (g(r, c + 1) - g(r, c - 1)) / 2.0; + let dy = (g(r + 1, c) - g(r - 1, c)) / 2.0; + let i = zz as usize * n + x as usize; + Colonne { alt_m: z[i], pente_deg: dx.hypot(dy).atan().to_degrees(), aspect_deg: (-dx).atan2(dy).to_degrees().rem_euclid(360.0), sol: sol[i], eau: eau[i], route: routes[i], bati: bati[i] } + }; + let arbres = arbres_depuis_mnh(&mnh, n, n, &col, 42); + let proc_ = (0..n as i32).flat_map(|zz| (0..n as i32).map(move |x| (x, zz))).filter(|&(x, zz)| arbre_en(&col(x, zz), x, zz, 42).is_some()).count(); + let hm = arbres.iter().map(|t| t.2.hauteur as f32).sum::() / arbres.len() as f32; + let conif = arbres.iter().filter(|t| t.2.essence.coniferes()).count(); + println!("arbres MNH : {} (hauteur moyenne {:.1} m, coniferes {:.0} %) ; procedural : {}", arbres.len(), hm, 100.0 * conif as f32 / arbres.len() as f32, proc_); + let mut img = vec![0u8; n * n * 3]; + for i in 0..n * n { let v = (60.0 + z[i] - 972.0).clamp(0., 255.) as u8; img[i * 3..i * 3 + 3].copy_from_slice(&[v / 2 + 60, v / 2 + 80, v / 3 + 40]); } + for (x, zz, t) in &arbres { + let c: [u8; 3] = if t.essence.coniferes() { [15, 60, 35] } else { [40, 120, 30] }; + let r = if t.hauteur > 20 { 2 } else { 1 }; + for dz in 0..r { for dx in 0..r { + let (xx, zz2) = (*x as usize + dx, *zz as usize + dz); + if xx < n && zz2 < n { let j = (zz2 * n + xx) * 3; img[j..j + 3].copy_from_slice(&c); } + } } + } + let mut e = png::Encoder::new(BufWriter::new(std::fs::File::create(&a[4]).unwrap()), n as u32, n as u32); + e.set_color(png::ColorType::Rgb); e.set_depth(png::BitDepth::Eight); + e.write_header().unwrap().write_image_data(&img).unwrap(); +} diff --git a/biomes/examples/vue_altitude.rs b/biomes/examples/vue_altitude.rs new file mode 100644 index 0000000..303af9d --- /dev/null +++ b/biomes/examples/vue_altitude.rs @@ -0,0 +1,105 @@ +//! Cartes de biomes/etages/neige/roche pour une tuile d'altitude (1000x1000 m). +//! cargo run --release --example vue_altitude -- +//! Pas de raster d'occupation du sol sur ces tuiles : sol = 4 (foret mixte potentielle) partout. +use biomes::*; +use physique::*; +use std::io::{BufWriter, Read}; + +fn npy(path: &str) -> Vec { + let mut b = Vec::new(); + std::fs::File::open(path).unwrap().read_to_end(&mut b).unwrap(); + let hl = u16::from_le_bytes([b[8], b[9]]) as usize; + b[10 + hl..].chunks_exact(4).map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]])).collect() +} +fn png(path: &str, w: usize, h: usize, rgb: &[u8]) { + let mut e = png::Encoder::new(BufWriter::new(std::fs::File::create(path).unwrap()), w as u32, h as u32); + e.set_color(png::ColorType::Rgb); + e.set_depth(png::BitDepth::Eight); + e.write_header().unwrap().write_image_data(rgb).unwrap(); +} + +fn main() { + let a: Vec = std::env::args().collect(); + let z = npy(&a[1]); + let n = 1000usize; + let seed = 42; + // Le MNT 1 m est bruite (stries WMS) : pente et ombrage sur un MNT lisse (moyenne 3x3), comme Horn dans rt-prep. + let raw = |r: isize, c: isize| z[r.clamp(0, n as isize - 1) as usize * n + c.clamp(0, n as isize - 1) as usize]; + let zs: Vec = (0..n * n).map(|i| { let (r, c) = ((i / n) as isize, (i % n) as isize); let mut s = 0.0; for dr in -1..=1 { for dc in -1..=1 { s += raw(r + dr, c + dc); } } s / 9.0 }).collect(); + let g = |r: isize, c: isize| zs[r.clamp(0, n as isize - 1) as usize * n + c.clamp(0, n as isize - 1) as usize]; + let col_at = |r: usize, c: usize| { + let (ri, ci) = (r as isize, c as isize); + let dx = (g(ri, ci + 1) - g(ri, ci - 1)) / 2.0; + let dy = (g(ri + 1, ci) - g(ri - 1, ci)) / 2.0; + Colonne { alt_m: z[r * n + c], pente_deg: dx.hypot(dy).atan().to_degrees(), aspect_deg: (-dx).atan2(dy).to_degrees().rem_euclid(360.0), sol: 4, eau: 0, route: 0, bati: 0 } + }; + let cols: Vec = (0..n * n).map(|i| col_at(i / n, i % n)).collect(); + let mut st = std::collections::BTreeMap::new(); + let mut roche = 0u32; + let mut etg = vec![0u8; n * n * 3]; + let mut rock = vec![0u8; n * n * 3]; + for i in 0..n * n { + let (c, x, zz) = (&cols[i], (i % n) as i32, (i / n) as i32); + let e = etage(c, x, zz, seed); + *st.entry(format!("{:?}", e)).or_insert(0u32) += 1; + let k: [u8; 3] = match e { Etage::Collineen => [60, 140, 60], Etage::Montagnard => [30, 100, 50], Etage::Subalpin => [120, 160, 60], Etage::Alpin => [190, 190, 120], Etage::Nival => [240, 240, 250] }; + etg[i * 3..i * 3 + 3].copy_from_slice(&k); + let pal = palette(c, x, zz, seed); + let nu = matches!(pal.haut, "minecraft:stone" | "minecraft:andesite"); + if nu { roche += 1; } + let s: [u8; 3] = if nu { [110, 110, 110] } else if c.pente_deg > 35.0 { [190, 150, 90] } else { [60, 150, 60] }; + rock[i * 3..i * 3 + 3].copy_from_slice(&s); + } + let pc = |v: u32| v as f32 / 1e4; + println!("{} etages: {}", a[2], st.iter().map(|(k, v)| format!("{k} {:.1}%", pc(*v))).collect::>().join(", ")); + let p35 = cols.iter().filter(|c| c.pente_deg > 35.0).count() as u32; + let p55 = cols.iter().filter(|c| c.pente_deg > 55.0).count() as u32; + println!("pente>35: {:.1}% pente>55: {:.1}% roche nue (stone/andesite): {:.1}%", pc(p35), pc(p55), pc(roche)); + png(&format!("{}/{}_etages.png", a[3], a[2]), n, n, &etg); + png(&format!("{}/{}_roche.png", a[3], a[2]), n, n, &rock); + let h = n / 2; + let mut mont = vec![0u8; 2 * h * 2 * h * 3]; + for (m, mois) in [1u32, 4, 7, 10].into_iter().enumerate() { + let mut bst = std::collections::BTreeMap::new(); + let mut neige = 0u32; + let mut img = vec![0u8; n * n * 3]; + for i in 0..n * n { + let (c, x, zz) = (&cols[i], (i % n) as i32, (i / n) as i32); + let b = biome(c, x, zz, seed); + *bst.entry(b.id()).or_insert(0u32) += 1; + let pal = palette(c, x, zz, seed); + let mut rgb: [f32; 3] = match (pal.haut, b) { + ("minecraft:grass_block", Biome::Forest) => [76., 140., 50.], + ("minecraft:grass_block", Biome::Taiga) => [60., 110., 75.], + ("minecraft:grass_block", Biome::Grove) => [110., 160., 90.], + ("minecraft:grass_block", _) => [100., 165., 60.], + ("minecraft:stone", _) => [125., 125., 125.], + ("minecraft:andesite", _) => [136., 136., 136.], + ("minecraft:gravel", _) => [131., 127., 126.], + ("minecraft:coarse_dirt", _) => [119., 85., 59.], + ("minecraft:podzol", _) => [91., 63., 24.], + _ => [200., 0., 200.], + }; + if arbre_en(c, x, zz, seed).is_some() { rgb = [20., 70., 40.]; } + let sh = (1.0 + (g(zz as isize, x as isize + 1) - g(zz as isize + 1, x as isize)) * 0.03).clamp(0.6, 1.3); + let ex = exposition(c.aspect_deg, c.pente_deg); + let cn = couche_neige(c.alt_m, c.pente_deg, ex, mois, Meteo::Sec); + if cn > 0 { + neige += 1; + let t = 0.55 + 0.05 * cn as f32; + for k in 0..3 { rgb[k] = rgb[k] * (1.0 - t) + 245.0 * t; } + } + for k in 0..3 { img[i * 3 + k] = (rgb[k] * sh).clamp(0., 255.) as u8; } + } + println!("mois {mois}: neige {:.1}% biomes {}", pc(neige), bst.iter().map(|(k, v)| format!("{} {:.1}%", k.trim_start_matches("minecraft:"), pc(*v))).collect::>().join(", ")); + for r in 0..h { + for c in 0..h { + let (ox, oy) = ((m % 2) * h, (m / 2) * h); + let s = (r * 2 * n + c * 2) * 3; + let d = ((oy + r) * 2 * h + ox + c) * 3; + mont[d..d + 3].copy_from_slice(&img[s..s + 3]); + } + } + } + png(&format!("{}/{}_saisons.png", a[3], a[2]), 2 * h, 2 * h, &mont); +} diff --git a/biomes/src/lib.rs b/biomes/src/lib.rs index 3c1e084..90dc19a 100644 --- a/biomes/src/lib.rs +++ b/biomes/src/lib.rs @@ -184,6 +184,33 @@ pub fn arbre_en(c: &Colonne, x: i32, z: i32, seed: u64) -> Option { Some(Arbre { essence: es, hauteur: (h0 + dh * r) as u8 }) } +/// Arbres reels depuis un MNH (hauteur de canopee, m, ligne 0 = nord, `w` x `h`). +/// Un arbre par cellule 4x4 : le pixel le plus haut s'il depasse 3 m et n'est ni bati, ni route, ni eau. +/// `colonne(x, z)` fournit la colonne (x = colonne, z = ligne). Essence selon l'etage/le sol, hauteur = MNH (3..=40). +pub fn arbres_depuis_mnh(mnh: &[f32], w: usize, h: usize, colonne: &dyn Fn(i32, i32) -> Colonne, seed: u64) -> Vec<(i32, i32, Arbre)> { + const CELL: usize = 4; + let mut out = Vec::new(); + for cz in 0..h.div_ceil(CELL) { + for cx in 0..w.div_ceil(CELL) { + let (mut best, mut bx, mut bz) = (0.0f32, 0usize, 0usize); + for z in cz * CELL..((cz + 1) * CELL).min(h) { + for x in cx * CELL..((cx + 1) * CELL).min(w) { + let v = mnh[z * w + x]; + if v.is_finite() && v > best { best = v; bx = x; bz = z; } + } + } + if best < 3.0 { continue; } + let c = colonne(bx as i32, bz as i32); + if c.bati > 0 || c.route > 0 || c.eau > 0 { continue; } + let e = etage(&c, bx as i32, bz as i32, seed); + if e == Etage::Nival { continue; } + let es = essence(&c, e, bx as i32, bz as i32, seed); + out.push((bx as i32, bz as i32, Arbre { essence: es, hauteur: best.round().clamp(3.0, 40.0) as u8 })); + } + } + out +} + #[cfg(test)] mod tests { use super::*; @@ -208,7 +235,7 @@ mod tests { assert_eq!(biome(&col(1200.0, 5.0, 1), 3, 3, 1), Biome::Meadow); assert_eq!(biome(&col(1200.0, 5.0, 3), 3, 3, 1), Biome::Taiga); assert_eq!(biome(&col(1200.0, 5.0, 2), 3, 3, 1), Biome::Forest); - assert_eq!(biome(&col(2800.0, 5.0, 1), 3, 3, 1), Biome::StonyPeaks); + assert_eq!(biome(&col(3000.0, 5.0, 1), 3, 3, 1), Biome::StonyPeaks); } #[test] fn pente_donne_roche() { assert_eq!(palette(&col(1200.0, 80.0, 1), 1, 1, 1).haut, "minecraft:stone"); @@ -244,6 +271,15 @@ mod tests { let a = (0..400).flat_map(|x| (0..400).map(move |z| (x, z))).find_map(|(x, z)| arbre_en(&c, x, z, 2)).unwrap(); assert!(!a.essence.coniferes()); } + #[test] fn arbres_mnh() { + let mut mnh = vec![0.0f32; 16 * 8]; + mnh[3 * 16 + 5] = 18.4; mnh[1 * 16 + 9] = 2.0; mnh[6 * 16 + 14] = 12.0; + let a = arbres_depuis_mnh(&mnh, 16, 8, &|_, _| col(1000.0, 5.0, 3), 1); + assert_eq!(a.len(), 2); + assert!(a.iter().any(|&(x, z, t)| (x, z, t.hauteur) == (5, 3, 18))); + let b = arbres_depuis_mnh(&mnh, 16, 8, &|_, _| { let mut c = col(1000.0, 5.0, 3); c.bati = 1; c }, 1); + assert!(b.is_empty()); + } #[test] fn pas_d_arbre_nival() { assert_eq!(densite(&col(3000.0, 5.0, 3), Etage::Nival), 0.0); }