LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LR-EDIT-OPTICS-PROFILE: Sony ARW lateral CA correction from the embedded table
dev-null-undefinedb677fbac0a0f
diff --git a/crates/raw/src/vendor/arw.rs b/crates/raw/src/vendor/arw.rsindex 5a23218c0..d6715d49e 100644--- a/crates/raw/src/vendor/arw.rs+++ b/crates/raw/src/vendor/arw.rs@@ -874,12 +874,12 @@ mod tests {TiffWriter::default().write(&[raw]).unwrap()}- /// The ILCE-7RM6's distortion table reaches `OpcodeList3`, in the headers-only probe and in the full decode;- /// another body's table doesn't (see [`super::super::arw_lens_rm6`]).+ /// The ILCE-7RM6's distortion table reaches `OpcodeList3`, in the headers-only probe and in the full decode, as+ /// one plane, or three with the CA table; another body's tables don't (see [`super::super::arw_lens_rm6`]).#[test]fn lens_tables_reach_opcode_list3() {use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value};- let file = |model: &str| {+ let file = |model: &str, ca: bool| {let mut raw = IfdBuilder::new();raw.set(t::MAKE, Value::Ascii("SONY".into()));raw.set(t::MODEL, Value::Ascii(model.into()));@@ -893,14 +893,23 @@ mod tests {raw.set(TONE_CURVE, Value::Short(vec![8000, 10400, 12900, 14100]));let table = vec![16, 0, 2, 7, 16, 28, 43, 61, 83, 109, 139, 175, 217, 267, 325, 395, 479];raw.set(super::super::arw_lens_rm6::DISTORTION_PARAMS, Value::SShort(table));+ if ca {+ let table = vec![+ 32, 242, 234, 224, 212, 196, 176, 154, 132, 108, 86, 66, 46, 30, 16, 8, 4, -276, -258, -238, -212, -184, -148, -114, -74, -40,+ -6, 20, 42, 56, 60, 54, 32,+ ];+ raw.set(super::super::arw_lens_rm6::CA_PARAMS, Value::SShort(table));+ }raw.set_image(ImageData::Strips { rows_per_strip: 64, strips: vec![vec![0u8; 96 * 64]] });TiffWriter::default().write(&[raw]).unwrap()};for mode in [Mode::Header, Mode::Full] {- let list3 = |model| decode(&file(model), mode).unwrap().opcodes.list3;- let ops = list3("ILCE-7RM6");- assert!(matches!(ops.as_slice(), [crate::Opcode::WarpRectilinear { planes, .. }] if planes.len() == 1), "{mode:?}: {ops:?}");- assert!(list3("ILCE-7M4").is_empty(), "{mode:?}");+ for (ca, n) in [(false, 1), (true, 3)] {+ let list3 = |model| decode(&file(model, ca), mode).unwrap().opcodes.list3;+ let ops = list3("ILCE-7RM6");+ assert!(matches!(ops.as_slice(), [crate::Opcode::WarpRectilinear { planes, .. }] if planes.len() == n), "{mode:?} {ca}: {ops:?}");+ assert!(list3("ILCE-7M4").is_empty(), "{mode:?} {ca}");+ }}}diff --git a/crates/raw/src/vendor/arw_lens_rm6.rs b/crates/raw/src/vendor/arw_lens_rm6.rsindex ba9aaaa9d..37d76fdd6 100644--- a/crates/raw/src/vendor/arw_lens_rm6.rs+++ b/crates/raw/src/vendor/arw_lens_rm6.rs@@ -28,8 +28,12 @@//! 0.049 px for the full-frame 16–35 mm example in the tests.//! - vignetting: read but never applied. The camera JPEGs keep the uncorrected render's radial falloff (median//! corner/centre ratio 0.996 over 39 photos) and no radial gain model fits the tables.-//! - lateral CA: red and blue relative to green on the same knots (unit about 1/3.36·10⁶; 0.399 px, borderline);-//! not applied yet.+//! - lateral CA: red's (blue's) source radius is `g · (1 + c(g) / 3.36·10⁶)` with `g` the green source radius and `c`+//! the red (blue) half on the same knots, as the warp's R and B planes. The unit is **provisional**: the+//! measurement is borderline (0.399 px worst against a 0.3 px budget; per-photo best units scatter from 1.5·10⁶+//! to 7.2·10⁶, about ±30 % scene bias), but it cuts the rms CA over 46 photos from 0.079 to 0.052 px. When a CA+//! value is implausible (beyond [`CA_MAX_RELATIVE`]) or a colour plane fails the fit gate above, both colour+//! planes are dropped and G alone is applied to all three channels.//!//! The correction is produced whatever the in-camera flag says. Only bodies listed in [`FULL_FRAME_CROP`] get it: the//! unit and the knot spacing are verified on the ILCE-7RM6 alone. Another body is added by repeating the measurement@@ -53,6 +57,12 @@ pub(crate) const CA_FLAG: u16 = 0x7034;const FULL_FRAME_CROP: &[(&str, (f64, f64))] = &[("ILCE-7RM6", (9984.0, 6656.0))];/// The distortion table's value of 1 (relative radius); a global least-squares fit over the 34 photos gives 15000.7.const DISTORTION_UNIT: f64 = 15000.0;+/// The CA table's value of 1 (relative to the green source radius). Provisional: the median best unit of the 20+/// cleanest photos; per-photo units scatter from 1.5·10⁶ to 7.2·10⁶ (the measurement's scene bias is about ±30 %).+const CA_UNIT: f64 = 3.36e6;+/// Largest plausible CA value relative to the green source radius (|c| / [`CA_UNIT`]): about 12 px at the full-frame+/// corner; the measured tables stay below 790 / 3.36·10⁶ ≈ 2.4·10⁻⁴. A table beyond it is refused.+const CA_MAX_RELATIVE: f64 = 2e-3;/// Crop border radii scanned by the frame-filling zoom.const ZOOM_SCAN: usize = 4096;/// Largest polynomial fit error accepted at the fit samples the crop shows, px at a 1440 px long edge.@@ -62,7 +72,7 @@ const FIT_ERROR_PX_AT_1440: f64 = 0.25;/// `vignetting` and `flags` are parsed for the tests and the docs only: don't build an opcode from them (the camera/// applies no vignetting correction to its JPEGs, and the flags don't decide anything).#[derive(Debug)]-// only the distortion table becomes an opcode so far+// vignetting and the flags never become an opcode#[cfg_attr(not(test), allow(dead_code))]pub(crate) struct LensTables {pub distortion: Option<Vec<f64>>,@@ -140,11 +150,13 @@ fn fill_zoom(source: &dyn Fn(f64) -> f64, x: f64, y: f64) -> Option<f64> {Some(0.5 * (lo + hi))}-/// The distortion table as a one-plane `WarpRectilinear` relative to the active area `active` (centred on the-/// default crop `crop`, as the camera corrects), with knots `knot_spacing` px apart. `None` when the table is absent-/// or all zero, the zoom or the fit fails, or the fit is worse than 0.25 px at a 1440 px long edge at one of the fit-/// samples within the crop (a padded active area, as in lossless files, reaches radii that are never shown).-pub(crate) fn distortion_opcode(t: &LensTables, knot_spacing: f64, active: Rect, crop: Rect) -> Option<Opcode> {+/// The distortion and CA tables as a `WarpRectilinear` relative to the active area `active` (centred on the default+/// crop `crop`, as the camera corrects), with knots `knot_spacing` px apart: planes R, G, B, or G alone (applied to+/// all three) when the CA table is absent or a colour plane's fit fails. `None` when the distortion table is absent or+/// all zero (CA alone is not applied: it is relative to green), the zoom or the G fit fails. A fit fails when it is+/// worse than 0.25 px at a 1440 px long edge at one of the fit samples within the crop (a padded active area, as in+/// lossless files, reaches radii that are never shown).+pub(crate) fn warp_opcode(t: &LensTables, knot_spacing: f64, active: Rect, crop: Rect) -> Option<Opcode> {let v = t.distortion.as_deref().filter(|v| v.iter().any(|&x| x != 0.0))?;let (aw, ah) = (active.width as f64, active.height as f64);if aw < 2.0 || ah < 2.0 || crop.width == 0 || crop.height == 0 {@@ -158,15 +170,32 @@ pub(crate) fn distortion_opcode(t: &LensTables, knot_spacing: f64, active: Rect,let m = max_radius(cx, cy, aw - 1.0, ah - 1.0);let max_fit_error = FIT_ERROR_PX_AT_1440 * (cw.max(ch) / 1440.0) / m;let shown = (cw / 2.0).hypot(ch / 2.0) / m;- let [k0, k1, k2, k3] = fit_radial_warp(&|u| source(u * m / z) / m, max_fit_error, shown)?;- Some(Opcode::WarpRectilinear { planes: vec![[k0, k1, k2, k3, 0.0, 0.0]], center: [cx / (aw - 1.0), cy / (ah - 1.0)] })+ // output radius (px) → green source radius+ let green = |r: f64| source(r / z);+ let plane = |map: &dyn Fn(f64) -> f64| {+ let [k0, k1, k2, k3] = fit_radial_warp(&|u| map(u * m) / m, max_fit_error, shown)?;+ Some([k0, k1, k2, k3, 0.0, 0.0])+ };+ let g = plane(&green)?;+ // red and blue: relative to the green source radius, at that radius+ let colour = |c: &[f64]| {+ plane(&|r| {+ let s = green(r);+ s * (1.0 + interpolate(c, knot_spacing, s) / CA_UNIT)+ })+ };+ // a NaN fails the comparison: refused too+ let plausible = |c: &[f64]| c.iter().all(|v| v.abs() <= CA_MAX_RELATIVE * CA_UNIT);+ let rgb = t.ca.as_ref().filter(|(red, blue)| plausible(red) && plausible(blue));+ let rgb = rgb.and_then(|(red, blue)| Some(vec![colour(red)?, g, colour(blue)?]));+ Some(Opcode::WarpRectilinear { planes: rgb.unwrap_or_else(|| vec![g]), center: [cx / (aw - 1.0), cy / (ah - 1.0)] })}/// The `OpcodeList3` lens corrections of a Sony raw IFD for the body `model` (Exif `Model`); empty for a body whose/// tables are not verified.pub(crate) fn lens_opcodes(raw: &Ifd, model: &str, active: Rect, crop: Rect) -> Vec<Opcode> {let Some(spacing) = knot_spacing(model) else { return Vec::new() };- distortion_opcode(&read_tables(raw), spacing, active, crop).into_iter().collect()+ warp_opcode(&read_tables(raw), spacing, active, crop).into_iter().collect()}#[cfg(test)]@@ -181,6 +210,11 @@ mod tests {32, 242, 234, 224, 212, 196, 176, 154, 132, 108, 86, 66, 46, 30, 16, 8, 4, -276, -258, -238, -212, -184, -148, -114, -74, -40, -6, 20, 42,56, 60, 54, 32,];+ /// The CA table of corpus `arw6-sony-ilce7rm6-ff-land-hq.arw` (the same scene; same distortion table).+ const FF_HQ_CA: [i16; 33] = [+ 32, 242, 234, 222, 208, 192, 172, 152, 128, 106, 82, 62, 42, 26, 12, 4, 2, -270, -254, -234, -208, -180, -146, -112, -72, -38, -4, 22, 44,+ 58, 64, 56, 36,+ ];/// The APS-C example (corpus `arw6-sony-ilce7rm6-apsc-land-hq.arw`): counts 11 / 11 / 22, then padding.const APSC_DISTORTION: [i16; 17] = [11, 0, -10, -36, -78, -134, -202, -277, -356, -435, -512, -583, -583, -583, -583, -583, -583];const APSC_VIGNETTING: [i16; 17] = [11, 0, 48, 208, 496, 880, 1360, 1952, 2624, 3568, 4832, 6176, 0, 0, 0, 0, 0];@@ -193,6 +227,14 @@ mod tests {const FF_CROP: Rect = Rect { x: 12, y: 8, width: 9984, height: 6656 };const APSC_ACTIVE: Rect = Rect { x: 0, y: 0, width: 6592, height: 4372 };const APSC_CROP: Rect = Rect { x: 16, y: 10, width: 6528, height: 4352 };+ /// The G planes of the examples on their ARW6 geometry, and the R and B planes with each file's CA table+ /// (docs/sony-ilce7rm6-lens-corrections.md).+ const FF_G: [f64; 4] = [0.9714495823, 0.022508032, 0.0006090085237, 0.005683284548];+ const FF_HQ_R: [f64; 4] = [0.9715153129, 0.02236266369, 0.0007060224765, 0.005666341563];+ const FF_HQ_B: [f64; 4] = [0.97137946, 0.02277016389, 0.0003830082563, 0.005727820598];+ const APSC_G: [f64; 4] = [1.01627551, -0.0618606692, 0.02768349621, -0.005595798468];+ const APSC_R: [f64; 4] = [1.016503991, -0.06206460153, 0.0278447625, -0.005644118171];+ const APSC_B: [f64; 4] = [1.016155702, -0.06162477627, 0.02753315326, -0.005554915901];fn knots() -> f64 {knot_spacing("ILCE-7RM6").unwrap()@@ -223,16 +265,18 @@ mod tests {table[1..=table[0] as usize].iter().map(|&v| v as f64).collect()}- /// The warp's one plane and centre against the recipe's numbers (docs/sony-ilce7rm6-lens-corrections.md).- fn assert_warp(op: Option<Opcode>, center: [f64; 2], k: [f64; 4]) {+ /// The warp's planes and centre against the recipe's numbers (docs/sony-ilce7rm6-lens-corrections.md); returns the planes.+ fn assert_warp(op: Option<Opcode>, center: [f64; 2], k: &[[f64; 4]]) -> Vec<[f64; 6]> {let Some(Opcode::WarpRectilinear { planes, center: c }) = op else { panic!("no warp: {op:?}") };- assert_eq!(planes.len(), 1);+ assert_eq!(planes.len(), k.len());assert!((c[0] - center[0]).abs() < 1e-9 && (c[1] - center[1]).abs() < 1e-9, "centre {c:?}, want {center:?}");- let p = planes[0];- for (i, want) in k.iter().enumerate() {- assert!((p[i] - want).abs() < 1e-6, "k{i} {}, want {want} ({p:?})", p[i]);+ for (p, k) in planes.iter().zip(k) {+ for (i, want) in k.iter().enumerate() {+ assert!((p[i] - want).abs() < 1e-6, "k{i} {}, want {want} ({p:?})", p[i]);+ }+ assert_eq!((p[4], p[5]), (0.0, 0.0), "radial only");}- assert_eq!((p[4], p[5]), (0.0, 0.0), "radial only");+ planes}#[test]@@ -281,7 +325,7 @@ mod tests {let ifd = ifd(vec![(DISTORTION_PARAMS, Value::SShort(table))]);let t = read_tables(&ifd);assert!(t.distortion.is_none(), "{what}");- assert!(distortion_opcode(&t, knots(), FF_ACTIVE, FF_CROP).is_none(), "{what}");+ assert!(warp_opcode(&t, knots(), FF_ACTIVE, FF_CROP).is_none(), "{what}");assert!(lens_opcodes(&ifd, "ILCE-7RM6", FF_ACTIVE, FF_CROP).is_empty(), "{what}");}// not an integer array, or absent@@ -309,7 +353,7 @@ mod tests {("not finite", vec![0.0, f64::NAN, 20.0]),("infinite", vec![0.0, f64::INFINITY, 20.0]),] {- assert!(distortion_opcode(&tables_with_distortion(&table), knots(), FF_ACTIVE, FF_CROP).is_none(), "{what}");+ assert!(warp_opcode(&tables_with_distortion(&table), knots(), FF_ACTIVE, FF_CROP).is_none(), "{what}");}// the same through the IFD, as 64-bit valuesfor v in [i64::MAX / 4, i64::MIN, i64::MAX] {@@ -326,25 +370,88 @@ mod tests {("knot spacing NaN", f64::NAN, FF_ACTIVE, FF_CROP),("knot spacing 0", 0.0, FF_ACTIVE, FF_CROP),] {- assert!(distortion_opcode(&ff, knots, active, crop).is_none(), "{what}");+ assert!(warp_opcode(&ff, knots, active, crop).is_none(), "{what}");}}#[test]fn ff_example_table_becomes_the_measured_warp() {let t = tables_with_distortion(&values(&FF_DISTORTION));- assert_warp(- distortion_opcode(&t, knots(), FF_ACTIVE, FF_CROP),- [0.4996005991, 0.5],- [0.9714495823, 0.022508032, 0.0006090085237, 0.005683284548],- );+ assert_warp(warp_opcode(&t, knots(), FF_ACTIVE, FF_CROP), [0.4996005991, 0.5], &[FF_G]);}#[test]fn apsc_example_table_becomes_the_measured_warp() {let t = tables_with_distortion(&values(&APSC_DISTORTION));- let op = distortion_opcode(&t, knots(), APSC_ACTIVE, APSC_CROP);- assert_warp(op, [0.4975724473, 0.5], [1.01627551, -0.0618606692, 0.02768349621, -0.005595798468]);+ let op = warp_opcode(&t, knots(), APSC_ACTIVE, APSC_CROP);+ assert_warp(op, [0.4975724473, 0.5], &[APSC_G]);+ }++ #[test]+ fn ca_table_shifts_red_and_blue_planes() {+ let t = read_tables(&sony_lens_ifd(&FF_DISTORTION, &FF_VIGNETTING, &FF_HQ_CA, [0, 2, 1]));+ let planes = assert_warp(warp_opcode(&t, knots(), FF_ACTIVE, FF_CROP), [0.4996005991, 0.5], &[FF_HQ_R, FF_G, FF_HQ_B]);+ assert_ne!(planes[0][0], planes[1][0]);+ // G is the distortion plane alone+ let g = warp_opcode(&tables_with_distortion(&values(&FF_DISTORTION)), knots(), FF_ACTIVE, FF_CROP);+ assert!(matches!(g, Some(Opcode::WarpRectilinear { planes: ref p, .. }) if p == &[planes[1]]), "{g:?}");+ }++ #[test]+ fn apsc_ca_planes_match_the_measured_warp() {+ let t = read_tables(&sony_lens_ifd(&APSC_DISTORTION, &APSC_VIGNETTING, &APSC_CA, [0, 2, 1]));+ assert_warp(warp_opcode(&t, knots(), APSC_ACTIVE, APSC_CROP), [0.4975724473, 0.5], &[APSC_R, APSC_G, APSC_B]);+ }++ #[test]+ fn ca_without_distortion_is_not_applied() {+ let ifd = ifd(vec![(CA_PARAMS, Value::SShort(FF_HQ_CA.to_vec()))]);+ let t = read_tables(&ifd);+ assert!(t.ca.is_some() && t.distortion.is_none());+ assert!(warp_opcode(&t, knots(), FF_ACTIVE, FF_CROP).is_none());+ assert!(lens_opcodes(&ifd, "ILCE-7RM6", FF_ACTIVE, FF_CROP).is_empty());+ // an all-zero distortion table counts as absent+ let zero = LensTables { ca: t.ca, ..tables_with_distortion(&[0.0; 16]) };+ assert!(warp_opcode(&zero, knots(), FF_ACTIVE, FF_CROP).is_none());+ }++ #[test]+ fn rejected_ca_keeps_the_single_green_plane() {+ let green =+ assert_warp(warp_opcode(&tables_with_distortion(&values(&FF_DISTORTION)), knots(), FF_ACTIVE, FF_CROP), [0.4996005991, 0.5], &[FF_G]);+ let ok = values(&FF_HQ_CA);+ let huge = vec![(i64::MAX / 4) as f64; 16];+ for (what, red, blue) in [+ ("huge red", huge.clone(), ok[16..].to_vec()),+ ("huge blue", ok[..16].to_vec(), huge),+ ("most negative blue", ok[..16].to_vec(), vec![i64::MIN as f64; 16]),+ ("not finite red", vec![0.0, f64::NAN, 20.0], ok[16..].to_vec()),+ ("one knot", vec![100.0], vec![100.0]),+ ] {+ let t = LensTables { ca: Some((red, blue)), ..tables_with_distortion(&values(&FF_DISTORTION)) };+ let Some(Opcode::WarpRectilinear { planes, .. }) = warp_opcode(&t, knots(), FF_ACTIVE, FF_CROP) else { panic!("{what}: no warp") };+ assert_eq!(planes, green, "{what}");+ }+ // through the IFD: an odd count, or values that overflow the fit+ let mut odd = FF_HQ_CA.to_vec();+ odd[0] = 31;+ let mut huge_ifd = vec![i64::MAX / 4; 33];+ huge_ifd[0] = 32;+ // a constant 32767 (the SShort maximum) fits as well as G does and would shift red ~59 px at the full-res+ // corner: refused as implausible (bound 2·10⁻³ relative = 6720)+ let mut max = vec![32767; 33];+ max[0] = 32;+ for (what, ca) in [("odd count", Value::SShort(odd)), ("huge", Value::SLong8(huge_ifd)), ("constant 32767", Value::SShort(max))] {+ let ifd = ifd(vec![(DISTORTION_PARAMS, Value::SShort(FF_DISTORTION.to_vec())), (CA_PARAMS, ca)]);+ let ops = lens_opcodes(&ifd, "ILCE-7RM6", FF_ACTIVE, FF_CROP);+ assert!(matches!(ops.as_slice(), [Opcode::WarpRectilinear { planes, .. }] if planes == &green), "{what}: {ops:?}");+ }+ // values up to the bound are kept+ let mut at_bound = vec![6720; 33];+ at_bound[0] = 32;+ let ifd = ifd(vec![(DISTORTION_PARAMS, Value::SShort(FF_DISTORTION.to_vec())), (CA_PARAMS, Value::SShort(at_bound))]);+ let ops = lens_opcodes(&ifd, "ILCE-7RM6", FF_ACTIVE, FF_CROP);+ assert!(matches!(ops.as_slice(), [Opcode::WarpRectilinear { planes, .. }] if planes.len() == 3), "{ops:?}");}/// The lossless files' padded active area (10240 × 7168) puts the farthest active-area corner (DNG radius 1) well@@ -354,7 +461,7 @@ mod tests {fn padded_active_area_gates_only_the_displayed_radii() {let strong: Vec<f64> = values(&FF_DISTORTION).iter().map(|v| v * 1.5).collect();let padded = Rect { x: 0, y: 0, width: 10240, height: 7168 };- let op = distortion_opcode(&tables_with_distortion(&strong), knots(), padded, FF_CROP);+ let op = warp_opcode(&tables_with_distortion(&strong), knots(), padded, FF_CROP);assert!(matches!(op, Some(Opcode::WarpRectilinear { .. })), "{op:?}");}@@ -365,7 +472,7 @@ mod tests {assert!(lens_opcodes(&ifd, "", FF_ACTIVE, FF_CROP).is_empty());// the camera's in-camera flag (0 = off here) doesn't matter: the table is appliedlet ops = lens_opcodes(&ifd, " ILCE-7RM6 ", FF_ACTIVE, FF_CROP);- assert_eq!(ops, distortion_opcode(&read_tables(&ifd), knots(), FF_ACTIVE, FF_CROP).into_iter().collect::<Vec<_>>());+ assert_eq!(ops, warp_opcode(&read_tables(&ifd), knots(), FF_ACTIVE, FF_CROP).into_iter().collect::<Vec<_>>());assert_eq!(ops.len(), 1);}}diff --git a/crates/raw/src/vendor/mod.rs b/crates/raw/src/vendor/mod.rsindex 5512a1169..ae4b0892d 100644--- a/crates/raw/src/vendor/mod.rs+++ b/crates/raw/src/vendor/mod.rs@@ -158,8 +158,8 @@ pub(crate) fn warp_from_forward_map(corrected: &dyn Fn(f64) -> f64, t_max: f64,/// Least-squares `source = u·(k0 + k1u² + k2u⁴ + k3u⁶)` through `source_of_u` sampled at `u = i/64`, i = 0..=64/// (`u` = output radius, `WarpRectilinear` units, so the result is directly a plane's `[k0, k1, k2, k3]`). `None` when-/// a sample is not finite, the normal equations are singular, or the worst fit error at the samples with-/// `u ≤ gate_until` (the radii the image shows; 1 = all) exceeds `max_fit_error`.+/// a sample is not finite, the normal equations are singular, or the worst fit error at the samples up to the first+/// one at or beyond `gate_until` (the radii the image shows; 1 = all) exceeds `max_fit_error`.pub(crate) fn fit_radial_warp(source_of_u: &dyn Fn(f64) -> f64, max_fit_error: f64, gate_until: f64) -> Option<[f64; 4]> {let samples: Vec<(f64, f64)> = (0..=DISTORTION_SAMPLES).map(|i| {@@ -187,6 +187,10 @@ pub(crate) fn fit_radial_warp(source_of_u: &dyn Fn(f64) -> f64, max_fit_error: f}let k = solve4(a, rhs)?;let fit = |u: f64| basis(u).iter().zip(&k).map(|(f, c)| f * c).sum::<f64>();+ // rounded up to a sample, so the band between the last sample inside and `gate_until` itself is checked too;+ // capped at 1 (`min` also turns a NaN into 1: every sample is gated)+ let n = DISTORTION_SAMPLES as f64;+ let gate_until = (gate_until * n).ceil().min(n) / n;let worst = samples.iter().filter(|&&(u, _)| u <= gate_until).map(|&(u, v)| (fit(u) - v).abs()).fold(0.0, f64::max);(worst <= max_fit_error).then_some(k)}@@ -306,5 +310,12 @@ mod tests {let step = |u: f64| if u > 0.99 { 1.1 } else { u };assert!(fit_radial_warp(&step, 0.01, 1.0).is_none());assert_eq!(fit_radial_warp(&step, 0.01, 0.9), fit_radial_warp(&step, 1.0, 1.0), "gated only where shown");+ // the first sample at or beyond `gate_until` is gated too (the band up to it is shown): 0.023 up to+ // u = 62/64, 0.032 at 63/64+ assert!(fit_radial_warp(&step, 0.03, 62.0 / 64.0).is_some(), "a sample exactly at the bound");+ assert!(fit_radial_warp(&step, 0.03, 0.98).is_none(), "63/64 is the next sample beyond 0.98");+ // capped at 1, and a NaN gates every sample (fails closed)+ assert_eq!(fit_radial_warp(&step, 1.0, f64::INFINITY), fit_radial_warp(&step, 1.0, 1.0));+ assert!(fit_radial_warp(&step, 0.01, f64::NAN).is_none(), "a NaN gate");}}diff --git a/crates/raw/tests/corpus.rs b/crates/raw/tests/corpus.rsindex 60c81fd1f..c32857100 100644--- a/crates/raw/tests/corpus.rs+++ b/crates/raw/tests/corpus.rs@@ -626,14 +626,14 @@ fn corpus_sony_16x9_crops() {eprintln!("Sony 16:9 crops checked on {seen} files");}-/// Sony ILCE-7RM6: the distortion table in the raw IFD (`0x7037`) becomes a `WarpRectilinear` in `OpcodeList3`-/// (`vendor::arw_lens_rm6`). Expected: the conversion recipe measured on 54 ILCE-7RM6 photos, evaluated in f64 for each-/// file's decoded active area (the padded lossless tiles) and default crop. Both files carry distortion correction-/// off in camera; the table is applied anyway.+/// Sony ILCE-7RM6: the distortion and lateral CA tables in the raw IFD (`0x7037`, `0x7035`) become a three-plane+/// (R, G, B) `WarpRectilinear` in `OpcodeList3` (`vendor::arw_lens_rm6`). Expected: the conversion recipe measured on 54+/// ILCE-7RM6 photos, evaluated in f64 for each file's tables, decoded active area (the padded lossless tiles) and+/// default crop. Both files carry distortion correction off in camera; the table is applied anyway.#[test]fn corpus_sony_lens_tables_become_opcodes() {let dir = corpus_root().join("raw");- // (file, active area, default crop x, y, width, height, opcode centre, G-plane k0..k3)+ // (file, active area, default crop x, y, width, height, opcode centre, R, G, B planes k0..k3)let cases = [// not pinned in `cargo xtask corpus` (at most two pins per PR; #625 pins two Compressed ARW 6.0 files): checked// only where the file is present (RawDB `ILCE-7RM6_FF_land_RAW.ARW`, CC0)@@ -642,7 +642,11 @@ fn corpus_sony_lens_tables_become_opcodes() {(10240, 7168),(12, 8, 9984, 6656),[0.488670768629749, 0.4653969582810102],- [0.9717033132764651, 0.023249297636569695, 0.008638979168841135, 0.003091041831374855],+ [+ [0.971770511193381, 0.023073568897462152, 0.00879158563716919, 0.0030468782543633132],+ [0.9717033132764651, 0.023249297636569695, 0.008638979168841135, 0.003091041831374855],+ [0.9716312798157171, 0.02356676356656341, 0.00830169937204417, 0.003182927930635947],+ ],),// pinned in `cargo xtask corpus` (RawDB `ILCE-7RM6_APSC_land_RAW.ARW`, CC0)(@@ -650,7 +654,11 @@ fn corpus_sony_lens_tables_become_opcodes() {(6656, 4608),(16, 10, 6528, 4352),[0.49278737791134486, 0.4743868026915563],- [1.016366854640611, -0.0688824189782517, 0.03615745253291194, -0.009438825010476538],+ [+ [1.0165959888027158, -0.0690974265041942, 0.036328960724338874, -0.009486844437228997],+ [1.016366854640611, -0.0688824189782517, 0.03615745253291194, -0.009438825010476538],+ [1.0162457267369314, -0.0686225599869027, 0.035974238433727206, -0.009384155126102897],+ ],),];let mut seen = 0;@@ -679,10 +687,12 @@ fn corpus_sony_lens_tables_become_opcodes() {}).collect();let [(planes, got)] = warps.as_slice() else { panic!("{name}: {:?}", img.opcodes.list3) };- assert_eq!(planes.len(), 1, "{name}: one plane (G)");+ assert_eq!(planes.len(), 3, "{name}: R, G, B planes");assert!((got[0] - center[0]).abs() < 1e-6 && (got[1] - center[1]).abs() < 1e-6, "{name}: centre {got:?}, want {center:?}");- for (i, want) in k.iter().enumerate() {- assert!((planes[0][i] - want).abs() < 1e-6, "{name}: k{i} {}, want {want}", planes[0][i]);+ for (plane, (p, k)) in ["R", "G", "B"].iter().zip(planes.iter().zip(k)) {+ for (i, want) in k.iter().enumerate() {+ assert!((p[i] - want).abs() < 1e-6, "{name}: {plane} k{i} {}, want {want}", p[i]);+ }}seen += 1;}