LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M5.6: a zoomed view with Dehaze keeps its airlight proxy (each pan and slider step resampled the whole original)
dev-null-undefinede7cd00ef56dc
diff --git a/crates/pipeline/src/geometry.rs b/crates/pipeline/src/geometry.rsindex bea792c19..1c4f20260 100644--- a/crates/pipeline/src/geometry.rs+++ b/crates/pipeline/src/geometry.rs@@ -16,7 +16,7 @@ use crate::optics::{Warp, reorient_lens};pub const BLANK: [f32; 3] = [0.55, 0.55, 0.55];/// The geometric frame of a render.-#[derive(Clone, Debug)]+#[derive(Clone, Debug, PartialEq)]pub struct Frame {/// Source (EXIF-oriented) dimensions in pixels.pub src_w: usize,diff --git a/crates/pipeline/src/local.rs b/crates/pipeline/src/local.rsindex ce3994cd8..a99530777 100644--- a/crates/pipeline/src/local.rs+++ b/crates/pipeline/src/local.rs@@ -543,12 +543,35 @@ pub(crate) fn prepare(/// The airlight of the whole output frame, estimated on a small render of it (`proxy_w` px wide):/// a windowed render must dehaze with the frame's airlight, not that of the pixels it holds.pub(crate) fn frame_airlight(src: &Rgb32f, info: &SourceInfo, s: &DevelopSettings, frame: &Frame, proxy_w: usize, proxy_h: usize) -> f32 {- let mut img = frame.sample(src, proxy_w, proxy_h);+ let mut img = Rgb32f::clone(&frame_proxy(src, frame, proxy_w, proxy_h));white_balance(&mut img, info, s);let sigma = (0.02 * frame.px_per_long(proxy_w)).max(1.0) as f32;airlight(&gaussian(&img.map(dark_of), sigma))}+/// How many airlight proxies [`frame_proxy`] keeps (one per photo and frame being zoomed into; each ≤ 1.8 MB).+const FRAME_PROXIES_KEPT: usize = 4;++/// `frame.sample(src, w, h)`, kept for the last few (source, frame, size): sampling a 64 MP original down to the+/// airlight proxy reads all of it (~190 ms of CPU), and every window of a zoomed view with Dehaze asked for it again,+/// on each pan and slider tick. The proxy is taken before white balance, so a WB change still hits.+fn frame_proxy(src: &Rgb32f, frame: &Frame, w: usize, h: usize) -> Arc<Rgb32f> {+ type Entry = (u64, Frame, usize, usize, Arc<Rgb32f>);+ static CACHE: std::sync::Mutex<Vec<Entry>> = std::sync::Mutex::new(Vec::new());+ let key = crate::optics::fingerprint(src);+ let found = |c: &[Entry]| c.iter().find(|e| e.0 == key && e.1 == *frame && (e.2, e.3) == (w, h)).map(|e| e.4.clone());+ if let Some(img) = found(&CACHE.lock().unwrap_or_else(std::sync::PoisonError::into_inner)) {+ return img;+ }+ let img = Arc::new(frame.sample(src, w, h));+ let mut c = CACHE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ c.push((key, frame.clone(), w, h, img.clone()));+ if c.len() > FRAME_PROXIES_KEPT {+ c.remove(0);+ }+ img+}+/// The airlight is estimated from every `AIRLIGHT_STEP`-th value of the dark channel.pub const AIRLIGHT_STEP: usize = 7;@@ -600,6 +623,36 @@ mod tests {assert!((luminance_2020(c) - 0.3).abs() < 0.01);}+ // A windowed render's airlight proxy is kept per (source, frame, size): the airlight is the one sampling anew gives,+ // and another source or frame of the same size gets its own, never the proxy kept for the last one+ #[test]+ fn the_kept_airlight_proxy_matches_a_fresh_one_and_misses_on_another_source_or_frame() {+ let (info, s) = (SourceInfo::default(), DevelopSettings::default());+ let hazy = Rgb32f::from_fn(300, 200, |x, y| {+ let v = 0.05 + 0.6 * x as f32 / 300.0;+ [v, v * 0.95, v * (0.8 + 0.2 * y as f32 / 200.0)]+ });+ let other = Rgb32f::from_fn(300, 200, |x, y| [0.02 + 0.1 * ((x + y) % 7) as f32 / 7.0; 3]);+ let fresh = |src: &Rgb32f, frame: &Frame| {+ let mut img = frame.sample(src, 48, 32);+ white_balance(&mut img, &info, &s);+ airlight(&gaussian(&img.map(dark_of), (0.02 * frame.px_per_long(48)).max(1.0) as f32))+ };+ let frame = crate::frame_for(&hazy, &info, &s, true);+ let kept = frame_proxy(&hazy, &frame, 48, 32);+ assert!(Arc::ptr_eq(&kept, &frame_proxy(&hazy, &frame, 48, 32)), "the second ask is served from the cache");+ assert_eq!(frame_airlight(&hazy, &info, &s, &frame, 48, 32).to_bits(), fresh(&hazy, &frame).to_bits());+ assert_eq!(frame_airlight(&hazy, &info, &s, &frame, 48, 32).to_bits(), fresh(&hazy, &frame).to_bits());+ // another source of the same size+ assert_ne!(fresh(&other, &frame), fresh(&hazy, &frame));+ assert_eq!(frame_airlight(&other, &info, &s, &frame, 48, 32).to_bits(), fresh(&other, &frame).to_bits());+ // the same source, cropped to its darker half+ let mut cropped = frame.clone();+ cropped.crop.rect.x1 = 0.5;+ assert_ne!(fresh(&hazy, &cropped), fresh(&hazy, &frame));+ assert_eq!(frame_airlight(&hazy, &info, &s, &cropped, 48, 32).to_bits(), fresh(&hazy, &cropped).to_bits());+ }+#[test]fn exposure_doubles() {let mut s = DevelopSettings::default();diff --git a/crates/pipeline/src/optics.rs b/crates/pipeline/src/optics.rsindex 843f1e822..f0756ecc1 100644--- a/crates/pipeline/src/optics.rs+++ b/crates/pipeline/src/optics.rs@@ -407,8 +407,9 @@ pub(crate) fn fingerprint(img: &Rgb32f) -> u64 {let mut h: u64 = 0xcbf2_9ce4_8422_2325 ^ ((img.width as u64) << 32 | img.height as u64);let n = img.data.len();for i in 0..512usize {- let p = img.data[(i.wrapping_mul(2_654_435_761) ^ i) % n.max(1)];- for c in p {+ // (an empty image has no pixels to sample: its dimensions are the fingerprint)+ let Some(p) = img.data.get((i.wrapping_mul(2_654_435_761) ^ i) % n.max(1)) else { break };+ for c in *p {h ^= c.to_bits() as u64;h = h.wrapping_mul(0x0100_0000_01b3);}@@ -648,6 +649,13 @@ fn min_filter(p: &Plane, r: usize, max: bool) -> Plane {mod tests {use super::*;+ // An empty image (no pixel to sample) has a fingerprint, its dimensions' (indexing its first pixel panicked)+ #[test]+ fn an_empty_image_has_a_fingerprint() {+ assert_eq!(fingerprint(&Rgb32f::new(0, 0)), fingerprint(&Rgb32f::new(0, 0)));+ assert_ne!(fingerprint(&Rgb32f::new(0, 3)), fingerprint(&Rgb32f::new(3, 0)));+ }+/// splitmix64: deterministic pseudo-random numbers for the warp tests.struct Rng(u64);diff --git a/docs/whats-new.md b/docs/whats-new.mdindex b5c2ac68c..9f2c50746 100644--- a/docs/whats-new.md+++ b/docs/whats-new.md@@ -8,6 +8,10 @@previews for up to a second.- A thumbnail of the photo open in Detail is made from its already decoded preview instead of decoding the fileagain.+### Dehaze while zoomed in+- With Dehaze on, panning a photo zoomed to 1:1 or moving a slider while zoomed no longer samples the whole+ original again to find the haze colour. On a 64 MP raw (Sony A7R VI) that took ~0.2 s of CPU per pan and per+ slider step; a slider step now takes ~5 ms on the GPU.## 2026-10-12### Canon CR2 highlights