Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

Merge PR #2639: LR-MASK-BRUSH: with the mask overlay hidden, the stroke being painted no longer tints the photo (#2549)

aiongg27c4692dcdf9
diff --cc crates/ui-egui/src/panels/detail/masks.rs
index 365ae2311,000000000..2be29f2ef
mode 100644,000000..100644
--- a/crates/ui-egui/src/panels/detail/masks.rs
+++ b/crates/ui-egui/src/panels/detail/masks.rs
@@@ -1,710 -1,0 +1,721 @@@
+use super::geometry::CanvasMap;
+use super::{
+ Color32, DevelopSettings, Gesture, LightcraftApp, MaskShape, Point, Pos2, Rect, Sense, Stroke, StrokeKind, Tokens, ToolOverlay, json, pos2,
+ register, vec2,
+};
+
+/// What the user did to a face box this frame.
+pub(super) enum RegionEdit {
+ /// The × was clicked.
+ Remove(usize),
+ /// A handle drag ended: the region's new box (normalized, upright frame).
+ Resize(usize, lightcraft_geom::Rect),
+ /// A name was typed or picked for the face.
+ Name(usize, String),
+ /// The name box's offer to set up face recognition was pressed.
+ SetUp,
+}
+
+/// Handles of a box: (x, y) as fractions of its width and height, and the cursor they show.
+const REGION_HANDLES: [(f32, f32, egui::CursorIcon); 8] = [
+ (0.0, 0.0, egui::CursorIcon::ResizeNwSe),
+ (0.5, 0.0, egui::CursorIcon::ResizeVertical),
+ (1.0, 0.0, egui::CursorIcon::ResizeNeSw),
+ (1.0, 0.5, egui::CursorIcon::ResizeHorizontal),
+ (1.0, 1.0, egui::CursorIcon::ResizeNwSe),
+ (0.5, 1.0, egui::CursorIcon::ResizeVertical),
+ (0.0, 1.0, egui::CursorIcon::ResizeNeSw),
+ (0.0, 0.5, egui::CursorIcon::ResizeHorizontal),
+];
+
+/// Face/pet/focus regions read from XMP (MWG-RS), drawn as boxes over the photo. Hovering a box shows
+/// a × in its corner and eight resize handles. A drag previews the new box live and is reported once,
+/// on release (one undo step); the × reports the region to remove. Both are catalog-only edits:
+/// LightCraft doesn't write regions to XMP. Regions are stored on the upright (EXIF-oriented) photo;
+/// `orient` is the user's Rotate / Flip on top of it, which the loupe's normalized frame includes.
+/// What the face/pet/focus regions of a photo are drawn from.
+pub(super) struct RegionContext<'a> {
+ pub photo: &'a lightcraft_catalog::Photo,
+ /// the user's Rotate / Flip on top of the upright photo
+ pub orient: lightcraft_geom::Orientation,
+ pub hints: Option<&'a crate::panels::faces::Hints>,
+ /// the names to offer when a region is named
+ pub people: &'a [String],
+ pub setup: crate::panels::faces::Setup,
+}
+
+pub(super) fn region_overlay(
+ ui: &egui::Ui,
+ p: &egui::Painter,
+ map: &CanvasMap,
+ regions: &RegionContext,
+ editing: &mut Option<crate::state::NameEdit>,
+) -> Option<RegionEdit> {
+ let RegionContext { photo, orient, hints, people, setup } = *regions;
+ let t = Tokens::get(p.ctx());
+ let clip = p.clip_rect();
+ let pointer = ui.input(|i| i.pointer.hover_pos());
+ // the box being dragged: (region index, its box so far)
+ let drag_key = egui::Id::unique("region-drag");
+ let live: Option<(usize, lightcraft_geom::Rect)> = ui.data(|d| d.get_temp(drag_key));
+ let mut edit = None;
+ for (index, r) in photo.meta.regions.iter().enumerate() {
+ let dragging = live.filter(|(i, _)| *i == index);
+ let norm = orient.map_norm_rect(dragging.map_or(r.rect, |(_, n)| n));
+ let rect = Rect::from_two_pos(map.screen(Point::new(norm.x0, norm.y0)), map.screen(Point::new(norm.x1, norm.y1)));
+ // white with a black keyline just outside it, so the box shows on any background
+ p.rect_stroke(rect.expand(1.0), 0.0, Stroke::new(1.0, Color32::from_black_alpha(190)), StrokeKind::Outside);
+ p.rect_stroke(rect, 0.0, Stroke::new(1.0, Color32::WHITE), StrokeKind::Outside);
+ if dragging.is_some() || (live.is_none() && pointer.is_some_and(|h| rect.expand(8.0).contains(h))) {
+ for (h, (fx, fy, cursor)) in REGION_HANDLES.iter().enumerate() {
+ let c = pos2(rect.left() + fx * rect.width(), rect.top() + fy * rect.height());
+ let resp = ui.interact(Rect::from_center_size(c, vec2(14.0, 14.0)), egui::Id::unique(("region-handle", index, h)), Sense::drag());
+ crate::widgets::announce(&resp, crate::i18n::tr("Resize region"));
+ if resp.hovered() || resp.dragged() {
+ ui.ctx().set_cursor_icon(*cursor);
+ }
+ let sq = Rect::from_center_size(c, vec2(7.0, 7.0));
+ p.rect_filled(sq, 0.0, if resp.hovered() || resp.dragged() { Color32::from_rgb(120, 190, 255) } else { Color32::WHITE });
+ p.rect_stroke(sq, 0.0, Stroke::new(1.0, Color32::from_black_alpha(220)), StrokeKind::Outside);
+ if resp.dragged()
+ && let Some(pp) = resp.interact_pointer_pos()
+ {
+ // move the dragged edge(s) to the pointer, never closer than 12 px to the opposite one
+ let mut n = rect;
+ if *fx == 0.0 {
+ n.min.x = pp.x.min(n.max.x - 12.0);
+ } else if *fx == 1.0 {
+ n.max.x = pp.x.max(n.min.x + 12.0);
+ }
+ if *fy == 0.0 {
+ n.min.y = pp.y.min(n.max.y - 12.0);
+ } else if *fy == 1.0 {
+ n.max.y = pp.y.max(n.min.y + 12.0);
+ }
+ let (a, b) = (map.norm(n.min), map.norm(n.max));
+ let shown = lightcraft_geom::Rect {
+ x0: a.x.min(b.x).clamp(0.0, 1.0),
+ y0: a.y.min(b.y).clamp(0.0, 1.0),
+ x1: a.x.max(b.x).clamp(0.0, 1.0),
+ y1: a.y.max(b.y).clamp(0.0, 1.0),
+ };
+ // back to the upright frame the region is stored in
+ let new = orient.inverse().map_norm_rect(shown);
+ ui.data_mut(|d| d.insert_temp(drag_key, (index, new)));
+ ui.ctx().request_repaint();
+ }
+ if resp.drag_stopped() {
+ if let Some((i, new)) = ui.data(|d| d.get_temp::<(usize, lightcraft_geom::Rect)>(drag_key)) {
+ edit = Some(RegionEdit::Resize(i, new));
+ }
+ ui.data_mut(|d| d.remove_temp::<(usize, lightcraft_geom::Rect)>(drag_key));
+ }
+ }
+ }
+ if dragging.is_none() && live.is_none() && pointer.is_some_and(|h| rect.expand(3.0).contains(h)) {
+ let xr = Rect::from_center_size(pos2(rect.right() - 13.0, rect.top() + 13.0), vec2(16.0, 16.0));
+ let resp = ui.interact(xr, egui::Id::unique(("region-x", index)), Sense::click());
+ crate::widgets::announce(&resp, crate::i18n::tr("Remove region"));
+ register(ui, format!("regionRemove:{index}"), xr);
+ let fill = Color32::from_black_alpha(if resp.hovered() { 235 } else { 190 });
+ p.rect_filled(xr, 2.0, fill);
+ p.rect_stroke(xr, 2.0, Stroke::new(1.0, Color32::from_white_alpha(120)), StrokeKind::Inside);
+ let (c, m) = (xr.center(), 3.5);
+ let cross = Stroke::new(1.4, if resp.hovered() { Color32::WHITE } else { Color32::from_gray(210) });
+ p.line_segment([c - vec2(m, m), c + vec2(m, m)], cross);
+ p.line_segment([c - vec2(m, -m), c + vec2(m, -m)], cross);
+ if resp.on_hover_text(crate::i18n::tr("Remove this face box (undo with Edit ▸ Undo)")).clicked() {
+ edit = Some(RegionEdit::Remove(index));
+ }
+ }
+ // what the label says: the name, a guess to confirm ("Jane Doe?"), or on hover an invitation to name the face
+ let is_face = r.kind == lightcraft_meta::RegionKind::Face;
+ let hint = hints.and_then(|h| h.by_index.get(&index));
+ let hovered = pointer.is_some_and(|h| rect.expand(3.0).contains(h));
+ let editing_this = editing.as_ref().is_some_and(|e| e.photo == photo.id.0 && e.index == index);
+ let (text, text_color, fill_alpha, invitation) = match (&r.name, hint.and_then(|h| h.suggestion.as_ref())) {
+ (Some(n), _) => (n.clone(), Color32::from_gray(225), 235, false),
+ (None, Some((n, _))) if is_face => (format!("{n}?"), Color32::from_gray(185), 200, false),
+ (None, None) if is_face && live.is_none() => ("Add name".to_string(), Color32::from_gray(150), 190, true),
+ _ => continue,
+ };
+ // the name in a dark label with a caret, centred above the box (below it when there is no room)
+ let name = &text;
+ let g = p.layout_no_wrap(name.clone(), t.font(13.0), text_color);
+ let (pad, caret) = (vec2(14.0, 7.0), 5.0);
+ let size = g.size() + pad * 2.0;
+ let above = rect.top() - caret - size.y >= clip.top();
+ let (top, tip, base) = if above {
+ (rect.top() - caret - size.y, rect.top() - 1.0, rect.top() - caret - 1.0)
+ } else {
+ (rect.bottom() + caret, rect.bottom() + 1.0, rect.bottom() + caret + 1.0)
+ };
+ let left = (rect.center().x - size.x / 2.0).clamp(clip.left(), (clip.right() - size.x).max(clip.left()));
+ let label = Rect::from_min_size(pos2(left, top), size);
+ // the invitation shows while the pointer is on the box *or on the label* (and the gap between), so it can be reached
+ if invitation && !(hovered || editing_this || pointer.is_some_and(|h| rect.union(label).expand(3.0).contains(h))) {
+ continue;
+ }
+ let fill = Color32::from_rgba_unmultiplied(56, 56, 56, fill_alpha);
+ p.rect_filled(label, 3.0, fill);
+ p.rect_stroke(label, 3.0, Stroke::new(1.0, Color32::from_black_alpha(160)), StrokeKind::Inside);
+ let cx = rect.center().x.clamp(label.left() + caret + 4.0, label.right() - caret - 4.0);
+ p.add(egui::Shape::convex_polygon(vec![pos2(cx - caret, base), pos2(cx + caret, base), pos2(cx, tip)], fill, Stroke::NONE));
+ p.galley(label.min + pad, g, text_color);
+ if is_face && live.is_none() {
+ // a click on the label opens the name box, filled with the name or the guess
+ let resp = ui.interact(label, egui::Id::unique(("region-label", index)), Sense::click());
+ crate::widgets::announce(&resp, crate::i18n::tr("Click to name this face"));
+ register(ui, format!("regionLabel:{index}"), label);
+ if resp.on_hover_text(crate::i18n::tr("Click to name this face")).clicked() {
+ let start = r.name.clone().or_else(|| hint.and_then(|h| h.suggestion.as_ref().map(|(n, _)| n.clone()))).unwrap_or_default();
+ *editing = Some(crate::state::NameEdit { photo: photo.id.0, index, text: start, fresh: true });
+ }
+ }
+ if editing_this && let Some(e) = editing.as_mut() {
+ let candidates = hint.map(|h| h.candidates.as_slice()).unwrap_or(&[]);
+ match crate::panels::faces::name_editor(ui.ctx(), pos2(label.left(), rect.bottom() + 8.0), e, candidates, people, setup) {
+ crate::panels::faces::Editor::Submit(name) => edit = Some(RegionEdit::Name(index, name)),
+ crate::panels::faces::Editor::Setup => edit = Some(RegionEdit::SetUp),
+ crate::panels::faces::Editor::Cancel => *editing = None,
+ crate::panels::faces::Editor::Open => {}
+ }
+ }
+ }
+ edit
+}
+
+// ------------------------------------------------------------------------ masks
+
+/// Where a mask component's pin sits (normalized), for shapes that have a place on the photo.
+pub(crate) fn component_pin(shape: &MaskShape) -> Option<Point> {
+ match shape {
+ MaskShape::Radial { center, .. } => Some(*center),
+ MaskShape::Linear { start, end } => Some(Point::new((start.x + end.x) / 2.0, (start.y + end.y) / 2.0)),
+ MaskShape::Brush { strokes } => strokes.iter().find(|s| !s.erase).and_then(|s| s.points.first()).copied(),
+ _ => None,
+ }
+}
+
+/// `shape` moved by `dn` (normalized); `handle` 1/2 = a linear gradient's start/end set to `at`.
+fn moved_shape(shape: &MaskShape, handle: u8, dn: Point, at: Point, map: &CanvasMap, alt: bool) -> MaskShape {
+ let mv = |p: Point| Point::new(p.x + dn.x, p.y + dn.y);
+ match shape.clone() {
+ MaskShape::Radial { center, rx, ry, angle, feather, invert } => match handle {
+ 1 | 3 => {
+ let l = frame_long_norm(map);
+ let dx = (at.x - center.x) / l.0;
+ let dy = (at.y - center.y) / l.1;
+ let (s, co) = angle.to_radians().sin_cos();
+ let new_rx = (dx * co + dy * s).abs().max(0.01);
+ let mut new_ry = ry;
+ if alt {
+ new_ry = ry * (new_rx / rx.max(0.01));
+ }
+ if (new_rx - new_ry).abs() / new_rx.max(new_ry) < 0.05 {
+ new_ry = new_rx;
+ }
+ MaskShape::Radial { center, rx: new_rx, ry: new_ry, angle, feather, invert }
+ }
+ 2 | 4 => {
+ let l = frame_long_norm(map);
+ let dx = (at.x - center.x) / l.0;
+ let dy = (at.y - center.y) / l.1;
+ let (s, co) = angle.to_radians().sin_cos();
+ let new_ry = (dx * (-s) + dy * co).abs().max(0.01);
+ let mut new_rx = rx;
+ if alt {
+ new_rx = rx * (new_ry / ry.max(0.01));
+ }
+ if (new_rx - new_ry).abs() / new_rx.max(new_ry) < 0.05 {
+ new_rx = new_ry;
+ }
+ MaskShape::Radial { center, rx: new_rx, ry: new_ry, angle, feather, invert }
+ }
+ 5 => {
+ let l = frame_long_norm(map);
+ let dx = (at.x - center.x) / l.0;
+ let dy = (at.y - center.y) / l.1;
+ let new_angle = dy.atan2(dx).to_degrees();
+ MaskShape::Radial { center, rx, ry, angle: new_angle, feather, invert }
+ }
+ _ => MaskShape::Radial { center: mv(center), rx, ry, angle, feather, invert },
+ },
+ MaskShape::Linear { start, end } => match handle {
+ 1 => MaskShape::Linear { start: at, end },
+ 2 => MaskShape::Linear { start, end: at },
+ _ => MaskShape::Linear { start: mv(start), end: mv(end) },
+ },
+ MaskShape::Brush { mut strokes } => {
+ for st in &mut strokes {
+ st.points.iter_mut().for_each(|p| *p = mv(*p));
+ }
+ MaskShape::Brush { strokes }
+ }
+ s => s,
+ }
+}
+
+/// Hit the geometric ellipse, independently of feather/inversion. Radii use long-edge units,
+/// so undo the same scaling and rotation used to draw its outline before testing containment.
+fn radial_body_contains(shape: &MaskShape, at: Point, map: &CanvasMap) -> bool {
+ let MaskShape::Radial { center, rx, ry, angle, .. } = shape else { return false };
+ if !rx.is_finite() || !ry.is_finite() || *rx <= 0.0 || *ry <= 0.0 {
+ return false;
+ }
+ let l = frame_long_norm(map);
+ let dx = (at.x - center.x) / l.0;
+ let dy = (at.y - center.y) / l.1;
+ let (s, co) = angle.to_radians().sin_cos();
+ let x = (dx * co + dy * s) / rx;
+ let y = (-dx * s + dy * co) / ry;
+ x * x + y * y <= 1.0
+}
+
+/// Colour Range eyedropper: a click samples the colour under it for the selected mask's
+/// colour range, at normalized frame coordinates (crop, rotation and zoom aware);
+/// ⇧-click adds a sample (up to 5).
+pub(super) fn color_range_pick(app: &mut LightcraftApp, ui: &egui::Ui, resp: &egui::Response, map: &CanvasMap) {
+ if resp.clicked()
+ && let Some(q) = resp.interact_pointer_pos()
+ {
+ let n = map.norm(q);
+ let add = ui.input(|i| i.modifiers.shift);
+ if let Err(e) = app.run("mask.sampleColor", json!({"x": n.x, "y": n.y, "add": add})) {
+ app.toast(ui.ctx(), e);
+ }
+ }
+}
+
+/// The Masking tool on the photo: outlines and handles of the selected mask, a pin per mask
+/// component (click selects its mask, drag moves the component), and brush painting. The mask
+/// itself shows as a rendered overlay ([`view_overlay`]).
+pub(super) fn mask_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap, d: &DevelopSettings) {
+ let active = app.session.active_mask;
+ let clip = app.canvas_rect.unwrap_or(map.rect);
+ let p = &ui.painter_at(clip);
+ // (mask, component, handle, screen position) of everything that can be grabbed
+ let mut grips: Vec<(u32, usize, u8, Pos2)> = Vec::new();
+ // pins follow Show Pins and the Tool Overlay mode (Shift+H); Auto hides them while brushing
+ let (mode, live) = (app.ui.tool_overlay, pins_live(app, resp, map));
+ let mut pins = p.clone();
+ if mode == ToolOverlay::Auto && matches!(app.gesture, Some(Gesture::Brush { .. })) {
+ pins.set_invisible();
+ }
+ for m in &d.masks {
+ let sel = Some(m.id) == active;
+ // Ctrl+Shift+O (`mask_overlay_all`) shows every visible mask's region; outline each one
+ // too, not just the selected mask. Handles and the rotation grip stay on the selected
+ // mask so nothing else becomes draggable. The component check keeps this in step with the
+ // painted region (`view_overlay` at detail.rs:1354 only covers masks with components).
+ let show_outline = sel || (app.ui.mask_overlay_all && m.visible && !m.components.is_empty());
+ for (ci, c) in m.components.iter().enumerate() {
+ if show_outline {
+ component_outline(ui, p, map, (m.id, ci), &c.shape, sel, &mut grips);
+ }
+ if app.ui.mask_pins
+ && mode.shows(sel, live)
+ && let Some(at) = component_pin(&c.shape)
+ {
+ let q = map.screen(at);
+ pin(&pins, q, sel);
+ register(ui, format!("maskPin:{}:{ci}", m.id), Rect::from_center_size(q, vec2(14.0, 14.0)));
+ grips.push((m.id, ci, 0, q));
+ }
+ }
+ }
+ mask_keys(app, ui, map, d, &grips);
+ object_marks(app, p, map, d, active);
+ // Colour Range "Pick": the Masking panel owns the loupe's clicks (general_interaction
+ // never runs while it is open), so the eyedropper is handled here too.
+ if app.ui.tool == "colorRange" {
+ if resp.hovered() {
+ ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);
+ }
+ color_range_pick(app, ui, resp, map);
+ return;
+ }
+ if app.ui.tool == "object" {
+ object_tool(app, ui, resp, map);
+ return;
+ }
+ if app.ui.tool == "brush" {
+ brush_tool(app, ui, resp, map, p, clip);
+ return;
+ }
+ grip_gestures(app, ui, resp, map, d, &grips);
+}
+
+/// The outline of one mask component, and (on the selected mask) its grips, registered and
+/// collected into `grips`.
+fn component_outline(
+ ui: &egui::Ui,
+ p: &egui::Painter,
+ map: &CanvasMap,
+ at: (u32, usize),
+ shape: &MaskShape,
+ sel: bool,
+ grips: &mut Vec<(u32, usize, u8, Pos2)>,
+) {
+ let (mask, ci) = at;
+ let stroke_a: u8 = if sel { 230 } else { 170 };
+ match shape {
+ MaskShape::Radial { center, rx, ry, angle, .. } => {
+ let pts: Vec<Pos2> = (0..64)
+ .map(|i| {
+ let a = i as f64 / 64.0 * std::f64::consts::TAU;
+ let (s, co) = angle.to_radians().sin_cos();
+ let (x, y) = (rx * a.cos(), ry * a.sin());
+ let l = frame_long_norm(map);
+ map.screen(Point::new(center.x + (x * co - y * s) * l.0, center.y + (x * s + y * co) * l.1))
+ })
+ .collect();
+ p.add(egui::Shape::closed_line(pts, Stroke::new(1.5, Color32::from_white_alpha(stroke_a))));
+
+ if sel {
+ let l = frame_long_norm(map);
+ for (i, a_deg) in [0.0_f64, 90.0_f64, 180.0_f64, 270.0_f64].into_iter().enumerate() {
+ let a_local = a_deg.to_radians();
+ let (s, co) = angle.to_radians().sin_cos();
+ let (x, y) = (rx * a_local.cos(), ry * a_local.sin());
+ let q = map.screen(Point::new(center.x + (x * co - y * s) * l.0, center.y + (x * s + y * co) * l.1));
+ p.circle_stroke(q, 5.0, Stroke::new(1.5, Color32::WHITE));
+ register(ui, format!("maskHandle:{}:{ci}:{}", mask, i + 1), Rect::from_center_size(q, vec2(14.0, 14.0)));
+ grips.push((mask, ci, i as u8 + 1, q));
+ }
+
+ let (s, co) = angle.to_radians().sin_cos();
+ let rot_r = rx + 0.08;
+ let rot_q = map.screen(Point::new(center.x + (rot_r * co) * l.0, center.y + (rot_r * s) * l.1));
+ let h1_q = map.screen(Point::new(center.x + (rx * co) * l.0, center.y + (rx * s) * l.1));
+ p.line_segment([h1_q, rot_q], Stroke::new(1.0, Color32::from_white_alpha(200)));
+ p.circle_stroke(rot_q, 4.0, Stroke::new(1.5, Color32::WHITE));
+ register(ui, format!("maskHandle:{}:{ci}:5", mask), Rect::from_center_size(rot_q, vec2(14.0, 14.0)));
+ grips.push((mask, ci, 5, rot_q));
+ }
+ }
+ MaskShape::Linear { start, end } => {
+ let (a, b) = (map.screen(*start), map.screen(*end));
+ let dir = (b - a).normalized();
+ let perp = vec2(-dir.y, dir.x) * 3000.0;
+ let (a1, a2): (u8, u8) = if sel { (230, 110) } else { (170, 80) };
+ for (q, alpha) in [(a, a1), (b, a2)] {
+ p.line_segment([q - perp, q + perp], Stroke::new(1.0, Color32::from_white_alpha(alpha)));
+ }
+ if sel {
+ for (i, q) in [a, b].iter().enumerate() {
+ p.circle_stroke(*q, 5.0, Stroke::new(1.5, Color32::WHITE));
+ register(ui, format!("maskHandle:{}:{ci}:{i}", mask), Rect::from_center_size(*q, vec2(14.0, 14.0)));
+ grips.push((mask, ci, i as u8 + 1, *q));
+ }
+ }
+ }
+ _ => {}
+ }
+}
+
+/// Object selections (SAM 3) of the selected mask: each click, green to include, red to exclude
+/// (clicks still on their way to the model included).
+fn object_marks(app: &LightcraftApp, p: &egui::Painter, map: &CanvasMap, d: &DevelopSettings, active: Option<u32>) {
+ let pending = app.session.segmenter.pending_clicks().cloned();
+ for m in d.masks.iter().filter(|m| Some(m.id) == active) {
+ for (k, c) in m.components.iter().enumerate() {
+ if let MaskShape::Object { hint, exclude, .. } = &c.shape {
+ let (hint, exclude) = match pending.as_ref().filter(|q| (q.mask, q.comp) == (m.id, k)) {
+ Some(q) => (&q.hint, &q.exclude),
+ None => (hint, exclude),
+ };
+ for (pts, col) in [(hint, Color32::from_rgb(40, 200, 90)), (exclude, Color32::from_rgb(230, 60, 60))] {
+ for q in pts {
+ let q = map.screen(*q);
+ p.circle_filled(q, 5.0, col);
+ p.circle_stroke(q, 5.0, Stroke::new(1.5, Color32::WHITE));
+ }
+ }
+ }
+ }
+ }
+}
+
+/// Object tool: a click includes what's under it, ⌥-click leaves it out.
+fn object_tool(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap) {
+ if resp.hovered() {
+ ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);
+ }
+ if resp.clicked()
+ && let Some(q) = resp.interact_pointer_pos()
+ {
+ let n = map.norm(q);
+ let exclude = ui.input(|i| i.modifiers.alt);
+ match app.run_typed("mask.objectPoint", json!({"x": n.x, "y": n.y, "exclude": exclude})) {
+ Ok(_) => {
+ if let Some(mid) = app.session.active_mask {
+ app.ui.detail_due = Some((app.tick_now() + 1.0, mid));
+ }
+ }
+ Err(e) => app.ai_error(ui.ctx(), e, Some(("object", "new"))),
+ }
+ }
+}
+
+/// Brush tool: the cursor, the stroke being painted and its commit.
+fn brush_tool(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap, p: &egui::Painter, clip: Rect) {
+ let long = (map.rect.width().max(map.rect.height())) as f64;
+ let r = (app.ui.brush_size as f64 * long) as f32;
+ if let Some(h) = resp.hover_pos() {
+ ui.ctx().set_cursor_icon(egui::CursorIcon::None);
+ p.circle_stroke(h, r, Stroke::new(1.0, Color32::WHITE));
+ p.circle_stroke(h, r * (1.0 - app.ui.brush_feather / 100.0).max(0.05), Stroke::new(1.0, Color32::from_white_alpha(120)));
+ }
+ if let Some(q) = resp.interact_pointer_pos()
+ && (resp.drag_started() || resp.dragged() || resp.clicked())
+ {
+ let n = map.norm(q);
+ let force = if app.ui.brush_pressure { ui.input(pen_force) } else { None };
+ match &mut app.gesture {
+ // a held, unmoving pointer records nothing: coverage builds by passes, not time (#518)
+ Some(Gesture::Brush { points, .. }) if points.last() == Some(&n) => {}
+ Some(Gesture::Brush { points, pressure }) => {
+ record_pressure(pressure, points.len(), force);
+ points.push(n);
+ }
+ _ => {
+ let mut pressure = Vec::new();
+ record_pressure(&mut pressure, 0, force);
+ app.gesture = Some(Gesture::Brush { points: vec![n], pressure });
+ }
+ }
+ }
+ // the stroke being painted (the render shows it once it's committed), with the committed
- // stroke's dab spacing, feather and flow (issue #517)
- if let Some(Gesture::Brush { points, pressure }) = &app.gesture {
++ // stroke's dab spacing, feather and flow (issue #517), tinted only when the overlay will
++ // show it: with the overlay hidden (O, or a mask slider hid it) or a colour overlay at
++ // opacity 0, the photo stays untinted while painting, so dodging and burning is judged on
++ // the photo (issue #2549)
++ use lightcraft_pipeline::MaskView;
++ let colored = matches!(MaskView::parse(&app.ui.mask_overlay_mode).unwrap_or_default(), MaskView::Color | MaskView::ColorOnBw);
++ // the all-masks overlay ([`view_overlay`]) shows only visible masks, and gives way to the
++ // selected mask's when none has anything in it (a stroke goes into the selected mask, or a new one)
++ let visible = active.and_then(|id| d.masks.iter().find(|m| m.id == id)).is_none_or(|m| m.visible);
++ let all = app.ui.mask_overlay_all && (visible || d.masks.iter().any(|m| m.visible && !m.components.is_empty()));
++ let shown = if all { visible } else { app.ui.mask_overlay } && !(colored && app.ui.mask_overlay_opacity <= 0.0);
++ if shown && let Some(Gesture::Brush { points, pressure }) = &app.gesture {
+ let screen: Vec<Pos2> = points.iter().map(|q| map.screen(*q)).collect();
- let opacity = if app.ui.mask_overlay && app.ui.mask_overlay_opacity > 0.0 { app.ui.mask_overlay_opacity / 100.0 } else { 110.0 / 255.0 };
++ // opacity 0 only gets here in the image views, which ignore it: a fixed tint there
++ let opacity = if app.ui.mask_overlay_opacity > 0.0 { app.ui.mask_overlay_opacity / 100.0 } else { 110.0 / 255.0 };
+ let params = crate::brush_live::LiveParams {
+ clip,
+ scale: ui.ctx().pixels_per_point(),
+ r,
+ hard: r * (1.0 - (app.ui.brush_feather / 100.0).clamp(0.0, 1.0)),
+ flow: (app.ui.brush_flow / 100.0).clamp(0.0, 1.0),
+ density: 1.0,
+ color: app.ui.mask_overlay_color,
+ opacity: opacity.clamp(0.0, 1.0),
+ };
+ crate::brush_live::paint(&mut app.brush_live, ui.ctx(), p, params, &screen, pressure);
+ } else {
+ app.brush_live = None;
+ }
+ if (resp.drag_stopped() || resp.clicked())
+ && let Some(Gesture::Brush { points, pressure }) = app.gesture.take()
+ {
+ app.brush_live = None;
+ let pts: Vec<[f64; 2]> = points.iter().map(|q| [q.x, q.y]).collect();
+ // holding ⌥ (Alt) paints with the other mode: Erase while adding, Add while erasing
+ let (alt, shift) = resp.ctx.input(|i| (i.modifiers.alt, i.modifiers.shift));
+ let erase = app.ui.brush_erase != alt;
+ // a ⇧-click draws a straight line from where the last stroke ended, as in Lightroom
+ let connect = shift && resp.clicked() && pts.len() == 1;
+ let _ = app.run(
+ "mask.brushStroke",
+ json!({"points": pts, "size": app.ui.brush_size, "feather": app.ui.brush_feather, "flow": app.ui.brush_flow,
+ "erase": erase, "autoMask": app.ui.brush_auto_mask, "pressure": pressure, "connect": connect}),
+ );
+ }
+}
+
+/// Grabbing mask grips and component bodies: select, drag, release.
+fn grip_gestures(
+ app: &mut LightcraftApp,
+ ui: &egui::Ui,
+ resp: &egui::Response,
+ map: &CanvasMap,
+ d: &DevelopSettings,
+ grips: &[(u32, usize, u8, Pos2)],
+) {
+ let active = app.session.active_mask;
+ // the grip under the pointer: the selected mask's first, then the nearest
+ let hit = |q: Pos2| {
+ grips
+ .iter()
+ .filter(|g| g.3.distance(q) < 10.0)
+ .min_by(|a, b| {
+ (Some(a.0) != active, a.3.distance(q)).partial_cmp(&(Some(b.0) != active, b.3.distance(q))).unwrap_or(std::cmp::Ordering::Equal)
+ })
+ .copied()
+ };
+ if resp.clicked()
+ && let Some(q) = resp.interact_pointer_pos()
+ && let Some((mid, ..)) = hit(q)
+ && Some(mid) != active
+ {
+ let _ = app.run("mask.select", json!({"id": mid}));
+ }
+ if resp.drag_started()
+ && let Some(q) = ui.input(|i| i.pointer.press_origin()).or(resp.interact_pointer_pos())
+ {
+ let grip = hit(q).map(|(m, c, h, _)| (m, c, h)).or_else(|| {
+ let m = d.masks.iter().find(|m| Some(m.id) == active)?;
+ // Handles take precedence; otherwise grab the selected radial component under
+ // the press, including components after the first in compound masks.
+ let at = map.norm(q);
+ if let Some(ci) = m.components.iter().position(|c| radial_body_contains(&c.shape, at, map)) {
+ return Some((m.id, ci, 0));
+ }
+ // anywhere on the photo drags the selected linear gradient
+ matches!(m.components.first()?.shape, MaskShape::Linear { .. }).then_some((m.id, 0, 0))
+ });
+ if let Some((mask, comp, handle)) = grip
+ && let Some(original_shape) = d.masks.iter().find(|m| m.id == mask).and_then(|m| m.components.get(comp)).map(|c| c.shape.clone())
+ {
+ if Some(mask) != active {
+ let _ = app.run("mask.select", json!({"id": mask}));
+ }
+ let _ = app.run("develop.beginInteraction", json!({"label": "Edit Mask"}));
+ app.gesture = Some(Gesture::MaskHandle { mask, comp, handle, original_shape });
+ }
+ }
+ if resp.dragged()
+ && let (Some(Gesture::MaskHandle { mask, comp, handle, original_shape }), Some(q)) = (app.gesture.clone(), resp.interact_pointer_pos())
+ {
+ let n = map.norm(q);
+ let press_origin = ui.input(|i| i.pointer.press_origin()).unwrap_or(q);
+ let n0 = map.norm(press_origin);
+ let dn = Point::new(n.x - n0.x, n.y - n0.y);
+ let alt = ui.input(|i| i.modifiers.alt);
+ let new_shape = moved_shape(&original_shape, handle, dn, n, map, alt);
+ let _ = app.run("mask.update", json!({"id": mask, "component": comp, "shape": new_shape}));
+ }
+ if resp.drag_stopped() && matches!(app.gesture, Some(Gesture::MaskHandle { .. })) {
+ app.gesture = None;
+ let _ = app.run("develop.endInteraction", json!({}));
+ }
+}
+
+/// A mask handle's name for screen readers: `handle` 0 is the component's pin, 1..5 a radial
+/// gradient's right / bottom / left / top edge and rotation, 1..2 a linear gradient's start and end.
+fn mask_handle_name(mask: &str, shape: &MaskShape, handle: u8) -> String {
+ let part = match (shape, handle) {
+ (_, 0) => "pin",
+ (MaskShape::Radial { .. }, 1) => "right edge",
+ (MaskShape::Radial { .. }, 2) => "bottom edge",
+ (MaskShape::Radial { .. }, 3) => "left edge",
+ (MaskShape::Radial { .. }, 4) => "top edge",
+ (MaskShape::Radial { .. }, _) => "rotation",
+ (MaskShape::Linear { .. }, 1) => "start",
+ (MaskShape::Linear { .. }, _) => "end",
+ _ => "handle",
+ };
+ format!("{mask} {}", crate::i18n::tr(part))
+}
+
+/// Keyboard stand-ins for the mask handles and pins: an arrow press moves the focused one by a
+/// step (one undo step), as dragging it would; Return on a pin selects its mask.
+fn mask_keys(app: &mut LightcraftApp, ui: &mut egui::Ui, map: &CanvasMap, d: &DevelopSettings, grips: &[(u32, usize, u8, Pos2)]) {
+ for &(mid, ci, handle, q) in grips {
+ let Some(m) = d.masks.iter().find(|m| m.id == mid) else { continue };
+ let Some(shape) = m.components.get(ci).map(|c| &c.shape) else { continue };
+ let at = map.norm(q);
+ let mask_name = if m.name.trim().is_empty() { format!("{} {mid}", crate::i18n::tr("Mask")) } else { m.name.clone() };
+ let name = mask_handle_name(&mask_name, shape, handle);
+ let keys = crate::canvas_keys::handle(ui, &format!("mask:{mid}:{ci}:{handle}"), &name, crate::canvas_keys::position_text(at.x, at.y), q);
+ if keys.activated && app.session.active_mask != Some(mid) {
+ let _ = app.run("mask.select", json!({"id": mid}));
+ }
+ let Some((dx, dy)) = keys.delta else { continue };
+ if app.session.active_mask != Some(mid) {
+ let _ = app.run("mask.select", json!({"id": mid}));
+ }
+ let to = Point::new(at.x + dx, at.y + dy);
+ let new_shape = moved_shape(shape, handle, Point::new(dx, dy), to, map, false);
+ let _ = app.run("develop.beginInteraction", json!({"label": "Edit Mask"}));
+ let _ = app.run("mask.update", json!({"id": mid, "component": ci, "shape": new_shape}));
+ let _ = app.run("develop.endInteraction", json!({}));
+ }
+}
+
+/// Long-edge units → normalized units for x and y.
+fn frame_long_norm(map: &CanvasMap) -> (f64, f64) {
+ // derive from the mapping: 1 normalized unit in x and y in screen points
+ let o = map.screen(Point::new(0.0, 0.0));
+ let x = map.screen(Point::new(1.0, 0.0)).distance(o) as f64;
+ let y = map.screen(Point::new(0.0, 1.0)).distance(o) as f64;
+ let l = x.max(y);
+ (l / x.max(1e-9), l / y.max(1e-9))
+}
+
+/// Auto's condition for the Tool Overlay (Shift+H): the pointer is over the photo, or a pin is
+/// being dragged.
+pub(super) fn pins_live(app: &LightcraftApp, resp: &egui::Response, map: &CanvasMap) -> bool {
+ resp.hover_pos().is_some_and(|q| map.rect.contains(q))
+ || matches!(app.gesture, Some(Gesture::SpotMove { .. } | Gesture::MaskHandle { .. }))
+ // a handle moved with the keyboard stays shown while it has the focus
+ || crate::canvas_keys::has_focus(&resp.ctx)
+}
+
+pub(super) fn pin(p: &egui::Painter, c: Pos2, sel: bool) {
+ p.circle_filled(c, 6.0, if sel { Color32::from_rgb(1, 101, 221) } else { Color32::from_gray(200) });
+ p.circle_stroke(c, 6.0, Stroke::new(1.5, Color32::WHITE));
+}
+
+/// The pen pressure (0..1) reported this frame: the force of the latest touch or pen event that carries one (winit
+/// reports a pen's pressure as a touch force, on the platforms that give it), `None` for a mouse.
+pub(crate) fn pen_force(i: &egui::InputState) -> Option<f32> {
+ i.events.iter().rev().find_map(|e| match e {
+ egui::Event::Touch { force: Some(f), .. } if f.is_finite() => Some(f.clamp(0.0, 1.0)),
+ _ => None,
+ })
+}
+
+/// Record the pressure of the stroke's point `index`: `force` when the pen reported one this frame, else the last
+/// known one. Points before the first reported force take it too; a stroke without any keeps no pressure list.
+pub(crate) fn record_pressure(pressure: &mut Vec<f32>, index: usize, force: Option<f32>) {
+ match (force, pressure.last().copied()) {
+ (Some(f), _) if pressure.is_empty() => pressure.extend(std::iter::repeat_n(f, index + 1)),
+ (Some(f), _) => pressure.push(f),
+ (None, Some(last)) => pressure.push(last),
+ (None, None) => {}
+ }
+}
+
+#[cfg(test)]
+mod pen_tests {
+ use super::*;
+
+ #[test]
+ fn pen_pressure_is_recorded_per_point_and_absent_for_a_mouse() {
+ let mut p = Vec::new();
+ record_pressure(&mut p, 0, None);
+ record_pressure(&mut p, 1, None);
+ assert!(p.is_empty(), "a mouse: no pressure list");
+ // the first force covers the points before it, a frame without one repeats the last
+ record_pressure(&mut p, 2, Some(0.4));
+ record_pressure(&mut p, 3, None);
+ record_pressure(&mut p, 4, Some(0.9));
+ assert_eq!(p, vec![0.4, 0.4, 0.4, 0.4, 0.9]);
+
+ let mut i = egui::InputState::default();
+ assert_eq!(pen_force(&i), None);
+ let touch = |force| egui::Event::Touch {
+ device_id: egui::TouchDeviceId(1),
+ id: egui::TouchId(1),
+ phase: egui::TouchPhase::Move,
+ pos: egui::pos2(1.0, 1.0),
+ force,
+ };
+ i.events = vec![touch(Some(0.3)), touch(Some(f32::NAN)), touch(None)];
+ assert_eq!(pen_force(&i), Some(0.3), "the latest usable force");
+ i.events = vec![touch(Some(4.0))];
+ assert_eq!(pen_force(&i), Some(1.0));
+ }
+}
diff --cc docs/parity-checklist.md
index 63d2dece2,cd9af999f..f41a39376
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@@ -1,6 -1,6 +1,6 @@@
# Lightroom parity checklist
- > **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-27 · **Change:** minor (LR-FILT-SEARCH-META: `>=` / `<=` in fielded search tokens; MENU-FILE-CLOSE, KEY-CLOSEWINDOW: the notes say Close Window quits the app, after the same check as Quit; MENU-EDIT-SELECTNONE, MENU-EDIT-PASTESELECTED: Edit lists Select Only Active Photo after Deselect All and Paste Settings from Previous after Paste Selected Settings…; on macOS no doubled separators are left where Settings… moved to the app menu; LR-BEHAV-TITLEBAR: a double-click follows the system setting, and a panel over the bar keeps the window still; KEYC-METADATA, LRC-LIB-KEYWORDS: ⌥0 / ⌥⇧0 go to the next / previous keyword set; LRC-DEV-HISTOGRAM-DRAG: the histogram's five tonal zones — hover for the value, drag to adjust the Basic control the press locked, double-click to reset; LR-VIEW-HISTOGRAM note updated; MENU-BAR: on macOS a menu item that yields its key to a focused text field or to shortcut recording really lets it go; LR-MERGE-HDR / LR-MERGE-PANO: Lanczos-3 warps; LR-IMP-LOCAL: browsing from the sidebar records the folder; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LR-IMP-ADD-DIALOG: hierarchical import album destination reconciled with main, #2362; KEY-SLIDER-NUDGE: vertical wheel nudges need a click or drag in the row; leaving it disarms them; LR-EDIT-OPTICS-PROFILE: Fujifilm nine-knot lens tables read at the plain radius; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LRC-LIB-LIBFOLDERS, LR-BEHAV-BG-TASKS: Synchronize Folder's scan shows its folder listing and stops it on ✕; LRC-LIB-LIBFOLDERS: Synchronize Folder says a folder is up to date; LR-LIB-STACK: filmstrip stack badge click; LRC-LIB-REFVIEW / CATALOG-SWITCH: Escape preserves edits; catalog-local pins; deleted and malformed references refused; LRC-LIB-COMPARE: the Info panel labels the active photo while culling, #2398; KEYC-RATING: `\` shows / hides the Filter Bar in the grids; LR-VIEW-PHOTOGRID: the grid reads only the photos an import batch or an edit touched, not the whole list; earlier: LRC-PRINT-PAGE: Print Page Options; LR-META-XMP: fewer false unimported-XMP warnings; KEYC-METADATA: ⌘K / Ctrl+K Add Keywords; LRC-DEV-HISTOGRAM-DRAG: the histogram's five tonal zones — hover for the value, drag to adjust the Basic control the press locked, double-click to reset; LR-VIEW-HISTOGRAM note updated; MENU-BAR: on macOS a menu item that yields its key to a focused text field or to shortcut recording really lets it go; LR-MERGE-HDR / LR-MERGE-PANO: Lanczos-3 warps; LR-IMP-LOCAL: browsing from the sidebar records the folder; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LR-IMP-ADD-DIALOG: hierarchical import album destination reconciled with main, #2362; KEY-SLIDER-NUDGE: vertical wheel nudges need a click or drag in the row; leaving it disarms them; LR-EDIT-OPTICS-PROFILE: Fujifilm nine-knot lens tables read at the plain radius; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LRC-LIB-LIBFOLDERS, LR-BEHAV-BG-TASKS: Synchronize Folder's scan shows its folder listing and stops it on ✕; LRC-LIB-LIBFOLDERS: Synchronize Folder says a folder is up to date; LR-LIB-STACK: filmstrip stack badge click; LRC-LIB-REFVIEW / CATALOG-SWITCH: Escape preserves edits; catalog-local pins; deleted and malformed references refused; LRC-LIB-COMPARE: the Info panel labels the active photo while culling, #2398; KEYC-RATING: `\` shows / hides the Filter Bar in the grids; LR-VIEW-PHOTOGRID: the grid reads only the photos an import batch or an edit touched, not the whole list; earlier: LRC-PRINT-PAGE: Print Page Options; LR-META-XMP: fewer false unimported-XMP warnings; LR-MASK-BRUSH: extreme brush segments skip the intermediate dabs) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-24 · **Change:** minor (LRC-DEV-HISTOGRAM-DRAG: the histogram's five tonal zones — hover for the value, drag to adjust the Basic control the press locked, double-click to reset; LR-VIEW-HISTOGRAM note updated; MENU-BAR: on macOS a menu item that yields its key to a focused text field or to shortcut recording really lets it go; LR-MERGE-HDR / LR-MERGE-PANO: Lanczos-3 warps; LR-IMP-LOCAL: browsing from the sidebar records the folder; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LR-IMP-ADD-DIALOG: hierarchical import album destination reconciled with main, #2362; KEY-SLIDER-NUDGE: vertical wheel nudges need a click or drag in the row; leaving it disarms them; LR-EDIT-OPTICS-PROFILE: Fujifilm nine-knot lens tables read at the plain radius; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LRC-LIB-LIBFOLDERS, LR-BEHAV-BG-TASKS: Synchronize Folder's scan shows its folder listing and stops it on ✕; LRC-LIB-LIBFOLDERS: Synchronize Folder says a folder is up to date; LR-LIB-STACK: filmstrip stack badge click; LRC-LIB-REFVIEW / CATALOG-SWITCH: Escape preserves edits; catalog-local pins; deleted and malformed references refused; LRC-LIB-COMPARE: the Info panel labels the active photo while culling, #2398; KEYC-RATING: `\` shows / hides the Filter Bar in the grids; LR-VIEW-PHOTOGRID: the grid reads only the photos an import batch or an edit touched, not the whole list; earlier: LRC-PRINT-PAGE: Print Page Options; LR-META-XMP: fewer false unimported-XMP warnings; LR-MASK-BRUSH: with the mask overlay hidden, the stroke being painted no longer tints the photo) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
++> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-27 · **Change:** minor (LR-FILT-SEARCH-META: `>=` / `<=` in fielded search tokens; MENU-FILE-CLOSE, KEY-CLOSEWINDOW: the notes say Close Window quits the app, after the same check as Quit; MENU-EDIT-SELECTNONE, MENU-EDIT-PASTESELECTED: Edit lists Select Only Active Photo after Deselect All and Paste Settings from Previous after Paste Selected Settings…; on macOS no doubled separators are left where Settings… moved to the app menu; LR-BEHAV-TITLEBAR: a double-click follows the system setting, and a panel over the bar keeps the window still; KEYC-METADATA, LRC-LIB-KEYWORDS: ⌥0 / ⌥⇧0 go to the next / previous keyword set; LRC-DEV-HISTOGRAM-DRAG: the histogram's five tonal zones — hover for the value, drag to adjust the Basic control the press locked, double-click to reset; LR-VIEW-HISTOGRAM note updated; MENU-BAR: on macOS a menu item that yields its key to a focused text field or to shortcut recording really lets it go; LR-MERGE-HDR / LR-MERGE-PANO: Lanczos-3 warps; LR-IMP-LOCAL: browsing from the sidebar records the folder; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LR-IMP-ADD-DIALOG: hierarchical import album destination reconciled with main, #2362; KEY-SLIDER-NUDGE: vertical wheel nudges need a click or drag in the row; leaving it disarms them; LR-EDIT-OPTICS-PROFILE: Fujifilm nine-knot lens tables read at the plain radius; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LRC-LIB-LIBFOLDERS, LR-BEHAV-BG-TASKS: Synchronize Folder's scan shows its folder listing and stops it on ✕; LRC-LIB-LIBFOLDERS: Synchronize Folder says a folder is up to date; LR-LIB-STACK: filmstrip stack badge click; LRC-LIB-REFVIEW / CATALOG-SWITCH: Escape preserves edits; catalog-local pins; deleted and malformed references refused; LRC-LIB-COMPARE: the Info panel labels the active photo while culling, #2398; KEYC-RATING: `\` shows / hides the Filter Bar in the grids; LR-VIEW-PHOTOGRID: the grid reads only the photos an import batch or an edit touched, not the whole list; earlier: LRC-PRINT-PAGE: Print Page Options; LR-META-XMP: fewer false unimported-XMP warnings; KEYC-METADATA: ⌘K / Ctrl+K Add Keywords; LRC-DEV-HISTOGRAM-DRAG: the histogram's five tonal zones — hover for the value, drag to adjust the Basic control the press locked, double-click to reset; LR-VIEW-HISTOGRAM note updated; MENU-BAR: on macOS a menu item that yields its key to a focused text field or to shortcut recording really lets it go; LR-MERGE-HDR / LR-MERGE-PANO: Lanczos-3 warps; LR-IMP-LOCAL: browsing from the sidebar records the folder; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LR-IMP-ADD-DIALOG: hierarchical import album destination reconciled with main, #2362; KEY-SLIDER-NUDGE: vertical wheel nudges need a click or drag in the row; leaving it disarms them; LR-EDIT-OPTICS-PROFILE: Fujifilm nine-knot lens tables read at the plain radius; LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict; LRC-LIB-LIBFOLDERS, LR-BEHAV-BG-TASKS: Synchronize Folder's scan shows its folder listing and stops it on ✕; LRC-LIB-LIBFOLDERS: Synchronize Folder says a folder is up to date; LR-LIB-STACK: filmstrip stack badge click; LRC-LIB-REFVIEW / CATALOG-SWITCH: Escape preserves edits; catalog-local pins; deleted and malformed references refused; LRC-LIB-COMPARE: the Info panel labels the active photo while culling, #2398; KEYC-RATING: `\` shows / hides the Filter Bar in the grids; LR-VIEW-PHOTOGRID: the grid reads only the photos an import batch or an edit touched, not the whole list; earlier: LRC-PRINT-PAGE: Print Page Options; LR-META-XMP: fewer false unimported-XMP warnings; LR-MASK-BRUSH: extreme brush segments skip the intermediate dabs; LR-MASK-BRUSH: with the mask overlay hidden, the stroke being painted no longer tints the photo) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
The measured, row-by-row checklist: one row per Lightroom feature, menu item and shortcut, what we
have and what is missing. It answers *does the feature exist?* (feature breadth). Whether it is good
@@@ -293,10 -293,10 +293,10 @@@ differences and missing bindings are i
| LR-MASK-SUBJECT | Select subject | P2 | 🟡 | `cmd:mask.add` (`subject`), `crates/pipeline/src/masks.rs` | saliency heuristic, no segmentation model; a photo that carries person mattes (DNG semantic masks: iPhone ProRAW portrait / skin / hair / teeth / glasses mattes) uses them instead (synthetic files only: no corpus file carries person mattes) |
| LR-MASK-SKY | Select sky | P2 | 🟡 | `cmd:mask.add` (`sky`), `crates/pipeline/src/masks.rs` (`Mattes`), `crates/raw/src/semantic.rs` | heuristic; a photo that carries a sky matte (DNG semantic mask, e.g. iPhone ProRAW) uses it instead, through orientation / crop / lens corrections, preview = export (checked on one CC0 iPhone 12 Pro ProRAW and synthetic files) |
| LR-MASK-BACKGROUND | Select background | P2 | 🟡 | `cmd:mask.add` (`background`) | inverse of the subject mask (heuristic, or the photo's person mattes) |
-| LR-MASK-OBJECTS | Object selection | P2 | 🟡 | `cmd:mask.add` (`object`, `prompt`), `cmd:mask.objectPoint`, `cmd:mask.refineDetail`, `cmd:segment.prepare`, `cmd:segment.model.status`, `cmd:segment.model.download`, `cmd:segment.model.cancel`, `cmd:app.openSamModelFolder`, `crates/segment`, `crates/engine/src/segment/mod.rs` | SAM 3 in pure Rust (candle; Metal on macOS, CPU elsewhere): Object tile → click to include, ⌥-click to leave out; Describe tile → a text prompt selects every instance ("sky", "the red car"); both also as Add/Subtract/Intersect components; + / − under the selected mask; comma lists (`car, road`); a zoomed-in detail pass for 5–10× finer edges on small objects; per-selection Edge (hard ↔ soft). The model runs on its own worker thread (the UI never waits; panics become errors; a job that fails on the Mac's GPU runs again on the CPU, which then serves the rest of the session, #1974), is unloaded after 10 min idle, and is optional: the segmentation is stored with the mask (288² logits), so renders and exports never need it. Weights are never bundled (SAM License): without them the app offers a consented background download (mirrors, resume, timeouts, SHA-256) — **but no default download location is configured yet** (users set `LIGHTCRAFT_SAM3_MIRRORS` or install by hand: the dialog names the three files, opens the configured model folder with the host opener, preserves setup on an open error, and links docs/ai-masks.md). Not verified against Lightroom's Select Object; no brush/box object mode; the first click on a photo waits for its analysis (~4 s on an M4 Pro, much longer on CPU) |
+| LR-MASK-OBJECTS | Object selection | P2 | 🟡 | `cmd:mask.add` (`object`, `prompt`), `cmd:mask.objectPoint`, `cmd:mask.refineDetail`, `cmd:segment.prepare`, `cmd:segment.model.status`, `cmd:segment.model.download`, `cmd:segment.model.cancel`, `cmd:app.openSamModelFolder`, `crates/segment`, `crates/engine/src/segment.rs` | SAM 3 in pure Rust (candle; Metal on macOS, CPU elsewhere): Object tile → click to include, ⌥-click to leave out; Describe tile → a text prompt selects every instance ("sky", "the red car"); both also as Add/Subtract/Intersect components; + / − under the selected mask; comma lists (`car, road`); a zoomed-in detail pass for 5–10× finer edges on small objects; per-selection Edge (hard ↔ soft). The model runs on its own worker thread (the UI never waits; panics become errors; a job that fails on the Mac's GPU runs again on the CPU, which then serves the rest of the session, #1974), is unloaded after 10 min idle, and is optional: the segmentation is stored with the mask (288² logits), so renders and exports never need it. Weights are never bundled (SAM License): without them the app offers a consented background download (mirrors, resume, timeouts, SHA-256) — **but no default download location is configured yet** (users set `LIGHTCRAFT_SAM3_MIRRORS` or install by hand: the dialog names the three files, opens the configured model folder with the host opener, preserves setup on an open error, and links docs/ai-masks.md). Not verified against Lightroom's Select Object; no brush/box object mode; the first click on a photo waits for its analysis (~4 s on an M4 Pro, much longer on CPU) |
| LR-MASK-PEOPLE | People parts | P2 | ⬜ | | shape exists (no UI): uses the photo's person / skin / hair / teeth / glasses mattes when it carries them (DNG semantic masks), else the subject heuristic |
| LR-MASK-LANDSCAPE | Landscape classes | P2 | ⬜ | | shape exists, evaluates empty |
- | LR-MASK-BRUSH | Brush mask | P0 | 🟡 | `cmd:tool.brush`, `cmd:mask.brushStroke` (`autoMask`), `crates/pipeline/src/masks.rs`, `crates/ui-egui/src/brush_live.rs` | size/feather/flow/density/erase; Create New Mask starts a separate brush in paint mode; the stroke shows while the button is held with the committed stroke's dab spacing, feather and flow, so fast strokes have no gaps (#517); coverage builds up by passes, not hold time (holding the brush still adds nothing, live or committed, #518); oversized path segments skip intermediate dabs instead of allocating a million samples; Auto Mask: dabs weighted by similarity to the colour under the dab centre, refined by a guided filter on luminance (CPU + GPU); ⇧-click draws a straight stroke from where the last stroke ended (`connect`), tapering size, feather and flow from that stroke's values when they changed; no A/B brushes; pen pressure (Brush ▸ Pen Pressure, on by default; `pressure` per point in `mask.brushStroke`) scales each dab's size (a tenth to all of it) and flow, live and committed alike, where winit reports a pen force (Windows; not macOS / Linux tablets yet); no tilt |
-| LR-MASK-BRUSH | Brush mask | P0 | 🟡 | `cmd:tool.brush`, `cmd:mask.brushStroke` (`autoMask`), `crates/pipeline/src/masks.rs`, `crates/ui-egui/src/brush_live.rs` | size/feather/flow/density/erase; Create New Mask starts a separate brush in paint mode; the stroke shows while the button is held with the committed stroke's dab spacing, feather and flow, so fast strokes have no gaps (#517); with the mask overlay hidden (O / the eye, or after a mask slider hid it) or a colour overlay at opacity 0 it is not tinted while painting either, so dodging and burning is judged on the photo, and its effect shows once the stroke is committed (#2549); coverage builds up by passes, not hold time (holding the brush still adds nothing, live or committed, #518); Auto Mask: dabs weighted by similarity to the colour under the dab centre, refined by a guided filter on luminance (CPU + GPU); ⇧-click draws a straight stroke from where the last stroke ended (`connect`), tapering size, feather and flow from that stroke's values when they changed; no A/B brushes; pen pressure (Brush ▸ Pen Pressure, on by default; `pressure` per point in `mask.brushStroke`) scales each dab's size (a tenth to all of it) and flow, live and committed alike, where winit reports a pen force (Windows; not macOS / Linux tablets yet); no tilt |
++| LR-MASK-BRUSH | Brush mask | P0 | 🟡 | `cmd:tool.brush`, `cmd:mask.brushStroke` (`autoMask`), `crates/pipeline/src/masks.rs`, `crates/ui-egui/src/brush_live.rs` | size/feather/flow/density/erase; Create New Mask starts a separate brush in paint mode; the stroke shows while the button is held with the committed stroke's dab spacing, feather and flow, so fast strokes have no gaps (#517); with the mask overlay hidden (O / the eye, or after a mask slider hid it) or a colour overlay at opacity 0 it is not tinted while painting either, so dodging and burning is judged on the photo, and its effect shows once the stroke is committed (#2549); coverage builds up by passes, not hold time (holding the brush still adds nothing, live or committed, #518); oversized path segments skip intermediate dabs instead of allocating a million samples; Auto Mask: dabs weighted by similarity to the colour under the dab centre, refined by a guided filter on luminance (CPU + GPU); ⇧-click draws a straight stroke from where the last stroke ended (`connect`), tapering size, feather and flow from that stroke's values when they changed; no A/B brushes; pen pressure (Brush ▸ Pen Pressure, on by default; `pressure` per point in `mask.brushStroke`) scales each dab's size (a tenth to all of it) and flow, live and committed alike, where winit reports a pen force (Windows; not macOS / Linux tablets yet); no tilt |
| LR-MASK-LINEAR | Linear gradient | P0 | ✅ | `cmd:tool.linear`, `cmd:mask.update` | |
| LR-MASK-RADIAL | Radial gradient | P0 | ✅ | `cmd:tool.radial`, `cmd:mask.update`, `crates/ui-egui/src/panels/detail.rs` | drag the selected ellipse's body or centre pin to move; edge grips resize, outer grip rotates; rotated and compound radial components, hidden pins, outside hit rejection and one-step undo tested |
| LR-MASK-COLORRANGE | Colour range | P1 | ✅ | `cmd:mask.add` (`colorRange`), `cmd:mask.sampleColor`, `cmd:mask.update`, `crates/pipeline/src/lib.rs` (`color_range_sample`) | Color tile → click the photo to sample (⇧-click adds, up to 5; samples taken in the space the mask compares in, respecting section eyes and the requested HDR/SDR rendition), Pick button, Refine slider |