//! Tone-curve commands: reset a channel or the whole curve; point-curve presets (built-in Linear / //! Medium / Strong Contrast plus the user's, saved with the library preferences, imported and //! exported as small JSON files). use lightcraft_develop::ToneCurve; use lightcraft_geom::Point; use serde::{Deserialize, Serialize}; use serde_json::{Value, json}; use super::{CommandSpec, always, bad, cmd, has_active, str_param}; use crate::{Result, Session}; /// Channels `curve.reset` accepts. pub const RESET_CHANNELS: [&str; 7] = ["all", "point", "parametric", "master", "red", "green", "blue"]; /// `c` with `channel` back at its default: `all` (the whole Tone Curve, incl. Refine Saturation), /// `point` (the four point curves), `parametric` (region sliders and splits) or one point channel. pub fn reset_channel(c: &mut ToneCurve, channel: &str) -> std::result::Result<(), String> { let d = ToneCurve::default(); match channel { "all" => *c = d, "point" => { c.master.clear(); c.red.clear(); c.green.clear(); c.blue.clear(); } "parametric" => { (c.highlights, c.lights, c.darks, c.shadows) = (d.highlights, d.lights, d.darks, d.shadows); (c.split_shadows, c.split_mid, c.split_highlights) = (d.split_shadows, d.split_mid, d.split_highlights); } "master" | "rgb" | "luma" => c.master.clear(), "red" => c.red.clear(), "green" => c.green.clear(), "blue" => c.blue.clear(), other => return Err(format!("unknown channel `{other}` (one of {})", RESET_CHANNELS.join(", "))), } Ok(()) } fn reset(s: &mut Session, p: &Value) -> Result { const C: &str = "curve.reset"; let id = s.active().ok_or_else(|| bad(C, "no active photo"))?; let channel = str_param(p, "channel").unwrap_or("all"); let mut d = (*s.develop_of(id).unwrap_or_default()).clone(); reset_channel(&mut d.curve, channel).map_err(|e| bad(C, e))?; let label = if channel == "all" { "Reset Tone Curve".to_string() } else { format!("Reset Tone Curve ({channel})") }; s.set_develop(id, d, &label)?; Ok(json!({"channel": channel})) } pub fn specs() -> Vec { vec![ cmd!( "curve.reset", "Reset Tone Curve", [], None, "{channel?: all|point|parametric|master|red|green|blue (default all)} — the active photo's tone curve (or one channel) back to linear", has_active, reset ), cmd!( query "curve.presets", "Point Curve Presets", [], None, "{} → {presets: [{name, master, red, green, blue: [[x,y],...], builtin?}], current: name of the preset the active photo's point curves match, or null}", always, |s, _| Ok(list(s)) ), cmd!( "curve.applyPreset", "Apply Point Curve Preset", [], None, "{name} — sets the active photo's point curves (all four channels; the parametric curve stays)", has_active, apply_preset ), cmd!( "curve.savePreset", "Save Point Curve Preset", [], None, "{name} — the active photo's point curves under a name (replaces a user preset of that name; built-in names are reserved), saved with the library", has_active, save_preset ), cmd!( "curve.deletePreset", "Delete Point Curve Preset", [], None, "{name} — a user preset (built-ins can't be deleted)", always, delete_preset ), cmd!( "curve.importPresets", "Import Point Curve Presets", [], None, "{path | paths: [file]} — .lccurve JSON files ({format, version, presets: [...]}, an array of presets, or one preset); same-named user presets are replaced → {imported: [name], failed: [[file, error]]}", always, import_presets ), cmd!( "curve.exportPresets", "Export Point Curve Presets", [], None, "{path, names?: [name] (default: every user preset)} — writes a .lccurve JSON file → {path, count}", always, export_presets ), ] } // ---------------------------------------------------------------- point-curve presets /// File extension of exported curve presets (JSON). pub const CURVE_PRESET_EXT: &str = "lccurve"; /// `format` tag of an exported curve-preset file. const FILE_FORMAT: &str = "lightcraft.curvePresets"; /// A named set of point curves (master + red/green/blue, points in 0..1; empty = linear). /// Built-ins ship with the app; the user's are saved with the library preferences. #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct CurvePreset { pub name: String, pub master: Vec<[f64; 2]>, pub red: Vec<[f64; 2]>, pub green: Vec<[f64; 2]>, pub blue: Vec<[f64; 2]>, /// Built-in presets can't be deleted or overwritten (never stored). #[serde(skip_serializing_if = "std::ops::Not::not")] pub builtin: bool, } /// Points clamped to 0..1, sorted by x, duplicates in x dropped; a linear curve becomes empty. fn normalize(v: &[[f64; 2]]) -> Vec<[f64; 2]> { let mut out: Vec<[f64; 2]> = v.iter().filter(|p| p[0].is_finite() && p[1].is_finite()).map(|p| [p[0].clamp(0.0, 1.0), p[1].clamp(0.0, 1.0)]).collect(); out.sort_by(|a, b| a[0].total_cmp(&b[0])); out.dedup_by(|a, b| (a[0] - b[0]).abs() < 1e-6); if out.len() < 2 || out.iter().all(|p| (p[0] - p[1]).abs() < 1e-9) { out.clear(); } out } fn from_points(v: &[Point]) -> Vec<[f64; 2]> { normalize(&v.iter().map(|p| [p.x, p.y]).collect::>()) } fn to_points(v: &[[f64; 2]]) -> Vec { normalize(v).iter().map(|p| Point::new(p[0], p[1])).collect() } impl CurvePreset { /// The point curves of `c` under `name`. pub fn from_curve(name: &str, c: &ToneCurve) -> CurvePreset { CurvePreset { name: name.into(), master: from_points(&c.master), red: from_points(&c.red), green: from_points(&c.green), blue: from_points(&c.blue), builtin: false, } } /// Set the four point curves of `c` (the parametric curve and Refine Saturation stay). pub fn apply(&self, c: &mut ToneCurve) { c.master = to_points(&self.master); c.red = to_points(&self.red); c.green = to_points(&self.green); c.blue = to_points(&self.blue); } /// Does `c` carry exactly this preset's point curves? pub fn matches(&self, c: &ToneCurve) -> bool { let same = |a: &[[f64; 2]], b: &[Point]| { let (a, b) = (normalize(a), from_points(b)); a.len() == b.len() && a.iter().zip(&b).all(|(p, q)| (p[0] - q[0]).abs() < 1e-6 && (p[1] - q[1]).abs() < 1e-6) }; same(&self.master, &c.master) && same(&self.red, &c.red) && same(&self.green, &c.green) && same(&self.blue, &c.blue) } fn is_linear(&self) -> bool { [&self.master, &self.red, &self.green, &self.blue].iter().all(|v| normalize(v).is_empty()) } } /// The presets that ship with the app: a linear curve and two symmetric S-curves (our own /// values: the quarter-tones pulled 0.05 / 0.11 towards the ends, midpoint fixed). pub fn builtin_presets() -> Vec { let s = |name: &str, master: Vec<[f64; 2]>| CurvePreset { name: name.into(), master, builtin: true, ..Default::default() }; vec![ s("Linear", Vec::new()), s("Medium Contrast", vec![[0.0, 0.0], [0.25, 0.2], [0.5, 0.5], [0.75, 0.8], [1.0, 1.0]]), s("Strong Contrast", vec![[0.0, 0.0], [0.25, 0.14], [0.5, 0.5], [0.75, 0.86], [1.0, 1.0]]), ] } /// Built-in presets, then the user's. pub fn all_presets(s: &Session) -> Vec { let mut v = builtin_presets(); v.extend(s.curve_presets.iter().cloned()); v } /// Name of the preset whose point curves `c` carries (built-ins first), if any. pub fn matching_preset(s: &Session, c: &ToneCurve) -> Option { all_presets(s).into_iter().find(|p| p.matches(c)).map(|p| p.name) } fn is_builtin_name(name: &str) -> bool { builtin_presets().iter().any(|p| p.name.eq_ignore_ascii_case(name)) } /// Add or replace (same name, ignoring case) a user preset. fn upsert(s: &mut Session, p: CurvePreset) { match s.curve_presets.iter_mut().find(|x| x.name.eq_ignore_ascii_case(&p.name)) { Some(x) => *x = p, None => s.curve_presets.push(p), } } fn name_param(p: &Value, c: &str) -> Result { str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).map(str::to_string).ok_or_else(|| bad(c, "missing `name`")) } fn list(s: &Session) -> Value { let current = s.active().and_then(|id| s.develop_of(id)).and_then(|d| matching_preset(s, &d.curve)); json!({"presets": all_presets(s), "current": current}) } fn apply_preset(s: &mut Session, p: &Value) -> Result { const C: &str = "curve.applyPreset"; let name = name_param(p, C)?; let preset = all_presets(s).into_iter().find(|x| x.name.eq_ignore_ascii_case(&name)).ok_or_else(|| bad(C, format!("no curve preset `{name}`")))?; let id = s.active().ok_or_else(|| bad(C, "no active photo"))?; let mut d = (*s.develop_of(id).unwrap_or_default()).clone(); preset.apply(&mut d.curve); s.set_develop(id, d, &format!("Point Curve: {}", preset.name))?; Ok(json!({"name": preset.name})) } fn save_preset(s: &mut Session, p: &Value) -> Result { const C: &str = "curve.savePreset"; let name = name_param(p, C)?; if is_builtin_name(&name) { return Err(bad(C, format!("`{name}` is a built-in preset: choose another name"))); } let id = s.active().ok_or_else(|| bad(C, "no active photo"))?; let preset = CurvePreset::from_curve(&name, &s.develop_of(id).unwrap_or_default().curve); if preset.is_linear() { return Err(bad(C, "the point curve is linear: shape it first")); } upsert(s, preset); s.save_prefs()?; Ok(list(s)) } fn delete_preset(s: &mut Session, p: &Value) -> Result { const C: &str = "curve.deletePreset"; let name = name_param(p, C)?; if is_builtin_name(&name) { return Err(bad(C, "built-in presets can't be deleted")); } let n = s.curve_presets.len(); s.curve_presets.retain(|x| !x.name.eq_ignore_ascii_case(&name)); if n == s.curve_presets.len() { return Err(bad(C, format!("no curve preset `{name}`"))); } s.save_prefs()?; Ok(list(s)) } /// Presets in a curve-preset file: `{format, version, presets: [...]}`, a bare array, or one preset. pub fn parse_file(bytes: &[u8]) -> std::result::Result, String> { let v: Value = serde_json::from_slice(bytes).map_err(|e| format!("not a curve preset file: {e}"))?; let items = match &v { Value::Object(o) if o.contains_key("presets") => o["presets"].clone(), Value::Array(_) => v.clone(), Value::Object(_) => Value::Array(vec![v.clone()]), _ => return Err("not a curve preset file".into()), }; let list: Vec = serde_json::from_value(items).map_err(|e| format!("not a curve preset file: {e}"))?; let list: Vec = list.into_iter().filter(|p| !p.name.trim().is_empty()).collect(); if list.is_empty() { return Err("no curve presets in the file".into()); } Ok(list) } /// The JSON of a curve-preset file holding `presets`. pub fn to_file(presets: &[CurvePreset]) -> String { let presets: Vec = presets.iter().map(|p| CurvePreset { builtin: false, ..p.clone() }).collect(); serde_json::to_string_pretty(&json!({"format": FILE_FORMAT, "version": 1, "presets": presets})).unwrap_or_default() } fn import_presets(s: &mut Session, p: &Value) -> Result { const C: &str = "curve.importPresets"; let mut paths: Vec = 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 imported, mut failed) = (Vec::new(), Vec::new()); for f in &paths { match std::fs::read(f).map_err(|e| e.to_string()).and_then(|b| parse_file(&b)) { Ok(list) => { for mut preset in list { preset.name = preset.name.trim().to_string(); preset.builtin = false; if is_builtin_name(&preset.name) { preset.name = format!("{} (imported)", preset.name); } imported.push(preset.name.clone()); upsert(s, preset); } } Err(e) => failed.push(json!([f, e])), } } if !imported.is_empty() { s.save_prefs()?; } Ok(json!({"imported": imported, "failed": failed})) } fn export_presets(s: &mut Session, p: &Value) -> Result { const C: &str = "curve.exportPresets"; 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(CURVE_PRESET_EXT); } let names: Option> = 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 = match &names { Some(n) => all_presets(s).into_iter().filter(|x| n.iter().any(|m| m.eq_ignore_ascii_case(&x.name))).collect(), None => s.curve_presets.clone(), }; if chosen.is_empty() { return Err(bad(C, "no curve presets to export (save one first, or pass names)")); } 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())))?; } std::fs::write(&path, to_file(&chosen)).map_err(|e| crate::EngineError::Other(format!("{}: {e}", path.display())))?; Ok(json!({"path": path.display().to_string(), "count": chosen.len()})) }