Skip to content

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

Merge remote-tracking branch 'upstream/main' into fix/colour-fit-lens-geometry

Michael Anderson9ad2c1766bba
diff --cc crates/engine/src/camera_preview.rs
index 4a300dc17,e01116b45..618cded8e
--- a/crates/engine/src/camera_preview.rs
+++ b/crates/engine/src/camera_preview.rs
@@@ -77,10 -76,38 +77,41 @@@ pub(crate) fn file_local_look(format: R
/// white (a monochrome picture style) has no colour to fit, but still gives its tone curve: with the camera profile's
/// colour in [`fit_preview`], else on top of the spectral matrices or the fallback ([`monochrome_look`]). Returns the
/// as-shot white, the camera transform at it and the fitted look.
- /// `lens` is the file's own lens-correction warp ([`lens_geometry`], read before the caller removes it from
++/// `warp` is the file's own lens-correction warp ([`lens_geometry`], read before the caller removes it from
+/// `OpcodeList3`): the camera applied it to its JPEG, so the sensor proxy is warped the same way before pairing.
- pub(crate) fn starting_colour(raw: &mut RawImage, bytes: &[u8], lens: Option<&LensGeometry>) -> (Xy, CameraTransform, Option<CameraLook>) {
- starting_colour_with(raw, |raw, t| fit_preview(raw, bytes, t, lens), |raw, t| monochrome_look(raw, bytes, t, lens))
+ pub(crate) fn starting_colour(
+ raw: &mut RawImage,
+ bytes: &[u8],
+ lens: Option<&lightcraft_develop::EmbeddedLens>,
++ warp: Option<&LensGeometry>,
+ ) -> (Xy, CameraTransform, Option<CameraLook>) {
- let (xy, t, look) = starting_colour_with(raw, |raw, t| fit_preview(raw, bytes, t), |raw, t| monochrome_look(raw, bytes, t));
++ let (xy, t, look) = starting_colour_with(raw, |raw, t| fit_preview(raw, bytes, t, warp), |raw, t| monochrome_look(raw, bytes, t, warp));
+ if look.is_none() && dng_tone_eligible(raw, &t) {
+ let look = fit_dng_tone(raw, bytes, &t, lens);
+ return (xy, t, look);
+ }
+ (xy, t, look)
+ }
+
+ /// Whether the profile's tone curve is absent or the identity (within 0.005 over the range).
+ fn identity_tone_curve(curve: Option<&lightcraft_raw::profile::ToneCurve>) -> bool {
+ curve.is_none_or(|c| {
+ (0..=32).all(|i| {
+ let x = i as f32 / 32.0;
+ (c.eval(x) - x).abs() < 0.005
+ })
+ })
+ }
+
+ /// A DNG with its own colour model whose tone is not (yet) defined by the file: a matrix, no
+ /// non-identity `ProfileToneCurve`, no `LookTable` (a look table is the file's own rendering).
+ pub(crate) fn dng_tone_eligible(raw: &RawImage, t: &CameraTransform) -> bool {
+ let p = &raw.color.profile;
+ raw.format == RawFormat::Dng
+ && !t.matrix_is_fallback
+ && identity_tone_curve(p.tone_curve.as_ref())
+ && p.look_table.is_none()
+ && p.gain_table_map.is_none()
}
/// [`starting_colour`] with the JPEG fit (the look, and whether the JPEG is black and white) and the black-and-white
@@@ -127,9 -154,7 +158,9 @@@ pub(crate) fn starting_colour_tags(raw
// the white the source shows, decided before `starting_colour` may fill in measured matrices
let scale = crate::files::WbScaleOf::new(raw.format, &raw.color, raw.wb_multipliers, &raw.metadata);
let white = scale.dng_white(&raw.color, lightcraft_raw::color::as_shot_white_xy(raw));
- let (_, t, look) = starting_colour(raw, bytes, None);
+ // (a merge frame arrives without its lens warp: `lightcraft_merge` removes it before calling, and Export as DNG
+ // takes the lens corrections off first)
- let (_, t, look) = starting_colour(raw, bytes, None);
++ let (_, t, look) = starting_colour(raw, bytes, None, None);
dng_colour(&raw.color, &white, &t, look.as_ref())
}
@@@ -231,7 -256,7 +262,7 @@@ pub(crate) fn fit_preview(raw: &RawImag
if !transform.matrix_is_fallback || !file_local_look(raw.format) {
return (None, false);
}
- let Some((sensor, reference, clipped)) = proxies(raw, bytes, transform, PROXY, lens) else { return (None, false) };
- let Some((sensor, reference, clipped)) = proxies(raw, bytes, transform, PROXY, 0.0) else { return (None, false) };
++ let Some((sensor, reference, clipped)) = proxies(raw, bytes, transform, PROXY, 0.0, lens) else { return (None, false) };
let black_and_white = monochrome(&reference);
// A camera profile pooled from many photos knows colours this photo shows too little of;
// try its colour first and fit tone/chroma per photo (picture styles vary).
@@@ -388,16 -413,163 +419,170 @@@ fn at_most(a: &CameraTone, b: &CameraTo
/// decodes at full size, so a 66.5 MP full-frame ILCE-7RM6 JPEG transiently needs ~200 MB (3 B/px);
/// 128 MP also admits 100 MP medium-format previews.
const FIT_PREVIEW_MAX_PIXELS: u64 = 128_000_000;
+
+ /// A DNG's tone and chroma curves fitted to its own camera JPEG ([`dng_tone_eligible`]); the file's colour model
+ /// (matrix, profile tables, white balance) stays as it is: the proxy goes through the file's tables and the given
+ /// colour of the search is the identity. Same held-out acceptance gates as [`fit_look`]; the preview must be near
+ /// the raw's size, show the same picture ([`structure_agrees`]), and the curve must not clip more highlights than
+ /// the plain render ([`clips_more`]).
+ fn fit_dng_tone(raw: &RawImage, bytes: &[u8], transform: &CameraTransform, lens: Option<&lightcraft_develop::EmbeddedLens>) -> Option<CameraLook> {
+ // Logged under LIGHTCRAFT_PROFILE so a corpus run can count the outcome per gate.
+ let refuse = |why: &str| {
+ if std::env::var_os("LIGHTCRAFT_PROFILE").is_some() {
+ eprintln!("DNGTONE refused {why}");
+ }
+ None
+ };
- let Some((mut sensor, reference, clipped)) = proxies(raw, bytes, transform, PROXY, MIN_PREVIEW_FRACTION) else { return refuse("preview") };
++ let Some((mut sensor, reference, clipped)) = proxies(raw, bytes, transform, PROXY, MIN_PREVIEW_FRACTION, None) else { return refuse("preview") };
+ // As the loader renders it: the profile's tables around the baseline exposure.
+ let xy = lightcraft_raw::color::as_shot_white_xy(raw);
+ if let Some(tables) = lightcraft_raw::profile::ProfileTables::new(&raw.color.profile, lightcraft_raw::color::illuminant_weight(&raw.color, xy)) {
+ let gain = 2f32.powf(transform.baseline_exposure as f32);
+ sensor.map_in_place(|p| tables.apply(p.map(|v| v / gain), gain));
+ }
+ correct_vignetting(&mut sensor, lens, raw.orientation);
+ if (sensor.width, sensor.height) != (reference.width, reference.height) {
+ return refuse("preview");
+ }
+ if !structure_agrees(&sensor, &reference) {
+ return refuse("structure");
+ }
+ let unclipped = without_clipped(&sensor, &clipped);
+ let fit_on = unclipped.as_ref().unwrap_or(&sensor);
+ let colour = Some((Mat3::IDENTITY, None));
+ let look = TONE_FITS.iter().find_map(|&tone| {
+ [false, true]
+ .into_iter()
+ .find_map(|away_from_edges| fit_attempt(fit_on, &reference, &colour, Attempt { tone, profile: true, away_from_edges, dark: true }))
+ });
+ let Some(look) = look else { return refuse("fit") };
+ let plain = match raw.color.profile.tone_curve.as_ref().and_then(crate::files::dng_tone_curve) {
+ Some(curve) => ToneMap::camera(&curve, 0.0, 0.0, 0.0),
+ None => ToneMap::new(0.0, 0.0, 0.0),
+ };
+ let fitted = ToneMap::camera(&look.tone, 0.0, 0.0, 0.0);
+ if clips_more(&sensor, &reference, &fitted, &plain) {
+ return refuse("clip");
+ }
+ if std::env::var_os("LIGHTCRAFT_PROFILE").is_some() {
+ eprintln!("DNGTONE accepted");
+ }
+ Some(look)
+ }
+
+ /// Whether the fitted tone map puts clearly more of the photo's proxy pixels at or near white than both the plain
+ /// render and the camera's own preview do ([`CLIP_TOLERANCE`]): a fit that clips what the camera clips too is the
+ /// camera's look, one that clips what neither does loses highlight detail.
+ fn clips_more(sensor: &Rgb32f, reference: &Rgb32f, fitted: &ToneMap, plain: &ToneMap) -> bool {
+ let near_white = |tone: &ToneMap| {
+ let n = sensor.data.iter().filter(|p| p.iter().all(|v| v.is_finite()) && tone.apply(luminance_2020(p.map(|v| v.max(0.0)))) >= 0.98).count();
+ n as f64 / sensor.data.len().max(1) as f64
+ };
+ let preview = reference.data.iter().filter(|p| luminance_2020(**p) >= 0.98).count() as f64 / reference.data.len().max(1) as f64;
+ near_white(fitted) > near_white(plain).max(preview) + CLIP_TOLERANCE
+ }
+
+ /// Multiply the sensor proxy (sensor orientation, default crop) by the embedded vignetting correction, the gain the
+ /// pipeline applies to the render (`optics::embedded_vignette_gain`; `lens` is in the oriented, cropped frame): the
+ /// camera JPEG has it applied, so a tone fitted without it brightens the render's corners twice.
+ fn correct_vignetting(sensor: &mut Rgb32f, lens: Option<&lightcraft_develop::EmbeddedLens>, orientation: lightcraft_geom::Orientation) {
+ let Some(vignette) = lens.and_then(|l| l.vignette) else { return };
+ let (w, h) = (sensor.width as f64, sensor.height as f64);
+ let (ow, oh) = if orientation.swaps_axes() { (h, w) } else { (w, h) };
+ let width = sensor.width.max(1);
+ for (i, p) in sensor.data.iter_mut().enumerate() {
+ let (x, y) = orientation.map((i % width) as f64 + 0.5, (i / width) as f64 + 0.5, w, h);
+ let gain = lightcraft_pipeline::optics::embedded_vignette_gain(&vignette, lightcraft_geom::Point::new(x, y), ow, oh) as f32;
+ *p = p.map(|v| v * gain);
+ }
+ }
+
+ /// The embedded preview's long edge must be at least this share of the raw's (and 384 px): a DNG whose preview is a
+ /// small thumbnail is not fitted.
+ const MIN_PREVIEW_FRACTION: f64 = 0.9;
+
+ /// Lowest preview luminance and channel value a tone-only fit trains on (the other fits use 0.015 and 0.004): a dark
+ /// night scene has most of its pixels below 0.015, and a curve fitted without them overshoots its shadows.
+ const DARK_FLOOR: (f32, f32) = (0.004, 0.001);
+
+ /// Share of the proxy by which the fitted curve may clip more highlights than the plain render and the camera's
+ /// preview (chosen on the CC0 and user DNGs from the clipped share of their 1440 px renders: it refuses the fits
+ /// that clip about 1% more than the camera does and passes the ones that clip like the camera).
+ const CLIP_TOLERANCE: f64 = 0.001;
+
+ /// Log-luminance correlation (5 × 5 box blurred) the unshifted proxies must reach.
+ const MIN_STRUCTURE: f64 = 0.85;
+
+ /// Whether the sensor proxy and the camera JPEG proxy show the same picture in the same place: their log luminance
+ /// correlates by at least [`MIN_STRUCTURE`] unshifted, and no shift of more than one proxy pixel (within ±3)
+ /// correlates better.
+ fn structure_agrees(sensor: &Rgb32f, reference: &Rgb32f) -> bool {
+ let (w, h) = (sensor.width, sensor.height);
+ if (w, h) != (reference.width, reference.height) || w < 16 || h < 16 || sensor.data.len() != w * h || reference.data.len() != w * h {
+ return false;
+ }
+ let log = |img: &Rgb32f| -> Vec<f64> {
+ let l: Vec<f64> =
+ img.data.iter().map(|p| f64::from(luminance_2020(p.map(|v| if v.is_finite() { v.max(0.0) } else { 0.0 }))).max(1e-4).ln()).collect();
+ (0..w * h)
+ .map(|i| {
+ let (x, y) = (i % w, i / w);
+ let (mut sum, mut n) = (0.0, 0.0);
+ for yy in y.saturating_sub(2)..(y + 3).min(h) {
+ for xx in x.saturating_sub(2)..(x + 3).min(w) {
+ if let Some(v) = l.get(yy * w + xx) {
+ sum += v;
+ n += 1.0;
+ }
+ }
+ }
+ sum / f64::max(n, 1.0)
+ })
+ .collect()
+ };
+ let (a, b) = (log(sensor), log(reference));
+ const M: usize = 3;
+ let corr = |dx: isize, dy: isize| -> f64 {
+ let (mut n, mut sa, mut sb, mut saa, mut sbb, mut sab) = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+ for y in M..h - M {
+ for x in M..w - M {
+ let (xx, yy) = (x.saturating_add_signed(dx), y.saturating_add_signed(dy));
+ let (Some(&u), Some(&v)) = (a.get(y * w + x), b.get(yy * w + xx)) else { continue };
+ n += 1.0;
+ sa += u;
+ sb += v;
+ saa += u * u;
+ sbb += v * v;
+ sab += u * v;
+ }
+ }
+ let var = (saa - sa * sa / n) * (sbb - sb * sb / n);
+ if n < 2.0 || var <= 1e-12 { 0.0 } else { (sab - sa * sb / n) / var.sqrt() }
+ };
+ let at_zero = corr(0, 0);
+ let (mut best, mut shift) = (at_zero, (0isize, 0isize));
+ for dy in -(M as isize)..=M as isize {
+ for dx in -(M as isize)..=M as isize {
+ let c = corr(dx, dy);
+ if c > best + 1e-9 {
+ (best, shift) = (c, (dx, dy));
+ }
+ }
+ }
+ at_zero >= MIN_STRUCTURE && shift.0.abs() <= 1 && shift.1.abs() <= 1
+ }
+
/// Same-size proxies of the sensor (white-balanced, baseline exposure, through `transform`'s
/// matrix: the generic camera ≈ sRGB model) and of the file's embedded camera JPEG (linear Rec.2020),
/// and per proxy pixel whether any sensor sample it covers is clipped.
-fn proxies(raw: &RawImage, bytes: &[u8], transform: &CameraTransform, size: usize, min_fraction: f64) -> Option<(Rgb32f, Rgb32f, Vec<bool>)> {
+fn proxies(
+ raw: &RawImage,
+ bytes: &[u8],
+ transform: &CameraTransform,
+ size: usize,
++ min_fraction: f64,
+ lens: Option<&LensGeometry>,
+) -> Option<(Rgb32f, Rgb32f, Vec<bool>)> {
let edge = (2 * size).max(384) as u32;
let decoded = crate::files::decode_raw_preview(
bytes,
@@@ -621,7 -784,7 +811,7 @@@ pub(crate) fn profile_pairs(raw: &RawIm
return None;
}
let transform = lightcraft_raw::color::camera_transform(raw, lightcraft_raw::color::as_shot_white_xy(raw));
- let (sensor, reference, clipped) = proxies(raw, bytes, &transform, PROFILE_PROXY, lens)?;
- let (sensor, reference, clipped) = proxies(raw, bytes, &transform, PROFILE_PROXY, 0.0)?;
++ let (sensor, reference, clipped) = proxies(raw, bytes, &transform, PROFILE_PROXY, 0.0, lens)?;
let to_camera = transform.matrix.inverse()?;
// clipped sensor pixels don't record the scene's colour (see `fit_look`)
let sensor = without_clipped(&sensor, &clipped).unwrap_or(sensor);
@@@ -1223,7 -1300,7 +1423,7 @@@ fn monochrome_look(raw: &RawImage, byte
if !file_local_look(raw.format) {
return None;
}
- let (sensor, reference, clipped) = proxies(raw, bytes, transform, PROXY, lens)?;
- let (sensor, reference, clipped) = proxies(raw, bytes, transform, PROXY, 0.0)?;
++ let (sensor, reference, clipped) = proxies(raw, bytes, transform, PROXY, 0.0, lens)?;
if !monochrome(&reference) {
return None;
}
@@@ -2172,93 -2334,6 +2457,93 @@@ mod tests
}
}
+ /// The lens warp the colour fit follows is the first `WarpRectilinear`'s green plane; no warp, a DNG 1.6 chain
+ /// (phone DNGs, which carry colour matrices), a centre outside the area or a non-finite term give none.
+ #[test]
+ fn lens_geometry_reads_the_first_rectilinear_warp() {
+ use lightcraft_raw::Opcode;
+ let warp = |k0: f64, c: [f64; 2]| Opcode::WarpRectilinear {
+ planes: vec![[9.0, 0.0, 0.0, 0.0, 0.0, 0.0], [k0, 0.1, -0.02, 0.003, 0.0, 0.0], [9.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+ center: c,
+ };
+ assert_eq!(lens_geometry(&[warp(0.97, [0.5, 0.4])]), Some(LensGeometry { k: [0.97, 0.1, -0.02, 0.003], center: [0.5, 0.4] }));
+ let single = Opcode::WarpRectilinear { planes: vec![[1.02, 0.0, 0.0, 0.0, 0.0, 0.0]], center: [0.5, 0.5] };
+ assert_eq!(lens_geometry(std::slice::from_ref(&single)).map(|g| g.k[0]), Some(1.02));
+ assert!(lens_geometry(&[]).is_none());
+ assert!(lens_geometry(&[warp(1.0, [1.5, 0.5])]).is_none());
+ assert!(lens_geometry(&[warp(f64::NAN, [0.5, 0.5])]).is_none());
+ let mut p = [0.0; lightcraft_raw::opcodes::WR2_LEN];
+ p[0] = 1.0;
+ p[18] = 1e6;
+ let chain = Opcode::WarpRectilinear2 { planes: vec![p], center: [0.5, 0.5], reciprocal: false, optional: false };
+ assert!(lens_geometry(&[chain, single]).is_none());
+ }
+
+ /// A binned sensor proxy moved into the camera JPEG's geometry: the identity warp leaves it as it is, a warp
+ /// whose source radius is 0.8 of the output's samples nearer the centre, output pixels whose source falls outside
+ /// the proxy are NaN (left out of the pairs), and a proxy of another size is left alone.
+ #[test]
+ fn the_sensor_proxy_follows_the_cameras_lens_warp() {
+ let mut raw = raw_of(RawFormat::Nef, "NIKON CORPORATION", "NIKON Z 6_2", Default::default());
+ raw.active_area = lightcraft_raw::Rect::new(0, 0, 64, 48);
+ raw.crop = raw.active_area;
+ // a 1/4 proxy whose pixels hold their own coordinates
+ let mut img = Rgb32f::new(16, 12);
+ for (i, p) in img.data.iter_mut().enumerate() {
+ *p = [(i % 16) as f32, (i / 16) as f32, 1.0];
+ }
+ let geometry = |k0: f64| LensGeometry { k: [k0, 0.0, 0.0, 0.0], center: [0.5, 0.5] };
+ let same = into_lens_geometry(&img, &raw, 4, &geometry(1.0)).unwrap();
+ assert!(same.data.iter().zip(&img.data).all(|(a, b)| (0..3).all(|c| (a[c] - b[c]).abs() < 1e-4)));
+ // the corner pixel's centre (1.5, 1.5) maps to (31.5 - 0.8 * 30, 23.5 - 0.8 * 22) = (7.5, 5.9) on the sensor
+ let zoomed = into_lens_geometry(&img, &raw, 4, &geometry(0.8)).unwrap();
+ assert!((zoomed.data[0][0] - 1.5).abs() < 1e-4 && (zoomed.data[0][1] - 1.1).abs() < 1e-4, "{:?}", zoomed.data[0]);
+ let outside = into_lens_geometry(&img, &raw, 4, &geometry(1.3)).unwrap();
+ assert!(outside.data[0][0].is_nan() && outside.data[6 * 16 + 8][0].is_finite());
+ assert!(into_lens_geometry(&Rgb32f::new(15, 12), &raw, 4, &geometry(1.0)).is_none());
+ }
+
+ /// A raw with an in-file lens correction (Fujifilm, Panasonic, the A7R IVA, Nikon) may have a lens-corrected
+ /// camera JPEG: the proxies the fit pairs line up with it at least as well as the uncorrected sensor, on every
+ /// corpus file the colour fit uses that carries such a warp, and better on those whose JPEG is corrected.
+ #[test]
+ fn corpus_lens_corrected_jpegs_pair_with_the_warped_sensor() {
+ let dir = std::env::var_os("LIGHTCRAFT_CORPUS")
+ .map(std::path::PathBuf::from)
+ .unwrap_or_else(|| std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../corpus"))
+ .join("raw");
+ let Ok(entries) = std::fs::read_dir(&dir) else {
+ eprintln!("skip: no corpus at {}", dir.display());
+ return;
+ };
+ let mut paths: Vec<_> = entries.flatten().map(|e| e.path()).collect();
+ paths.sort();
+ let (mut checked, mut gain) = (0, 0.0);
+ for path in paths {
+ let Ok(bytes) = std::fs::read(&path) else { continue };
+ let Ok(mut raw) = lightcraft_raw::decode(&bytes) else { continue };
+ let Some(lens) = lens_geometry(&raw.opcodes.list3) else { continue };
+ if !file_local_look(raw.format) || lightcraft_raw::color::has_matrix(&raw.color) {
+ continue;
+ }
+ raw.opcodes.list3.retain(|op| !op.is_lens_correction());
+ let t = lightcraft_raw::color::camera_transform(&raw, lightcraft_raw::color::as_shot_white_xy(&raw));
+ let (Some((plain, reference, _)), Some((chosen, chosen_reference, _))) =
- (proxies(&raw, &bytes, &t, PROXY, None), proxies(&raw, &bytes, &t, PROXY, Some(&lens)))
++ (proxies(&raw, &bytes, &t, PROXY, 0.0, None), proxies(&raw, &bytes, &t, PROXY, 0.0, Some(&lens)))
+ else {
+ continue;
+ };
+ let (before, after) = (alignment(&plain, &reference), alignment(&chosen, &chosen_reference));
+ eprintln!("{}: alignment {before:.3} -> {after:.3}", path.display());
+ // (chosen on camera RGB, measured after the colour transform: a near tie may flip by a little)
+ assert!(after >= before - 0.01, "{}: {before:.3} -> {after:.3}", path.display());
+ gain += after - before;
+ checked += 1;
+ }
+ eprintln!("{checked} corpus raws with an in-file lens warp, mean gain {:.3}", gain / checked.max(1) as f64);
+ assert!(checked == 0 || gain > 0.0);
+ }
+
/// Step 1: a file's own colour matrices win over everything, including a spectral row for its model; no JPEG fit
/// is tried.
#[test]
@@@ -2306,7 -2381,7 +2591,7 @@@
assert!(crate::camera_profiles::get("ILCE-7M4").is_some());
let camera = lightcraft_raw::spectral::find(Some("SONY"), "ILCE-7M4").unwrap();
let mut raw = raw_of(RawFormat::Arw, "SONY", "ILCE-7M4", Default::default());
-- let (_, t, look) = starting_colour(&mut raw, &[], None);
++ let (_, t, look) = starting_colour(&mut raw, &[], None, None);
assert!(look.is_none());
assert_eq!(raw.color.color_matrix, camera.color_matrix.map(Some));
assert!(!t.matrix_is_fallback);
@@@ -2365,13 -2440,13 +2650,13 @@@
#[test]
fn a_camera_outside_the_table_keeps_the_fallback() {
let mut raw = raw_of(RawFormat::Cr2, "Canon", "Canon EOS 7D", Default::default());
-- let (_, t, look) = starting_colour(&mut raw, &[], None);
++ let (_, t, look) = starting_colour(&mut raw, &[], None, None);
assert!(look.is_none() && t.matrix_is_fallback);
assert_eq!(raw.color, lightcraft_raw::ColorData::default());
// without a model there is no table row
let mut raw = raw_of(RawFormat::Cr2, "Canon", "", Default::default());
raw.metadata.model = None;
-- assert!(starting_colour(&mut raw, &[], None).1.matrix_is_fallback);
++ assert!(starting_colour(&mut raw, &[], None, None).1.matrix_is_fallback);
}
/// The colour precedence on public raws (each skipped without its corpus file): a photo whose JPEG fit is
@@@ -2397,7 -2471,7 +2682,7 @@@
let measured = lightcraft_raw::spectral::find(make, model).is_some();
let covered = measured || lightcraft_raw::kelvin_presets::covers(make, model);
let before = raw.color.clone();
- let (_, t, fitted) = starting_colour(&mut raw, &bytes, lens.as_ref());
- let (_, t, fitted) = starting_colour(&mut raw, &bytes, None);
++ let (_, t, fitted) = starting_colour(&mut raw, &bytes, None, lens.as_ref());
let spectral = !own && fitted.is_none() && measured;
eprintln!("{name}: own matrices {own}, JPEG fit {}, spectral {spectral}", fitted.is_some());
assert_eq!(raw.color != before, spectral, "{name}");
@@@ -2877,9 -2981,9 +3192,9 @@@
let mut raw = lightcraft_raw::decode(&bytes).unwrap();
raw.opcodes.list3.retain(|op| !op.is_lens_correction());
let transform = lightcraft_raw::color::camera_transform(&raw, lightcraft_raw::color::as_shot_white_xy(&raw));
- let look = fit_preview(&raw, &bytes, &transform).0.expect("a camera look");
+ let look = fit_preview(&raw, &bytes, &transform, None).0.expect("a camera look");
// the look fitted to the JPEG, as before this change
- let (sensor, reference, clipped) = proxies(&raw, &bytes, &transform, PROXY, None).unwrap();
- let (sensor, reference, clipped) = proxies(&raw, &bytes, &transform, PROXY, 0.0).unwrap();
++ let (sensor, reference, clipped) = proxies(&raw, &bytes, &transform, PROXY, 0.0, None).unwrap();
let profile = raw.metadata.model.as_deref().and_then(crate::camera_profiles::get);
let colour = profile.as_ref().and_then(|p| Some((p.matrix().mul(&transform.matrix.inverse()?), p.hue_sat.clone())));
let fitted = fit_look(&sensor, &reference, &clipped, colour).unwrap();
diff --cc crates/engine/src/files.rs
index 2c3c85341,e68632ef7..6b1cc2dfb
--- a/crates/engine/src/files.rs
+++ b/crates/engine/src/files.rs
@@@ -408,8 -428,8 +430,10 @@@ fn load_bytes_now
// the camera's measured matrices (`Photo::relative_wb` decides the same from the catalog's camera)
let scale = WbScaleOf::new(raw.format, &raw.color, raw.wb_multipliers, &raw.metadata);
// the source's segmentation mattes (DNG semantic masks), read while the starting colour is fitted
-- let ((xy, t, camera_look), mattes) =
- rayon::join(|| crate::camera_preview::starting_colour(&mut raw, &bytes, lens_geometry.as_ref()), || dng_mattes(&bytes, &info));
- rayon::join(|| crate::camera_preview::starting_colour(&mut raw, &bytes, lens.as_ref()), || dng_mattes(&bytes, &info));
++ let ((xy, t, camera_look), mattes) = rayon::join(
++ || crate::camera_preview::starting_colour(&mut raw, &bytes, lens.as_ref(), lens_geometry.as_ref()),
++ || dng_mattes(&bytes, &info),
++ );
drop(bytes);
// Previews and thumbnails bin the mosaic straight to (about) the size they need; only
// larger levels (exports, 1:1) demosaic the whole sensor.
diff --cc crates/engine/src/tests_xmp.rs
index 6921a6f8c,c5f2b05c0..231a7bee3
--- a/crates/engine/src/tests_xmp.rs
+++ b/crates/engine/src/tests_xmp.rs
@@@ -973,7 -975,7 +975,7 @@@ fn dngs_of_raws_without_colour_matrices
std::fs::write(&path, &bytes).unwrap();
let mut opened = lightcraft_raw::decode(&bytes).unwrap();
assert!(!has_matrix(&opened.color));
-- let (_, want, look) = crate::camera_preview::starting_colour(&mut opened, &bytes, None);
++ let (_, want, look) = crate::camera_preview::starting_colour(&mut opened, &bytes, None, None);
assert_eq!((want.matrix_is_fallback, look.is_none()), (!measured, true), "{model}");
let mut s = Session::new().with_fs();
diff --cc docs/whats-new.md
index cc8092233,f85aa7c50..e97c24b50
--- a/docs/whats-new.md
+++ b/docs/whats-new.md
@@@ -117,10 -117,29 +117,33 @@@
#1236). The D7000, D5100, D800, D800E, Df, D4, D3, D3S, D700, D300, D300S, D600, D610, D810, D4S, D5600,
Coolpix A, D3000, D40X, D60, D80, D2Xs, D200, D3200, D3100, D5000, D40, D50, D70, D70s and Nikon 1 V1 now show
the area the camera itself frames, a few pixels smaller than before.
+ - A command given photos it can't read as photo ids (`"id": "5"`, or a list with something else in it) from a
+ script, the control channel or MCP is now refused (issue #1506). It used to act on the selected photos instead,
+ or on the part of the list it could read, so a mistyped id could rate, move or delete the wrong photos.
+
+ ### An empty library leads to Import
+ - A library with no photos now opens on the Photo Grid with the sidebar (Square Grid stays as it is), instead of a
+ Detail view that pointed at an empty grid. The grid and Detail view offer Import Photos… and, in the desktop app,
+ Import Lightroom Catalog… as buttons, and say that photos (and, in the desktop app, folders) can be dropped into
+ the window. The shortcut they show is the one Import Photos… has now.
+ - The top bar has an Import button, beside Export, in every library.
+
+ ### Reliability
+
+ ### One kind of button
+ - Dialogs' buttons and About's Discord link are drawn by one button component: primary (filled with the accent),
+ secondary, danger (filled red) and ghost, in three sizes, with an icon or without, and an icon alone (named for
+ screen readers). Each darkens a little when hovered and more when pressed, shows a ring where the keyboard is, and
+ its text reads at 4.5:1 or more on its fill in every theme. Dialog buttons are 30 points tall, like the welcome's.
+
+ ### A dialog's confirm button says it's the next step
+ - In dialogs, the confirm button is on the right with Cancel to its left, and filled with the accent when it makes or
+ brings in something (Import N Photos, Merge, Save, Create, Download…). Delete and Remove stay plain, so a destructive
+ choice is never the eye-catching default.
+### Closer camera colour for lens-corrected raws
+- Raws from cameras that correct their own JPEG for lens distortion (Panasonic and Fujifilm with that setting on, the
+ Sony A7R IVA) now start from colours closer to the camera's. The starting look was being fitted against a JPEG that
+ didn't line up with the raw near the edges. Photos you already imported pick this up when their previews are rebuilt.
### Hard-edged Heal and Clone spots
- A spot with Feather at 0 no longer draws black pixels exactly on its radius. This also fixes spots at 0% Opacity