LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LRC-DEV-LOUPEOVERLAY: a layout image over the loupe (View ▸ Loupe Overlay)
BuonBreda4551790eabb2
diff --git a/crates/engine/src/export.rs b/crates/engine/src/export.rsindex 403cb71f6..6ee4cfb46 100644--- a/crates/engine/src/export.rs+++ b/crates/engine/src/export.rs@@ -560,12 +560,19 @@ fn watermark_logo(path: &str) -> Option<std::sync::Arc<Rgba8>> {{return Some(img.clone());}- let bytes = std::fs::read(path).ok()?;- let img = Arc::new(lightcraft_codecs::decode(&bytes, Default::default()).ok()?.to_srgb8());+ let img = Arc::new(read_graphic(path).ok()?);map.insert(path.to_string(), (modified, img.clone()));Some(img)}+/// A graphic file (a PNG with transparency, typically) as 8-bit sRGB with its alpha: the+/// watermark logo, the loupe's layout image. The error says why it couldn't be read or decoded.+pub fn read_graphic(path: &str) -> Result<Rgba8, String> {+ let bytes = std::fs::read(path).map_err(|e| format!("can't read {path}: {e}"))?;+ let decoded = lightcraft_codecs::decode(&bytes, Default::default()).map_err(|e| format!("can't decode {path}: {e}"))?;+ Ok(decoded.to_srgb8())+}+/// The graphic watermark: scaled (premultiplied, so transparent edges stay clean) to/// `image_width` of the photo, placed like the text, blended with its alpha × opacity.fn logo_coverage(width: usize, height: usize, wm: &Watermark, mut blend_px: impl FnMut(usize, usize, f32, [u8; 3])) {diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 37fb86df3..ae0550e6a 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -89,6 +89,8 @@ mod tests_keywording;#[cfg(test)]mod tests_labels;#[cfg(test)]+mod tests_layout_image;+#[cfg(test)]mod tests_library_problem;#[cfg(test)]mod tests_lights_out;diff --git a/crates/ui-egui/src/menubar.rs b/crates/ui-egui/src/menubar.rsindex fe6905cad..7a00ec8a3 100644--- a/crates/ui-egui/src/menubar.rs+++ b/crates/ui-egui/src/menubar.rs@@ -136,6 +136,7 @@ const LAYOUT: &[(&str, &[&str])] = &["view.histogram","view.navigator","view.infoOverlay",+ "@Loupe Overlay","@Appearance","---","view.fullScreenPreview",@@ -329,6 +330,7 @@ pub fn checked(app: &LightcraftApp, id: &str) -> Option<bool> {"view.autoAdvance" => Some(u.auto_advance),"view.filterBar" => Some(u.filter_bar),"view.navigator" => Some(u.navigator),+ "view.layoutImage" => Some(u.layout_image.show && !u.layout_image.path.trim().is_empty()),"view.fullScreenPreview" => Some(u.fullscreen),"view.lightsOut" => Some(u.lights_out != crate::state::LightsOut::On),"view.enterFullScreen" => Some(app.window_is_fullscreen),@@ -367,7 +369,7 @@ fn live_label(app: &LightcraftApp, id: &str, label: &str) -> String {}/// The parameterized submenus.-fn expanded(app: &LightcraftApp, name: &str) -> Option<Vec<MenuNode>> {+pub(crate) fn expanded(app: &LightcraftApp, name: &str) -> Option<Vec<MenuNode>> {let active = app.session.active().and_then(|id| app.session.catalog.photo(id).cloned());let has = active.is_some();Some(match name {@@ -507,6 +509,36 @@ fn expanded(app: &LightcraftApp, name: &str) -> Option<Vec<MenuNode>> {}v}+ "Loupe Overlay" => {+ // Lightroom Classic's View ▸ Loupe Overlay ▸ Layout Image: choose the graphic, show it,+ // and how opaque it is and how dark the photo is outside it+ let li = &app.ui.layout_image;+ let chosen = !li.path.trim().is_empty();+ let mut v = vec![+ item("view.chooseLayoutImage", Value::Null, "Choose Layout Image…", None, true, None),+ item(+ "view.layoutImage",+ Value::Null,+ "Show Layout Image",+ crate::shortcuts::shortcut_of(&app.ui.settings.keymap, "view.layoutImage"),+ chosen,+ Some(li.show && chosen),+ ),+ MenuNode::Separator,+ ];+ let near = |a: f32, b: f32| (a - b).abs() < 0.005;+ for step in crate::state::LayoutImage::OPACITY_STEPS {+ let label = format!("{} {:.0}%", crate::i18n::tr("Opacity"), step * 100.0);+ v.push(item("view.layoutImageOpacity", json!({"opacity": step}), label, None, chosen, Some(near(li.opacity, step))));+ }+ v.push(MenuNode::Separator);+ for step in crate::state::LayoutImage::MATTE_STEPS {+ let label =+ if step == 0.0 { crate::i18n::tr("No Matte").to_string() } else { format!("{} {:.0}%", crate::i18n::tr("Matte"), step * 100.0) };+ v.push(item("view.layoutImageMatte", json!({"matte": step}), label, None, chosen, Some(near(li.matte, step))));+ }+ v+ }"Grid Info" => ["filename", "exposure", "date"].into_iter().zip(["File Name", "Exposure (shutter · aperture · ISO)", "Capture Date"])diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rsindex ad31c57bf..52f8dbbbe 100644--- a/crates/ui-egui/src/menus.rs+++ b/crates/ui-egui/src/menus.rs@@ -112,6 +112,10 @@ pub const UI_COMMANDS: &[UiCommand] = &[("view.lightsOut", "Lights Out", Some("Shift+L"), "View"),("view.enterFullScreen", "Enter Full Screen", Some("Cmd+Shift+F"), "View"),("view.infoOverlay", "Cycle Info Overlay", Some("Cmd+I"), "View"),+ ("view.chooseLayoutImage", "Choose Layout Image…", None, "View"),+ ("view.layoutImage", "Show Layout Image", Some("Cmd+Alt+O"), "View"),+ ("view.layoutImageOpacity", "Layout Image Opacity", None, ""),+ ("view.layoutImageMatte", "Layout Image Matte", None, ""),("view.navigator", "Navigator", None, "View"),("panel.edit", "Edit", Some("E"), "Window"),("panel.profiles", "Profile Browser", None, "Window"),@@ -651,6 +655,54 @@ pub fn run_ui_command(app: &mut LightcraftApp, id: &str, p: &Value) -> Option<Reapp.toast(&ctx, label);Ok(json!({"infoOverlay": app.ui.info_overlay}))}+ "view.chooseLayoutImage" => {+ let path = match p.get("path").and_then(Value::as_str) {+ Some(path) => path.trim().to_string(),+ None => {+ let req = PickRequest::file(crate::i18n::tr("Choose Layout Image…"), "PNG", &["png"]);+ match crate::pick::ask(app, id, p, "path", req, |s| s.pick_files.as_mut().map(|f| f())) {+ Picked::Now(paths) => match paths.first() {+ Some(path) => path.trim().to_string(),+ None => return Some(Ok(Value::Null)),+ },+ Picked::Later => return Some(Ok(Value::Null)),+ Picked::Unavailable => return Some(Err("no file dialog on this platform; supply path".into())),+ }+ }+ };+ if path.is_empty() {+ return Some(Err("view.chooseLayoutImage: path is empty".into()));+ }+ let li = &mut app.ui.layout_image;+ li.path = path;+ li.show = true;+ li.revision = li.revision.wrapping_add(1);+ app.toast(&ctx, "Layout Image On");+ Ok(json!({"layoutImage": app.ui.layout_image}))+ }+ "view.layoutImage" => {+ let show = p.get("show").and_then(Value::as_bool).unwrap_or(!app.ui.layout_image.show);+ // nothing chosen yet: showing it chooses one first+ if show && app.ui.layout_image.path.trim().is_empty() {+ return run_ui_command(app, "view.chooseLayoutImage", &json!({}));+ }+ app.ui.layout_image.show = show;+ app.toast(&ctx, if show { "Layout Image On" } else { "Layout Image Off" });+ Ok(json!({"layoutImage": app.ui.layout_image}))+ }+ "view.layoutImageOpacity" | "view.layoutImageMatte" => {+ let key = if id == "view.layoutImageOpacity" { "opacity" } else { "matte" };+ let Some(v) = p.get(key).and_then(Value::as_f64).filter(|v| v.is_finite()) else {+ return Some(Err(format!("{id}: {key} (0..1) is required")));+ };+ let v = v.clamp(0.0, 1.0) as f32;+ if key == "opacity" {+ app.ui.layout_image.opacity = v;+ } else {+ app.ui.layout_image.matte = v;+ }+ Ok(json!({"layoutImage": app.ui.layout_image}))+ }"view.navigator" => {app.ui.navigator = !app.ui.navigator;Ok(json!({"navigator": app.ui.navigator}))diff --git a/crates/ui-egui/src/panels/detail.rs b/crates/ui-egui/src/panels/detail.rsindex 151d4a57a..96697c16e 100644--- a/crates/ui-egui/src/panels/detail.rs+++ b/crates/ui-egui/src/panels/detail.rs@@ -689,6 +689,8 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {if app.ui.show_clipping && !show_before && !fullscreen {clipping_overlay(app, &p, img_rect);}+ // View ▸ Loupe Overlay ▸ Layout Image, over the photo (the After view in a before/after)+ super::layout_overlay::draw(app, &p, img_rect);register(ui.ctx(), "canvas:image", img_rect);let map = CanvasMap::new(&frame, img_rect);info_overlay(app, &p, canvas, &photo);diff --git a/crates/ui-egui/src/panels/layout_overlay.rs b/crates/ui-egui/src/panels/layout_overlay.rsnew file mode 100644index 000000000..9b4800d0f--- /dev/null+++ b/crates/ui-egui/src/panels/layout_overlay.rs@@ -0,0 +1,223 @@+//! View ▸ Loupe Overlay ▸ Layout Image, as in Lightroom Classic: a graphic with transparency (a+//! magazine cover's masthead and cover lines, a web banner's safe areas, a print layout's+//! margins) drawn over the photo in the loupe, so a shot can be judged against the page it is made+//! for. The graphic is fitted inside the photo and centred, and follows zoom and pan with it.+//! `opacity` fades it; `matte` darkens the photo outside its box, where the page would crop it.+//!+//! The file is read and decoded off the UI thread, once per path and Choose Layout Image… (an+//! offline drive never holds up a frame); until it arrives nothing is drawn, and a file that can't+//! be read says so at the canvas' bottom left. Graphics larger than [`MAX_SIDE`] are scaled down+//! once, premultiplied so transparent edges stay clean.++use std::sync::{Arc, Mutex, PoisonError};++use egui::{Color32, Rect, pos2, vec2};+use lightcraft_raster::Rgba8;++use crate::LightcraftApp;+use crate::theme::Tokens;+use crate::widgets::register;++/// The longest side a layout image keeps (a screen never shows more of it).+pub const MAX_SIDE: usize = 4096;++/// The decoded graphic once the worker is done, or why it couldn't be read.+type Loaded = Arc<Mutex<Option<Result<Rgba8, String>>>>;++/// What the loupe keeps between frames (in egui's temporary memory).+#[derive(Clone)]+struct Cache {+ /// The (path, revision) the file was read for.+ file: (String, u32),+ loaded: Loaded,+ /// The texture made from the graphic, and the display profile it was made for.+ tex: Option<(Option<u64>, egui::TextureHandle)>,+}++/// The rectangle a `size` (pixels) graphic takes fitted inside `photo` and centred on it.+pub fn fit(photo: Rect, size: [usize; 2]) -> Rect {+ let (w, h) = (size[0].max(1) as f32, size[1].max(1) as f32);+ let scale = (photo.width() / w).min(photo.height() / h).max(0.0);+ Rect::from_center_size(photo.center(), vec2(w * scale, h * scale))+}++/// The parts of `photo` outside `inner` (the matte): up to four strips.+pub fn outside(photo: Rect, inner: Rect) -> Vec<Rect> {+ let inner = inner.intersect(photo);+ let strips = [+ Rect::from_min_max(photo.min, pos2(inner.left(), photo.bottom())),+ Rect::from_min_max(pos2(inner.right(), photo.top()), photo.max),+ Rect::from_min_max(pos2(inner.left(), photo.top()), pos2(inner.right(), inner.top())),+ Rect::from_min_max(pos2(inner.left(), inner.bottom()), pos2(inner.right(), photo.bottom())),+ ];+ strips.into_iter().filter(|r| r.width() > 0.0 && r.height() > 0.0).collect()+}++/// `img` with its longest side at most `max` pixels (scaled premultiplied, so transparent edges+/// keep their colour); an empty graphic is an error.+pub fn fit_within(img: Rgba8, max: usize) -> Result<Rgba8, String> {+ let (w, h) = (img.width, img.height);+ if w == 0 || h == 0 {+ return Err("the layout image is empty".into());+ }+ let max = max.max(1);+ if w.max(h) <= max {+ return Ok(img);+ }+ let s = max as f32 / w.max(h) as f32;+ let (nw, nh) = (((w as f32 * s).round() as usize).clamp(1, max), ((h as f32 * s).round() as usize).clamp(1, max));+ let pre: lightcraft_raster::Image<[f32; 4]> = lightcraft_raster::Image::from_fn(w, h, |x, y| {+ let p = img.get(x, y);+ let a = p[3] as f32 / 255.0;+ [p[0] as f32 * a, p[1] as f32 * a, p[2] as f32 * a, a]+ });+ let scaled = lightcraft_raster::resample::resize(&pre, nw, nh, lightcraft_raster::resample::Filter::Mitchell);+ Ok(Rgba8::from_fn(nw, nh, |x, y| {+ let [r, g, b, a] = scaled.get(x, y);+ let a = a.clamp(0.0, 1.0);+ let c = |v: f32| if a <= 1e-4 { 0 } else { (v / a).round().clamp(0.0, 255.0) as u8 };+ [c(r), c(g), c(b), (a * 255.0).round() as u8]+ }))+}++/// Reads and decodes `path` on a worker thread (in place on the web, which has no threads and no+/// files to read: the error says so).+fn start(ctx: &egui::Context, path: &str) -> Loaded {+ let loaded: Loaded = Default::default();+ let max = match ctx.input(|i| i.max_texture_side) {+ 0 => MAX_SIDE,+ m => m.min(MAX_SIDE),+ };+ let (out, repaint, path) = (loaded.clone(), ctx.clone(), path.to_string());+ let work = move || {+ let r = lightcraft_engine::export::read_graphic(&path).and_then(|img| fit_within(img, max));+ *out.lock().unwrap_or_else(PoisonError::into_inner) = Some(r);+ repaint.request_repaint();+ };+ #[cfg(not(target_arch = "wasm32"))]+ if let Err(e) = std::thread::Builder::new().name("lc-layout-image".into()).spawn(work) {+ *loaded.lock().unwrap_or_else(PoisonError::into_inner) = Some(Err(format!("can't start reading the layout image: {e}")));+ }+ #[cfg(target_arch = "wasm32")]+ work();+ loaded+}++/// Draws the layout image (when shown) over `photo`, the photo's rectangle on screen; `p` clips it+/// to the canvas.+pub fn draw(app: &LightcraftApp, p: &egui::Painter, photo: Rect) {+ let li = &app.ui.layout_image;+ let path = li.path.trim();+ if !li.show || path.is_empty() || photo.width() < 1.0 || photo.height() < 1.0 {+ return;+ }+ let ctx = p.ctx().clone();+ let id = egui::Id::new("loupe-layout-image");+ let file = (path.to_string(), li.revision);+ let mut cache = match ctx.data(|d| d.get_temp::<Cache>(id)) {+ Some(c) if c.file == file => c,+ _ => Cache { loaded: start(&ctx, path), file, tex: None },+ };+ let display_id = app.renderer.display_id();+ if cache.tex.as_ref().is_none_or(|(d, _)| *d != display_id) {+ let made = match cache.loaded.lock().unwrap_or_else(PoisonError::into_inner).as_ref() {+ // still reading: the worker repaints when it is done+ None => None,+ Some(Err(e)) => Some(Err(e.clone())),+ Some(Ok(img)) => {+ let mut img = img.clone();+ // shown through the monitor profile like every other preview+ if let Some(d) = app.renderer.display()+ && let Err(e) = d.profile.from_srgb(&mut img)+ {+ log::warn!("layout image, display profile: {e}");+ }+ let color = egui::ColorImage::from_rgba_unmultiplied([img.width, img.height], &img.as_bytes());+ Some(Ok(ctx.load_texture("loupe-layout-image", color, egui::TextureOptions::LINEAR)))+ }+ };+ match made {+ None => {}+ Some(Ok(tex)) => cache.tex = Some((display_id, tex)),+ Some(Err(e)) => note(p, &e),+ }+ }+ if let Some((_, tex)) = &cache.tex {+ let r = fit(photo, tex.size());+ let matte = li.matte.clamp(0.0, 1.0);+ if matte > 0.0 {+ let veil = Color32::from_black_alpha((matte * 255.0).round() as u8);+ for strip in outside(photo, r) {+ p.rect_filled(strip, 0.0, veil);+ }+ }+ let alpha = (li.opacity.clamp(0.0, 1.0) * 255.0).round() as u8;+ p.image(tex.id(), r, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::from_white_alpha(alpha));+ register(&ctx, "canvas:layoutImage", r.intersect(p.clip_rect()));+ }+ ctx.data_mut(|d| d.insert_temp(id, cache));+}++/// Why the layout image isn't shown, at the canvas' bottom left.+fn note(p: &egui::Painter, why: &str) {+ let t = Tokens::get(p.ctx());+ let canvas = p.clip_rect();+ let lines = [crate::i18n::tr("The layout image can't be shown"), why];+ let mut y = canvas.bottom() - 14.0;+ for (i, l) in lines.iter().enumerate().rev() {+ let font = if i == 0 { t.semibold(13.0) } else { t.font(12.0) };+ let g = p.layout_no_wrap(l.to_string(), font, Color32::WHITE);+ y -= g.size().y;+ let at = pos2(canvas.left() + 14.0, y);+ p.galley(at + vec2(1.0, 1.0), g.clone(), Color32::from_black_alpha(200));+ p.galley(at, g, Color32::WHITE);+ y -= 3.0;+ }+ register(p.ctx(), "canvas:layoutImageError", Rect::from_min_max(pos2(canvas.left(), y), pos2(canvas.left() + 360.0, canvas.bottom())));+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn a_graphic_fits_inside_the_photo_centred() {+ let photo = Rect::from_min_size(pos2(100.0, 50.0), vec2(600.0, 400.0));+ // a portrait cover over a landscape photo: as tall as the photo, centred across+ let r = fit(photo, [800, 1000]);+ assert!((r.height() - 400.0).abs() < 1e-3 && (r.width() - 320.0).abs() < 1e-3, "{r:?}");+ assert!((r.center().x - photo.center().x).abs() < 1e-3 && (r.center().y - photo.center().y).abs() < 1e-3);+ // the same shape fills it+ let same = fit(photo, [1200, 800]);+ assert!((same.width() - 600.0).abs() < 1e-3 && (same.height() - 400.0).abs() < 1e-3);+ // a zero-size graphic never divides by zero+ assert!(fit(photo, [0, 0]).width().is_finite());+ }++ #[test]+ fn the_matte_covers_the_photo_outside_the_graphic_only() {+ let photo = Rect::from_min_size(pos2(0.0, 0.0), vec2(600.0, 400.0));+ let r = fit(photo, [800, 1000]);+ let strips = outside(photo, r);+ assert_eq!(strips.len(), 2, "{strips:?}");+ let area: f32 = strips.iter().map(|s| s.area()).sum();+ assert!((area - (photo.area() - r.area())).abs() < 1e-2);+ assert!(strips.iter().all(|s| s.intersect(r).area() < 1e-3));+ // a graphic of the photo's own shape leaves nothing to darken+ assert!(outside(photo, fit(photo, [3, 2])).is_empty());+ }++ #[test]+ fn large_graphics_are_scaled_down_keeping_shape_and_transparency() {+ // a transparent graphic with an opaque red bar across the middle+ let img = Rgba8::from_fn(5000, 2500, |_, y| if (1000..1500).contains(&y) { [255, 0, 0, 255] } else { [0, 0, 0, 0] });+ let out = fit_within(img, 1000).unwrap();+ assert_eq!((out.width, out.height), (1000, 500));+ assert_eq!(out.get(500, 250), [255, 0, 0, 255]);+ assert_eq!(out.get(500, 20)[3], 0);+ // small graphics are kept as they are, empty ones are refused+ let small = Rgba8::from_fn(10, 4, |x, _| [x as u8, 0, 0, 255]);+ assert_eq!(fit_within(small.clone(), 1000).unwrap().data, small.data);+ assert!(fit_within(Rgba8::new(0, 0), 1000).is_err());+ }+}diff --git a/crates/ui-egui/src/panels/mod.rs b/crates/ui-egui/src/panels/mod.rsindex a8d99aed2..d3d44e911 100644--- a/crates/ui-egui/src/panels/mod.rs+++ b/crates/ui-egui/src/panels/mod.rs@@ -15,6 +15,7 @@ pub mod grid;pub mod keymap;pub mod keyword_list;pub mod keywording;+pub mod layout_overlay;pub mod left;pub mod library_problem;pub mod masking;diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rsindex cc583e7b3..5acd9d9c9 100644--- a/crates/ui-egui/src/state.rs+++ b/crates/ui-egui/src/state.rs@@ -135,6 +135,39 @@ impl InfoOverlay {}}+/// View ▸ Loupe Overlay ▸ Layout Image (Lightroom Classic's loupe overlay): a graphic with+/// transparency, such as a magazine cover's masthead and cover lines, drawn over the photo in the+/// loupe (`panels::layout_overlay`). Saved with the UI state, so the layout stays chosen across+/// launches.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(default, rename_all = "camelCase")]+pub struct LayoutImage {+ /// The graphic's file; empty until one is chosen.+ pub path: String,+ /// Drawn over the loupe (⌥⌘O).+ pub show: bool,+ /// The graphic's opacity, 0..=1.+ pub opacity: f32,+ /// How dark the photo is outside the graphic's box, 0..=1 (0: not darkened).+ pub matte: f32,+ /// Bumped by each Choose Layout Image…, so choosing the same file again reads it again (after+ /// it was edited elsewhere).+ #[serde(skip)]+ pub revision: u32,+}++impl Default for LayoutImage {+ fn default() -> Self {+ LayoutImage { path: String::new(), show: false, opacity: 1.0, matte: 0.0, revision: 0 }+ }+}++impl LayoutImage {+ /// The opacity and matte steps View ▸ Loupe Overlay offers.+ pub const OPACITY_STEPS: [f32; 4] = [0.25, 0.5, 0.75, 1.0];+ pub const MATTE_STEPS: [f32; 4] = [0.0, 0.25, 0.5, 0.75];+}+/// Lights Out (View ▸ Lights Out, Shift+L cycles On → Dim → Off → On; Esc turns the lights back/// on): everything but the photo is veiled in black, the panels stay where they are.#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]@@ -725,6 +758,8 @@ pub struct UiState {pub slideshow: Option<(f64, f64, bool)>,/// Info overlay on the loupe.pub info_overlay: InfoOverlay,+ /// The loupe's layout image overlay (View ▸ Loupe Overlay).+ pub layout_image: LayoutImage,/// Navigator mini map in the loupe while zoomed in.pub navigator: bool,/// App preferences (Settings dialog).@@ -1145,6 +1180,7 @@ impl Default for UiState {keyword_list_selected: None,dragging_keyword: None,info_overlay: InfoOverlay::Off,+ layout_image: LayoutImage::default(),navigator: true,settings: AppSettings::default(),window_fullscreen: None,diff --git a/crates/ui-egui/src/tests_layout_image.rs b/crates/ui-egui/src/tests_layout_image.rsnew file mode 100644index 000000000..f07b391ca--- /dev/null+++ b/crates/ui-egui/src/tests_layout_image.rs@@ -0,0 +1,181 @@+//! Headless tests of View ▸ Loupe Overlay ▸ Layout Image: a PNG with transparency drawn over the+//! photo in the loupe, fitted and centred, its opaque parts covering the photo and its transparent+//! parts leaving it alone; opacity, matte, ⌥⌘O, a file that can't be read, and the choice saved+//! with the UI state.++use std::time::Duration;++use serde_json::json;++use crate::headless::Headless;+use crate::{LightcraftApp, Services};++const T: Duration = Duration::from_secs(20);+const SETTLE: Duration = Duration::from_secs(120);++/// The graphic's opaque band: magenta, unlike anything in the demo photos.+const BAND: [u8; 4] = [255, 0, 255, 255];++fn loupe() -> Headless {+ let services = Services { png: None, ..Default::default() };+ let mut app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), services);+ app.ui.settings.gpu = false;+ let mut h = Headless::new(app, [1400.0, 900.0], 1.0);+ let r = h.request("ui.set", json!({"view": "detail", "right": "edit"}), T);+ assert_eq!(r["ok"], true, "{r}");+ h.settle(SETTLE);+ h+}++/// A portrait "cover": an opaque magenta masthead across its top quarter, transparent below.+fn cover(tag: &str) -> std::path::PathBuf {+ let dir = std::env::temp_dir().join(format!("lc-layout-image-{tag}-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&dir);+ std::fs::create_dir_all(&dir).unwrap();+ let img = lightcraft_raster::Rgba8::from_fn(300, 400, |_, y| if y < 100 { BAND } else { [0, 0, 0, 0] });+ let png = lightcraft_codecs::encode_png(&lightcraft_codecs::EncodeImage::rgba8(&img), &lightcraft_codecs::EncodeMeta::default()).unwrap();+ let path = dir.join("cover.png");+ std::fs::write(&path, png).unwrap();+ path+}++fn widget(h: &Headless, name: &str) -> Option<egui::Rect> {+ h.app.widgets.iter().find(|(w, _)| w == name).map(|(_, r)| *r)+}++fn run(h: &mut Headless, command: &str, params: serde_json::Value) -> serde_json::Value {+ let r = h.request("engine.execute", json!({"command": command, "params": params}), T);+ h.step();+ h.step();+ r+}++fn px(img: &egui::ColorImage, p: egui::Pos2) -> [u8; 3] {+ let c = img.pixels[(p.y as usize) * img.size[0] + p.x as usize];+ [c.r(), c.g(), c.b()]+}++fn close(a: [u8; 3], b: [u8; 3], tol: i32) -> bool {+ a.iter().zip(b).all(|(x, y)| (*x as i32 - y as i32).abs() <= tol)+}++#[test]+fn the_layout_image_covers_the_photo_where_opaque_and_follows_opacity_matte_and_the_toggle() {+ let mut h = loupe();+ let path = cover("draw");+ let photo = widget(&h, "canvas:image").expect("the loupe shows a photo");+ let before = h.snapshot(SETTLE);++ let r = run(&mut h, "view.chooseLayoutImage", json!({"path": path.to_string_lossy()}));+ assert_eq!(r["ok"], true, "{r}");+ assert!(h.app.ui.layout_image.show, "choosing a layout image shows it");+ assert!(h.step_until(T, |h| widget(h, "canvas:layoutImage").is_some()), "the layout image is drawn once read");+ let shown = h.snapshot(SETTLE);+ let r = widget(&h, "canvas:layoutImage").unwrap();+ // fitted inside the photo, centred, with the graphic's 3:4 shape+ assert!(photo.expand(1.0).contains_rect(r), "{r:?} inside {photo:?}");+ assert!((r.center().x - photo.center().x).abs() < 1.5 && (r.center().y - photo.center().y).abs() < 1.5, "{r:?} centred on {photo:?}");+ assert!((r.width() / r.height() - 0.75).abs() < 0.02, "{r:?}");+ // the masthead covers the photo; below it the photo shows through untouched+ let masthead = egui::pos2(r.center().x, r.top() + r.height() * 0.12);+ let clear = egui::pos2(r.center().x, r.top() + r.height() * 0.7);+ assert!(close(px(&shown, masthead), [255, 0, 255], 12), "masthead {:?}", px(&shown, masthead));+ assert!(close(px(&shown, clear), px(&before, clear), 3), "{:?} vs {:?}", px(&shown, clear), px(&before, clear));++ // half opacity: the masthead blends with the photo+ let r2 = run(&mut h, "view.layoutImageOpacity", json!({"opacity": 0.5}));+ assert_eq!(r2["ok"], true, "{r2}");+ let half = h.snapshot(SETTLE);+ let m = px(&half, masthead);+ assert!(!close(m, [255, 0, 255], 12) && !close(m, px(&before, masthead), 12), "half-opaque masthead {m:?}");++ // the matte darkens the photo outside the graphic's box, and only there+ // (a 3:4 graphic leaves the sides of a wider photo, the top and bottom of a taller one)+ let side = if r.left() - photo.left() > 8.0 {+ egui::pos2((photo.left() + r.left()) / 2.0, photo.center().y)+ } else {+ egui::pos2(photo.center().x, (photo.top() + r.top()) / 2.0)+ };+ assert!(!r.expand(2.0).contains(side) && photo.contains(side), "{side:?}: in the photo, outside {r:?}");+ run(&mut h, "view.layoutImageMatte", json!({"matte": 0.75}));+ let matte = h.snapshot(SETTLE);+ let (lit, dark) = (px(&before, side), px(&matte, side));+ assert!(dark.iter().zip(lit).all(|(d, l)| *d as i32 <= l as i32 / 2 + 2), "matte {dark:?} vs {lit:?}");+ assert!(close(px(&matte, clear), px(&before, clear), 3), "inside the box the matte leaves the photo alone");+ assert!(run(&mut h, "view.layoutImageMatte", json!({}))["ok"] == false, "a matte is required");++ // ⌥⌘O hides it and shows it again+ let k = h.request("ui.key", json!({"key": "o", "cmd": true, "alt": true}), T);+ assert_eq!(k["ok"], true, "{k}");+ h.step();+ h.step();+ assert!(!h.app.ui.layout_image.show);+ assert!(widget(&h, "canvas:layoutImage").is_none(), "hidden: not drawn");+ let back = h.snapshot(SETTLE);+ assert!(close(px(&back, masthead), px(&before, masthead), 3), "hidden: the photo is untouched");+ run(&mut h, "view.layoutImage", json!({"show": true}));+ assert!(h.step_until(T, |h| widget(h, "canvas:layoutImage").is_some()));++ // saved with the UI state (the revision is not)+ let saved = serde_json::to_value(&h.app.ui).unwrap();+ assert_eq!(saved["layoutImage"]["path"], json!(path.to_string_lossy()));+ assert_eq!(saved["layoutImage"]["show"], true);+ assert_eq!(saved["layoutImage"]["opacity"], json!(0.5));+ assert!(saved["layoutImage"].get("revision").is_none());+ let back: crate::state::UiState = serde_json::from_value(saved).unwrap();+ assert_eq!(back.layout_image.path, path.to_string_lossy());+ // an older ui.json without it opens with nothing chosen+ let old: crate::state::UiState = serde_json::from_value(json!({})).unwrap();+ assert_eq!(old.layout_image, crate::state::LayoutImage::default());+ let _ = std::fs::remove_dir_all(path.parent().unwrap());+}++#[test]+fn a_layout_image_that_cant_be_read_says_so_and_showing_none_asks_for_one() {+ let mut h = loupe();+ // nothing chosen: showing it asks for a file, which headless has no dialog for+ let r = run(&mut h, "view.layoutImage", json!({}));+ assert_eq!(r["ok"], false, "{r}");+ assert!(!h.app.ui.layout_image.show);+ assert!(run(&mut h, "view.chooseLayoutImage", json!({"path": " "}))["ok"] == false, "an empty path is refused");++ let dir = cover("missing");+ let missing = dir.parent().unwrap().join("no-such-cover.png");+ let r = run(&mut h, "view.chooseLayoutImage", json!({"path": missing.to_string_lossy()}));+ assert_eq!(r["ok"], true, "{r}");+ assert!(h.step_until(T, |h| widget(h, "canvas:layoutImageError").is_some()), "the canvas says the file can't be read");+ assert!(widget(&h, "canvas:layoutImage").is_none());+ // choosing a readable one replaces the error+ let r = run(&mut h, "view.chooseLayoutImage", json!({"path": dir.to_string_lossy()}));+ assert_eq!(r["ok"], true, "{r}");+ assert!(h.step_until(T, |h| widget(h, "canvas:layoutImage").is_some()));+ h.step();+ assert!(widget(&h, "canvas:layoutImageError").is_none());+ let _ = std::fs::remove_dir_all(dir.parent().unwrap());+}++#[test]+fn view_loupe_overlay_lists_the_layout_image_commands() {+ let mut h = loupe();+ let names = |h: &Headless| -> Vec<(String, bool, Option<bool>)> {+ let menu = crate::menubar::expanded(&h.app, "Loupe Overlay").unwrap_or_default();+ menu.into_iter()+ .filter_map(|n| match n {+ crate::menubar::MenuNode::Item { id, enabled, checked, .. } => Some((id, enabled, checked)),+ _ => None,+ })+ .collect()+ };+ let before = names(&h);+ assert_eq!(before[0], ("view.chooseLayoutImage".to_string(), true, None));+ // nothing chosen: only Choose… is enabled+ assert!(before[1..].iter().all(|(_, enabled, _)| !enabled), "{before:?}");+ let path = cover("menu");+ run(&mut h, "view.chooseLayoutImage", json!({"path": path.to_string_lossy()}));+ let after = names(&h);+ assert_eq!(after[1], ("view.layoutImage".to_string(), true, Some(true)));+ // 100% opacity and no matte are checked by default+ let checked: Vec<&String> = after.iter().filter(|(_, _, c)| *c == Some(true)).map(|(id, ..)| id).collect();+ assert_eq!(checked, ["view.layoutImage", "view.layoutImageOpacity", "view.layoutImageMatte"]);+ let _ = std::fs::remove_dir_all(path.parent().unwrap());+}diff --git a/docs/parity-checklist.md b/docs/parity-checklist.mdindex 7bb187811..3e94700e5 100644--- a/docs/parity-checklist.md+++ b/docs/parity-checklist.md@@ -52,10 +52,10 @@ cited here still exists. Formerly docs/parity.md.| X. Cross-cutting behaviours (BEHAV) | 23 | 6 | 1 | 1 | 8/8 (100%) | 7/10 (70%) || Y. Menus | 84 | 0 | 4 | 8 | 47/47 (100%) | 23/23 (100%) || Z. Keyboard shortcuts (desktop) | 76 | 4 | 3 | 1 | 49/52 (94%) | 23/25 (92%) |-| Lightroom Classic extras | 34 | 16 | 35 | 8 | — | 24/26 (92%) |-| **Total** | 409 | 53 | 72 | 35 | 193/201 (96%) | 146/159 (92%) |+| Lightroom Classic extras | 34 | 17 | 35 | 8 | — | 24/26 (92%) |+| **Total** | 409 | 54 | 72 | 35 | 193/201 (96%) | 146/159 (92%) |-Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **81.6%** of 534 in-scope rows — P0 98.0% of 201 · P1 95.0% of 159 · P2 50.0% of 173.+Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **81.5%** of 535 in-scope rows — P0 98.0% of 201 · P1 95.0% of 159 · P2 50.0% of 174.<!-- /parity:summary -->## Top gaps and shortcut notes@@ -724,6 +724,7 @@ From `08-lightroom-classic-extras.md` (Classic-only features) and part 2 of `06-| LRC-DEV-DEFAULTS | Per-camera raw defaults | P1 | ✅ | `cmd:library.preferences` (`camera`, `import.perCamera`), `crates/ui-egui/src/panels/settings.rs` | Settings → Import: raw default and per-camera presets || LRC-DEV-PROCESS | Process versions, Update to Current Process | P1 | ✅ | `cmd:develop.updateProcess`, `cmd:develop.reset`, `cmd:develop.get`, `crates/develop/src/settings.rs`, `crates/pipeline/src/finish.rs`, `docs/process-versions.md` | each photo records the rendering process its settings are interpreted by: settings saved before this existed load as V1, new photos and Reset get the latest, virtual copies inherit, copy / paste / sync / presets keep each photo's own; Photo ▸ Update to Current Process (one undo step, enabled while a selected photo is on an older process); a number from a newer LightCraft is kept and renders with the newest known process. Only V1 exists so far: this is what lets a retuned default tone (#146) or stronger Light sliders (#196) ship without changing existing edits || LRC-DEV-VIEWOPTIONS | Develop view options | P2 | ⬜ | | |+| LRC-DEV-LOUPEOVERLAY | Loupe overlay: layout image | P2 | 🟡 | `cmd:view.chooseLayoutImage`, `cmd:view.layoutImage`, `cmd:view.layoutImageOpacity`, `cmd:view.layoutImageMatte`, `crates/ui-egui/src/panels/layout_overlay.rs` | View ▸ Loupe Overlay: a PNG with transparency (a cover layout, a banner's safe areas) fitted and centred over the loupe photo, following zoom and pan; opacity and matte (the photo darkened outside the graphic's box) in steps; ⌥⌘O shows / hides it; read off the UI thread; saved with the UI state. Not yet: the Grid and Guides overlays, moving and resizing the layout with ⌘ held, free opacity / matte sliders || LRC-DEV-VIDEO | Video frame capture | P2 | ⬜ | | || LRC-MAP-VIEW | Map view | P2 | ⬜ | | || LRC-MAP-GEOTAG | Drag photos onto the map | P2 | ⬜ | | |diff --git a/docs/whats-new.md b/docs/whats-new.mdindex 1bf44c3f4..58c3c9f4f 100644--- a/docs/whats-new.md+++ b/docs/whats-new.md@@ -2,6 +2,12 @@## 2026-10-14+### Layout image over the loupe+- View ▸ Loupe Overlay ▸ Choose Layout Image… draws a PNG with transparency over the photo in the loupe, such as+ a magazine cover's masthead and cover lines, so you can frame a shot for the page it is made for. It fits inside+ the photo, follows zoom and pan, and ⌥⌘O shows or hides it. The same menu sets its opacity and a matte that+ darkens the photo outside it. The layout stays chosen across launches.+### Hard-edged Heal and Clone spots- A spot with Feather at 0 no longer draws black pixels exactly on its radius. This also fixes spots at 0% Opacitychanging pixels along their edge. The hard edge now leaves pixels on the radius unchanged.