LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LR-MASK-EFFECTS: mask effect (brush) presets and Lightroom local preset import
OneSlips594c046d5214
diff --git a/crates/engine/src/cmd/mask_effects.rs b/crates/engine/src/cmd/mask_effects.rsnew file mode 100644index 000000000..64b9fcac5--- /dev/null+++ b/crates/engine/src/cmd/mask_effects.rs@@ -0,0 +1,379 @@+//! Mask effect presets: named sets of local adjustment sliders picked from the Masking panel's+//! Effect menu (Lightroom's local adjustment / brush presets), saved with the library preferences.+//! Imported from Lightroom `.lrtemplate` local presets (`type = "LocalizedAdjustmentPreset"`)+//! and our own `.lceffect` JSON files.++use lightcraft_develop::LocalAdjustments;+use serde::{Deserialize, Serialize};+use serde_json::{Value, json};++use super::{CommandSpec, always, bad, cmd, has_active, str_param};+use crate::preset_import::{Lua, parse_lua};+use crate::{Result, Session};++/// File extension of exported effect presets (JSON).+pub const EFFECT_EXT: &str = "lceffect";+/// `format` tag of an exported effect-preset file.+const FILE_FORMAT: &str = "lightcraft.maskEffects";+/// The Lua `type` of a Lightroom local adjustment preset.+const LR_LOCAL_TYPE: &str = "LocalizedAdjustmentPreset";++/// A named set of local adjustment sliders. Applying one sets every slider of the mask (those the+/// preset doesn't name go to 0); the mask's Amount stays.+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]+#[serde(default)]+pub struct MaskEffect {+ pub name: String,+ pub adjust: LocalAdjustments,+}++impl MaskEffect {+ /// `a` with this preset's sliders and `a`'s Amount.+ pub fn apply(&self, a: &LocalAdjustments) -> LocalAdjustments {+ LocalAdjustments { amount: a.amount, ..self.adjust }+ }+ /// Does `a` carry exactly this preset's sliders (Amount aside)?+ pub fn matches(&self, a: &LocalAdjustments) -> bool {+ let strip = |a: &LocalAdjustments| LocalAdjustments { amount: 100.0, ..*a };+ let (x, y) = (serde_json::to_value(strip(&self.adjust)).unwrap_or_default(), serde_json::to_value(strip(a)).unwrap_or_default());+ match (x.as_object(), y.as_object()) {+ (Some(x), Some(y)) => x.iter().all(|(k, v)| {+ let (p, q) = (v.as_f64().unwrap_or(0.0), y.get(k).and_then(Value::as_f64).unwrap_or(0.0));+ (p - q).abs() < 1e-6+ }),+ _ => false,+ }+ }+}++/// Name of the effect the mask adjustments `a` match, if any.+pub fn matching_effect(s: &Session, a: &LocalAdjustments) -> Option<String> {+ s.mask_effects.iter().find(|e| e.matches(a)).map(|e| e.name.clone())+}++/// Add or replace (same name, ignoring case) an effect.+fn upsert(s: &mut Session, e: MaskEffect) {+ match s.mask_effects.iter_mut().find(|x| x.name.eq_ignore_ascii_case(&e.name)) {+ Some(x) => *x = e,+ None => s.mask_effects.push(e),+ }+}++fn name_param(p: &Value, c: &str) -> Result<String> {+ str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).map(str::to_string).ok_or_else(|| bad(c, "missing `name`"))+}++/// The selected mask's adjustments on the active photo.+fn selected_adjust(s: &Session, p: &Value, c: &str) -> Result<(u32, LocalAdjustments)> {+ let id = s.active().ok_or_else(|| bad(c, "no active photo"))?;+ let mid = p.get("id").and_then(Value::as_u64).map(|v| v as u32).or(s.active_mask).ok_or_else(|| bad(c, "no mask selected (give `id`)"))?;+ let d = s.develop_of(id).unwrap_or_default();+ let m = d.masks.iter().find(|m| m.id == mid).ok_or_else(|| bad(c, format!("no mask {mid}")))?;+ Ok((mid, m.adjust))+}++fn list(s: &Session) -> Value {+ let current = s+ .active()+ .and_then(|id| s.develop_of(id))+ .and_then(|d| s.active_mask.and_then(|mid| d.masks.iter().find(|m| m.id == mid).map(|m| m.adjust)))+ .and_then(|a| matching_effect(s, &a));+ json!({"effects": s.mask_effects, "current": current})+}++fn apply_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.applyEffect";+ let name = name_param(p, C)?;+ let effect = s.mask_effects.iter().find(|x| x.name.eq_ignore_ascii_case(&name)).cloned().ok_or_else(|| bad(C, format!("no effect `{name}`")))?;+ let (mid, _) = selected_adjust(s, p, C)?;+ let id = s.active().ok_or_else(|| bad(C, "no active photo"))?;+ let mut d = (*s.develop_of(id).unwrap_or_default()).clone();+ let m = d.masks.iter_mut().find(|m| m.id == mid).ok_or_else(|| bad(C, format!("no mask {mid}")))?;+ m.adjust = super::masks::clamp_local(effect.apply(&m.adjust));+ s.set_develop(id, d, &format!("Mask Effect: {}", effect.name))?;+ Ok(json!({"name": effect.name, "mask": mid}))+}++fn save_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.saveEffect";+ let name = name_param(p, C)?;+ let (_, adjust) = selected_adjust(s, p, C)?;+ upsert(s, MaskEffect { name, adjust: LocalAdjustments { amount: 100.0, ..adjust } });+ s.save_prefs()?;+ Ok(list(s))+}++fn delete_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.deleteEffect";+ let name = name_param(p, C)?;+ let n = s.mask_effects.len();+ s.mask_effects.retain(|x| !x.name.eq_ignore_ascii_case(&name));+ if n == s.mask_effects.len() {+ return Err(bad(C, format!("no effect `{name}`")));+ }+ s.save_prefs()?;+ Ok(list(s))+}++/// Is `text` a Lightroom local adjustment preset (`.lrtemplate`)?+pub fn is_lr_local_template(text: &str) -> bool {+ parse_lua(text.trim_start_matches('\u{feff}'))+ .ok()+ .and_then(|root| root.get("type").and_then(Lua::str).map(|t| t == LR_LOCAL_TYPE))+ .unwrap_or(false)+}++/// A Lightroom local adjustment preset → an effect named after its title (else `stem`), and the+/// non-zero sliders we have no equivalent for (e.g. `toningLuminance`, `grain`).+pub fn parse_lr_local_template(text: &str, stem: &str) -> std::result::Result<(MaskEffect, Vec<String>), String> {+ let root = parse_lua(text.trim_start_matches('\u{feff}'))?;+ if root.get("type").and_then(Lua::str) != Some(LR_LOCAL_TYPE) {+ return Err("not a local adjustment preset".into());+ }+ let Some(Lua::Table(_, fields)) = root.get("value") else { return Err("no adjustments in this local preset".into()) };+ // `exposure2012` → `LocalExposure2012`: the template's keys are the XMP `Local*` names, lower camel case+ let crs = |k: &str| {+ let mut c = k.chars();+ c.next().map(|f| format!("Local{}{}", f.to_ascii_uppercase(), c.as_str())).unwrap_or_default()+ };+ let num = |k: &str| fields.iter().find(|(f, _)| crs(f) == k).and_then(|(_, v)| if let Lua::Num(n) = v { Some(*n) } else { None });+ let values = crate::crs_masks::local_values(num);+ let unmapped: Vec<String> = fields+ .iter()+ .filter(|(k, v)| matches!(v, Lua::Num(n) if n.abs() > 1e-9) && !crate::crs_masks::is_local_field(&crs(k)))+ // a colour tint's hue without saturation does nothing+ .filter(|(k, _)| k != "toningHue")+ .map(|(k, _)| k.clone())+ .collect();+ let adjust: LocalAdjustments = serde_json::from_value(Value::Object(values)).map_err(|e| format!("unreadable local preset: {e}"))?;+ let title = root.get("title").or_else(|| root.get("internalName")).and_then(Lua::str).map(str::trim).filter(|t| !t.is_empty());+ let name =+ title.map(|t| t.strip_prefix("$$$/").and_then(|r| r.split_once('=')).map_or(t, |(_, d)| d).to_string()).unwrap_or_else(|| stem.to_string());+ Ok((MaskEffect { name, adjust: super::masks::clamp_local(LocalAdjustments { amount: 100.0, ..adjust }) }, unmapped))+}++/// Effects in an `.lceffect` file: `{format, version, effects: [...]}`, a bare array, or one effect.+pub fn parse_file(bytes: &[u8]) -> std::result::Result<Vec<MaskEffect>, String> {+ let v: Value = serde_json::from_slice(bytes).map_err(|e| format!("not an effect preset file: {e}"))?;+ let items = match &v {+ Value::Object(o) if o.contains_key("effects") => o["effects"].clone(),+ Value::Array(_) => v.clone(),+ Value::Object(_) => Value::Array(vec![v.clone()]),+ _ => return Err("not an effect preset file".into()),+ };+ let list: Vec<MaskEffect> = serde_json::from_value(items).map_err(|e| format!("not an effect preset file: {e}"))?;+ let list: Vec<MaskEffect> = list+ .into_iter()+ .filter(|e| !e.name.trim().is_empty())+ .map(|e| MaskEffect { name: e.name.trim().to_string(), adjust: super::masks::clamp_local(LocalAdjustments { amount: 100.0, ..e.adjust }) })+ .collect();+ if list.is_empty() {+ return Err("no effect presets in the file".into());+ }+ Ok(list)+}++/// Effects in file `path` (`.lrtemplate` or `.lceffect`) with the sliders each one couldn't keep.+pub fn read_file(path: &str) -> std::result::Result<Vec<(MaskEffect, Vec<String>)>, String> {+ let bytes = std::fs::read(path).map_err(|e| e.to_string())?;+ let p = std::path::Path::new(path);+ let stem = p.file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_else(|| "Effect".into());+ match p.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).as_deref() {+ Some("lrtemplate") => parse_lr_local_template(&String::from_utf8_lossy(&bytes), &stem).map(|e| vec![e]),+ _ => parse_file(&bytes).map(|v| v.into_iter().map(|e| (e, Vec::new())).collect()),+ }+}++/// Add `effects` (same-named ones replaced) and save → the import report rows.+pub fn add_effects(s: &mut Session, effects: Vec<(MaskEffect, Vec<String>, String)>) -> Result<Vec<Value>> {+ let rows: Vec<Value> = effects.iter().map(|(e, unmapped, file)| json!({"name": e.name, "file": file, "unmapped": unmapped})).collect();+ let any = !effects.is_empty();+ for (e, _, _) in effects {+ upsert(s, e);+ }+ if any {+ s.save_prefs()?;+ }+ Ok(rows)+}++/// The files under `paths` (folders walked, at most 8 levels) an effect import reads.+fn effect_files(paths: &[String]) -> Vec<String> {+ fn walk(dir: &std::path::Path, depth: usize, out: &mut Vec<String>) {+ let Ok(rd) = std::fs::read_dir(dir) else { return };+ let mut entries: Vec<_> = rd.flatten().map(|e| e.path()).collect();+ entries.sort();+ for p in entries {+ if p.is_dir() {+ if depth < 8 {+ walk(&p, depth + 1, out);+ }+ } else if p.extension().is_some_and(|e| e.eq_ignore_ascii_case("lrtemplate") || e.eq_ignore_ascii_case(EFFECT_EXT)) {+ out.push(p.to_string_lossy().to_string());+ }+ }+ }+ let mut out = Vec::new();+ for x in paths {+ let p = std::path::Path::new(x);+ if p.is_dir() {+ walk(p, 0, &mut out);+ } else {+ out.push(x.clone());+ }+ }+ out+}++fn import_effects(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.importEffects";+ let mut paths: Vec<String> =+ p.get("paths").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect()).unwrap_or_default();+ if let Some(x) = str_param(p, "path") {+ paths.push(x.to_string());+ }+ if paths.is_empty() {+ return Err(bad(C, "missing `path` / `paths`"));+ }+ let (mut ok, mut failed) = (Vec::new(), Vec::new());+ for f in effect_files(&paths) {+ match read_file(&f) {+ Ok(list) => ok.extend(list.into_iter().map(|(e, u)| (e, u, f.clone()))),+ Err(e) => failed.push(json!([f, e])),+ }+ }+ let imported = add_effects(s, ok)?;+ Ok(json!({"imported": imported, "failed": failed}))+}++fn export_effects(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.exportEffects";+ let path = str_param(p, "path").filter(|x| !x.trim().is_empty()).ok_or_else(|| bad(C, "missing `path`"))?;+ let mut path = std::path::PathBuf::from(path);+ if path.extension().is_none() {+ path.set_extension(EFFECT_EXT);+ }+ let names: Option<Vec<String>> =+ p.get("names").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());+ let chosen: Vec<&MaskEffect> =+ s.mask_effects.iter().filter(|e| names.as_ref().is_none_or(|n| n.iter().any(|x| x.eq_ignore_ascii_case(&e.name)))).collect();+ if chosen.is_empty() {+ return Err(bad(C, "no effect presets to export"));+ }+ if let Some(dir) = path.parent().filter(|d| !d.as_os_str().is_empty()) {+ std::fs::create_dir_all(dir).map_err(|e| crate::EngineError::Other(format!("{}: {e}", dir.display())))?;+ }+ let text = serde_json::to_string_pretty(&json!({"format": FILE_FORMAT, "version": 1, "effects": chosen})).unwrap_or_default();+ std::fs::write(&path, text).map_err(|e| crate::EngineError::Other(format!("{}: {e}", path.display())))?;+ Ok(json!({"path": path.display().to_string(), "count": chosen.len()}))+}++pub fn specs() -> Vec<CommandSpec> {+ vec![+ cmd!(+ query "mask.effects",+ "Mask Effect Presets",+ [],+ None,+ "{} → {effects: [{name, adjust: {exposure, contrast, …}}], current: name of the effect the selected mask's sliders match, or null}",+ always,+ |s, _| Ok(list(s))+ ),+ cmd!(+ "mask.applyEffect",+ "Apply Mask Effect",+ [],+ None,+ "{name, id?} — sets every slider of the selected mask (or mask `id`) from the effect preset; Amount stays",+ has_active,+ apply_effect+ ),+ cmd!(+ "mask.saveEffect",+ "Save Mask Effect",+ [],+ None,+ "{name, id?} — the selected mask's sliders as an effect preset (replaces one of that name), saved with the library",+ has_active,+ save_effect+ ),+ cmd!("mask.deleteEffect", "Delete Mask Effect", [], None, "{name} — removes an effect preset", always, delete_effect),+ cmd!(+ "mask.importEffects",+ "Import Mask Effects",+ [],+ None,+ "{path | paths: [file or folder]} — Lightroom local adjustment presets (.lrtemplate) and .lceffect files; same-named effects are replaced → {imported: [{name, file, unmapped}], failed: [[file, error]]}",+ always,+ import_effects+ ),+ cmd!(+ "mask.exportEffects",+ "Export Mask Effects",+ [],+ None,+ "{path, names?: [name] (default: all)} — writes an .lceffect JSON file → {path, count}",+ always,+ export_effects+ ),+ ]+}++#[cfg(test)]+mod tests {+ use super::*;++ // A synthetic template in the shape Lightroom writes (our own values).+ const TEMPLATE: &str = r#"s = {+ id = "00000000-0000-0000-0000-000000000001",+ internalName = "Soft Glow",+ title = "Soft Glow",+ type = "LocalizedAdjustmentPreset",+ value = {+ clarity = 0.5,+ clarity2012 = -0.25,+ exposure = 0,+ exposure2012 = 0.125,+ highlights2012 = -0.5,+ temperature = 0.2,+ texture = -0.3,+ toningHue = 240,+ toningLuminance = 0.1,+ toningSaturation = 0,+ },+ version = 0,+}"#;++ #[test]+ fn reads_a_lightroom_local_template() {+ assert!(is_lr_local_template(TEMPLATE));+ let (e, unmapped) = parse_lr_local_template(TEMPLATE, "file").unwrap();+ assert_eq!(e.name, "Soft Glow");+ assert!((e.adjust.exposure - 0.5).abs() < 1e-9, "exposure2012 is a quarter of the stops");+ assert!((e.adjust.clarity + 25.0).abs() < 1e-9, "the 2012 field wins over the old one");+ assert!((e.adjust.highlights + 50.0).abs() < 1e-9);+ assert!((e.adjust.temp - 20.0).abs() < 1e-9);+ assert!((e.adjust.texture + 30.0).abs() < 1e-9);+ assert!((e.adjust.amount - 100.0).abs() < 1e-9);+ assert_eq!(unmapped, vec!["toningLuminance".to_string()]);+ }++ #[test]+ fn develop_templates_are_not_local_ones() {+ let develop = r#"s = { title = "X", type = "Develop", value = { settings = { Exposure2012 = 1 } } }"#;+ assert!(!is_lr_local_template(develop));+ assert!(parse_lr_local_template(develop, "x").is_err());+ assert!(parse_lr_local_template("garbage {", "x").is_err());+ assert!(parse_lr_local_template(r#"s = { type = "LocalizedAdjustmentPreset", value = 3 }"#, "x").is_err());+ }++ #[test]+ fn apply_keeps_amount_and_matches_ignore_it() {+ let e = MaskEffect { name: "E".into(), adjust: LocalAdjustments { exposure: 1.0, ..Default::default() } };+ let current = LocalAdjustments { shadows: 40.0, amount: 60.0, ..Default::default() };+ let out = e.apply(¤t);+ assert_eq!((out.exposure, out.shadows, out.amount), (1.0, 0.0, 60.0));+ assert!(e.matches(&out));+ assert!(!e.matches(¤t));+ }+}diff --git a/crates/engine/src/cmd/masks.rs b/crates/engine/src/cmd/masks.rsindex ae8b862b6..d05f80abb 100644--- a/crates/engine/src/cmd/masks.rs+++ b/crates/engine/src/cmd/masks.rs@@ -971,7 +971,7 @@ fn pick_source(s: &mut Session, id: crate::PhotoId, d: &lightcraft_develop::Develightcraft_pipeline::spots::pick_source(&src, &info, d, spot, avoid)}-fn clamp_local(mut a: LocalAdjustments) -> LocalAdjustments {+pub(crate) fn clamp_local(mut a: LocalAdjustments) -> LocalAdjustments {let c = |v: &mut f64, lo: f64, hi: f64| *v = if v.is_finite() { v.clamp(lo, hi) } else { 0.0 };c(&mut a.exposure, -4.0, 4.0);for v in [diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rsindex 4de460761..36b242741 100644--- a/crates/engine/src/cmd/mod.rs+++ b/crates/engine/src/cmd/mod.rs@@ -24,6 +24,7 @@ pub mod keywords;pub mod library;pub mod lut_profiles;pub mod manage;+pub mod mask_effects;mod masks;mod merge;pub mod metadata;@@ -145,6 +146,7 @@ pub fn command_specs() -> &'static [CommandSpec] {v.extend(manage::specs());v.extend(previews::specs());v.extend(lut_profiles::specs());+ v.extend(mask_effects::specs());v.extend(cull::specs());v.extend(convert::specs());v.extend(convert::edit_specs());diff --git a/crates/engine/src/cmd/preset_files.rs b/crates/engine/src/cmd/preset_files.rsindex fc385f34c..ec31130d4 100644--- a/crates/engine/src/cmd/preset_files.rs+++ b/crates/engine/src/cmd/preset_files.rs@@ -18,9 +18,22 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {let mut imported = Vec::new();let mut failed = Vec::new();let mut skipped = 0usize;+ // Lightroom local adjustment (brush) presets become mask effects+ let mut effects = Vec::new();for top in &paths {let from_dir = std::path::Path::new(top).is_dir();for f in expand_preset_paths(std::slice::from_ref(top)) {+ if f.to_ascii_lowercase().ends_with(".lrtemplate") {+ let text = std::fs::read(&f).map(|b| String::from_utf8_lossy(&b).to_string()).unwrap_or_default();+ if super::mask_effects::is_lr_local_template(&text) {+ let stem = std::path::Path::new(&f).file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_default();+ match super::mask_effects::parse_lr_local_template(&text, &stem) {+ Ok((e, unmapped)) => effects.push((e, unmapped, f.clone())),+ Err(e) => failed.push(json!([f, e])),+ }+ continue;+ }+ }// presets in a folder go to a group named after it (unless the file names its own)// the path from the imported folder (inclusive) to the file's folderlet base = std::path::Path::new(top).parent().unwrap_or(std::path::Path::new(""));@@ -45,7 +58,12 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {}}}- Ok(json!({"imported": imported, "skipped": skipped, "failed": failed}))+ let effects = if dry {+ effects.iter().map(|(e, unmapped, file)| json!({"name": e.name, "file": file, "unmapped": unmapped})).collect()+ } else {+ super::mask_effects::add_effects(s, effects)?+ };+ Ok(json!({"imported": imported, "skipped": skipped, "failed": failed, "effects": effects}))}fn export(s: &mut Session, p: &Value) -> Result<Value> {@@ -83,7 +101,7 @@ pub fn specs() -> Vec<CommandSpec> {"Import Presets",[],None,- "{paths: [file or folder], group?, dryRun?} — .lcpreset, XMP presets, .lrtemplate, photos carrying edits (DNG/JPEG/TIFF \"DNG presets\"), Luminar looks (.lmp, .mplumpack collections) and .zip bundles of these; folders give their name as group; crs: fields mapped per docs/xmp-interop.md → {imported: [{id,name,group,file,unmapped}], skipped, failed}",+ "{paths: [file or folder], group?, dryRun?} — .lcpreset, XMP presets, .lrtemplate, photos carrying edits (DNG/JPEG/TIFF \"DNG presets\"), Luminar looks (.lmp, .mplumpack collections) and .zip bundles of these; folders give their name as group; crs: fields mapped per docs/xmp-interop.md; Lightroom local adjustment presets (.lrtemplate) become mask effects (`mask.effects`) → {imported: [{id,name,group,file,unmapped}], skipped, failed, effects: [{name,file,unmapped}]}",always,import),diff --git a/crates/engine/src/crs_masks.rs b/crates/engine/src/crs_masks.rsindex 483d1778b..798555e4f 100644--- a/crates/engine/src/crs_masks.rs+++ b/crates/engine/src/crs_masks.rs@@ -64,13 +64,20 @@ const LOCAL: &[(&str, &str, f64)] = &[("LocalClarity", "clarity", 100.0),];-fn adjust(c: &XmpValue) -> Value {+/// Is `crs` (without the `crs:` prefix) a local slider field we map?+pub(crate) fn is_local_field(crs: &str) -> bool {+ LOCAL.iter().any(|(k, _, _)| *k == crs)+}++/// Our local adjustment values from the `Local*` slider fields that `get` finds (the name without+/// the `crs:` prefix → the stored fraction); process-version 2012 fields win over the older ones.+pub(crate) fn local_values(get: impl Fn(&str) -> Option<f64>) -> serde_json::Map<String, Value> {let mut a = serde_json::Map::new();for (crs, ours, k) in LOCAL {if a.contains_key(*ours) {continue;}- if let Some(v) = num(c, &format!("crs:{crs}")) {+ if let Some(v) = get(crs).filter(|v| v.is_finite()) {let lim = if *ours == "exposure" {4.0} else if *ours == "color_hue" {@@ -82,6 +89,11 @@ fn adjust(c: &XmpValue) -> Value {a.insert((*ours).into(), json!(v));}}+ a+}++fn adjust(c: &XmpValue) -> Value {+ let mut a = local_values(|crs| num(c, &format!("crs:{crs}")));let amount = num(c, "crs:CorrectionAmount").unwrap_or(1.0);a.insert("amount".into(), json!((amount * 100.0).clamp(0.0, 200.0)));Value::Object(a)diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 3bc6c431e..b8114eaf2 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -257,6 +257,8 @@ pub struct Session {/// The user's point-curve presets (`curve.*`; built-ins: [`cmd::curves::builtin_presets`]),/// persisted in prefs.json.pub curve_presets: Vec<cmd::curves::CurvePreset>,+ /// Mask effect presets (the Masking panel's Effect menu).+ pub mask_effects: Vec<cmd::mask_effects::MaskEffect>,/// Saved colour-label name sets.pub label_sets: Vec<cmd::manage::LabelSet>,/// Look-alike signatures by content key (Find Similar).@@ -373,6 +375,7 @@ impl Session {metadata_presets: Vec::new(),filter_presets: Vec::new(),curve_presets: Vec::new(),+ mask_effects: Vec::new(),label_sets: Vec::new(),signatures: Default::default(),lut_profiles: Vec::new(),diff --git a/crates/engine/src/library.rs b/crates/engine/src/library.rsindex 2bb5511c2..36a7378f6 100644--- a/crates/engine/src/library.rs+++ b/crates/engine/src/library.rs@@ -167,6 +167,8 @@ struct PrefsFile {filter_presets: Vec<crate::cmd::filters::FilterPreset>,/// Point-curve presets.curve_presets: Vec<crate::cmd::curves::CurvePreset>,+ /// Mask effect presets.+ mask_effects: Vec<crate::cmd::mask_effects::MaskEffect>,/// Colour-label name sets.label_sets: Vec<crate::cmd::manage::LabelSet>,/// Imported LUT profiles.@@ -396,6 +398,7 @@ impl Session {self.metadata_presets = prefs.metadata_presets;self.filter_presets = prefs.filter_presets;self.curve_presets = prefs.curve_presets;+ self.mask_effects = prefs.mask_effects;self.label_sets = prefs.label_sets;self.lut_profiles = prefs.lut_profiles;crate::cmd::lut_profiles::register_all(self);@@ -631,6 +634,7 @@ impl Session {metadata_presets: self.metadata_presets.clone(),filter_presets: self.filter_presets.clone(),curve_presets: self.curve_presets.clone(),+ mask_effects: self.mask_effects.clone(),label_sets: self.label_sets.clone(),lut_profiles: self.lut_profiles.clone(),keyword_sets: self.keyword_sets.clone(),diff --git a/crates/engine/src/tests_prefs.rs b/crates/engine/src/tests_prefs.rsindex 3534064f2..494b17ede 100644--- a/crates/engine/src/tests_prefs.rs+++ b/crates/engine/src/tests_prefs.rs@@ -265,6 +265,60 @@ fn curve_presets_save_apply_export_import_and_persist() {let _ = std::fs::remove_dir_all(&lib);}+#[test]+fn mask_effects_import_apply_save_export_and_persist() {+ let lib = temp_dir("effects");+ let src = lib.join("Local Adjustment Presets");+ std::fs::create_dir_all(&src).unwrap();+ // a Lightroom local adjustment preset (synthetic values) and a develop template beside it+ std::fs::write(+ src.join("Brighten.lrtemplate"),+ "s = {\n\ttitle = \"Brighten\",\n\ttype = \"LocalizedAdjustmentPreset\",\n\tvalue = {\n\t\texposure2012 = 0.25,\n\t\tshadows2012 = 0.2,\n\t\tgrain = 0.3,\n\t},\n\tversion = 0,\n}",+ )+ .unwrap();+ std::fs::write(src.join("Look.lrtemplate"), "s = { title = \"Look\", type = \"Develop\", value = { settings = { Exposure2012 = 0.5 } } }")+ .unwrap();+ {+ let mut s = Session::new().with_fs();+ s.open_library(&lib, true).unwrap();+ // the general preset import routes the local one to the effects+ let r = s.execute("preset.import", &json!({"paths": [src.to_string_lossy()]})).unwrap();+ assert_eq!(r["imported"].as_array().unwrap().len(), 1, "the develop template stays a develop preset");+ assert_eq!(r["effects"][0]["name"], "Brighten");+ assert_eq!(r["effects"][0]["unmapped"], json!(["grain"]));+ assert_eq!(s.mask_effects.len(), 1);+ // apply to a mask: every slider set, Amount kept+ s.execute("mask.add", &json!({"kind": "radial"})).unwrap();+ s.execute("mask.adjust", &json!({"values": {"clarity": 30, "amount": 70}})).unwrap();+ assert!(s.execute("mask.applyEffect", &json!({"name": "nope"})).is_err());+ s.execute("mask.applyEffect", &json!({"name": "brighten"})).unwrap();+ let d = s.develop_of(s.active().unwrap()).unwrap();+ let a = d.masks.last().unwrap().adjust;+ assert_eq!((a.exposure, a.shadows, a.clarity, a.amount), (1.0, 20.0, 0.0, 70.0));+ assert_eq!(s.execute("mask.effects", &json!({})).unwrap()["current"], "Brighten");+ // save the mask's sliders under a new name, export, delete, re-import+ s.execute("mask.adjust", &json!({"values": {"dehaze": 15}})).unwrap();+ s.execute("mask.saveEffect", &json!({"name": "Brighten + Dehaze"})).unwrap();+ let r = s.execute("mask.exportEffects", &json!({"path": lib.join("out").join("mine").to_string_lossy()})).unwrap();+ assert_eq!(r["count"], 2);+ let path = r["path"].as_str().unwrap().to_string();+ assert!(path.ends_with(".lceffect"));+ s.execute("mask.deleteEffect", &json!({"name": "brighten + dehaze"})).unwrap();+ assert!(s.execute("mask.deleteEffect", &json!({"name": "brighten + dehaze"})).is_err());+ let r = s.execute("mask.importEffects", &json!({"path": path})).unwrap();+ assert_eq!(r["imported"].as_array().unwrap().len(), 2);+ assert_eq!(s.mask_effects.len(), 2, "same-named effects are replaced");+ s.close_library().unwrap();+ }+ // saved with the library preferences+ let mut s = Session::new().with_fs();+ s.open_library(&lib, false).unwrap();+ let names: Vec<String> = s.mask_effects.iter().map(|e| e.name.clone()).collect();+ assert_eq!(names, ["Brighten", "Brighten + Dehaze"]);+ assert_eq!(s.mask_effects[1].adjust.dehaze, 15.0);+ let _ = std::fs::remove_dir_all(&lib);+}+#[test]fn resizing_the_disk_cache_keeps_the_cache_and_its_thumbnails() {let lib = temp_dir("resize");diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rsindex daf0f08e0..81811fe0e 100644--- a/crates/ui-egui/src/menus.rs+++ b/crates/ui-egui/src/menus.rs@@ -1559,9 +1559,14 @@ pub fn run_ui_command(app: &mut LightcraftApp, id: &str, p: &Value) -> Option<Reif let (false, Ok(v)) = (preset_paths.is_empty(), &r) {let n = v["imported"].as_array().map_or(0, Vec::len);let failed = v["failed"].as_array().map_or(0, Vec::len);+ // Lightroom local adjustment presets land in the Masking panel's Effect menu: part of the same toast+ let effects = v["effects"].as_array().map_or(0, Vec::len);+ if effects > 0 {+ parts.push(crate::i18n::tr_format!("Imported {e} mask effect{} (Masking ▸ Effect)", if effects == 1 { "" } else { "s" }, e = effects));+ }let profile_news = !parts.is_empty() || !problems.is_empty();let msg = match (n, failed) {- // a zip of LUTs only: the profile half already says what happened+ // a zip of LUTs (or only local presets): the other half already says what happened(0, 0) if profile_news => None,(0, 0) => Some("No new presets".to_string()),(n, 0) => Some(crate::i18n::tr_format!("Imported {n} preset{}", if n == 1 { "" } else { "s" }, n = n)),diff --git a/crates/ui-egui/src/panels/masking.rs b/crates/ui-egui/src/panels/masking.rsindex 640bc4f11..5e3f8dc6d 100644--- a/crates/ui-egui/src/panels/masking.rs+++ b/crates/ui-egui/src/panels/masking.rs@@ -16,6 +16,56 @@ const fn spec(id: &'static str, label: &'static str, min: f64, max: f64, step: fControlSpec { id, label, section: Section::Light, min, max, default: 0.0, step, decimals, track }}+/// The Effect menu above the mask's sliders: apply, save, import and delete effect presets.+fn effect_row(app: &mut LightcraftApp, ui: &mut egui::Ui, adjust: &LocalAdjustments) {+ use lightcraft_engine::cmd::mask_effects::matching_effect;+ let t = Tokens::get(ui.ctx());+ egui::Frame::NONE.inner_margin(egui::Margin { left: 24, right: 22, top: 2, bottom: 4 }).show(ui, |ui| {+ ui.horizontal(|ui| {+ ui.label(egui::RichText::new(crate::i18n::tr("Effect")).font(t.font(12.0)).color(t.text_label));+ let current = matching_effect(&app.session, adjust);+ let label = current.clone().unwrap_or_else(|| crate::i18n::tr("Custom").to_string());+ let r = crate::widgets::dropdown(ui, "maskEffect", &label, t.font(12.0), t.text);+ egui::Popup::menu(&r).show(|ui| {+ ui.set_min_width(220.0);+ let effects: Vec<String> = app.session.mask_effects.iter().map(|e| e.name.clone()).collect();+ egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {+ for name in &effects {+ let r = ui.selectable_label(current.as_deref() == Some(name.as_str()), name);+ register(ui.ctx(), format!("maskEffect:{name}"), r.rect);+ if r.clicked() {+ let _ = app.run("mask.applyEffect", json!({"name": name}));+ ui.close();+ }+ r.context_menu(|ui| {+ if ui.button(crate::i18n::tr("Delete Preset")).clicked() {+ let _ = app.run("mask.deleteEffect", json!({"name": name}));+ ui.close();+ }+ });+ }+ });+ if !effects.is_empty() {+ ui.separator();+ }+ let r = ui.button(crate::i18n::tr("Save Current Settings as New Preset…"));+ register(ui.ctx(), "maskEffectMenu:save", r.rect);+ if r.clicked() {+ crate::panels::dialogs::prompt(app, "Save Effect Preset", "Preset name", "", "mask.saveEffect", json!({}), "name");+ ui.close();+ }+ if ui.add_enabled(app.services.pick_preset_files.is_some(), egui::Button::new(crate::i18n::tr("Import Presets…"))).clicked() {+ let _ = app.run("file.importPresets", json!({}));+ ui.close();+ }+ if !effects.is_empty() {+ ui.label(egui::RichText::new(crate::i18n::tr("Right-click a preset to delete it")).font(t.font(11.0)).color(t.text_dim));+ }+ });+ });+ });+}+/// Local adjustment sliders (key = `LocalAdjustments` field name).pub const LOCAL: &[ControlSpec] = &[spec("temp", "Temp", -100.0, 100.0, 1.0, 0, Track::Temp),@@ -368,6 +418,7 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {brush_settings(app, ui);}divider(ui);+ effect_row(app, ui, &m.adjust);for s in LOCAL {let v = local_get(&m.adjust, s.id);let out = slider(ui, s, v, true, None);diff --git a/crates/ui-egui/src/tests_masking.rs b/crates/ui-egui/src/tests_masking.rsindex 8024c62c5..eb2b18a22 100644--- a/crates/ui-egui/src/tests_masking.rs+++ b/crates/ui-egui/src/tests_masking.rs@@ -137,6 +137,9 @@ fn new_brush_starts_a_separate_mask_in_paint_mode() {fn mask_adjustments_hide_overlay_without_disabling_the_mask() {use lightcraft_pipeline::Overlay;let mut h = detail("panel.masking");+ // tall enough for the Exposure slider below the Effect menu to be on screen+ let r = h.request("ui.resize", json!({"width": 1200, "height": 1000}), T);+ assert_eq!(r["ok"], true, "{r}");exec(&mut h, "mask.add", json!({"kind": "linear", "start": [0.5, 0.2], "end": [0.5, 0.7]}));assert!(h.app.ui.mask_overlay);@@ -1416,3 +1419,33 @@ fn a_fast_brush_stroke_shows_without_gaps_before_the_button_is_released() {assert!((0..3).all(|i| (l[i] - k[i]).abs() < 24.0), "live {l:?} vs committed {k:?} at ({x}, {y})");}}++#[test]+fn effect_dropdown_applies_saves_and_shows_the_matching_effect() {+ let mut h = detail("panel.masking");+ exec(&mut h, "mask.add", json!({"kind": "radial"}));+ exec(&mut h, "mask.adjust", json!({"values": {"exposure": 0.7, "shadows": 25, "amount": 80}}));+ h.step();+ // save the mask's sliders from the menu (name prompt)+ click(&mut h, "dropdown:maskEffect");+ click(&mut h, "maskEffectMenu:save");+ let mut dlg = h.app.ui.dialog.take().expect("a name prompt opens");+ match &mut dlg {+ crate::state::Dialog::TextPrompt { command, value, .. } => {+ assert_eq!(command, "mask.saveEffect");+ *value = "Lift".into();+ }+ _ => panic!("a name prompt opens"),+ }+ let r = crate::panels::dialogs::confirm_dialog(&mut h.app, &dlg);+ assert!(r.is_ok(), "{r:?}");+ assert_eq!(h.app.session.mask_effects.len(), 1);+ // change the sliders, then pick the effect again: sliders back, Amount kept+ exec(&mut h, "mask.adjust", json!({"values": {"exposure": -1, "clarity": 40, "amount": 50}}));+ h.step();+ click(&mut h, "dropdown:maskEffect");+ click(&mut h, "maskEffect:Lift");+ let a = develop(&h).masks.last().expect("a mask").adjust;+ assert_eq!((a.exposure, a.shadows, a.clarity, a.amount), (0.7, 25.0, 0.0, 50.0));+ assert_eq!(exec(&mut h, "mask.effects", json!({}))["current"], "Lift");+}