Skip to content

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

LR-IMP-PROFILES: carry masks over from presets, .lrtemplate and XMP sidecars

Brandon Thomasb7d497d049c1
diff --git a/crates/develop/src/presets.rs b/crates/develop/src/presets.rs
index f00e7bca6..64bb116ca 100644
--- a/crates/develop/src/presets.rs
+++ b/crates/develop/src/presets.rs
@@ -208,8 +208,29 @@ impl Preset {
pub fn from_settings(id: &str, name: &str, group: &str, s: &DevelopSettings, groups: &[SettingsGroup]) -> Preset {
Preset { id: id.into(), name: name.into(), group: group.into(), settings: extract_groups(s, groups), favorite: false, builtin: false }
}
+ /// Apply at `amount` (1.0 = 100 %). Masks in the preset are added to the photo's own (ones it
+ /// already has are skipped), their effect scaled by the amount.
pub fn apply(&self, s: &DevelopSettings, amount: f64) -> DevelopSettings {
- apply_partial(s, &self.settings, amount)
+ let Some(masks) = self.settings.get("masks").and_then(Value::as_array).filter(|m| !m.is_empty()) else {
+ return apply_partial(s, &self.settings, amount);
+ };
+ let mut rest = self.settings.clone();
+ if let Some(o) = rest.as_object_mut() {
+ o.remove("masks");
+ }
+ let mut out = apply_partial(s, &rest, amount);
+ let mut next = out.masks.iter().map(|m| m.id).max().unwrap_or(0);
+ for m in masks {
+ let Ok(mut m) = serde_json::from_value::<crate::Mask>(m.clone()) else { continue };
+ if out.masks.iter().any(|q| q.name == m.name && q.components == m.components) {
+ continue;
+ }
+ next += 1;
+ m.id = next;
+ m.adjust.amount = (m.adjust.amount * amount).clamp(0.0, 200.0);
+ out.masks.push(m);
+ }
+ out
}
}
diff --git a/crates/engine/src/crs.rs b/crates/engine/src/crs.rs
index ec56ebaac..dce623d02 100644
--- a/crates/engine/src/crs.rs
+++ b/crates/engine/src/crs.rs
@@ -354,10 +354,25 @@ pub fn to_partial(props: &Props, raw: Option<bool>) -> Value {
/// [`to_partial`], plus the adjustments in the packet it could not carry over (field names
/// without the `crs:` prefix, grouped: `CameraProfile`, `Look`, `MaskGroupBasedCorrections`…).
-pub fn to_partial_report(props: &Props, raw: Option<bool>) -> (Value, Vec<String>) {
+///
+/// With `values` (the packet's structured properties), local corrections become masks too
+/// ([`crate::crs_masks`]; radial masks fitted to `aspect` = width / height); components that
+/// can't be carried over are reported as `Mask: <kind>`.
+pub fn to_partial_report(props: &Props, values: Option<&crate::crs_masks::Values>, raw: Option<bool>, aspect: f64) -> (Value, Vec<String>) {
READ.with(|r| *r.borrow_mut() = Some(Default::default()));
- let out = to_partial(props, raw);
- let read = READ.with(|r| r.borrow_mut().take()).unwrap_or_default();
+ let mut out = to_partial(props, raw);
+ let mut read = READ.with(|r| r.borrow_mut().take()).unwrap_or_default();
+ let mut mask_skips = Vec::new();
+ if let Some(values) = values {
+ let (masks, skipped) = crate::crs_masks::masks(values, aspect);
+ if !masks.is_empty() {
+ put(&mut out, "masks", Value::Array(masks));
+ }
+ if values.keys().any(|k| crate::crs_masks::CONTAINERS.contains(&k.as_str())) {
+ read.extend(crate::crs_masks::CONTAINERS.iter().map(|c| c.to_string()));
+ mask_skips = skipped.into_iter().map(|k| format!("Mask: {k}")).collect();
+ }
+ }
// fields that only switch a panel on/off or name things: not adjustments by themselves
let quiet = |k: &str| k.starts_with("Enable") || k.starts_with("ToneCurveName") || k == "AutoTone" || k == "AutoGrayscaleMix";
let mut unmapped: Vec<String> = props
@@ -369,6 +384,7 @@ pub fn to_partial_report(props: &Props, raw: Option<bool>) -> (Value, Vec<String
.filter(|k| !quiet(k))
.collect();
unmapped.dedup();
+ unmapped.extend(mask_skips);
(out, unmapped)
}
diff --git a/crates/engine/src/crs_masks.rs b/crates/engine/src/crs_masks.rs
new file mode 100644
index 000000000..feea9234c
--- /dev/null
+++ b/crates/engine/src/crs_masks.rs
@@ -0,0 +1,379 @@
+//! Interchange: local corrections (masks) stored as `crs:` structures in XMP sidecars, XMP
+//! presets and `.lrtemplate` files → our [`Mask`](lightcraft_develop::Mask)s.
+//!
+//! Four containers hold them: `MaskGroupBasedCorrections` (current: each correction has a list
+//! of mask components) and the older `GradientBasedCorrections`, `CircularGradientBasedCorrections`
+//! and `PaintBasedCorrections`. Every correction carries its local sliders (`Local*`, stored as
+//! −1..1 fractions; exposure ×4 EV) and its components (`crs:What` = `Mask/Gradient`,
+//! `Mask/CircularGradient`, `Mask/Paint`, `Mask/Image`, `Mask/RangeMask`).
+//!
+//! Implemented from the public XMP data model and black-box observation; best effort — the
+//! pipelines differ, and the component combine modes and AI mask kinds are mapped from what the
+//! fields evidently mean. Unsupported components are reported, never guessed.
+
+use std::collections::BTreeMap;
+
+use lightcraft_meta::XmpValue;
+use serde_json::{Value, json};
+
+/// Top-level properties keyed `prefix:name`, with structure.
+pub type Values = BTreeMap<String, XmpValue>;
+
+/// The containers this module reads.
+pub const CONTAINERS: [&str; 4] =
+ ["crs:MaskGroupBasedCorrections", "crs:GradientBasedCorrections", "crs:CircularGradientBasedCorrections", "crs:PaintBasedCorrections"];
+
+fn text<'a>(v: &'a XmpValue, k: &str) -> Option<&'a str> {
+ v.field(k).and_then(XmpValue::text).filter(|s| !s.is_empty())
+}
+
+fn num(v: &XmpValue, k: &str) -> Option<f64> {
+ let s = text(v, k)?;
+ let s = s.strip_prefix('+').unwrap_or(s);
+ s.parse::<f64>().ok().filter(|x| x.is_finite())
+}
+
+fn flag(v: &XmpValue, k: &str) -> Option<bool> {
+ text(v, k).map(|s| s.eq_ignore_ascii_case("true") || s == "1")
+}
+
+/// Local slider fields → (our `adjust` field, scale from the stored fraction).
+const LOCAL: &[(&str, &str, f64)] = &[
+ ("LocalExposure2012", "exposure", 4.0),
+ ("LocalContrast2012", "contrast", 100.0),
+ ("LocalHighlights2012", "highlights", 100.0),
+ ("LocalShadows2012", "shadows", 100.0),
+ ("LocalWhites2012", "whites", 100.0),
+ ("LocalBlacks2012", "blacks", 100.0),
+ ("LocalClarity2012", "clarity", 100.0),
+ ("LocalTexture", "texture", 100.0),
+ ("LocalDehaze", "dehaze", 100.0),
+ ("LocalTemperature", "temp", 100.0),
+ ("LocalTint", "tint", 100.0),
+ ("LocalSaturation", "saturation", 100.0),
+ ("LocalHue", "hue", 100.0),
+ ("LocalSharpness", "sharpness", 100.0),
+ ("LocalLuminanceNoise", "noise", 100.0),
+ ("LocalMoire", "moire", 100.0),
+ ("LocalDefringe", "defringe", 100.0),
+ ("LocalToningSaturation", "color_sat", 100.0),
+ ("LocalToningHue", "color_hue", 1.0),
+ // older process versions
+ ("LocalExposure", "exposure", 4.0),
+ ("LocalContrast", "contrast", 100.0),
+ ("LocalClarity", "clarity", 100.0),
+];
+
+fn adjust(c: &XmpValue) -> 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}")) {
+ let lim = if *ours == "exposure" {
+ 4.0
+ } else if *ours == "color_hue" {
+ 360.0
+ } else {
+ 100.0
+ };
+ let v = (v * k).clamp(if *ours == "color_hue" { 0.0 } else { -lim }, lim);
+ a.insert((*ours).into(), json!(v));
+ }
+ }
+ 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)
+}
+
+/// Perceptual lightness 0..1 (how range masks store luminance) → our range scale: log
+/// luminance on −8..+4 EV mapped to 0..1.
+fn lightness_to_range(l: f64) -> f64 {
+ let y = l.clamp(1e-4, 1.0).powf(2.2);
+ ((y.log2() + 8.0) / 12.0).clamp(0.0, 1.0)
+}
+
+fn pt(x: f64, y: f64) -> Value {
+ json!({"x": x, "y": y})
+}
+
+/// One mask component → our component JSON; `Err(kind)` names an unsupported one.
+fn component(m: &XmpValue, aspect: f64) -> Result<Value, String> {
+ let what = text(m, "crs:What").unwrap_or("");
+ let op = match num(m, "crs:MaskBlendMode").unwrap_or(0.0) as i64 {
+ 1 => "subtract",
+ 2 => "intersect",
+ _ => "add",
+ };
+ let invert = flag(m, "crs:MaskInverted").unwrap_or(false);
+ // positions are fractions of the image's width / height; our radii are in long-edge units
+ let (sx, sy) = if aspect >= 1.0 { (1.0, 1.0 / aspect) } else { (aspect, 1.0) };
+ let shape = match what {
+ "Mask/Gradient" => {
+ let g = |k: &str, d: f64| num(m, &format!("crs:{k}")).unwrap_or(d);
+ json!({"kind": "linear", "start": pt(g("FullX", 0.5), g("FullY", 0.0)), "end": pt(g("ZeroX", 0.5), g("ZeroY", 1.0))})
+ }
+ "Mask/CircularGradient" => {
+ let g = |k: &str, d: f64| num(m, &format!("crs:{k}")).unwrap_or(d);
+ let (l, r, t, b) = (g("Left", 0.25), g("Right", 0.75), g("Top", 0.25), g("Bottom", 0.75));
+ json!({
+ "kind": "radial",
+ "center": pt((l + r) / 2.0, (t + b) / 2.0),
+ "rx": ((r - l).abs() / 2.0 * sx).max(1e-3),
+ "ry": ((b - t).abs() / 2.0 * sy).max(1e-3),
+ "angle": g("Angle", 0.0),
+ "feather": g("Feather", 50.0).clamp(0.0, 100.0),
+ "invert": flag(m, "crs:Flipped").unwrap_or(false),
+ })
+ }
+ "Mask/Paint" => {
+ let pts: Vec<Value> = m
+ .field("crs:Dabs")
+ .map(XmpValue::items)
+ .unwrap_or_default()
+ .iter()
+ .filter_map(XmpValue::text)
+ .filter_map(|d| {
+ let mut it = d.split_whitespace().skip(1).filter_map(|v| v.parse::<f64>().ok());
+ Some(pt(it.next()?, it.next()?))
+ })
+ .collect();
+ if pts.is_empty() {
+ return Err("empty brush".into());
+ }
+ let erase = num(m, "crs:MaskValue").is_some_and(|v| v <= 0.0);
+ json!({"kind": "brush", "strokes": [{
+ "points": pts,
+ "size": num(m, "crs:Radius").unwrap_or(0.03).clamp(0.001, 1.0),
+ "feather": (num(m, "crs:CenterWeight").unwrap_or(0.5) * 100.0).clamp(0.0, 100.0),
+ "flow": (num(m, "crs:Flow").unwrap_or(1.0) * 100.0).clamp(0.0, 100.0),
+ "density": (num(m, "crs:MaskValue").unwrap_or(1.0).abs() * 100.0).clamp(0.0, 100.0),
+ "erase": erase,
+ }]})
+ }
+ "Mask/Image" => match text(m, "crs:MaskSubType") {
+ Some("1") => json!({"kind": "subject"}),
+ Some("2") => json!({"kind": "sky"}),
+ other => return Err(format!("AI mask ({})", other.unwrap_or("?"))),
+ },
+ "Mask/RangeMask" => {
+ let r = m.field("crs:CorrectionRangeMask").unwrap_or(m);
+ match text(r, "crs:Type") {
+ Some("2") => {
+ let q: Vec<f64> = text(r, "crs:LumRange").unwrap_or("0 0 1 1").split_whitespace().filter_map(|v| v.parse().ok()).collect();
+ let [a, b, c, d] = q[..] else { return Err("luminance range".into()) };
+ let (a, b, c, d) = (lightness_to_range(a), lightness_to_range(b), lightness_to_range(c), lightness_to_range(d));
+ json!({"kind": "luminanceRange", "lo": b, "hi": c, "lo_feather": (b - a).max(0.0), "hi_feather": (d - c).max(0.0)})
+ }
+ Some("3") => {
+ let q: Vec<f64> = text(r, "crs:DepthRange").unwrap_or("0 0 1 1").split_whitespace().filter_map(|v| v.parse().ok()).collect();
+ let [a, b, c, _] = q[..] else { return Err("depth range".into()) };
+ json!({"kind": "depthRange", "lo": b, "hi": c, "feather": (b - a).max(0.0)})
+ }
+ _ => return Err("colour range".into()),
+ }
+ }
+ other => return Err(if other.is_empty() { "unknown mask".into() } else { other.trim_start_matches("Mask/").to_string() }),
+ };
+ Ok(json!({"op": op, "invert": invert, "shape": shape}))
+}
+
+/// Masks in `values` (JSON for `DevelopSettings::masks`), plus the kinds of component that
+/// couldn't be carried over. `aspect` = width / height of the target (presets: assume 3:2).
+pub fn masks(values: &Values, aspect: f64) -> (Vec<Value>, Vec<String>) {
+ let mut out = Vec::new();
+ let mut skipped = Vec::new();
+ for container in CONTAINERS {
+ let Some(list) = values.get(container) else { continue };
+ for c in list.items() {
+ if flag(c, "crs:CorrectionActive") == Some(false) {
+ continue;
+ }
+ let comps = c.field("crs:CorrectionMasks").map(XmpValue::items).unwrap_or_default();
+ let mut parts = Vec::new();
+ for m in comps {
+ match component(m, aspect) {
+ Ok(v) => parts.push(v),
+ Err(kind) => skipped.push(kind),
+ }
+ }
+ if parts.is_empty() {
+ continue;
+ }
+ // brush dabs of one correction are one brush component
+ let mut merged: Vec<Value> = Vec::new();
+ for p in parts {
+ let is_brush = p["shape"]["kind"] == "brush";
+ if is_brush
+ && let Some(prev) = merged.iter_mut().find(|q| q["shape"]["kind"] == "brush" && q["op"] == p["op"])
+ && let (Some(a), Some(b)) = (prev["shape"]["strokes"].as_array_mut(), p["shape"]["strokes"].as_array())
+ {
+ a.extend(b.iter().cloned());
+ continue;
+ }
+ merged.push(p);
+ }
+ let n = out.len() + 1;
+ let name = text(c, "crs:CorrectionName").map(str::to_string).unwrap_or_else(|| format!("Mask {n}"));
+ out.push(json!({"id": n, "name": name, "visible": true, "invert": false, "components": merged, "adjust": adjust(c)}));
+ }
+ }
+ skipped.sort();
+ skipped.dedup();
+ (out, skipped)
+}
+
+/// A `.lrtemplate` Lua value as an XMP value (field names get the `crs:` prefix).
+pub fn from_lua(v: &crate::preset_import::Lua) -> XmpValue {
+ use crate::preset_import::Lua;
+ match v {
+ Lua::Nil => XmpValue::Text(String::new()),
+ Lua::Bool(b) => XmpValue::Text(if *b { "true" } else { "false" }.into()),
+ Lua::Num(n) => XmpValue::Text(format!("{n}")),
+ Lua::Str(s) => XmpValue::Text(s.clone()),
+ Lua::Table(arr, map) if map.is_empty() => XmpValue::Array(arr.iter().map(from_lua).collect()),
+ Lua::Table(_, map) => XmpValue::Struct(map.iter().map(|(k, v)| (format!("crs:{k}"), from_lua(v))).collect()),
+ }
+}
+
+/// The aspect radial masks are computed for when the target's shape isn't known yet.
+pub const DEFAULT_ASPECT: f64 = 1.5;
+
+/// Re-fit radial masks in `partial` (computed for aspect `from`) to a target of aspect `to`.
+pub fn refit_radials(partial: &mut Value, from: f64, to: f64) {
+ let scale = |a: f64| if a >= 1.0 { (1.0, 1.0 / a) } else { (a, 1.0) };
+ let ((fx, fy), (tx, ty)) = (scale(from), scale(to));
+ let Some(masks) = partial.get_mut("masks").and_then(Value::as_array_mut) else { return };
+ for m in masks {
+ for c in m["components"].as_array_mut().into_iter().flatten() {
+ let s = &mut c["shape"];
+ if s["kind"] == "radial" {
+ if let Some(rx) = s["rx"].as_f64() {
+ s["rx"] = json!(rx / fx * tx);
+ }
+ if let Some(ry) = s["ry"].as_f64() {
+ s["ry"] = json!(ry / fy * ty);
+ }
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use lightcraft_develop::{DevelopSettings, MaskOp, MaskShape};
+
+ /// A packet in the shape local corrections take (values written for this test).
+ const PACKET: &str = 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.2">
+ <crs:MaskGroupBasedCorrections><rdf:Seq>
+ <rdf:li><rdf:Description crs:What="Correction" crs:CorrectionAmount="1" crs:CorrectionActive="true" crs:CorrectionName="Darker sky"
+ crs:LocalExposure2012="-0.25" crs:LocalSaturation="0.3" crs:LocalTemperature="-0.1">
+ <crs:CorrectionMasks><rdf:Seq>
+ <rdf:li crs:What="Mask/Image" crs:MaskSubType="2" crs:MaskBlendMode="0" crs:MaskInverted="false"/>
+ <rdf:li crs:What="Mask/Gradient" crs:MaskBlendMode="2" crs:FullX="0.5" crs:FullY="0" crs:ZeroX="0.5" crs:ZeroY="0.6"/>
+ </rdf:Seq></crs:CorrectionMasks>
+ </rdf:Description></rdf:li>
+ <rdf:li><rdf:Description crs:What="Correction" crs:CorrectionAmount="0.5" crs:LocalContrast2012="0.2">
+ <crs:CorrectionMasks><rdf:Seq>
+ <rdf:li crs:What="Mask/CircularGradient" crs:Top="0.3" crs:Left="0.2" crs:Bottom="0.7" crs:Right="0.8" crs:Angle="10" crs:Feather="40" crs:Flipped="true"/>
+ <rdf:li crs:What="Mask/RangeMask" crs:MaskBlendMode="2"><crs:CorrectionRangeMask crs:Type="2" crs:LumRange="0.4 0.5 0.8 0.9"/></rdf:li>
+ <rdf:li crs:What="Mask/Image" crs:MaskSubType="9"/>
+ </rdf:Seq></crs:CorrectionMasks>
+ </rdf:Description></rdf:li>
+ <rdf:li><rdf:Description crs:What="Correction" crs:CorrectionActive="false" crs:LocalExposure2012="1">
+ <crs:CorrectionMasks><rdf:Seq><rdf:li crs:What="Mask/Image" crs:MaskSubType="1"/></rdf:Seq></crs:CorrectionMasks>
+ </rdf:Description></rdf:li>
+ </rdf:Seq></crs:MaskGroupBasedCorrections>
+ <crs:PaintBasedCorrections><rdf:Seq>
+ <rdf:li crs:What="Correction" crs:LocalClarity2012="0.4"><crs:CorrectionMasks><rdf:Seq>
+ <rdf:li crs:What="Mask/Paint" crs:Radius="0.05" crs:Flow="0.8" crs:CenterWeight="0.3" crs:MaskValue="1">
+ <crs:Dabs><rdf:Seq><rdf:li>d 0.1 0.2</rdf:li><rdf:li>d 0.15 0.22</rdf:li></rdf:Seq></crs:Dabs></rdf:li>
+ <rdf:li crs:What="Mask/Paint" crs:Radius="0.02" crs:MaskValue="1"><crs:Dabs><rdf:Seq><rdf:li>d 0.5 0.5</rdf:li></rdf:Seq></crs:Dabs></rdf:li>
+ </rdf:Seq></crs:CorrectionMasks></rdf:li>
+ </rdf:Seq></crs:PaintBasedCorrections>
+</rdf:Description></rdf:RDF></x:xmpmeta>"#;
+
+ fn settings() -> (DevelopSettings, Vec<String>) {
+ let d = lightcraft_meta::parse_xmp(PACKET).unwrap();
+ let (partial, unmapped) = crate::crs::to_partial_report(&d.properties, Some(&d.values), None, 1.5);
+ (DevelopSettings::default().merged(&partial).expect("valid settings"), unmapped)
+ }
+
+ #[test]
+ fn corrections_become_masks() {
+ let (s, unmapped) = settings();
+ assert_eq!(s.light.exposure, 0.2, "global settings still map");
+ assert_eq!(s.masks.len(), 3, "inactive corrections are skipped: {:?}", s.masks);
+ let sky = &s.masks[0];
+ assert_eq!(sky.name, "Darker sky");
+ assert_eq!((sky.adjust.exposure, sky.adjust.saturation, sky.adjust.temp, sky.adjust.amount), (-1.0, 30.0, -10.0, 100.0));
+ assert_eq!(sky.components[0].shape, MaskShape::Sky);
+ assert_eq!(sky.components[1].op, MaskOp::Intersect);
+ let MaskShape::Linear { start, end } = &sky.components[1].shape else { panic!() };
+ assert_eq!((start.y, end.y), (0.0, 0.6), "full effect at the Full point");
+ let rad = &s.masks[1];
+ assert_eq!((rad.name.as_str(), rad.adjust.contrast, rad.adjust.amount), ("Mask 2", 20.0, 50.0));
+ let MaskShape::Radial { center, rx, ry, angle, feather, invert } = &rad.components[0].shape else { panic!() };
+ assert!((center.x - 0.5).abs() < 1e-9 && (center.y - 0.5).abs() < 1e-9);
+ assert!((rx - 0.3).abs() < 1e-9 && (ry - 0.2 / 1.5).abs() < 1e-9, "radii in long-edge units: {rx} {ry}");
+ assert_eq!((*angle, *feather, *invert), (10.0, 40.0, true));
+ let MaskShape::LuminanceRange { lo, hi, lo_feather, .. } = &rad.components[1].shape else { panic!() };
+ assert!(lo < hi && *lo_feather > 0.0);
+ let brush = &s.masks[2];
+ assert_eq!(brush.adjust.clarity, 40.0);
+ assert_eq!(brush.components.len(), 1, "the brush's dab runs are one component");
+ let MaskShape::Brush { strokes } = &brush.components[0].shape else { panic!() };
+ assert_eq!((strokes.len(), strokes[0].points.len(), strokes[0].flow, strokes[0].feather), (2, 2, 80.0, 30.0));
+ assert_eq!(unmapped, vec!["Mask: AI mask (9)".to_string()]);
+ }
+
+ #[test]
+ fn masks_render() {
+ let (s, _) = settings();
+ let img = lightcraft_scenes::demo_library()[0].render(96, 64);
+ let render = |d: &DevelopSettings| {
+ lightcraft_pipeline::render(&img, &Default::default(), d, &lightcraft_pipeline::RenderRequest::fit(96, 64)).image.data
+ };
+ assert_ne!(render(&DevelopSettings { light: s.light, ..Default::default() }), render(&s), "the masks change the picture");
+ }
+
+ #[test]
+ fn lrtemplate_corrections() {
+ let t = r#"s = { title = "Grad", value = { settings = { Exposure2012 = 0.1, GradientBasedCorrections = {
+ { What = "Correction", CorrectionAmount = 1, LocalExposure2012 = -0.5, CorrectionMasks = {
+ { What = "Mask/Gradient", ZeroX = 0.5, ZeroY = 0.5, FullX = 0.5, FullY = 0, MaskValue = 1 } } } } } } }"#;
+ let v = crate::preset_import::read_presets("Grad.lrtemplate", t.as_bytes(), None).unwrap();
+ assert!(v[0].unmapped.is_empty(), "{:?}", v[0].unmapped);
+ let s = DevelopSettings::default().merged(&v[0].preset.settings).unwrap();
+ assert_eq!(s.masks.len(), 1);
+ assert_eq!(s.masks[0].adjust.exposure, -2.0);
+ }
+
+ #[test]
+ fn presets_add_masks_once() {
+ let (s, _) = settings();
+ let partial = json!({"masks": serde_json::to_value(&s.masks).unwrap(), "light": {"exposure": 0.5}});
+ let p =
+ lightcraft_develop::Preset { id: "t".into(), name: "t".into(), group: "g".into(), settings: partial, favorite: false, builtin: false };
+ let mut mine = DevelopSettings::default();
+ mine.masks.push(lightcraft_develop::Mask { id: 7, name: "Mine".into(), ..Default::default() });
+ let once = p.apply(&mine, 1.0);
+ assert_eq!(once.masks.len(), 4, "added to the photo's own mask");
+ assert_eq!(once.masks[1].id, 8, "fresh ids");
+ assert_eq!(p.apply(&once, 1.0).masks.len(), 4, "applying again adds nothing");
+ let half = p.apply(&mine, 0.5);
+ assert_eq!(half.masks[1].adjust.amount, 50.0, "amount scales the masks");
+ }
+
+ #[test]
+ fn sidecar_radials_fit_the_photo() {
+ let mut v = json!({"masks": [{"components": [{"shape": {"kind": "radial", "rx": 0.3, "ry": 0.2}}]}]});
+ refit_radials(&mut v, 1.5, 1.0);
+ let s = &v["masks"][0]["components"][0]["shape"];
+ assert!((s["rx"].as_f64().unwrap() - 0.3).abs() < 1e-9);
+ assert!((s["ry"].as_f64().unwrap() - 0.3).abs() < 1e-9, "square photo: y radius = its box half-height");
+ }
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index b3cac0a66..5bae1b709 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -12,6 +12,7 @@
pub mod cmd;
pub mod crs;
+pub mod crs_masks;
pub mod demo;
pub mod devices;
pub mod export;
diff --git a/crates/engine/src/preset_import.rs b/crates/engine/src/preset_import.rs
index ec24c6b2f..f86ac030e 100644
--- a/crates/engine/src/preset_import.rs
+++ b/crates/engine/src/preset_import.rs
@@ -340,15 +340,20 @@ fn delocalize(s: &str) -> String {
}
}
-/// The develop settings of an `.lrtemplate` as `crs:` properties, plus its title.
-pub fn lrtemplate_props(text: &str) -> Result<(Option<String>, Props), String> {
+/// The develop settings of an `.lrtemplate` as `crs:` properties (flat, and structured for local
+/// corrections), plus its title.
+pub fn lrtemplate_props(text: &str) -> Result<(Option<String>, Props, crate::crs_masks::Values), String> {
let root = parse_lua(text)?;
let title = root.get("title").or_else(|| root.get("internalName")).and_then(Lua::str).map(delocalize).filter(|t| !t.trim().is_empty());
let settings = root.get("value").and_then(|v| v.get("settings")).ok_or("no develop settings in this template")?;
let Lua::Table(_, fields) = settings else { return Err("no develop settings in this template".into()) };
let mut props = Props::new();
+ let mut values = crate::crs_masks::Values::new();
for (k, v) in fields {
let key = format!("crs:{k}");
+ if crate::crs_masks::CONTAINERS.contains(&key.as_str()) {
+ values.insert(key.clone(), crate::crs_masks::from_lua(v));
+ }
let vals: Vec<String> = match v {
Lua::Num(n) => vec![format!("{n}")],
Lua::Bool(b) => vec![if *b { "True" } else { "False" }.to_string()],
@@ -368,7 +373,7 @@ pub fn lrtemplate_props(text: &str) -> Result<(Option<String>, Props), String> {
};
props.insert(key, vals);
}
- Ok((title, props))
+ Ok((title, props, values))
}
// ------------------------------------------------------------------------------- XMP in files
@@ -429,8 +434,8 @@ pub fn group_from_dir(dir: &str) -> Option<String> {
dir.split(['/', '\\']).rev().find(|p| !p.is_empty() && !generic(p)).map(str::to_string)
}
-fn build(props: &Props, name: String, group: Option<String>, from_photo: bool) -> Option<Imported> {
- let (mut settings, unmapped) = crate::crs::to_partial_report(props, None);
+fn build(props: &Props, values: &crate::crs_masks::Values, name: String, group: Option<String>, from_photo: bool) -> Option<Imported> {
+ let (mut settings, unmapped) = crate::crs::to_partial_report(props, Some(values), None, crate::crs_masks::DEFAULT_ASPECT);
if from_photo && let Some(o) = settings.as_object_mut() {
// a photo's own framing and absolute white balance don't belong in a look
o.remove("crop");
@@ -483,8 +488,8 @@ pub fn read_presets(name: &str, bytes: &[u8], group: Option<String>) -> Result<V
}
"lrtemplate" => {
let text = String::from_utf8_lossy(bytes);
- let (title, props) = lrtemplate_props(text.trim_start_matches('\u{feff}'))?;
- build(&props, title.unwrap_or(stem), group, false)
+ let (title, props, values) = lrtemplate_props(text.trim_start_matches('\u{feff}'))?;
+ build(&props, &values, title.unwrap_or(stem), group, false)
.map(|i| vec![i])
.ok_or_else(|| "no develop settings we can use in this template".into())
}
@@ -493,13 +498,13 @@ pub fn read_presets(name: &str, bytes: &[u8], group: Option<String>) -> Result<V
let d = lightcraft_meta::parse_xmp(text.trim_start_matches('\u{feff}')).map_err(|e| e.to_string())?;
let props = &d.properties;
let name = props.get("crs:Name").and_then(|v| v.first()).map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).unwrap_or(stem);
- build(props, name, group, false).map(|i| vec![i]).ok_or_else(|| "no develop settings in this XMP file".into())
+ build(props, &d.values, name, group, false).map(|i| vec![i]).ok_or_else(|| "no develop settings in this XMP file".into())
}
// a photo carrying its edits (mobile "DNG presets", edited JPEG / TIFF)
"dng" | "jpg" | "jpeg" | "tif" | "tiff" => {
let xmp = embedded_xmp(bytes).ok_or("this photo carries no edits (no XMP)")?;
let d = lightcraft_meta::parse_xmp(&xmp).map_err(|e| e.to_string())?;
- build(&d.properties, stem, group, true).map(|i| vec![i]).ok_or_else(|| "this photo carries no edits we can use".into())
+ build(&d.properties, &d.values, stem, group, true).map(|i| vec![i]).ok_or_else(|| "this photo carries no edits we can use".into())
}
_ => crate::presets::parse_preset_file(name, bytes).map(|v| {
v.into_iter()
diff --git a/crates/engine/src/sidecar.rs b/crates/engine/src/sidecar.rs
index 0a54b8e65..ac101580e 100644
--- a/crates/engine/src/sidecar.rs
+++ b/crates/engine/src/sidecar.rs
@@ -125,7 +125,9 @@ pub fn parse_sidecar(xmp: &str, raw: bool) -> std::result::Result<SidecarData, S
let full = d.lc_settings.as_deref().and_then(|j| serde_json::from_str::<Value>(j).ok()).and_then(|v| DevelopSettings::from_json(&v).ok());
out.develop = match full {
Some(s) => Some(DevelopPatch::Full(Box::new(s))),
- None if crate::crs::has_adjustments(&d.properties) => Some(DevelopPatch::Partial(crate::crs::to_partial(&d.properties, Some(raw)))),
+ None if crate::crs::has_adjustments(&d.properties) => {
+ Some(DevelopPatch::Partial(crate::crs::to_partial_report(&d.properties, Some(&d.values), Some(raw), crate::crs_masks::DEFAULT_ASPECT).0))
+ }
None => None,
};
Ok(out)
@@ -164,7 +166,13 @@ pub fn merge_into(p: &mut Photo, sc: &SidecarData, now: &str) -> bool {
}
let develop = match &sc.develop {
Some(DevelopPatch::Full(s)) => (**s).clone(),
- Some(DevelopPatch::Partial(v)) => lightcraft_develop::apply_partial(&p.develop, v, 1.0),
+ Some(DevelopPatch::Partial(v)) => {
+ let mut v = v.clone();
+ if p.width > 0 && p.height > 0 {
+ crate::crs_masks::refit_radials(&mut v, crate::crs_masks::DEFAULT_ASPECT, p.width as f64 / p.height as f64);
+ }
+ lightcraft_develop::apply_partial(&p.develop, &v, 1.0)
+ }
None => return false,
};
if develop == *p.develop {
diff --git a/crates/meta/src/lib.rs b/crates/meta/src/lib.rs
index fe283d955..052cbd6c7 100644
--- a/crates/meta/src/lib.rs
+++ b/crates/meta/src/lib.rs
@@ -20,7 +20,7 @@ pub use datetime::DateTime;
pub use exif::{from_tiff, read_exif, strip_exif_header, try_read_exif, write_exif};
pub use iptc::parse_iptc;
pub use lightcraft_geom::Orientation;
-pub use xmp::{CRS_NS, LC_NS, XmpData, XmpError, parse_xmp, write_xmp, write_xmp_lc};
+pub use xmp::{CRS_NS, LC_NS, XmpData, XmpError, XmpValue, parse_xmp, write_xmp, write_xmp_lc};
use serde::{Deserialize, Serialize};
diff --git a/crates/meta/src/xmp.rs b/crates/meta/src/xmp.rs
index 2643532f6..0c686d894 100644
--- a/crates/meta/src/xmp.rs
+++ b/crates/meta/src/xmp.rs
@@ -65,6 +65,67 @@ pub struct XmpData {
/// Every property found, keyed `prefix:name` (struct fields as `prefix:name/prefix:field`); arrays keep
/// item order, language alternatives put `x-default` first.
pub properties: BTreeMap<String, Vec<String>>,
+ /// Every top-level property with its full structure (arrays of structs such as local
+ /// corrections, which [`XmpData::properties`] flattens).
+ pub values: BTreeMap<String, XmpValue>,
+}
+
+/// A structured XMP value.
+#[derive(Clone, Debug, PartialEq)]
+pub enum XmpValue {
+ Text(String),
+ Array(Vec<XmpValue>),
+ Struct(BTreeMap<String, XmpValue>),
+}
+
+impl XmpValue {
+ /// A struct field (`prefix:name`).
+ pub fn field(&self, k: &str) -> Option<&XmpValue> {
+ match self {
+ XmpValue::Struct(m) => m.get(k),
+ _ => None,
+ }
+ }
+ pub fn text(&self) -> Option<&str> {
+ match self {
+ XmpValue::Text(s) => Some(s.trim()),
+ XmpValue::Array(a) => a.first().and_then(XmpValue::text),
+ XmpValue::Struct(_) => None,
+ }
+ }
+ /// Array items (a lone value is a one-item array).
+ pub fn items(&self) -> &[XmpValue] {
+ match self {
+ XmpValue::Array(a) => a,
+ other => std::slice::from_ref(other),
+ }
+ }
+}
+
+fn node_struct(n: &Node) -> XmpValue {
+ let mut m = BTreeMap::new();
+ for (k, v) in &n.attrs {
+ if !is_rdf_meta_attr(k) {
+ m.insert(k.clone(), XmpValue::Text(v.clone()));
+ }
+ }
+ for c in &n.children {
+ m.insert(c.name.clone(), node_value(c));
+ }
+ XmpValue::Struct(m)
+}
+
+fn node_value(n: &Node) -> XmpValue {
+ if let Some(arr) = n.children.iter().find(|c| matches!(c.name.as_str(), "rdf:Seq" | "rdf:Bag" | "rdf:Alt")) {
+ return XmpValue::Array(arr.children.iter().filter(|li| li.name == "rdf:li").map(node_value).collect());
+ }
+ if let Some(d) = n.children.iter().find(|c| c.name == "rdf:Description") {
+ return node_struct(d);
+ }
+ if !n.children.is_empty() || n.attrs.iter().any(|(k, _)| !is_rdf_meta_attr(k)) {
+ return node_struct(n);
+ }
+ XmpValue::Text(n.attr("rdf:resource").map(str::to_string).unwrap_or_else(|| n.text.trim().to_string()))
}
#[derive(Debug, Default)]
@@ -322,8 +383,12 @@ pub fn parse_xmp(s: &str) -> Result<XmpData, XmpError> {
let mut descs = Vec::new();
find_descriptions(&tree, &mut descs);
let mut props = BTreeMap::new();
+ let mut values = BTreeMap::new();
for d in descs {
collect_description(d, "", &mut props);
+ if let XmpValue::Struct(m) = node_struct(d) {
+ values.extend(m);
+ }
}
let first = |k: &str| props.get(k).and_then(|v| v.first()).map(|s| s.trim().to_string()).filter(|s| !s.is_empty());
let num = |k: &str| first(k).and_then(|s| parse_number(&s));
@@ -394,7 +459,7 @@ pub fn parse_xmp(s: &str) -> Result<XmpData, XmpError> {
m.gps = Some(Gps { latitude: lat, longitude: lon, altitude });
}
let lc_settings = props.get("lc:settings").and_then(|v| v.first()).cloned();
- Ok(XmpData { metadata: m, lc_settings, properties: props })
+ Ok(XmpData { metadata: m, lc_settings, properties: props, values })
}
fn frac(v: f64) -> String {
diff --git a/docs/parity.md b/docs/parity.md
index dff3abe6d..51f07aa2e 100644
--- a/docs/parity.md
+++ b/docs/parity.md
@@ -106,7 +106,7 @@ under the UI command that wraps it (a no-op error); the UI command now wins.
| LR-IMP-PRESET | Preset on import | P2 | ✅ | `cmd:library.import` (`preset`) | chosen in the import review; one History entry |
| LR-IMP-RAWDEFAULT | Raw defaults | P1 | ✅ | `cmd:library.preferences`, `crates/engine/src/import.rs`, `crates/ui-egui/src/panels/settings.rs` | LightCraft default / a preset / per camera (make + model); non-raw default too; the preset look counts as unedited and Reset returns to it |
| LR-IMP-MIGRATE | Migrate other catalogs | OOS | 🚫 | | |
-| LR-IMP-PROFILES | Import profiles & presets | P1 | 🟡 | `cmd:file.importPresets`, `cmd:preset.import`, `crates/engine/src/preset_import.rs` | presets: .lcpreset, XMP, classic .lrtemplate, photos carrying edits ("DNG presets"), .zip bundles, folders (folder → group), drag & drop; unmapped settings reported; no profile import (Adobe profile formats deliberately unsupported) |
+| LR-IMP-PROFILES | Import profiles & presets | P1 | 🟡 | `cmd:file.importPresets`, `cmd:preset.import`, `crates/engine/src/preset_import.rs` | presets: .lcpreset, XMP, classic .lrtemplate, photos carrying edits ("DNG presets"), .zip bundles, folders (folder → group), drag & drop; masks (gradients, radial, brush, subject/sky, luminance/depth range) carried over; unmapped settings reported; no profile import (Adobe profile formats deliberately unsupported) |
| LR-IMP-LOCAL | Work on files in place | P0 | ✅ | `cmd:library.browse`, `cmd:photo.addToLibrary`, `cmd:library.import` (mode add), `crates/engine/src/cmd/browse.rs`, `crates/ui-egui/src/panels/left.rs` (`local_section`), `crates/ui-egui/src/panels/grid.rs` (`folder_header`) | Local: browse Pictures / Desktop / Downloads / Home or any folder without adding it (breadcrumb, Include subfolders, Add N to My Photos); browsed photos stay out of All Photos, albums and counts; edits go to XMP sidecars; importing promotes them |
| LR-IMP-SIDECAR-SPLIT | Separate XMP sidecar variants | P2 | ⬜ | `cmd:library.xmpPreferences` | sidecar naming option exists (stem/full), no split sidecars |
| LR-IMP-FORMATS | Supported formats | P0 | 🟡 | `crates/codecs/src/lib.rs`, `crates/raw/src/lib.rs` | JPEG, PNG, TIFF, WebP, JXL, PSD, GIF, BMP; DNG, CR2, ARW, NEF, RAF, RW2, PEF, ORF. Missing: CR3, compressed NEF/RAF/ORF, RW2 v4 (preview only), HEIC/AVIF decode |
diff --git a/docs/xmp-interop.md b/docs/xmp-interop.md
index a51f3af5b..dab57443f 100644
--- a/docs/xmp-interop.md
+++ b/docs/xmp-interop.md
@@ -83,6 +83,29 @@ Values pass through our control specs, so anything outside our slider ranges get
**Not mapped:** camera profiles and looks (`CameraProfile`, `Look`; we have our own profile set), local adjustments
(masks, gradients, brushes), spot removal, red eye, lens blur, process-version 2010 field names, and AI features.
+## Local corrections (masks)
+
+Masks stored as `crs:` structures are read from sidecars, DNG-embedded XMP, XMP presets and `.lrtemplate` files
+(`crates/engine/src/crs_masks.rs`). Four containers hold them: `MaskGroupBasedCorrections` (current) and the older
+`GradientBasedCorrections`, `CircularGradientBasedCorrections` and `PaintBasedCorrections`. Each correction becomes one
+mask: `CorrectionName` → name, `CorrectionAmount` → Amount, inactive corrections are skipped.
+
+| Field | Ours | Notes |
+|---|---|---|
+| `LocalExposure2012` | `adjust.exposure` | stored as a fraction, ×4 EV |
+| `LocalContrast2012`, `LocalHighlights2012`, `LocalShadows2012`, `LocalWhites2012`, `LocalBlacks2012`, `LocalClarity2012`, `LocalTexture`, `LocalDehaze`, `LocalTemperature`, `LocalTint`, `LocalSaturation`, `LocalHue`, `LocalSharpness`, `LocalLuminanceNoise`, `LocalMoire`, `LocalDefringe`, `LocalToningSaturation` | the matching `adjust.*` | stored −1..1, ×100 |
+| `LocalToningHue` | `adjust.color_hue` | degrees |
+| `Mask/Gradient` (`FullX/Y`, `ZeroX/Y`) | linear gradient | full effect at the Full point |
+| `Mask/CircularGradient` (`Top/Left/Bottom/Right`, `Angle`, `Feather`, `Flipped`) | radial gradient | box fractions → long-edge radii (presets assume 3:2; sidecars use the photo's shape); `Flipped` → invert |
+| `Mask/Paint` (`Dabs` "d x y", `Radius`, `Flow`, `CenterWeight`, `MaskValue`) | brush | one brush component per correction; `MaskValue` ≤ 0 erases |
+| `Mask/Image` `MaskSubType` 1 / 2 | Subject / Sky | other AI selections are reported, not guessed |
+| `Mask/RangeMask` `Type` 2 / 3 (`LumRange`, `DepthRange`) | luminance / depth range | lightness converted to our range scale; colour ranges are reported |
+| `MaskBlendMode` 0 / 1 / 2, `MaskInverted` | add / subtract / intersect, invert | |
+
+Applying a preset adds its masks to the photo's own (masks the photo already has are not added twice), and the Amount
+slider scales them. A sidecar's masks replace the photo's, because a sidecar holds the whole edit. Components we can't
+carry over are listed in `preset.import`'s `unmapped` as `Mask: <kind>`.
+
## Preset files
| | |