mirror of
https://github.com/storytold/lightcraft.git
synced 2026-10-26 19:17:02 -06:00
754 lines
30 KiB
Rust
754 lines
30 KiB
Rust
//! 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.
|
|
//! Grouped (folders in the menu), favourites, partial presets (only some sliders, with or without
|
|
//! Amount) and optional brush settings. Files: [`super::mask_effect_files`].
|
|
|
|
use std::cmp::Ordering;
|
|
|
|
use lightcraft_catalog::PhotoId;
|
|
use lightcraft_develop::{DevelopSettings, LocalAdjustments, Mask};
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::{Map, Value, json};
|
|
|
|
use super::mask_effect_files as files;
|
|
use super::{CommandSpec, always, bad, cmd, has_active, str_param};
|
|
use crate::{Result, Session};
|
|
|
|
/// The local sliders an effect can set (`LocalAdjustments` field names; Amount aside).
|
|
pub const FIELDS: &[&str] = &[
|
|
"temp",
|
|
"tint",
|
|
"exposure",
|
|
"contrast",
|
|
"highlights",
|
|
"shadows",
|
|
"whites",
|
|
"blacks",
|
|
"texture",
|
|
"clarity",
|
|
"dehaze",
|
|
"hue",
|
|
"saturation",
|
|
"sharpness",
|
|
"noise",
|
|
"moire",
|
|
"defringe",
|
|
"color_hue",
|
|
"color_sat",
|
|
];
|
|
|
|
/// Brush settings an effect can carry (Lightroom keeps these per brush, not in presets).
|
|
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
|
|
#[serde(default)]
|
|
pub struct BrushSettings {
|
|
/// Radius as a fraction of the image's long edge.
|
|
pub size: f64,
|
|
/// 0..100.
|
|
pub feather: f64,
|
|
pub flow: f64,
|
|
pub density: f64,
|
|
pub auto_mask: bool,
|
|
}
|
|
|
|
impl Default for BrushSettings {
|
|
fn default() -> Self {
|
|
Self { size: 0.04, feather: 50.0, flow: 100.0, density: 100.0, auto_mask: false }
|
|
}
|
|
}
|
|
|
|
impl BrushSettings {
|
|
fn clamped(self) -> Self {
|
|
let c = |v: f64, lo: f64, hi: f64, d: f64| if v.is_finite() { v.clamp(lo, hi) } else { d };
|
|
let d = Self::default();
|
|
Self {
|
|
size: c(self.size, 0.002, 0.5, d.size),
|
|
feather: c(self.feather, 0.0, 100.0, d.feather),
|
|
flow: c(self.flow, 1.0, 100.0, d.flow),
|
|
density: c(self.density, 1.0, 100.0, d.density),
|
|
auto_mask: self.auto_mask,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A named set of local adjustment sliders. Applying one sets the sliders it names (all of them
|
|
/// when `fields` is empty, as Lightroom's presets do: those it doesn't change go to 0); the mask's
|
|
/// Amount stays unless `with_amount`.
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
#[serde(default)]
|
|
pub struct MaskEffect {
|
|
pub name: String,
|
|
pub adjust: LocalAdjustments,
|
|
/// The Effect menu folder ("" = none).
|
|
#[serde(skip_serializing_if = "String::is_empty")]
|
|
pub group: String,
|
|
#[serde(skip_serializing_if = "std::ops::Not::not")]
|
|
pub favorite: bool,
|
|
/// The sliders this effect sets ([`FIELDS`] names); empty = all of them.
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
pub fields: Vec<String>,
|
|
/// Applying sets the mask's Amount to `adjust.amount` too.
|
|
#[serde(skip_serializing_if = "std::ops::Not::not")]
|
|
pub with_amount: bool,
|
|
/// Brush settings the brush takes when the effect is applied.
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub brush: Option<BrushSettings>,
|
|
/// Settings of an imported preset that we have no slider for (Lightroom key → value), kept so
|
|
/// an export carries them.
|
|
#[serde(skip_serializing_if = "Map::is_empty")]
|
|
pub extra: Map<String, Value>,
|
|
}
|
|
|
|
impl Default for MaskEffect {
|
|
fn default() -> Self {
|
|
Self {
|
|
name: String::new(),
|
|
adjust: LocalAdjustments::default(),
|
|
group: String::new(),
|
|
favorite: false,
|
|
fields: Vec::new(),
|
|
with_amount: false,
|
|
brush: None,
|
|
extra: Map::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Field `k` of `a` (0 for an unknown name).
|
|
pub fn get(a: &LocalAdjustments, k: &str) -> f64 {
|
|
serde_json::to_value(a).ok().and_then(|v| v.get(k).and_then(Value::as_f64)).unwrap_or(0.0)
|
|
}
|
|
|
|
/// `a` with field `k` set to `v` (unchanged for an unknown name).
|
|
pub fn set(a: &LocalAdjustments, k: &str, v: f64) -> LocalAdjustments {
|
|
let Ok(Value::Object(mut o)) = serde_json::to_value(a) else { return *a };
|
|
if !o.contains_key(k) || !v.is_finite() {
|
|
return *a;
|
|
}
|
|
o.insert(k.into(), json!(v));
|
|
serde_json::from_value(Value::Object(o)).unwrap_or(*a)
|
|
}
|
|
|
|
/// The sliders of `a` away from 0 (the colour's hue only with its saturation).
|
|
pub fn changed_fields(a: &LocalAdjustments) -> Vec<String> {
|
|
let mut out: Vec<String> = FIELDS.iter().filter(|k| get(a, k).abs() > 1e-9 && **k != "color_hue").map(|k| k.to_string()).collect();
|
|
if a.color_sat.abs() > 1e-9 {
|
|
out.push("color_hue".into());
|
|
}
|
|
out
|
|
}
|
|
|
|
impl MaskEffect {
|
|
/// The sliders this effect sets.
|
|
pub fn field_list(&self) -> Vec<&str> {
|
|
if self.fields.is_empty() { FIELDS.to_vec() } else { FIELDS.iter().copied().filter(|k| self.fields.iter().any(|f| f == k)).collect() }
|
|
}
|
|
/// `a` with this preset's sliders (and Amount, if it carries it).
|
|
pub fn apply(&self, a: &LocalAdjustments) -> LocalAdjustments {
|
|
let mut out = if self.fields.is_empty() {
|
|
LocalAdjustments { amount: a.amount, ..self.adjust }
|
|
} else {
|
|
self.field_list().iter().fold(*a, |acc, k| set(&acc, k, get(&self.adjust, k)))
|
|
};
|
|
if self.with_amount {
|
|
out.amount = self.adjust.amount;
|
|
}
|
|
out
|
|
}
|
|
/// Does `a` carry exactly this preset's sliders? A tint's hue doesn't count without its
|
|
/// saturation (it does nothing then).
|
|
pub fn matches(&self, a: &LocalAdjustments) -> bool {
|
|
let fields = self.field_list();
|
|
let colorless = |x: &LocalAdjustments| x.color_sat.abs() < 1e-9;
|
|
let same = |k: &str| (get(&self.adjust, k) - get(a, k)).abs() < 1e-6;
|
|
fields.iter().all(|k| *k == "color_hue" && colorless(&self.adjust) && colorless(a) || same(k))
|
|
&& (!self.with_amount || (self.adjust.amount - a.amount).abs() < 1e-6)
|
|
}
|
|
/// Does the effect set nothing (all its sliders at 0, nothing kept from an import)?
|
|
pub fn is_empty(&self) -> bool {
|
|
self.extra.is_empty() && changed_fields(&self.adjust).iter().all(|k| !self.field_list().contains(&k.as_str()))
|
|
}
|
|
/// The same effect with its values in range and its field list normalised.
|
|
pub fn normalized(mut self) -> Self {
|
|
self.name = self.name.trim().to_string();
|
|
self.group = self.group.trim().to_string();
|
|
let amount = if self.with_amount { self.adjust.amount } else { 100.0 };
|
|
self.adjust = super::masks::clamp_local(LocalAdjustments { amount, ..self.adjust });
|
|
self.fields.retain(|f| FIELDS.contains(&f.as_str()));
|
|
if self.fields.iter().any(|f| f == "color_sat") && !self.fields.iter().any(|f| f == "color_hue") {
|
|
self.fields.push("color_hue".into());
|
|
}
|
|
self.fields.sort_by_key(|f| FIELDS.iter().position(|k| k == f));
|
|
self.fields.dedup();
|
|
if self.fields.len() == FIELDS.len() {
|
|
self.fields.clear();
|
|
}
|
|
self.brush = self.brush.map(BrushSettings::clamped);
|
|
self
|
|
}
|
|
}
|
|
|
|
/// Compare names the way people number their presets: digit runs as numbers ("2 …" before
|
|
/// "10 …"), letters ignoring case.
|
|
pub fn natural_cmp(a: &str, b: &str) -> Ordering {
|
|
fn chunks(s: &str) -> Vec<(bool, String)> {
|
|
let mut out: Vec<(bool, String)> = Vec::new();
|
|
for c in s.chars() {
|
|
let d = c.is_ascii_digit();
|
|
match out.last_mut() {
|
|
Some((kind, text)) if *kind == d => text.push(c),
|
|
_ => out.push((d, c.to_string())),
|
|
}
|
|
}
|
|
out
|
|
}
|
|
let (x, y) = (chunks(a), chunks(b));
|
|
for (p, q) in x.iter().zip(y.iter()) {
|
|
let o = match (p, q) {
|
|
((true, m), (true, n)) => {
|
|
let (m, n) = (m.trim_start_matches('0'), n.trim_start_matches('0'));
|
|
m.len().cmp(&n.len()).then_with(|| m.cmp(n))
|
|
}
|
|
((_, m), (_, n)) => m.to_lowercase().cmp(&n.to_lowercase()),
|
|
};
|
|
if o != Ordering::Equal {
|
|
return o;
|
|
}
|
|
}
|
|
x.len().cmp(&y.len()).then_with(|| a.cmp(b))
|
|
}
|
|
|
|
/// The Effect menu's order: groups in the order they first appear (ungrouped first), each with
|
|
/// its effects (indices into `effects`) sorted by name.
|
|
pub fn menu_order(effects: &[MaskEffect]) -> Vec<(String, Vec<usize>)> {
|
|
let mut groups: Vec<(String, Vec<usize>)> = Vec::new();
|
|
if effects.iter().any(|e| e.group.is_empty()) {
|
|
groups.push((String::new(), Vec::new()));
|
|
}
|
|
for (i, e) in effects.iter().enumerate() {
|
|
match groups.iter_mut().find(|(g, _)| g.eq_ignore_ascii_case(&e.group)) {
|
|
Some((_, v)) => v.push(i),
|
|
None => groups.push((e.group.clone(), vec![i])),
|
|
}
|
|
}
|
|
for (_, v) in &mut groups {
|
|
v.sort_by(|a, b| match (effects.get(*a), effects.get(*b)) {
|
|
(Some(x), Some(y)) => natural_cmp(&x.name, &y.name),
|
|
_ => Ordering::Equal,
|
|
});
|
|
}
|
|
groups
|
|
}
|
|
|
|
/// Name of the effect the mask adjustments `a` match, if any (full presets before partial ones).
|
|
pub fn matching_effect(s: &Session, a: &LocalAdjustments) -> Option<String> {
|
|
let full = s.mask_effects.iter().filter(|e| e.fields.is_empty()).find(|e| e.matches(a));
|
|
full.or_else(|| s.mask_effects.iter().find(|e| e.matches(a))).map(|e| e.name.clone())
|
|
}
|
|
|
|
fn position(s: &Session, name: &str) -> Option<usize> {
|
|
s.mask_effects.iter().position(|x| x.name.eq_ignore_ascii_case(name.trim()))
|
|
}
|
|
|
|
/// Add or replace (same name, ignoring case) an effect; a replaced one keeps its star.
|
|
pub(crate) fn upsert(s: &mut Session, e: MaskEffect) {
|
|
match position(s, &e.name).and_then(|i| s.mask_effects.get_mut(i)) {
|
|
Some(x) => {
|
|
let favorite = x.favorite || e.favorite;
|
|
*x = MaskEffect { favorite, ..e };
|
|
}
|
|
None => s.mask_effects.push(e),
|
|
}
|
|
}
|
|
|
|
fn name_param(p: &Value, c: &str) -> Result<String> {
|
|
name_of(p, "name", c)
|
|
}
|
|
|
|
fn name_of(p: &Value, key: &str, c: &str) -> Result<String> {
|
|
str_param(p, key).map(str::trim).filter(|n| !n.is_empty()).map(str::to_string).ok_or_else(|| bad(c, format!("missing `{key}`")))
|
|
}
|
|
|
|
fn strings(p: &Value, key: &str) -> Option<Vec<String>> {
|
|
p.get(key).and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect())
|
|
}
|
|
|
|
/// The names a command acts on: `names: [...]` or `name`.
|
|
fn names_param(p: &Value, c: &str) -> Result<Vec<String>> {
|
|
match strings(p, "names").filter(|v| !v.is_empty()) {
|
|
Some(v) => Ok(v),
|
|
None => name_param(p, c).map(|n| vec![n]),
|
|
}
|
|
}
|
|
|
|
fn effect_index(s: &Session, name: &str, c: &str) -> Result<usize> {
|
|
position(s, name).ok_or_else(|| bad(c, format!("no effect `{name}`")))
|
|
}
|
|
|
|
/// The selected mask's adjustments on the active photo.
|
|
fn selected_mask(s: &Session, p: &Value, c: &str) -> Result<Mask> {
|
|
let id = s.active().ok_or_else(|| bad(c, "no active photo"))?;
|
|
let mid = super::masks::mask_id(p, s.active_mask, c)?;
|
|
let d = s.develop_of(id).unwrap_or_default();
|
|
d.masks.iter().find(|m| m.id == mid).cloned().ok_or_else(|| bad(c, format!("no mask {mid}")))
|
|
}
|
|
|
|
/// The kind of a mask's first component (`brush`, `linear`, `radial`, `subject`…): the tool the
|
|
/// effect is remembered for.
|
|
pub fn mask_tool(m: &Mask) -> Option<String> {
|
|
m.components.first().and_then(|c| serde_json::to_value(&c.shape).ok()).and_then(|v| v.get("kind").and_then(Value::as_str).map(str::to_string))
|
|
}
|
|
|
|
/// The adjustments a new mask made with `tool` starts with: the effect last applied to a mask of
|
|
/// that kind (Lightroom carries the chosen effect over to the next mask), else all at 0.
|
|
pub fn new_mask_adjust(s: &Session, tool: &str) -> LocalAdjustments {
|
|
s.mask_tool_effects
|
|
.get(tool)
|
|
.and_then(|name| position(s, name))
|
|
.and_then(|i| s.mask_effects.get(i))
|
|
.map(|e| super::masks::clamp_local(e.apply(&LocalAdjustments::default())))
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
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));
|
|
let groups: Vec<Value> = menu_order(&s.mask_effects)
|
|
.into_iter()
|
|
.map(|(g, ix)| json!({"name": g, "effects": ix.iter().filter_map(|i| s.mask_effects.get(*i)).map(|e| e.name.clone()).collect::<Vec<_>>()}))
|
|
.collect();
|
|
json!({"effects": s.mask_effects, "groups": groups, "current": current, "toolEffects": s.mask_tool_effects})
|
|
}
|
|
|
|
/// Masks on `d` named like one of `names` (ignoring case).
|
|
fn masks_named(d: &DevelopSettings, names: &[String]) -> Vec<u32> {
|
|
d.masks.iter().filter(|m| names.iter().any(|n| n.eq_ignore_ascii_case(&m.name))).map(|m| m.id).collect()
|
|
}
|
|
|
|
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.get(effect_index(s, &name, C)?).cloned().ok_or_else(|| bad(C, format!("no effect `{name}`")))?;
|
|
let id = s.active().ok_or_else(|| bad(C, "no active photo"))?;
|
|
let d = s.develop_of(id).unwrap_or_default();
|
|
// the masks: `ids`, `all`, else `id` or the selected one
|
|
let ids: Vec<u32> = if p.get("all").and_then(Value::as_bool).unwrap_or(false) {
|
|
d.masks.iter().map(|m| m.id).collect()
|
|
} else {
|
|
match p.get("ids") {
|
|
None | Some(Value::Null) => vec![selected_mask(s, p, C)?.id],
|
|
Some(Value::Array(a)) => a.iter().map(|v| super::masks::parse_mask_id(v, C)).collect::<Result<_>>()?,
|
|
Some(_) => return Err(bad(C, "`ids` must be a list of mask IDs")),
|
|
}
|
|
};
|
|
if ids.is_empty() {
|
|
return Err(bad(C, "no masks to apply the effect to"));
|
|
}
|
|
if let Some(missing) = ids.iter().find(|m| !d.masks.iter().any(|x| x.id == **m)) {
|
|
return Err(bad(C, format!("no mask {missing}")));
|
|
}
|
|
let set_masks = |d: &DevelopSettings, ids: &[u32]| {
|
|
let mut d = d.clone();
|
|
for m in d.masks.iter_mut().filter(|m| ids.contains(&m.id)) {
|
|
m.adjust = super::masks::clamp_local(effect.apply(&m.adjust));
|
|
}
|
|
d
|
|
};
|
|
let label = format!("Mask Effect: {}", effect.name);
|
|
// with `photos: "selected"`, the other selected photos' masks of the same names too
|
|
let others: Vec<(PhotoId, DevelopSettings)> = if str_param(p, "photos") == Some("selected") {
|
|
let names: Vec<String> = d.masks.iter().filter(|m| ids.contains(&m.id)).map(|m| m.name.clone()).collect();
|
|
s.selection
|
|
.ids
|
|
.iter()
|
|
.filter(|x| **x != id)
|
|
.filter_map(|x| s.develop_of(*x).map(|o| (*x, o)))
|
|
.filter_map(|(x, o)| {
|
|
let found = masks_named(&o, &names);
|
|
(!found.is_empty()).then(|| (x, set_masks(&o, &found)))
|
|
})
|
|
.collect()
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
let mine = set_masks(&d, &ids);
|
|
let photos = 1 + others.len();
|
|
if others.is_empty() {
|
|
s.set_develop(id, mine, &label)?;
|
|
} else {
|
|
// one undo step for every photo
|
|
let mut ops: Vec<_> = s.develop_op(id, mine, &label).into_iter().collect();
|
|
ops.extend(others.into_iter().filter_map(|(x, o)| s.develop_op(x, o, &label)));
|
|
s.commit(&label, lightcraft_catalog::Op::Batch { ops })?;
|
|
}
|
|
// the next mask made with this tool starts with the effect
|
|
if p.get("remember").and_then(Value::as_bool).unwrap_or(true) {
|
|
for m in d.masks.iter().filter(|m| ids.contains(&m.id)) {
|
|
if let Some(tool) = mask_tool(m) {
|
|
s.mask_tool_effects.insert(tool, effect.name.clone());
|
|
}
|
|
}
|
|
s.save_prefs()?;
|
|
}
|
|
Ok(json!({"name": effect.name, "masks": ids, "photos": photos, "brush": effect.brush}))
|
|
}
|
|
|
|
/// The fields a save keeps: `fields: [..]` | `"changed"` | `"all"` (default).
|
|
fn fields_param(p: &Value, a: &LocalAdjustments, c: &str) -> Result<Vec<String>> {
|
|
match p.get("fields") {
|
|
None | Some(Value::Null) => Ok(Vec::new()),
|
|
Some(Value::String(x)) if x == "all" => Ok(Vec::new()),
|
|
Some(Value::String(x)) if x == "changed" => {
|
|
let f = changed_fields(a);
|
|
if f.is_empty() { Err(bad(c, "the mask changes no slider; nothing to save")) } else { Ok(f) }
|
|
}
|
|
Some(Value::Array(v)) => {
|
|
let f: Vec<String> = v.iter().filter_map(Value::as_str).filter(|k| FIELDS.contains(k)).map(str::to_string).collect();
|
|
if f.is_empty() { Err(bad(c, format!("`fields` names no slider (one of {})", FIELDS.join(", ")))) } else { Ok(f) }
|
|
}
|
|
Some(_) => Err(bad(c, "`fields` is \"all\", \"changed\" or a list of slider names")),
|
|
}
|
|
}
|
|
|
|
fn brush_param(p: &Value, c: &str) -> Result<Option<BrushSettings>> {
|
|
match p.get("brush") {
|
|
None | Some(Value::Null) | Some(Value::Bool(false)) => Ok(None),
|
|
Some(v) => serde_json::from_value::<BrushSettings>(v.clone()).map(|b| Some(b.clamped())).map_err(|e| bad(c, format!("`brush`: {e}"))),
|
|
}
|
|
}
|
|
|
|
fn save_effect(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.saveEffect";
|
|
let name = name_param(p, C)?;
|
|
let adjust = selected_mask(s, p, C)?.adjust;
|
|
let group = str_param(p, "group").map(|g| g.trim().to_string()).unwrap_or_default();
|
|
let e = MaskEffect {
|
|
name,
|
|
adjust,
|
|
group,
|
|
fields: fields_param(p, &adjust, C)?,
|
|
with_amount: p.get("amount").and_then(Value::as_bool).unwrap_or(false),
|
|
brush: brush_param(p, C)?,
|
|
..Default::default()
|
|
};
|
|
upsert(s, e.normalized());
|
|
s.save_prefs()?;
|
|
Ok(list(s))
|
|
}
|
|
|
|
/// Overwrite an effect's sliders with the selected mask's (keeping which sliders and whether
|
|
/// Amount it carries, its group and star).
|
|
fn update_effect(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.updateEffect";
|
|
let name = name_param(p, C)?;
|
|
let i = effect_index(s, &name, C)?;
|
|
let adjust = selected_mask(s, p, C)?.adjust;
|
|
let brush = brush_param(p, C)?;
|
|
let e = s.mask_effects.get_mut(i).ok_or_else(|| bad(C, format!("no effect `{name}`")))?;
|
|
let mut next = MaskEffect { adjust, extra: Map::new(), ..e.clone() };
|
|
if let Some(f) = p.get("fields").filter(|v| !v.is_null()) {
|
|
next.fields = fields_param(&json!({"fields": f}), &adjust, C)?;
|
|
}
|
|
if let Some(a) = p.get("amount").and_then(Value::as_bool) {
|
|
next.with_amount = a;
|
|
}
|
|
if brush.is_some() {
|
|
next.brush = brush;
|
|
}
|
|
*e = next.normalized();
|
|
s.save_prefs()?;
|
|
Ok(list(s))
|
|
}
|
|
|
|
fn rename_effect(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.renameEffect";
|
|
let name = name_param(p, C)?;
|
|
let to = name_of(p, "to", C)?;
|
|
let i = effect_index(s, &name, C)?;
|
|
if position(s, &to).is_some_and(|j| j != i) {
|
|
return Err(bad(C, format!("an effect named `{to}` exists already")));
|
|
}
|
|
if let Some(e) = s.mask_effects.get_mut(i) {
|
|
e.name = to.clone();
|
|
}
|
|
for v in s.mask_tool_effects.values_mut() {
|
|
if v.eq_ignore_ascii_case(&name) {
|
|
*v = to.clone();
|
|
}
|
|
}
|
|
s.save_prefs()?;
|
|
Ok(list(s))
|
|
}
|
|
|
|
/// A name like `base` that no effect has: `base`, `base 2`, `base 3`…
|
|
fn free_name(s: &Session, base: &str) -> String {
|
|
(1..10_000)
|
|
.map(|n| if n == 1 { base.to_string() } else { format!("{base} {n}") })
|
|
.find(|n| position(s, n).is_none())
|
|
.unwrap_or_else(|| base.into())
|
|
}
|
|
|
|
fn duplicate_effect(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.duplicateEffect";
|
|
let name = name_param(p, C)?;
|
|
let e = s.mask_effects.get(effect_index(s, &name, C)?).cloned().ok_or_else(|| bad(C, format!("no effect `{name}`")))?;
|
|
let to = match str_param(p, "to").map(str::trim).filter(|t| !t.is_empty()) {
|
|
Some(t) if position(s, t).is_some() => return Err(bad(C, format!("an effect named `{t}` exists already"))),
|
|
Some(t) => t.to_string(),
|
|
None => free_name(s, &format!("{} copy", e.name)),
|
|
};
|
|
s.mask_effects.push(MaskEffect { name: to.clone(), favorite: false, ..e });
|
|
s.save_prefs()?;
|
|
let mut out = list(s);
|
|
out["name"] = json!(to);
|
|
Ok(out)
|
|
}
|
|
|
|
fn delete_effect(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.deleteEffect";
|
|
let names = names_param(p, C)?;
|
|
if let Some(missing) = names.iter().find(|n| position(s, n).is_none()) {
|
|
return Err(bad(C, format!("no effect `{missing}`")));
|
|
}
|
|
s.mask_effects.retain(|x| !names.iter().any(|n| n.eq_ignore_ascii_case(&x.name)));
|
|
s.mask_tool_effects.retain(|_, v| !names.iter().any(|n| n.eq_ignore_ascii_case(v)));
|
|
s.save_prefs()?;
|
|
Ok(list(s))
|
|
}
|
|
|
|
fn favorite_effect(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.favoriteEffect";
|
|
let names = names_param(p, C)?;
|
|
let mut idx = Vec::new();
|
|
for n in &names {
|
|
idx.push(effect_index(s, n, C)?);
|
|
}
|
|
let want = p.get("favorite").and_then(Value::as_bool);
|
|
for i in idx {
|
|
if let Some(e) = s.mask_effects.get_mut(i) {
|
|
e.favorite = want.unwrap_or(!e.favorite);
|
|
}
|
|
}
|
|
s.save_prefs()?;
|
|
Ok(list(s))
|
|
}
|
|
|
|
fn set_group(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.setEffectGroup";
|
|
let names = names_param(p, C)?;
|
|
let group = str_param(p, "group").map(|g| g.trim().to_string()).ok_or_else(|| bad(C, "missing `group` (\"\" = none)"))?;
|
|
let mut idx = Vec::new();
|
|
for n in &names {
|
|
idx.push(effect_index(s, n, C)?);
|
|
}
|
|
// an existing group's spelling wins
|
|
let group = s.mask_effects.iter().map(|e| &e.group).find(|g| g.eq_ignore_ascii_case(&group)).cloned().unwrap_or(group);
|
|
for i in idx {
|
|
if let Some(e) = s.mask_effects.get_mut(i) {
|
|
e.group = group.clone();
|
|
}
|
|
}
|
|
s.save_prefs()?;
|
|
Ok(list(s))
|
|
}
|
|
|
|
fn rename_group(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.renameEffectGroup";
|
|
let group = name_of(p, "group", C)?;
|
|
let to = str_param(p, "to").map(|g| g.trim().to_string()).ok_or_else(|| bad(C, "missing `to` (\"\" = ungroup)"))?;
|
|
let mut n = 0;
|
|
for e in s.mask_effects.iter_mut().filter(|e| e.group.eq_ignore_ascii_case(&group)) {
|
|
e.group = to.clone();
|
|
n += 1;
|
|
}
|
|
if n == 0 {
|
|
return Err(bad(C, format!("no group `{group}`")));
|
|
}
|
|
s.save_prefs()?;
|
|
Ok(list(s))
|
|
}
|
|
|
|
fn tool_effect(s: &mut Session, p: &Value) -> Result<Value> {
|
|
const C: &str = "mask.toolEffect";
|
|
let tool = name_of(p, "tool", C)?;
|
|
match str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()) {
|
|
Some(n) => {
|
|
let i = effect_index(s, n, C)?;
|
|
let name = s.mask_effects.get(i).map(|e| e.name.clone()).unwrap_or_default();
|
|
s.mask_tool_effects.insert(tool, name);
|
|
}
|
|
None => {
|
|
s.mask_tool_effects.remove(&tool);
|
|
}
|
|
}
|
|
s.save_prefs()?;
|
|
Ok(json!({"toolEffects": s.mask_tool_effects}))
|
|
}
|
|
|
|
pub fn specs() -> Vec<CommandSpec> {
|
|
vec![
|
|
cmd!(
|
|
query "mask.effects",
|
|
"Mask Effect Presets",
|
|
[],
|
|
None,
|
|
"{} → {effects: [{name, adjust, group?, favorite?, fields?, with_amount?, brush?, extra?}], groups: [{name, effects: [name]}] (menu order), current: the effect the selected mask matches or null, toolEffects: {tool: effect a new mask of that kind starts with}}",
|
|
always,
|
|
|s, _| Ok(list(s))
|
|
),
|
|
cmd!(
|
|
"mask.applyEffect",
|
|
"Apply Mask Effect",
|
|
[],
|
|
None,
|
|
"{name, id? | ids?: [maskId] | all?: bool, photos?: \"selected\" (also the masks of the same names on the other selected photos, one undo step), remember?: bool (true: new masks of this kind start with it)} — sets the effect's sliders (all, or the ones it keeps; Amount only if it carries it) → {name, masks, photos, brush}",
|
|
has_active,
|
|
apply_effect
|
|
),
|
|
cmd!(
|
|
"mask.saveEffect",
|
|
"Save Mask Effect",
|
|
[],
|
|
None,
|
|
"{name, id?, group?, fields?: \"all\" (default) | \"changed\" | [slider], amount?: bool (carry Amount), brush?: {size, feather, flow, density, auto_mask}} — the selected mask's sliders as an effect preset (replaces one of that name), saved with the library",
|
|
has_active,
|
|
save_effect
|
|
),
|
|
cmd!(
|
|
"mask.updateEffect",
|
|
"Update Mask Effect",
|
|
[],
|
|
None,
|
|
"{name, id?, fields?, amount?, brush?} — overwrite the effect with the selected mask's sliders (keeps its group, star and which sliders it carries unless given)",
|
|
has_active,
|
|
update_effect
|
|
),
|
|
cmd!("mask.renameEffect", "Rename Mask Effect", [], None, "{name, to}", always, rename_effect),
|
|
cmd!(
|
|
"mask.duplicateEffect",
|
|
"Duplicate Mask Effect",
|
|
[],
|
|
None,
|
|
"{name, to?} (default \"<name> copy\") → list + {name}",
|
|
always,
|
|
duplicate_effect
|
|
),
|
|
cmd!("mask.deleteEffect", "Delete Mask Effect", [], None, "{name | names: [name]} — removes effect presets", always, delete_effect),
|
|
cmd!("mask.favoriteEffect", "Favorite Mask Effect", [], None, "{name | names, favorite?: bool (default: toggle)}", always, favorite_effect),
|
|
cmd!("mask.setEffectGroup", "Move Mask Effect to Group", [], None, "{name | names, group: name (\"\" = none)}", always, set_group),
|
|
cmd!(
|
|
"mask.renameEffectGroup",
|
|
"Rename Mask Effect Group",
|
|
[],
|
|
None,
|
|
"{group, to} (\"\" ungroups; an existing name merges)",
|
|
always,
|
|
rename_group
|
|
),
|
|
cmd!(
|
|
"mask.toolEffect",
|
|
"Set Effect for New Masks",
|
|
[],
|
|
None,
|
|
"{tool: brush|linear|radial|subject|…, name?} — the effect new masks of that kind start with (no name: none)",
|
|
always,
|
|
tool_effect
|
|
),
|
|
cmd!(
|
|
"mask.importEffects",
|
|
"Import Mask Effects",
|
|
[],
|
|
None,
|
|
"{path | paths: [file or folder], group?, dryRun?} — Lightroom Classic local adjustment presets (.lrtemplate), Camera Raw local correction presets (.xmp), .lceffect files and .zip bundles of these; folders and Lightroom's divider presets (\"10 ----- DETAIL ----- 10\") become groups; same-named effects are replaced → {imported: [{name, group, file, unmapped}], dividers: [{name, group, file}], failed: [[file, error]]}",
|
|
always,
|
|
files::import_effects
|
|
),
|
|
cmd!(
|
|
"mask.exportEffects",
|
|
"Export Mask Effects",
|
|
[],
|
|
None,
|
|
"{path, names?: [name], group?: name (default: all)} — writes an .lceffect JSON file (groups, stars and kept Lightroom settings included) → {path, count}",
|
|
always,
|
|
files::export_effects
|
|
),
|
|
]
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn apply_keeps_amount_and_matches_ignore_it() {
|
|
let e = MaskEffect { name: "E".into(), adjust: LocalAdjustments { exposure: 1.0, ..Default::default() }, ..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));
|
|
}
|
|
|
|
#[test]
|
|
fn partial_effects_leave_other_sliders_and_can_carry_amount() {
|
|
let e = MaskEffect {
|
|
name: "Lift".into(),
|
|
adjust: LocalAdjustments { shadows: 30.0, clarity: 99.0, amount: 70.0, ..Default::default() },
|
|
fields: vec!["shadows".into()],
|
|
with_amount: true,
|
|
..Default::default()
|
|
};
|
|
let current = LocalAdjustments { exposure: 0.5, clarity: 10.0, ..Default::default() };
|
|
let out = e.apply(¤t);
|
|
assert_eq!((out.exposure, out.shadows, out.clarity, out.amount), (0.5, 30.0, 10.0, 70.0));
|
|
assert!(e.matches(&out));
|
|
assert!(!e.matches(&LocalAdjustments { amount: 100.0, ..out }), "Amount counts when carried");
|
|
}
|
|
|
|
#[test]
|
|
fn hue_without_saturation_still_matches() {
|
|
let e = MaskEffect {
|
|
name: "E".into(),
|
|
adjust: LocalAdjustments { color_hue: 240.0, exposure: 0.25, ..Default::default() },
|
|
..Default::default()
|
|
};
|
|
assert!(e.matches(&LocalAdjustments { exposure: 0.25, ..Default::default() }));
|
|
assert!(!e.matches(&LocalAdjustments { exposure: 0.25, color_sat: 10.0, ..Default::default() }));
|
|
}
|
|
|
|
#[test]
|
|
fn natural_order_and_groups() {
|
|
let mut v = vec!["10 b", "2 a", "Burn", "01 x", "1 y"];
|
|
v.sort_by(|a, b| natural_cmp(a, b));
|
|
assert_eq!(v, vec!["01 x", "1 y", "2 a", "10 b", "Burn"]);
|
|
let e = |n: &str, g: &str| MaskEffect { name: n.into(), group: g.into(), ..Default::default() };
|
|
let list = vec![e("12 b", "Detail"), e("3 a", ""), e("11 a", "detail"), e("20 r", "Retouch"), e("Burn", "")];
|
|
let order = menu_order(&list);
|
|
let names: Vec<(String, Vec<&str>)> = order.iter().map(|(g, ix)| (g.clone(), ix.iter().map(|i| list[*i].name.as_str()).collect())).collect();
|
|
assert_eq!(
|
|
names,
|
|
vec![("".to_string(), vec!["3 a", "Burn"]), ("Detail".to_string(), vec!["11 a", "12 b"]), ("Retouch".to_string(), vec!["20 r"]),]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn normalized_clamps_and_tidies_fields() {
|
|
let e = MaskEffect {
|
|
name: " X ".into(),
|
|
adjust: LocalAdjustments { exposure: 99.0, amount: 150.0, ..Default::default() },
|
|
fields: vec!["color_sat".into(), "bogus".into(), "exposure".into()],
|
|
brush: Some(BrushSettings { size: f64::NAN, flow: 0.0, ..Default::default() }),
|
|
..Default::default()
|
|
}
|
|
.normalized();
|
|
assert_eq!(e.name, "X");
|
|
assert_eq!(e.adjust.exposure, 4.0);
|
|
assert_eq!(e.adjust.amount, 100.0, "Amount isn't carried");
|
|
assert_eq!(e.fields, vec!["exposure", "color_hue", "color_sat"]);
|
|
let b = e.brush.unwrap();
|
|
assert_eq!((b.size, b.flow), (0.04, 1.0));
|
|
}
|
|
}
|