From 1bb3542b992716b7feb51a987dcfec272a63b13b Mon Sep 17 00:00:00 2001 From: David Mann Date: Sat, 17 Oct 2026 15:42:14 +0200 Subject: [PATCH] Lens Correction: smart filters keep the exact focal length (#7029) Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/lens_cmds.rs | 58 ++++++++++++++++++++++++++-------- 1 file changed, 45 insertions(+), 13 deletions(-) diff --git a/crates/engine/src/lens_cmds.rs b/crates/engine/src/lens_cmds.rs index 379ca2402a..9546731b7b 100644 --- a/crates/engine/src/lens_cmds.rs +++ b/crates/engine/src/lens_cmds.rs @@ -65,13 +65,7 @@ pub fn lens_params(cmd: &str, p: &Value, frame: Rect, info: Option<&exif::Camera "background" | "color" => EdgeMode::Color(crate::commands::color_param(p, "edgeColor", [0.0, 0.0, 0.0, 1.0])), other => return Err(bad(cmd, format!("unknown edge `{other}` (transparency|edgeExtension|black|white|color)"))), }; - let focal = num(p, "focalLength", 0.0); - lc.profile = match p.get("profile").and_then(Value::as_str).unwrap_or("none") { - "none" | "" => None, - "generic" => Some(lens::generic_profile(if focal > 0.0 { focal } else { 50.0 })), - "auto" => info.and_then(|i| i.focal_length_35mm.or(i.focal_length)).or((focal > 0.0).then_some(focal)).map(lens::generic_profile), - other => return Err(bad(cmd, format!("unknown profile `{other}` (none|auto|generic)"))), - }; + lc.profile = profile_focal(cmd, p, info)?.map(lens::generic_profile); if let Some(Value::Array(line)) = p.get("straighten") { let pt = |v: &Value| -> Option<[f64; 2]> { Some([v.get(0)?.as_f64()?, v.get(1)?.as_f64()?]) }; let (Some(a), Some(b)) = (line.first().and_then(pt), line.get(1).and_then(pt)) else { @@ -85,8 +79,20 @@ pub fn lens_params(cmd: &str, p: &Value, frame: Rect, info: Option<&exif::Camera Ok(lc) } -/// Writes the resolved profile / angle / scale back into the params (for smart filters). -fn resolved_lens_params(p: &Value, lc: &LensCorrection) -> Value { +/// The 35 mm-equivalent focal length of the generic profile the params ask for (`None`: no profile). +fn profile_focal(cmd: &str, p: &Value, info: Option<&exif::CameraInfo>) -> Result> { + let focal = num(p, "focalLength", 0.0); + Ok(match p.get("profile").and_then(Value::as_str).unwrap_or("none") { + "none" | "" => None, + "generic" => Some(if focal > 0.0 { focal } else { 50.0 }), + "auto" => info.and_then(|i| i.focal_length_35mm.or(i.focal_length)).or((focal > 0.0).then_some(focal)), + other => return Err(bad(cmd, format!("unknown profile `{other}` (none|auto|generic)"))), + }) +} + +/// Writes the resolved profile (its exact focal length, not the rounded one in its name) / +/// angle / scale back into the params (for smart filters). +fn resolved_lens_params(p: &Value, lc: &LensCorrection, focal: Option) -> Value { let mut q = p.clone(); if let Value::Object(m) = &mut q { m.remove("straighten"); @@ -94,10 +100,9 @@ fn resolved_lens_params(p: &Value, lc: &LensCorrection) -> Value { m.remove("layer"); m.insert("angle".into(), json!(lc.angle)); m.insert("scale".into(), json!(lc.scale)); - match &lc.profile { - Some(pr) => { + match lc.profile.as_ref().and(focal) { + Some(f) => { m.insert("profile".into(), json!("generic")); - let f = pr.name.trim_start_matches("Generic Lens (").split(' ').next().and_then(|v| v.parse::().ok()).unwrap_or(50.0); m.insert("focalLength".into(), json!(f)); } None => { @@ -320,7 +325,7 @@ fn lens_correction(s: &mut Session, p: &Value) -> Result { let frame = st.doc.bounds(); let info = camera_info(&st.doc); let lc = lens_params(LENS, p, frame, info.as_ref())?; - let stored = resolved_lens_params(p, &lc); + let stored = resolved_lens_params(p, &lc, profile_focal(LENS, p, info.as_ref())?); let t0 = Stopwatch::start(); let id = run_filter(s, LENS, "Lens Correction", stored.clone(), matches!(lc.edge, EdgeMode::Transparency), &|surf, canvas| lens::correct(surf, canvas, &lc))?; @@ -554,6 +559,33 @@ mod tests { assert!(corner[0] > 0.4, "{corner:?}"); } + #[test] + fn lens_smart_filter_keeps_the_exact_focal_length() { + // A generic profile at a fractional focal length, and the auto profile from EXIF. + let generic = json!({"profile": "generic", "focalLength": 27.4, "edge": "edgeExtension"}); + let auto = json!({"profile": "auto", "edge": "edgeExtension"}); + for (p, focal) in [(generic, 27.4), (auto, 18.5)] { + let mut s = session(8); + s.edit("exif", |doc, _| { + doc.metadata.exif = Some(std::sync::Arc::new(exif::build(&exif::CameraInfo { focal_length: Some(18.5), ..Default::default() }))); + Ok(()) + }) + .unwrap(); + let d = s.active().unwrap(); + let src = d.doc.layer(d.active_layer.unwrap()).unwrap().surface().unwrap().clone(); + let (frame, info) = (d.doc.bounds(), camera_info(&d.doc)); + s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap(); + let r = s.execute(LENS, p.clone()).unwrap(); + assert_eq!(r["params"]["focalLength"], focal, "{r}"); + // Re-rendering from the stored params gives the pixels the command rendered. + let d = s.active().unwrap(); + let LayerContent::Smart(sm) = &d.doc.layer(LayerId(r["layer"].as_u64().unwrap())).unwrap().content else { panic!("smart") }; + let original = lens::correct(&src, frame, &lens_params(LENS, &p, frame, info.as_ref()).unwrap()); + let rerender = apply_to_surface(LENS, &sm.smart_filters[0].params, &src, frame).unwrap(); + assert!(original == rerender, "re-render differs for {p}"); + } + } + #[test] fn adaptive_wide_angle_straightens() { let mut s = session(8);