5a24289898fd
mask_effects.rs
//! Mask effect presets end to end: managing them (rename, update, duplicate, delete, stars,
//! groups), applying (several masks, other photos, new masks remembering the effect), saving
//! some sliders, and importing Lightroom / Camera Raw local presets from folders and zips.
use std::path::PathBuf;
use serde_json::{Value, json};
use crate::Session;
fn temp_dir(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("lc-effects-{tag}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
std::fs::create_dir_all(&d).unwrap();
d
}
/// A Lightroom local preset (synthetic values) in the Lua shape Lightroom writes.
fn lr_local(title: &str, value: &str) -> String {
format!(
"s = {{\n\tid = \"0\",\n\tinternalName = \"{title}\",\n\ttitle = \"{title}\",\n\ttype = \"LocalizedAdjustmentPreset\",\n\tvalue = {{\n{value}\n\t}},\n\tversion = 0,\n}}"
)
}
const ZERO: &str = "\t\texposure2012 = 0,\n\t\ttoningHue = 240,\n\t\ttoningSaturation = 0,";
fn names(v: &Value) -> Vec<String> {
v["effects"].as_array().unwrap().iter().map(|e| e["name"].as_str().unwrap().to_string()).collect()
}
fn mask_adjust(s: &Session, id: u32) -> lightcraft_develop::LocalAdjustments {
s.develop_of(s.active().unwrap()).unwrap().masks.iter().find(|m| m.id == id).unwrap().adjust
}
fn with_effect(s: &mut Session, name: &str, values: Value) {
s.execute("mask.add", &json!({"kind": "radial"})).unwrap();
s.execute("mask.adjust", &json!({"values": values})).unwrap();
s.execute("mask.saveEffect", &json!({"name": name})).unwrap();
s.execute("mask.delete", &json!({})).unwrap();
}
#[test]
fn managing_effects() {
let mut s = Session::with_demo();
with_effect(&mut s, "Lift", json!({"shadows": 30}));
with_effect(&mut s, "Dark", json!({"exposure": -1}));
// rename (not onto another one's name)
assert!(s.execute("mask.renameEffect", &json!({"name": "lift", "to": "dark"})).is_err());
assert!(s.execute("mask.renameEffect", &json!({"name": "nope", "to": "x"})).is_err());
let v = s.execute("mask.renameEffect", &json!({"name": "lift", "to": "Lift Shadows"})).unwrap();
assert_eq!(names(&v), ["Lift Shadows", "Dark"]);
// duplicate: "<name> copy", then "<name> copy 2"
let v = s.execute("mask.duplicateEffect", &json!({"name": "Dark"})).unwrap();
assert_eq!(v["name"], "Dark copy");
let v = s.execute("mask.duplicateEffect", &json!({"name": "Dark"})).unwrap();
assert_eq!(v["name"], "Dark copy 2");
assert!(s.execute("mask.duplicateEffect", &json!({"name": "Dark", "to": "dark copy"})).is_err());
// stars and groups
s.execute("mask.favoriteEffect", &json!({"name": "Dark copy"})).unwrap();
assert!(s.mask_effects[2].favorite);
s.execute("mask.favoriteEffect", &json!({"name": "Dark copy"})).unwrap();
assert!(!s.mask_effects[2].favorite, "toggles");
s.execute("mask.setEffectGroup", &json!({"names": ["Dark", "Dark copy"], "group": "Burn"})).unwrap();
s.execute("mask.setEffectGroup", &json!({"name": "Dark copy 2", "group": "burn"})).unwrap();
assert_eq!(s.mask_effects[3].group, "Burn", "an existing group's spelling wins");
let v = s.execute("mask.effects", &json!({})).unwrap();
assert_eq!(v["groups"], json!([{"name": "", "effects": ["Lift Shadows"]}, {"name": "Burn", "effects": ["Dark", "Dark copy", "Dark copy 2"]}]));
s.execute("mask.renameEffectGroup", &json!({"group": "BURN", "to": "Darken"})).unwrap();
assert!(s.mask_effects.iter().skip(1).all(|e| e.group == "Darken"));
assert!(s.execute("mask.renameEffectGroup", &json!({"group": "Burn", "to": "x"})).is_err());
// update with the selected mask's sliders
s.execute("mask.add", &json!({"kind": "linear"})).unwrap();
s.execute("mask.adjust", &json!({"values": {"exposure": -2, "clarity": 10}})).unwrap();
s.execute("mask.updateEffect", &json!({"name": "Dark"})).unwrap();
let dark = &s.mask_effects[1];
assert_eq!((dark.adjust.exposure, dark.adjust.clarity, dark.group.as_str()), (-2.0, 10.0, "Darken"));
// delete several (the menu asks first)
s.execute("mask.deleteEffect", &json!({"names": ["Dark copy", "Dark copy 2"]})).unwrap();
assert!(s.execute("mask.deleteEffect", &json!({"names": ["Dark", "gone"]})).is_err(), "nothing deleted when one is missing");
assert_eq!(s.mask_effects.len(), 2);
for bad in [json!({}), json!({"name": ""}), json!({"name": 3}), json!({"names": [1, 2]})] {
assert!(s.execute("mask.deleteEffect", &bad).is_err(), "{bad}");
assert!(s.execute("mask.favoriteEffect", &bad).is_err());
}
}
#[test]
fn saving_some_sliders_and_amount() {
let mut s = Session::with_demo();
s.execute("mask.add", &json!({"kind": "brush"})).unwrap();
s.execute("mask.adjust", &json!({"values": {"shadows": 25, "texture": -10, "amount": 60}})).unwrap();
s.execute("mask.saveEffect", &json!({"name": "Only", "fields": "changed", "amount": true, "brush": {"size": 0.1, "flow": 40}})).unwrap();
let e = &s.mask_effects[0];
assert_eq!(e.fields, ["shadows", "texture"]);
assert!(e.with_amount);
assert_eq!(e.brush.map(|b| (b.size, b.flow)), Some((0.1, 40.0)));
s.execute("mask.saveEffect", &json!({"name": "Pick", "fields": ["exposure", "bogus"]})).unwrap();
assert_eq!(s.mask_effects[1].fields, ["exposure"]);
for bad in [
json!({"name": "x", "fields": []}),
json!({"name": "x", "fields": 3}),
json!({"name": "x", "fields": "some"}),
json!({"name": "x", "brush": 7}),
] {
assert!(s.execute("mask.saveEffect", &bad).is_err(), "{bad}");
}
// applying a partial effect leaves the other sliders and sets Amount; it brings its brush
s.execute("mask.adjust", &json!({"values": {"shadows": 0, "texture": 0, "clarity": 50, "amount": 100}})).unwrap();
let mid = s.active_mask.unwrap();
let r = s.execute("mask.applyEffect", &json!({"name": "only"})).unwrap();
assert_eq!(r["brush"]["flow"], 40.0);
let a = mask_adjust(&s, mid);
assert_eq!((a.shadows, a.texture, a.clarity, a.amount), (25.0, -10.0, 50.0, 60.0));
// a mask that changes nothing has nothing to save as "changed"
s.execute("mask.add", &json!({"kind": "radial"})).unwrap();
assert!(s.execute("mask.saveEffect", &json!({"name": "Empty", "fields": "changed"})).is_err());
}
#[test]
fn applying_to_several_masks_and_photos_is_one_undo_step() {
let mut s = Session::with_demo();
with_effect(&mut s, "Bright", json!({"exposure": 1}));
let ids: Vec<u64> = s.catalog.photos().take(2).map(|p| p.id.0).collect();
s.execute("library.select", &json!({"ids": ids, "active": ids[0]})).unwrap();
for _ in 0..2 {
s.execute("mask.add", &json!({"kind": "radial", "name": "Face"})).unwrap();
}
s.execute("mask.add", &json!({"kind": "linear", "name": "Sky"})).unwrap();
let all: Vec<u32> = s.develop_of(s.active().unwrap()).unwrap().masks.iter().map(|m| m.id).collect();
let face = all[all.len() - 3];
s.execute("mask.applyEffect", &json!({"name": "Bright", "ids": [face, all[all.len() - 2]], "remember": false})).unwrap();
assert_eq!(mask_adjust(&s, face).exposure, 1.0);
assert_eq!(mask_adjust(&s, *all.last().unwrap()).exposure, 0.0, "only the masks named");
assert!(s.execute("mask.applyEffect", &json!({"name": "Bright", "ids": [999]})).is_err());
assert!(s.execute("mask.applyEffect", &json!({"name": "Bright", "ids": []})).is_err());
s.execute("mask.applyEffect", &json!({"name": "Bright", "all": true, "remember": false})).unwrap();
assert_eq!(mask_adjust(&s, *all.last().unwrap()).exposure, 1.0);
// the other selected photo's "Face" mask gets the effect too, in the same undo step
s.execute("library.select", &json!({"ids": ids, "active": ids[1]})).unwrap();
s.execute("mask.add", &json!({"kind": "radial", "name": "face"})).unwrap();
s.execute("mask.add", &json!({"kind": "radial", "name": "Other"})).unwrap();
s.execute("library.select", &json!({"ids": ids, "active": ids[0]})).unwrap();
with_effect(&mut s, "Warm", json!({"temp": 20}));
let r = s.execute("mask.applyEffect", &json!({"name": "Warm", "id": face, "photos": "selected", "remember": false})).unwrap();
assert_eq!(r["photos"], 2);
let other = s.develop_of(lightcraft_catalog::PhotoId(ids[1])).unwrap();
assert_eq!(other.masks.iter().map(|m| m.adjust.temp).collect::<Vec<_>>(), [20.0, 0.0]);
s.execute("edit.undo", &json!({})).unwrap();
let other = s.develop_of(lightcraft_catalog::PhotoId(ids[1])).unwrap();
assert_eq!(other.masks[0].adjust.temp, 0.0, "undone on every photo");
assert_eq!(mask_adjust(&s, face).temp, 0.0);
}
#[test]
fn new_masks_start_with_the_last_effect_of_their_tool() {
let mut s = Session::with_demo();
with_effect(&mut s, "Dodge", json!({"exposure": 0.5}));
with_effect(&mut s, "Grad", json!({"highlights": -40}));
s.execute("mask.add", &json!({"kind": "brush"})).unwrap();
s.execute("mask.applyEffect", &json!({"name": "Dodge"})).unwrap();
s.execute("mask.add", &json!({"kind": "linear"})).unwrap();
s.execute("mask.applyEffect", &json!({"name": "Grad"})).unwrap();
assert_eq!(s.execute("mask.effects", &json!({})).unwrap()["toolEffects"], json!({"brush": "Dodge", "linear": "Grad"}));
// a new brush mask (painted with no mask selected) starts as Dodge, a new gradient as Grad
s.execute("mask.select", &json!({"id": null})).unwrap();
s.execute("mask.brushStroke", &json!({"points": [[0.2, 0.2], [0.3, 0.3]]})).unwrap();
assert_eq!(mask_adjust(&s, s.active_mask.unwrap()).exposure, 0.5);
s.execute("mask.add", &json!({"kind": "linear"})).unwrap();
assert_eq!(mask_adjust(&s, s.active_mask.unwrap()).highlights, -40.0);
s.execute("mask.add", &json!({"kind": "radial"})).unwrap();
assert_eq!(mask_adjust(&s, s.active_mask.unwrap()).exposure, 0.0, "radial has none");
// set / clear explicitly; renaming and deleting the effect follow
s.execute("mask.toolEffect", &json!({"tool": "radial", "name": "dodge"})).unwrap();
assert!(s.execute("mask.toolEffect", &json!({"tool": "radial", "name": "nope"})).is_err());
s.execute("mask.renameEffect", &json!({"name": "Dodge", "to": "Dodge 2"})).unwrap();
assert_eq!(s.mask_tool_effects.get("brush").map(String::as_str), Some("Dodge 2"));
s.execute("mask.deleteEffect", &json!({"name": "Dodge 2"})).unwrap();
assert!(!s.mask_tool_effects.contains_key("brush") && !s.mask_tool_effects.contains_key("radial"));
s.execute("mask.toolEffect", &json!({"tool": "linear"})).unwrap();
assert!(s.mask_tool_effects.is_empty());
}
#[test]
fn lightroom_folder_import_groups_by_dividers_and_round_trips() {
let lib = temp_dir("folder");
let src = lib.join("Local Adjustment Presets");
std::fs::create_dir_all(src.join("Kit")).unwrap();
let files: [(&str, String); 7] = [
("01 Burn.lrtemplate", lr_local("01 Burn", "\t\texposure2012 = -0.25,")),
("10 ----- DETAIL ----- 10.lrtemplate", lr_local("10 ----- DETAIL ----- 10", ZERO)),
("12 Sky.lrtemplate", lr_local("12 Sky | Cloud", "\t\thighlights2012 = -1,\n\t\tgrain = 0.06,")),
("20 ----- RETOUCHING ----- 20.lrtemplate", lr_local("20 ----- RETOUCHING ----- 20", ZERO)),
("21 Skin.lrtemplate", lr_local("21 Skin", "\t\tclarity2012 = -1,\n\t\tsharpness = -0.25,")),
("Kit/Glow.lrtemplate", lr_local("Glow", "\t\tdehaze = -0.2,")),
("Look.lrtemplate", "s = { title = \"Look\", type = \"Develop\", value = { settings = { Exposure2012 = 0.5 } } }".to_string()),
];
for (f, text) in &files {
std::fs::write(src.join(f), text).unwrap();
}
std::fs::write(src.join("broken.lrtemplate"), "s = { type = \"LocalizedAdjustmentPreset\", value = 5 }").unwrap();
{
let mut s = Session::new().with_fs();
s.open_library(&lib, true).unwrap();
// an earlier import that kept the dividers as effects
s.mask_effects.push(crate::cmd::mask_effects::MaskEffect { name: "10 ----- DETAIL ----- 10".into(), ..Default::default() });
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["effectDividers"].as_array().unwrap().len(), 2);
assert_eq!(r["failed"].as_array().unwrap().len(), 1, "{r}");
let groups: Vec<(String, String)> = s.mask_effects.iter().map(|e| (e.name.clone(), e.group.clone())).collect();
assert_eq!(
groups,
[
("01 Burn".to_string(), "".to_string()),
("12 Sky | Cloud".into(), "Detail".into()),
("21 Skin".into(), "Retouching".into()),
("Glow".into(), "Kit".into()),
],
"the old divider effect is gone; folders and dividers give groups"
);
let sky = &r["effects"].as_array().unwrap().iter().find(|e| e["name"] == "12 Sky | Cloud").unwrap()["unmapped"];
assert_eq!(sky, &json!(["Grain"]));
// the effects' own import: a dry run changes nothing
let r = s.execute("mask.importEffects", &json!({"path": src.to_string_lossy(), "dryRun": true, "group": "X"})).unwrap();
assert_eq!(r["imported"].as_array().unwrap().len(), 4);
assert!(s.mask_effects.iter().all(|e| e.group != "X"));
// export one group, everything; re-import keeps groups, stars and the kept grain
s.execute("mask.favoriteEffect", &json!({"name": "21 Skin"})).unwrap();
let out = lib.join("backup.lceffect");
let r = s.execute("mask.exportEffects", &json!({"path": out.to_string_lossy(), "group": "retouching"})).unwrap();
assert_eq!(r["count"], 1);
assert!(s.execute("mask.exportEffects", &json!({"path": out.to_string_lossy(), "group": "none"})).is_err());
s.execute("mask.exportEffects", &json!({"path": out.to_string_lossy()})).unwrap();
let before = s.mask_effects.clone();
s.execute("mask.deleteEffect", &json!({"names": before.iter().map(|e| e.name.clone()).collect::<Vec<_>>()})).unwrap();
// through the general import too (File ▸ Import Profiles & Presets…, drag & drop)
let r = s.execute("preset.import", &json!({"paths": [out.to_string_lossy()]})).unwrap();
assert_eq!(r["effects"].as_array().unwrap().len(), 4);
assert_eq!(s.mask_effects, before, "round trip");
assert_eq!(s.mask_effects[1].extra.get("grain"), Some(&json!(0.06)));
s.close_library().unwrap();
}
let mut s = Session::new().with_fs();
s.open_library(&lib, false).unwrap();
assert_eq!(s.mask_effects.len(), 4, "persisted");
assert!(s.mask_effects[2].favorite);
let _ = std::fs::remove_dir_all(&lib);
}
#[test]
fn zips_and_camera_raw_xmp_presets_import() {
let lib = temp_dir("zip");
let xmp = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="" xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:PresetType="Local" crs:LocalSaturation="-0.5">
<crs:Name><rdf:Alt><rdf:li xml:lang="x-default">Mute</rdf:li></rdf:Alt></crs:Name>
</rdf:Description></rdf:RDF></x:xmpmeta>"#;
let develop_xmp = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="" xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:Exposure2012="0.5" crs:Name="Bright"/></rdf:RDF></x:xmpmeta>"#;
let brush = lr_local("Brush A", "\t\tshadows2012 = 0.5,");
let zip = crate::preset_import::tests::zip(
&[("Skin Kit/Brush A.lrtemplate", brush.as_bytes()), ("Skin Kit/Mute.xmp", xmp.as_bytes()), ("Looks/Bright.xmp", develop_xmp.as_bytes())],
true,
);
let path = lib.join("bundle.zip");
std::fs::write(&path, zip).unwrap();
let mut s = Session::with_demo();
let r = s.execute("preset.import", &json!({"paths": [path.to_string_lossy()]})).unwrap();
assert_eq!(r["imported"].as_array().unwrap().len(), 1, "the develop XMP: {r}");
assert_eq!(r["effects"].as_array().unwrap().len(), 2);
let got: Vec<(String, String)> = s.mask_effects.iter().map(|e| (e.name.clone(), e.group.clone())).collect();
assert_eq!(got, [("Brush A".to_string(), "Skin Kit".to_string()), ("Mute".into(), "Skin Kit".into())]);
assert_eq!(s.mask_effects[1].adjust.saturation, -50.0);
// the effects' own import reads the zip and a lone XMP; a develop XMP named on its own fails
let mut s = Session::with_demo();
let lone = lib.join("Mute.xmp");
std::fs::write(&lone, xmp).unwrap();
let dev = lib.join("Bright.xmp");
std::fs::write(&dev, develop_xmp).unwrap();
let r = s.execute("mask.importEffects", &json!({"paths": [path.to_string_lossy(), lone.to_string_lossy(), dev.to_string_lossy()]})).unwrap();
assert_eq!(r["imported"].as_array().unwrap().len(), 3);
assert_eq!(r["failed"].as_array().unwrap().len(), 1);
assert_eq!(s.mask_effects.len(), 2, "same names replaced");
// unreadable things are errors, never panics
std::fs::write(lib.join("junk.zip"), b"PK\x03\x04\xff\xff").unwrap();
std::fs::write(lib.join("junk.lceffect"), b"{\"effects\": [{\"name\": \"x\", \"adjust\": {\"exposure\": \"high\"}}]}").unwrap();
for f in ["junk.zip", "junk.lceffect", "missing.lrtemplate"] {
let r = s.execute("mask.importEffects", &json!({"path": lib.join(f).to_string_lossy()})).unwrap();
assert_eq!(r["failed"].as_array().unwrap().len(), 1, "{f}: {r}");
let _ = s.execute("preset.import", &json!({"paths": [lib.join(f).to_string_lossy()]}));
}
assert!(s.execute("mask.importEffects", &json!({})).is_err());
let _ = std::fs::remove_dir_all(&lib);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.