Skip to content

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.rs
new file mode 100644
index 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(&current);
+ assert_eq!((out.exposure, out.shadows, out.amount), (1.0, 0.0, 60.0));
+ assert!(e.matches(&out));
+ assert!(!e.matches(&current));
+ }
+}
diff --git a/crates/engine/src/cmd/masks.rs b/crates/engine/src/cmd/masks.rs
index 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::Deve
lightcraft_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.rs
index 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.rs
index 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 folder
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<Re
if 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.rs
index 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: f
ControlSpec { 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.rs
index 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");
+}