LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LR-MERGE-HDR: keep the reference frame's lens corrections in HDR merges
Claude4c1dfc5b0fb3
diff --git a/crates/engine/src/merge.rs b/crates/engine/src/merge.rsindex 53c7f546e..9dfa1b7e6 100644--- a/crates/engine/src/merge.rs+++ b/crates/engine/src/merge.rs@@ -128,11 +128,14 @@ impl MergeJob {return Err("cancelled".into());}let sub = |a: f32, b: f32| move |f: f32, s: &str| progress(a + (b - a) * f, s);+ // the reference frame's lens corrections (HDR); panoramas carry none+ let mut lens = Vec::new();let (image, color, orientation, metadata, baseline, samples, crop, mut info, ghost) = match &self.kind {MergeKind::Hdr { hdr } => {let frames = self.load(false, progress, (0.0, 0.3))?;let p = sub(0.3, 0.9);- let r = lightcraft_merge::merge_hdr(frames, hdr, &p).map_err(err)?;+ let mut r = lightcraft_merge::merge_hdr(frames, hdr, &p).map_err(err)?;+ lens = std::mem::take(&mut r.lens);let info = json!({"reference": self.sources[r.reference].0.0,"ev": r.ev, "evExif": r.ev_exif,@@ -181,6 +184,7 @@ impl MergeJob {orientation: r.orientation,metadata: r.metadata,baseline_exposure: r.baseline_exposure,+ lens: Vec::new(),};f.orient();merged.push(f);@@ -212,7 +216,7 @@ impl MergeJob {metadata.caption = Some(format!("Merged from {}", names.join(", ")));}metadata.software = Some("LightCraft Photo Merge".into());- let dng = lightcraft_merge::write_linear_dng(&image, &color, orientation, &metadata, baseline, samples).map_err(err)?;+ let dng = lightcraft_merge::write_linear_dng(&image, &color, orientation, &metadata, baseline, samples, &lens).map_err(err)?;info["width"] = json!(image.width);info["height"] = json!(image.height);let preview = match self.preview {diff --git a/crates/engine/src/tests_merge.rs b/crates/engine/src/tests_merge.rsindex a0784dd15..42049a4e8 100644--- a/crates/engine/src/tests_merge.rs+++ b/crates/engine/src/tests_merge.rs@@ -67,6 +67,57 @@ fn hdr_merge_command_creates_and_imports_a_dng() {let _ = std::fs::remove_dir_all(&dir);}+/// An HDR merge keeps the reference frame's lens corrections. The sources carry an off-centre `WarpRectilinear` and+/// `FixVignetteRadial` for their active area and have a default crop; the merged DNG must give "Enable Profile+/// Corrections" the same correction as the reference photo, upright and for a vertical bracket (whose DNG keeps the+/// pixels unturned).+#[test]+fn hdr_merge_keeps_the_reference_frames_lens_corrections() {+ use lightcraft_geom::{Orientation, Point};+ use lightcraft_pipeline::optics::{embedded_vignette_gain, embedded_warp};+ use lightcraft_raw::Opcode;+ for orientation in [Orientation::Normal, Orientation::Rotate90] {+ let dir = temp_dir(&format!("hdr-lens-{orientation:?}"));+ let mut paths = Vec::new();+ for (i, b) in lightcraft_merge::synth::bracket_dngs(480, 320, &[-2.0, 0.0, 2.0]).unwrap().into_iter().enumerate() {+ let mut raw = lightcraft_raw::decode(&b).unwrap();+ raw.crop = lightcraft_raw::Rect::new(10, 6, 452, 304);+ raw.orientation = orientation;+ raw.metadata.orientation = Some(orientation);+ raw.opcodes.list3 = vec![+ Opcode::WarpRectilinear { planes: vec![[0.96, 0.05, -0.012, 0.002, 0.001, -0.0005]], center: [0.48, 0.53] },+ Opcode::FixVignetteRadial { k: [0.35, -0.05, 0.01, 0.0, 0.0], center: [0.48, 0.53] },+ ];+ let p = dir.join(format!("IMG_{i}.dng"));+ std::fs::write(&p, lightcraft_raw::write_dng(&raw, &Default::default()).unwrap()).unwrap();+ paths.push(p.to_string_lossy().to_string());+ }+ let mut s = Session::new().with_fs();+ let ids = import(&mut s, paths);+ let r = s.execute("merge.hdr", &json!({"ids": ids})).unwrap();+ assert_eq!(r["reference"].as_u64(), Some(ids[1]), "{r}");+ let merged = s.catalog.photo(lightcraft_catalog::PhotoId(r["id"].as_u64().unwrap())).unwrap().clone();+ let reference = s.catalog.photo(lightcraft_catalog::PhotoId(ids[1])).unwrap().clone();+ let expect = if orientation == Orientation::Normal { (452, 304) } else { (304, 452) };+ assert_eq!(((merged.width, merged.height), (reference.width, reference.height)), (expect, expect));+ let a = reference.embedded_lens.expect("the source's correction");+ let b = merged.embedded_lens.expect("the merged DNG carries the reference frame's correction");+ let (wa, wb) = (a.warp.unwrap(), b.warp.unwrap());+ let (va, vb) = (a.vignette.unwrap(), b.vignette.unwrap());+ let (w, h) = (expect.0 as f64, expect.1 as f64);+ for (x, y) in [(0.0, 0.0), (w, h), (w, 0.0), (0.0, h), (w * 0.3, h * 0.7), (w * 0.5, h * 0.5)] {+ let p = Point::new(x, y);+ for ch in 0..3 {+ let (pa, pb) = (embedded_warp(&wa, p, ch, w, h), embedded_warp(&wb, p, ch, w, h));+ assert!((pa.x - pb.x).abs() < 1e-6 && (pa.y - pb.y).abs() < 1e-6, "{orientation:?} {p:?}: {pa:?} vs {pb:?}");+ }+ let (ga, gb) = (embedded_vignette_gain(&va, p, w, h), embedded_vignette_gain(&vb, p, w, h));+ assert!((ga - gb).abs() < 1e-9, "{orientation:?} {p:?}: {ga} vs {gb}");+ }+ let _ = std::fs::remove_dir_all(&dir);+ }+}+#[test]fn panorama_command_with_auto_crop() {let dir = temp_dir("pano");diff --git a/crates/merge/src/frame.rs b/crates/merge/src/frame.rsindex 360c7424e..b7c583220 100644--- a/crates/merge/src/frame.rs+++ b/crates/merge/src/frame.rs@@ -6,7 +6,7 @@ use lightcraft_geom::Orientation;use lightcraft_meta::Metadata;use lightcraft_raster::Rgb32f;use lightcraft_raster::resample::{Filter, fit};-use lightcraft_raw::ColorData;+use lightcraft_raw::{ColorData, Opcode};use crate::{MergeError, Result};@@ -36,6 +36,10 @@ pub struct Frame {pub metadata: Metadata,/// Raw files: the source's `BaselineExposure` (EV), carried into the output.pub baseline_exposure: f64,+ /// Raw files: the lens corrections the source applies (`WarpRectilinear`, `WarpRectilinear2`, `FixVignetteRadial`,+ /// in order), re-expressed for `image` (the default crop, not yet turned), for the merged DNG to carry. Empty for+ /// other sources and once [`Frame::orient`] has turned the pixels.+ pub lens: Vec<Opcode>,}impl Frame {@@ -53,6 +57,7 @@ impl Frame {orientation: Orientation::Normal,metadata: Metadata::default(),baseline_exposure: 0.0,+ lens: Vec::new(),}}@@ -63,11 +68,12 @@ impl Frame {self.image.height}- /// Apply the display orientation to the pixels.+ /// Apply the display orientation to the pixels. The lens corrections, written for the unturned pixels, are dropped.pub fn orient(&mut self) {if self.orientation != Orientation::Normal {self.image = self.image.oriented(self.orientation);self.orientation = Orientation::Normal;+ self.lens.clear();}}}@@ -110,7 +116,21 @@ pub fn load_frame(bytes: &[u8], max_edge: Option<usize>, orient: bool) -> Resultlet exposure = exif_exposure(&metadata);if lightcraft_raw::probe(bytes).is_some() {let mut raw = lightcraft_raw::decode(bytes).map_err(|e| MergeError::Decode(e.to_string()))?;- // geometric lens corrections stay with the develop settings ("profile corrections")+ // Lens corrections stay with the develop settings ("profile corrections"): frames are merged uncorrected, and+ // the output DNG carries the reference frame's corrections, re-expressed for the default crop `develop` keeps.+ // The DNG 1.6 skip rule is applied here, so no `WarpRectilinear2` is left optional.+ let (aw, ah) = (raw.active_area.width, raw.active_area.height);+ let crop = raw.develop_crop(aw, ah);+ let lens = lightcraft_raw::opcodes::applied_ops(&raw.opcodes.list3)+ .filter(|op| op.is_lens_correction())+ .filter_map(|op| op.cropped(aw, ah, crop))+ .map(|op| match op {+ Opcode::WarpRectilinear2 { planes, center, reciprocal, .. } => {+ Opcode::WarpRectilinear2 { planes, center, reciprocal, optional: false }+ }+ op => op,+ })+ .collect();raw.opcodes.list3.retain(|op| !op.is_lens_correction());let small = max_edge.is_some_and(|m| m <= 1200);let method = if small { lightcraft_raw::Method::Bilinear } else { lightcraft_raw::Method::Ahd };@@ -133,6 +153,7 @@ pub fn load_frame(bytes: &[u8], max_edge: Option<usize>, orient: bool) -> Resultorientation: raw.orientation,metadata: if raw.metadata == Metadata::default() { metadata } else { raw.metadata.clone() },baseline_exposure: raw.color.baseline_exposure,+ lens,};if f.exposure.is_none() {f.exposure = exif_exposure(&f.metadata);@@ -163,6 +184,7 @@ pub fn load_frame(bytes: &[u8], max_edge: Option<usize>, orient: bool) -> Resultorientation: Orientation::from_exif(d.orientation),metadata,baseline_exposure: 0.0,+ lens: Vec::new(),};if orient {f.orient();diff --git a/crates/merge/src/hdr.rs b/crates/merge/src/hdr.rsindex 7c596c4a7..59aa5286c 100644--- a/crates/merge/src/hdr.rs+++ b/crates/merge/src/hdr.rs@@ -83,6 +83,8 @@ pub struct HdrResult {pub orientation: lightcraft_geom::Orientation,pub metadata: lightcraft_meta::Metadata,pub baseline_exposure: f64,+ /// The reference frame's lens corrections, for `radiance` ([`Frame::lens`]).+ pub lens: Vec<lightcraft_raw::Opcode>,}#[inline]@@ -277,6 +279,7 @@ pub fn merge_hdr(mut frames: Vec<Frame>, opts: &HdrOptions, progress: &Progress)orientation: rf.orientation,metadata: rf.metadata.clone(),baseline_exposure: rf.baseline_exposure,+ lens: rf.lens.clone(),})}diff --git a/crates/merge/src/output.rs b/crates/merge/src/output.rsindex e020ac45d..5d4b02e27 100644--- a/crates/merge/src/output.rs+++ b/crates/merge/src/output.rs@@ -8,12 +8,14 @@//! still camera RGB.//! - Other sources: the "camera" is the file's linear RGB space; `ColorMatrix1` = XYZ(D65) → RGB,//! `ForwardMatrix1` = RGB → XYZ(D50), `AsShotNeutral` = (1, 1, 1).+//! - Lens corrections (an HDR merge's: the reference frame's, [`crate::Frame::lens`]) go in `OpcodeList3`, where the+//! develop settings' profile corrections find them as they do in the sources.use lightcraft_color::{D50, D65, Mat3, bradford};use lightcraft_geom::Orientation;use lightcraft_meta::Metadata;use lightcraft_raster::Rgb32f;-use lightcraft_raw::{BlackLevel, ColorData, DngCompression, DngWriteOptions, OpcodeLists, RawData, RawFormat, RawImage, Rect};+use lightcraft_raw::{BlackLevel, ColorData, DngCompression, DngWriteOptions, Opcode, OpcodeLists, RawData, RawFormat, RawImage, Rect};use crate::frame::FrameColor;use crate::{MergeError, Result};@@ -58,7 +60,8 @@ pub fn color_data(color: &FrameColor) -> ColorData {}}-/// Encode `img` (scene-linear, 1.0 = source white) as a LinearRaw DNG.+/// Encode `img` (scene-linear, 1.0 = source white) as a LinearRaw DNG, with `lens` (lens corrections for `img`, not+/// yet turned by `orientation`) as its `OpcodeList3`.pub fn write_linear_dng(img: &Rgb32f,color: &FrameColor,@@ -66,6 +69,7 @@ pub fn write_linear_dng(metadata: &Metadata,baseline_exposure: f64,samples: DngSamples,+ lens: &[Opcode],) -> Result<Vec<u8>> {let (w, h) = (img.width, img.height);if w == 0 || h == 0 {@@ -106,7 +110,7 @@ pub fn write_linear_dng(color: cd,wb_multipliers: None,linearized: false,- opcodes: OpcodeLists::default(),+ opcodes: OpcodeLists { list3: lens.to_vec(), ..Default::default() },metadata: meta,};let compression = DngCompression::Deflate { tile: 256, half: samples == DngSamples::Half };@@ -121,7 +125,7 @@ mod tests {fn linear_dng_round_trips_through_the_raw_decoder() {let img = Rgb32f::from_fn(80, 60, |x, y| [x as f32 / 20.0, y as f32 / 30.0, 0.3]);let color = FrameColor::Linear { to_xyz_d50: bradford(D65, D50).mul(&lightcraft_color::SRGB.to_xyz()) };- let bytes = write_linear_dng(&img, &color, Orientation::Normal, &Metadata::default(), 0.0, DngSamples::Half).unwrap();+ let bytes = write_linear_dng(&img, &color, Orientation::Normal, &Metadata::default(), 0.0, DngSamples::Half, &[]).unwrap();let raw = lightcraft_raw::decode(&bytes).unwrap();assert_eq!((raw.width, raw.height, raw.cpp), (80, 60, 3));let gain = 2f32.powf(raw.color.baseline_exposure as f32);@@ -144,7 +148,7 @@ mod tests {for c in 0..3 {assert!((red[c] / k - want[c]).abs() < 5e-3, "{red:?} vs {want:?}");}- let u16 = write_linear_dng(&img, &color, Orientation::Normal, &Metadata::default(), 0.0, DngSamples::U16).unwrap();+ let u16 = write_linear_dng(&img, &color, Orientation::Normal, &Metadata::default(), 0.0, DngSamples::U16, &[]).unwrap();assert!(lightcraft_raw::decode(&u16).is_ok());}}diff --git a/crates/merge/src/synth.rs b/crates/merge/src/synth.rsindex d15646ecb..223cb3021 100644--- a/crates/merge/src/synth.rs+++ b/crates/merge/src/synth.rs@@ -48,7 +48,7 @@ pub fn bracket_dngs(w: usize, h: usize, evs: &[f64]) -> Result<Vec<Vec<u8>>> {iso: Some(100),..Default::default()};- write_linear_dng(&img, &srgb_color(), Orientation::Normal, &meta, 0.0, DngSamples::U16)+ write_linear_dng(&img, &srgb_color(), Orientation::Normal, &meta, 0.0, DngSamples::U16, &[])}).collect()}diff --git a/crates/raw/src/opcodes.rs b/crates/raw/src/opcodes.rsindex 1d3a2c546..bcc59ab57 100644--- a/crates/raw/src/opcodes.rs+++ b/crates/raw/src/opcodes.rs@@ -129,6 +129,76 @@ impl Opcode {pub fn is_lens_correction(&self) -> bool {matches!(self, Opcode::WarpRectilinear { .. } | Opcode::WarpRectilinear2 { .. } | Opcode::FixVignetteRadial { .. })}++ /// This lens correction re-expressed for the part `crop` of the `width × height` image it was written for: applied+ /// to the cropped image it gives the crop of the corrected whole. The centre moves into the crop and the+ /// coefficients are rescaled for the crop's farthest corner, the radius every coordinate is normalised by. Centres+ /// use the warps' convention (0 and 1 at the first and last pixel), also for `FixVignetteRadial`, as the develop+ /// pipeline reads them. `None` for other opcodes, an image or crop under 2 × 2, or a crop outside the image.+ pub fn cropped(&self, width: usize, height: usize, crop: crate::Rect) -> Option<Opcode> {+ let fits = crop.x.checked_add(crop.width).is_some_and(|r| r <= width) && crop.y.checked_add(crop.height).is_some_and(|b| b <= height);+ if width < 2 || height < 2 || crop.width < 2 || crop.height < 2 || !fits {+ return None;+ }+ let (aw, ah) = (width as f64 - 1.0, height as f64 - 1.0);+ let (cw, ch) = (crop.width as f64 - 1.0, crop.height as f64 - 1.0);+ // the centre in the crop, and the ratio of the crop's normalising radius to the image's+ let reframe = |c: [f64; 2]| -> Option<([f64; 2], f64)> {+ let (px, py) = (c[0] * aw, c[1] * ah);+ let (qx, qy) = (px - crop.x as f64, py - crop.y as f64);+ let s = max_radius(qx, qy, cw, ch) / max_radius(px, py, aw, ah);+ (s.is_finite() && s > 0.0 && qx.is_finite() && qy.is_finite()).then_some(([qx / cw, qy / ch], s))+ };+ match self {+ // source radius r·(kr0 + kr1 r² + kr2 r⁴ + kr3 r⁶) and tangential terms quadratic in r: with r = r'·s,+ // kr_i scales by s^2i and kt by s+ Opcode::WarpRectilinear { planes, center } => {+ let (center, s) = reframe(*center)?;+ let planes = planes+ .iter()+ .map(|k| {+ let mut k = *k;+ for (i, v) in k[..4].iter_mut().enumerate() {+ *v *= s.powi(2 * i as i32);+ }+ k[4] *= s;+ k[5] *= s;+ k+ })+ .collect();+ Some(Opcode::WarpRectilinear { planes, center })+ }+ // radial factor Σ kr_i r^i between the valid radii: kr_i scales by s^i, the radii by 1/s+ Opcode::WarpRectilinear2 { planes, center, reciprocal, optional } => {+ let (center, s) = reframe(*center)?;+ let planes = planes+ .iter()+ .map(|k| {+ let mut k = *k;+ for (i, v) in k[..15].iter_mut().enumerate() {+ *v *= s.powi(i as i32);+ }+ k[15] *= s;+ k[16] *= s;+ k[17] /= s;+ k[18] /= s;+ k+ })+ .collect();+ Some(Opcode::WarpRectilinear2 { planes, center, reciprocal: *reciprocal, optional: *optional })+ }+ // gain 1 + Σ k_i r^(2i+2)+ Opcode::FixVignetteRadial { k, center } => {+ let (center, s) = reframe(*center)?;+ let mut k = *k;+ for (i, v) in k.iter_mut().enumerate() {+ *v *= s.powi(2 * i as i32 + 2);+ }+ Some(Opcode::FixVignetteRadial { k, center })+ }+ _ => None,+ }+ }}/// The opcodes of a list that a reader applies, in order: all of them, minus the DNG 1.6 skip rule (specification@@ -1032,4 +1102,60 @@ pub(crate) mod tests {let bad = Opcode::Unknown { id: 14, flags: 1, params: vec![] };assert!(applied_ops(&[bad, wr]).any(|o| matches!(o, Opcode::WarpRectilinear { .. })));}++ /// `cropped` re-expresses a lens correction for a crop: the corrected crop is the crop of the corrected whole. A+ /// linear ramp makes bilinear sampling exact, so only the borders (where the warp reaches past the crop) differ.+ #[test]+ fn cropped_lens_corrections_correct_the_crop_like_the_whole() {+ let (w, h) = (90usize, 64usize);+ let crop = crate::Rect::new(7, 5, 70, 50);+ let ramp = Rgb32f::from_fn(w, h, |x, y| [0.002 * x as f32 + 0.001 * y as f32 + 0.1, 0.3 + 0.0015 * y as f32, 0.2]);+ let mut wr2 = [0.0; WR2_LEN];+ wr2[..5].copy_from_slice(&[1.0, 0.01, -0.03, 0.0, 0.01]);+ wr2[15] = 0.002;+ wr2[16] = -0.001;+ wr2[17] = 0.05;+ wr2[18] = 0.9;+ let warps = [+ Opcode::WarpRectilinear { planes: vec![[0.97, 0.04, -0.01, 0.002, 0.003, -0.002]], center: [0.47, 0.53] },+ Opcode::WarpRectilinear2 { planes: vec![wr2], center: [0.52, 0.46], reciprocal: false, optional: true },+ Opcode::WarpRectilinear2 { planes: vec![wr2], center: [0.52, 0.46], reciprocal: true, optional: false },+ ];+ for op in &warps {+ let mut whole = ramp.clone();+ apply_list3(std::slice::from_ref(op), &mut whole);+ let re = op.cropped(w, h, crop).unwrap();+ let mut part = ramp.clone().into_crop(crop.x, crop.y, crop.width, crop.height);+ apply_list3(std::slice::from_ref(&re), &mut part);+ let mut worst = 0f32;+ for y in 6..crop.height - 6 {+ for x in 6..crop.width - 6 {+ let (a, b) = (whole.data[(y + crop.y) * w + x + crop.x], part.data[y * crop.width + x]);+ worst = (0..3).map(|c| (a[c] - b[c]).abs()).fold(worst, f32::max);+ }+ }+ assert!(worst < 1e-4, "{op:?} → {re:?}: {worst}");+ }+ // the vignette, in the warps' centre convention the develop pipeline reads it with+ let gain = |k: &[f64; 5], c: [f64; 2], w: usize, h: usize, x: f64, y: f64| {+ let (aw, ah) = (w as f64 - 1.0, h as f64 - 1.0);+ let (px, py) = (c[0] * aw, c[1] * ah);+ let r2 = ((x - px).powi(2) + (y - py).powi(2)) / max_radius(px, py, aw, ah).powi(2);+ 1.0 + (0..5).map(|i| k[i] * r2.powi(i as i32 + 1)).sum::<f64>()+ };+ let (k, center) = ([-0.3, 0.1, -0.05, 0.02, -0.01], [0.45, 0.55]);+ let Some(Opcode::FixVignetteRadial { k: k2, center: c2 }) = (Opcode::FixVignetteRadial { k, center }).cropped(w, h, crop) else {+ panic!("vignette")+ };+ for (x, y) in [(0.0, 0.0), (69.0, 49.0), (33.5, 20.0), (69.0, 0.0), (12.0, 40.0)] {+ let (a, b) = (gain(&k, center, w, h, x + crop.x as f64, y + crop.y as f64), gain(&k2, c2, crop.width, crop.height, x, y));+ assert!((a - b).abs() < 1e-12, "({x}, {y}): {a} vs {b}");+ }+ // no change for a full-frame "crop"; nothing for other opcodes, tiny images or a crop past the edge+ assert_eq!(warps[0].cropped(w, h, crate::Rect::new(0, 0, w, h)).unwrap(), warps[0]);+ assert!(Opcode::TrimBounds { top: 0, left: 0, bottom: 2, right: 2 }.cropped(w, h, crop).is_none());+ assert!(warps[0].cropped(1, h, crate::Rect::new(0, 0, 1, h)).is_none());+ assert!(warps[0].cropped(w, h, crate::Rect::new(30, 0, 70, 50)).is_none());+ assert!(warps[0].cropped(w, h, crate::Rect::new(usize::MAX, 0, 70, 50)).is_none());+ }}diff --git a/docs/merge.md b/docs/merge.mdindex e78c356fb..7c298cb10 100644--- a/docs/merge.md+++ b/docs/merge.md@@ -27,6 +27,11 @@ homography (the simplest model that explains ≥ 97 % of the matches). ExposureRadiance is a weighted mean in linear light, weight `k · (1 − smoothstep(0.8·clip, 0.96·clip, maxchannel))`. Deghost: a per-pixel consistency test against the reference radiance (with a noisefloor), dilated and feathered masks; the union is the deghost overlay. Output: 16-bit float DNG.+Lens corrections: frames are merged uncorrected, and the DNG's `OpcodeList3` carries the reference frame's+(`WarpRectilinear`, `WarpRectilinear2`, `FixVignetteRadial`: a DNG's own, or a camera's correction a raw reader+converts, e.g. Sony, Panasonic), re-expressed for its default crop (`Opcode::cropped`). So Optics ▸ Enable Lens+Corrections works on the result as on the sources; a vertical bracket keeps its pixels unturned and its+corrections.**Panorama** (`pano/`): MOPS-style features, pairwise RANSAC homographies with Brown & Lowe'sverification, focal from homographies (or EXIF 35 mm), rotations chained along a maximum spanning@@ -54,7 +59,9 @@ scale in `BaselineExposure`; raw sources keep their DNG colour tags (camera RGB)## Limits (known gaps)- No lens-distortion model in the panorama bundle adjustment (rectilinear lenses assumed); no- 360° wrap-around; flat (translating-camera) scans are fitted with the rotation model.+ 360° wrap-around; flat (translating-camera) scans are fitted with the rotation model. Panoramas and HDR+ panoramas carry no lens corrections, nor does an HDR whose frames don't share an orientation (they are turned+ before merging).- No camera response calibration for JPEG brackets (sRGB decoding is taken as linear light).- Boundary Warp is a separable stretch, not a content-preserving mesh warp; Fill Edges is diffusion,not patch synthesis.diff --git a/docs/parity-checklist.md b/docs/parity-checklist.mdindex 77ae26e4c..ca4b71d5a 100644--- a/docs/parity-checklist.md+++ b/docs/parity-checklist.md@@ -346,7 +346,7 @@ differences and missing bindings are in [ui-parity.md](ui-parity.md#shortcuts).| Id | Feature | Tier | Status | Evidence | Missing / notes ||---|---|---|---|---|---|-| LR-MERGE-HDR | HDR merge | P2 | ✅ | `cmd:merge.hdr`, `cmd:dialog.mergeHdr` | auto align, deghost None–High + overlay, auto settings, float DNG, Create Stack; JPEG brackets treated as linear |+| LR-MERGE-HDR | HDR merge | P2 | ✅ | `cmd:merge.hdr`, `cmd:dialog.mergeHdr`, `crates/merge/src/frame.rs` (`Frame::lens`) | auto align, deghost None–High + overlay, auto settings, float DNG, Create Stack; the DNG keeps the reference frame's embedded lens corrections (tested by `hdr_merge_keeps_the_reference_frames_lens_corrections`); JPEG brackets treated as linear; measured on synthetic brackets only (docs/merge.md) || LR-MERGE-PANO | Panorama | P2 | ✅ | `cmd:merge.panorama`, `cmd:dialog.mergePanorama` | spherical/cylindrical/perspective + auto, boundary warp, auto crop, fill edges (diffusion), DNG; no lens model / 360° wrap || LR-MERGE-HDRPANO | HDR panorama | P2 | ✅ | `cmd:merge.hdrPanorama`, `cmd:dialog.mergeHdrPanorama` | brackets grouped by EXIF || LR-MERGE-HEADLESS | Merge with last settings | P2 | ✅ | `cmd:merge.hdrLast`, `cmd:merge.panoramaLast`, `cmd:merge.hdrPanoramaLast` | no dialog; the options of the last merge of that kind (defaults the first time) |diff --git a/docs/whats-new.md b/docs/whats-new.mdindex fb8b285a3..fa14499a7 100644--- a/docs/whats-new.md+++ b/docs/whats-new.md@@ -1,5 +1,12 @@# What's new in LightCraft+## 2026-10-13++### HDR merges keep the lens correction+- An HDR made with Photo ▸ Photo Merge ▸ HDR now keeps the lens correction the photos carry (Sony's, Panasonic's+ and Leica's, and the one some DNGs carry, e.g. from drones): Optics ▸ Enable Lens Corrections straightens it as it+ does the photos it was made from. HDRs merged before this don't have it; merge them again.+## 2026-10-11### JPEG XL export