5a24289898fd
lib.rs
//! Procedurally generated, photographic-looking demo scenes.
//!
//! Scenes are resolution independent (`render(w, h)` evaluates a continuous function) and return
//! scene-referred linear Rec.2020 radiance with real highlight headroom (the sun is ≫ 1.0), so the
//! develop pipeline's highlight recovery, tone mapping and colour tools have something real to do.
//! Every scene is deterministic for its seed. No external assets: zero licensing or privacy risk.
#![forbid(unsafe_code)]
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
mod noise;
mod paint;
use lightcraft_raster::Rgb32f;
use serde::Serialize;
pub use paint::render_srgb_linear;
/// Kinds of scene the generator knows.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum Kind {
AlpineLake,
Dunes,
OceanSunset,
Aurora,
MistyForest,
Lavender,
Macro,
Canyon,
Beach,
BlueHour,
}
/// Fake capture metadata so the library looks like a real shoot.
#[derive(Clone, Debug, Serialize)]
pub struct SceneMeta {
pub camera: &'static str,
pub lens: &'static str,
pub focal_mm: f32,
pub aperture: f32,
pub shutter: &'static str,
pub iso: u32,
/// ISO 8601 local time.
pub captured: String,
pub location: &'static str,
pub keywords: Vec<&'static str>,
}
#[derive(Clone, Debug, Serialize)]
pub struct Scene {
pub id: u32,
pub name: String,
pub kind: Kind,
pub seed: u32,
/// Native pixel size (what an import would report).
pub width: u32,
pub height: u32,
pub meta: SceneMeta,
}
impl Scene {
pub fn aspect(&self) -> f32 {
self.width as f32 / self.height as f32
}
/// Render at `w × h` (any size; the aspect should match `aspect()`).
pub fn render(&self, w: usize, h: usize) -> Rgb32f {
paint::render(self.kind, self.seed, w, h)
}
/// Render fitting within `max_edge` on the long side (at most the scene's own size).
pub fn render_fit(&self, max_edge: usize) -> Rgb32f {
let (w, h) = self.fit(max_edge);
self.render(w, h)
}
/// [`Scene::render_fit`] on the calling thread alone, without rayon (the same pixels).
pub fn render_fit_serial(&self, max_edge: usize) -> Rgb32f {
let (w, h) = self.fit(max_edge);
paint::render_serial(self.kind, self.seed, w, h)
}
fn fit(&self, max_edge: usize) -> (usize, usize) {
// never past the scene's own size: that is a demo photo's full resolution, and a size
// from a damaged catalog (a width of 4294967295) asked for more memory than exists
let max_edge = max_edge.min(self.width.max(self.height).max(1) as usize);
let a = self.aspect();
let (w, h) = if a >= 1.0 { (max_edge, (max_edge as f32 / a).round() as usize) } else { ((max_edge as f32 * a).round() as usize, max_edge) };
(w.max(1), h.max(1))
}
}
struct Def {
kind: Kind,
name: &'static str,
seed: u32,
portrait: bool,
location: &'static str,
keywords: &'static [&'static str],
}
const DEFS: &[Def] = &[
Def {
kind: Kind::AlpineLake,
name: "Lake at first light",
seed: 11,
portrait: false,
location: "Dolomites",
keywords: &["mountains", "lake", "sunrise"],
},
Def { kind: Kind::Dunes, name: "Dune ridges", seed: 7, portrait: false, location: "Namib", keywords: &["desert", "dunes"] },
Def { kind: Kind::OceanSunset, name: "Last light over the sea", seed: 3, portrait: false, location: "Big Sur", keywords: &["ocean", "sunset"] },
Def {
kind: Kind::Aurora,
name: "Aurora over the ridge",
seed: 21,
portrait: false,
location: "Lofoten",
keywords: &["night", "aurora", "stars"],
},
Def { kind: Kind::MistyForest, name: "Morning fog", seed: 5, portrait: false, location: "Black Forest", keywords: &["forest", "fog"] },
Def { kind: Kind::Lavender, name: "Lavender rows", seed: 9, portrait: false, location: "Valensole", keywords: &["fields", "lavender", "summer"] },
Def { kind: Kind::Macro, name: "Cosmos bloom", seed: 13, portrait: true, location: "Home garden", keywords: &["flower", "macro", "bokeh"] },
Def { kind: Kind::Canyon, name: "Canyon walls", seed: 17, portrait: false, location: "Utah", keywords: &["canyon", "rock"] },
Def { kind: Kind::Beach, name: "Lagoon", seed: 19, portrait: false, location: "Maldives", keywords: &["beach", "tropical"] },
Def { kind: Kind::BlueHour, name: "Blue hour peaks", seed: 23, portrait: false, location: "Patagonia", keywords: &["mountains", "blue hour"] },
Def { kind: Kind::AlpineLake, name: "Still water", seed: 41, portrait: false, location: "Banff", keywords: &["mountains", "lake"] },
Def { kind: Kind::OceanSunset, name: "Golden horizon", seed: 44, portrait: false, location: "Algarve", keywords: &["ocean", "sunset"] },
Def { kind: Kind::Dunes, name: "Afternoon sand", seed: 57, portrait: true, location: "Sahara", keywords: &["desert"] },
Def { kind: Kind::Aurora, name: "Green curtains", seed: 60, portrait: false, location: "Yukon", keywords: &["night", "aurora"] },
Def { kind: Kind::Macro, name: "Pink petals", seed: 71, portrait: false, location: "Home garden", keywords: &["flower", "macro"] },
Def { kind: Kind::MistyForest, name: "Valley haze", seed: 73, portrait: false, location: "Oregon", keywords: &["forest", "fog"] },
Def { kind: Kind::Canyon, name: "Red layers", seed: 79, portrait: true, location: "Arizona", keywords: &["canyon"] },
Def { kind: Kind::Beach, name: "Turquoise shallows", seed: 83, portrait: false, location: "Bahamas", keywords: &["beach"] },
Def { kind: Kind::Lavender, name: "Evening fields", seed: 89, portrait: false, location: "Provence", keywords: &["fields"] },
Def { kind: Kind::BlueHour, name: "Cold summit", seed: 97, portrait: false, location: "Alps", keywords: &["mountains", "snow"] },
Def { kind: Kind::AlpineLake, name: "Alpenglow", seed: 101, portrait: true, location: "Zermatt", keywords: &["mountains"] },
Def { kind: Kind::OceanSunset, name: "Calm sea", seed: 107, portrait: false, location: "Crete", keywords: &["ocean"] },
Def { kind: Kind::Macro, name: "Violet bloom", seed: 113, portrait: false, location: "Kew", keywords: &["flower"] },
Def { kind: Kind::Dunes, name: "Wind lines", seed: 127, portrait: false, location: "Death Valley", keywords: &["desert"] },
];
const CAMERAS: &[(&str, &str, f32)] = &[
("Synthetic S1", "24-70mm f/2.8", 35.0),
("Synthetic S1", "70-200mm f/4", 135.0),
("Synthetic X2", "16-35mm f/4", 18.0),
("Synthetic X2", "90mm f/2.8 Macro", 90.0),
];
/// The demo library: 24 scenes, 6000×4000 (or 4000×6000) nominal size.
pub fn demo_library() -> Vec<Scene> {
DEFS.iter()
.enumerate()
.map(|(i, d)| {
let cam = if d.kind == Kind::Macro { CAMERAS[3] } else { CAMERAS[i % 3] };
let shutter = match d.kind {
Kind::Aurora => "8",
Kind::BlueHour => "1/4",
Kind::MistyForest => "1/60",
_ => ["1/250", "1/500", "1/125", "1/1000"][i % 4],
};
let iso = match d.kind {
Kind::Aurora => 3200,
Kind::BlueHour => 400,
_ => [100, 200, 64, 100][i % 4],
};
let (w, h) = if d.portrait { (4000, 6000) } else { (6000, 4000) };
Scene {
id: i as u32 + 1,
name: d.name.to_string(),
kind: d.kind,
seed: d.seed,
width: w,
height: h,
meta: SceneMeta {
camera: cam.0,
lens: cam.1,
focal_mm: cam.2,
aperture: [2.8, 8.0, 11.0, 4.0][i % 4],
shutter,
iso,
captured: format!("2026-{:02}-{:02}T{:02}:{:02}:00", 3 + i % 7, 1 + (i * 5) % 27, 5 + (i * 3) % 15, (i * 17) % 60),
location: d.location,
keywords: d.keywords.to_vec(),
},
}
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn library_is_deterministic_and_varied() {
let lib = demo_library();
assert_eq!(lib.len(), 24);
let a = lib[0].render(64, 43);
let b = lib[0].render(64, 43);
assert_eq!(a, b);
// every scene renders finite, non-negative, non-trivial images
for s in &lib {
let img = s.render_fit(48);
assert!(img.data.iter().all(|p| p.iter().all(|v| v.is_finite() && *v >= 0.0)), "{}", s.name);
let mean: f32 = img.data.iter().map(|p| p[1]).sum::<f32>() / img.len() as f32;
assert!(mean > 0.005 && mean < 3.0, "{} mean {mean}", s.name);
}
}
/// Found by fuzzing catalog snapshots: a demo photo whose width read 4294967295 asked its scene
/// for a render that size, and the pixel buffer's size overflowed (a panic on the render
/// thread). A scene renders at most at its own size, which is the photo's full resolution.
#[test]
fn a_scene_renders_at_most_at_its_own_size() {
let mut s = demo_library().remove(0);
(s.width, s.height) = (40, 30);
let img = s.render_fit(usize::MAX);
assert_eq!((img.width, img.height), (40, 30));
assert_eq!(s.fit(20), (20, 15), "smaller sizes as asked");
}
#[test]
fn sunsets_have_highlight_headroom() {
let lib = demo_library();
let s = lib.iter().find(|s| s.kind == Kind::OceanSunset).unwrap();
let img = s.render_fit(200);
let max = img.data.iter().map(|p| p[0]).fold(0.0f32, f32::max);
assert!(max > 2.0, "{max}");
}
/// The serial render is the parallel one, pixel for pixel (both with and without supersampling), and
/// an empty size is an empty image.
#[test]
fn the_serial_render_is_the_same_picture() {
for s in demo_library().iter().take(3) {
for edge in [40, 700] {
assert_eq!(s.render_fit_serial(edge), s.render_fit(edge), "{} at {edge}", s.name);
}
}
assert!(paint::render_serial(Kind::Dunes, 1, 0, 5).data.is_empty());
assert!(demo_library()[0].render(0, 0).data.is_empty());
}
#[test]
fn resolution_independent() {
let s = &demo_library()[1];
let small = s.render(60, 40);
let big = s.render(240, 160);
let down = lightcraft_raster::resample::resize(&big, 60, 40, lightcraft_raster::resample::Filter::Box);
let err: f32 = small.data.iter().zip(&down.data).map(|(a, b)| (a[1] - b[1]).abs()).sum::<f32>() / small.len() as f32;
assert!(err < 0.08, "{err}");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.