From 8bd9db8771177b0c45ec3da99404d0508608172e Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 05:40:01 +0000 Subject: [PATCH 1/4] LR-EDIT-OPTICS-PROFILE: script to measure Sony distortion against camera JPEGs Renders each ARW with the embedded correction on and off and compares it with the camera's own JPEG: residual offsets by radius after a similarity fit, checkerboard line straightness, and the ratio of the camera's correction to LightCraft's. Checked on synthetic boards with known radial distortion (corrected: 0.04 px median, ratio 1.000; 80 % corrected: ratio 1.26, expected about 1.25-1.28). Needs numpy, scipy and opencv-python-headless. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015gRtdWF1E9358FfzhzYqCS --- scripts/sony_distortion_check.py | 361 +++++++++++++++++++++++++++++++ 1 file changed, 361 insertions(+) create mode 100755 scripts/sony_distortion_check.py diff --git a/scripts/sony_distortion_check.py b/scripts/sony_distortion_check.py new file mode 100755 index 0000000000..ee81a118cd --- /dev/null +++ b/scripts/sony_distortion_check.py @@ -0,0 +1,361 @@ +#!/usr/bin/env python3 +"""Compare LightCraft's Sony embedded distortion correction with the camera's own JPEG. + + sony_distortion_check.py --cli target/release/lightcraft-cli --work WORKDIR PHOTO_DIR [PHOTO_DIR…] + +Every ARW with a JPG of the same name is rendered by LightCraft twice, embedded correction on +and off, and measured against the camera JPEG (shot with Lens Comp. Distortion on Auto): + +* agreement: offsets of matching features after the best similarity (scale, rotation, shift) + between the render and the JPEG, by distance from the centre (0 = centre, 1 = corner); +* straightness: how far each checkerboard row and column bows away from a straight line. + +Checkerboard shots use the board's corners (sub-pixel), other shots SIFT features (agreement +only). Offsets are in pixels of the camera JPEG (6000 px wide on the A7 III); the "@2376" +columns rescale them to the 2376 px exports docs/sony-lens-corrections.md reports. +Needs numpy, scipy and opencv-python-headless. +""" + +import argparse +import json +import os +import subprocess +import sys + +import cv2 +import numpy as np +from scipy.spatial import cKDTree + +WORK_LONG_EDGE = 3000 # detection resolution; coordinates are rescaled to the JPEG's pixels +BINS = [0.0, 0.25, 0.5, 0.75, 0.9, 1.01] +REPORT_WIDTH = 2376 + + +def render(cli, arw, out, on): + settings = out + ".settings.json" + with open(settings, "w") as f: + json.dump({"optics": {"lens_profile": on, "profile_distortion": 100}}, f) + if not os.path.exists(out): + subprocess.run([cli, "render", arw, "-o", out, "--settings", settings], check=True, capture_output=True) + return out + + +def load_gray(path): + """Grey image at the working resolution and the factor back to its own full-size pixels.""" + img = cv2.imread(path, cv2.IMREAD_GRAYSCALE) + if img is None: + raise RuntimeError(f"cannot read {path}") + h, w = img.shape + k = WORK_LONG_EDGE / max(w, h) + small = cv2.resize(img, (round(w * k), round(h * k)), interpolation=cv2.INTER_AREA) + return small, 1.0 / k, (w, h) + + +# ---------------------------------------------------------------- checkerboard corners + +def detect_corners(gray): + """X-corners of a checkerboard: Hessian saddle points, refined with cornerSubPix.""" + g = cv2.GaussianBlur(gray.astype(np.float32), (0, 0), 3.0) + gxx = cv2.Sobel(g, cv2.CV_32F, 2, 0, ksize=5) + gyy = cv2.Sobel(g, cv2.CV_32F, 0, 2, ksize=5) + gxy = cv2.Sobel(g, cv2.CV_32F, 1, 1, ksize=5) + saddle = gxy * gxy - gxx * gyy + top = np.percentile(saddle, 99.95) + if top <= 0: + return np.zeros((0, 2), np.float32) + peaks = (saddle == cv2.dilate(saddle, np.ones((15, 15), np.uint8))) & (saddle > 0.08 * top) + ys, xs = np.nonzero(peaks) + pts = np.stack([xs, ys], 1).astype(np.float32).reshape(-1, 1, 2) + if len(pts) == 0: + return pts.reshape(-1, 2) + crit = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 50, 0.005) + pts = cv2.cornerSubPix(gray, pts, (11, 11), (-1, -1), crit) + return pts.reshape(-1, 2).astype(np.float64) + + +def label_lattice(pts, centre): + """Integer (i, j) grid labels for corners connected to the one nearest the centre. + i grows along +x, j along +y; local lattice vectors follow the distortion gradually.""" + if len(pts) < 20: + return {} + tree = cKDTree(pts) + start = int(tree.query(centre)[1]) + d, idx = tree.query(pts[start], k=5) + offsets = pts[idx[1:]] - pts[start] + spacing = float(np.median(d[1:])) + a = offsets[np.argmax(offsets @ np.array([1.0, 0.0]))] + b = offsets[np.argmax(offsets @ np.array([0.0, 1.0]))] + if abs(np.dot(a, b)) > 0.5 * np.linalg.norm(a) * np.linalg.norm(b): + return {} + labels = {start: (0, 0)} + taken = {(0, 0): start} + vec = {start: (a, b)} + queue = [start] + while queue: + p = queue.pop() + i, j = labels[p] + va, vb = vec[p] + for di, dj, step in ((1, 0, va), (-1, 0, -va), (0, 1, vb), (0, -1, -vb)): + key = (i + di, j + dj) + if key in taken: + continue + dist, q = tree.query(pts[p] + step) + if dist > 0.3 * np.linalg.norm(step) or q in labels: + continue + found = pts[q] - pts[p] + na = found * di if di else va + nb = found * dj if dj else vb + labels[q] = key + taken[key] = q + vec[q] = (na, nb) + queue.append(q) + return labels if len(labels) > 50 else {} + + +def board(path): + gray, back, size = load_gray(path) + pts = detect_corners(gray) + labels = label_lattice(pts, np.array(gray.shape[::-1]) / 2.0) + full = {lab: pts[k] * back for k, lab in labels.items()} + return full, size + + +def straightness(grid): + """Largest deviation from a fitted straight line over every row/column with 8+ corners.""" + lines = {} + for (i, j), p in grid.items(): + lines.setdefault(("col", i), []).append(p) + lines.setdefault(("row", j), []).append(p) + worst = [] + for pts in lines.values(): + if len(pts) < 8: + continue + pts = np.array(pts) + keep = np.ones(len(pts), bool) + for _ in range(3): # drop stray corners, then refit + c = pts[keep].mean(0) + _, _, vt = np.linalg.svd(pts[keep] - c) + dev = (pts - c) @ vt[1] + keep = np.abs(dev) <= max(1.0, 4 * np.median(np.abs(dev[keep]))) + if keep.sum() < 8: + break + if keep.sum() >= 8: + worst.append(np.abs(dev[keep]).max()) + if not worst: + return None + worst = np.array(worst) + return {"lines": len(worst), "median": float(np.median(worst)), "max": float(worst.max())} + + +def match_boards(src, src_size, dst, dst_size): + """Corner pairs between two labellings of the same shot. A board is periodic, so a fit can't + tell a one-square shift from the right match; the corners near the centre can, unfitted: + the two framings differ by a few percent of zoom, far less than a square there.""" + sc, dc = np.array(src_size) / 2.0, np.array(dst_size) / 2.0 + half_diag = np.hypot(*dst_size) / 2.0 + best = None + for oi in range(-3, 4): + for oj in range(-3, 4): + pairs = [(p, dst[(i + oi, j + oj)]) for (i, j), p in src.items() if (i + oi, j + oj) in dst] + central = [np.linalg.norm((p - sc) - (q - dc)) for p, q in pairs if np.linalg.norm(q - dc) < 0.3 * half_diag] + if len(pairs) < 50 or len(central) < 10: + continue + err = float(np.median(central)) + if best is None or err < best[0]: + best = (err, pairs) + if best is None: + return None, None + s, d = map(np.array, zip(*best[1])) + return s, d + + +# ---------------------------------------------------------------- SIFT (other scenes) + +def sift_pairs(src_path, dst_path): + """SIFT matches; both point sets in the destination's full-size pixels.""" + a, ka, size_a = load_gray(src_path) + b, kb, size_b = load_gray(dst_path) + sift = cv2.SIFT_create(nfeatures=20000) + pa, da = sift.detectAndCompute(a, None) + pb, db = sift.detectAndCompute(b, None) + if da is None or db is None: + return None, None + good = [m for m, n in cv2.BFMatcher().knnMatch(da, db, k=2) if m.distance < 0.75 * n.distance] + if len(good) < 30: + return None, None + s = np.array([pa[m.queryIdx].pt for m in good]) * ka * (size_b[0] / size_a[0]) + d = np.array([pb[m.trainIdx].pt for m in good]) * kb + return s, d + + +# ---------------------------------------------------------------- geometry + +def fit_similarity(s, d): + zs = s[:, 0] + 1j * s[:, 1] + zd = d[:, 0] + 1j * d[:, 1] + ms, md = zs.mean(), zd.mean() + c = np.vdot(zs - ms, zd - md) / np.vdot(zs - ms, zs - ms) + return c, md - c * ms + + +def apply(model, p): + c, t = model + z = c * (p[:, 0] + 1j * p[:, 1]) + t + return np.stack([z.real, z.imag], 1) + + +def agreement(s, d, size): + """Similarity-fit render points s onto JPEG points d; residual statistics by radius.""" + pairs = {tuple(q): p for q, p in zip(d, s)} + keep = np.ones(len(s), bool) + # A loose first pass, then reject gross mismatches (SIFT outliers, mislabelled corners). + for limit in (0.02 * size[0], None, None): + model = fit_similarity(s[keep], d[keep]) + res = np.linalg.norm(apply(model, s) - d, axis=1) + cut = limit if limit else max(5 * np.median(res[keep]), 2.0) + keep = res < cut + if keep.sum() < 20: + return None + model = fit_similarity(s[keep], d[keep]) + s, d = s[keep], d[keep] + fitted = apply(model, s) + res = fitted - d + centre = np.array(size) / 2.0 + half_diag = np.hypot(*size) / 2.0 + rel = d - centre + r = np.linalg.norm(rel, axis=1) / half_diag + radial = np.sum(res * rel, axis=1) / np.maximum(np.linalg.norm(rel, axis=1), 1e-9) + mag = np.linalg.norm(res, axis=1) + bins = [] + for lo, hi in zip(BINS, BINS[1:]): + m = (r >= lo) & (r < hi) + bins.append({"r": f"{lo:.2f}-{min(hi, 1):.2f}", "n": int(m.sum()), + "median": float(np.median(mag[m])) if m.any() else None, + "radial": float(np.mean(radial[m])) if m.any() else None}) + return {"n": int(len(s)), "scale": float(abs(model[0])), "median": float(np.median(mag)), + "p95": float(np.percentile(mag, 95)), "max": float(mag.max()), "max_r": float(r.max()), + "bins": bins, "pairs": pairs} + + +def correction_fraction(on, off, size): + """How the camera's correction compares with LightCraft's: JPEG ≈ off + α·(on − off) radially, + both renders aligned to the JPEG on the same corners. 1 = the same amount as the camera; + above 1, the camera corrects more than LightCraft.""" + keys = [k for k in on["pairs"] if k in off["pairs"]] + if len(keys) < 50: + return None + d = np.array(keys) + raw_on = np.array([on["pairs"][k] for k in keys]) + raw_off = np.array([off["pairs"][k] for k in keys]) + keep = np.ones(len(d), bool) + for _ in range(4): + a = apply(fit_similarity(raw_on[keep], d[keep]), raw_on) + b = apply(fit_similarity(raw_off[keep], d[keep]), raw_off) + rel = d - np.array(size) / 2.0 + unit = rel / np.maximum(np.linalg.norm(rel, axis=1, keepdims=True), 1e-9) + u = np.sum((a - b) * unit, axis=1) + v = np.sum((d - b) * unit, axis=1) + if np.median(np.abs(u[keep])) < 1.0: # too little distortion at this focal length to tell + return None + alpha = float(u[keep] @ v[keep] / (u[keep] @ u[keep])) + e = np.abs(v - alpha * u) + keep = e <= max(0.5, 4 * np.median(e[keep])) # mismatched corners, not the lens + return alpha + + +# ---------------------------------------------------------------- driver + +def jpeg_for(arw): + stem = os.path.splitext(arw)[0] + for ext in (".JPG", ".jpg", ".JPEG", ".jpeg"): + if os.path.exists(stem + ext): + return stem + ext + return None + + +def exif_summary(jpg): + from PIL import Image + tags = Image.open(jpg).getexif().get_ifd(0x8769) + lens = tags.get(0xA434, "?") + focal = tags.get(0x920A) + fnum = tags.get(0x829D) + return f"{lens} {float(focal):.0f}mm f/{float(fnum):.1f}" if focal and fnum else str(lens) + + +def measure(cli, work, arw): + jpg = jpeg_for(arw) + if not jpg: + return None + name = os.path.splitext(os.path.basename(arw))[0] + on = render(cli, arw, os.path.join(work, name + ".on.png"), True) + off = render(cli, arw, os.path.join(work, name + ".off.png"), False) + out = {"file": name, "shot": exif_summary(jpg)} + jgrid, jsize = board(jpg) + out["kind"] = "board" if jgrid else "scene" + if jgrid: + out["straight_jpeg"] = straightness(jgrid) + for tag, path in (("on", on), ("off", off)): + if jgrid: + grid, size = board(path) + if not grid: + continue + k = jsize[0] / size[0] + grid = {key: p * k for key, p in grid.items()} + out["straight_" + tag] = straightness(grid) + s, d = match_boards(grid, (size[0] * k, size[1] * k), jgrid, jsize) + else: + s, d = sift_pairs(path, jpg) + if s is not None: + out["vs_jpeg_" + tag] = agreement(s, d, jsize) + if "vs_jpeg_on" in out and "vs_jpeg_off" in out and out["kind"] == "board": + out["fraction"] = correction_fraction(out["vs_jpeg_on"], out["vs_jpeg_off"], jsize) + for tag in ("on", "off"): + out.get("vs_jpeg_" + tag, {}).pop("pairs", None) + out["jpeg_width"] = jsize[0] + return out + + +def show(o): + k = REPORT_WIDTH / o["jpeg_width"] + print(f"\n{o['file']} {o['shot']} [{o['kind']}]") + for tag, label in (("on", "LightCraft corrected"), ("off", "LightCraft uncorrected")): + a = o.get("vs_jpeg_" + tag) + if a: + print(f" {label:24s} vs camera JPEG: median {a['median']:.2f} px, p95 {a['p95']:.2f}, max {a['max']:.2f}" + f" (@{REPORT_WIDTH}: {a['median'] * k:.2f} / {a['p95'] * k:.2f}) n={a['n']} reach r={a['max_r']:.2f}") + print(" by radius: " + " ".join( + f"{b['r']}: {b['median']:.2f} ({b['radial']:+.2f})" for b in a["bins"] if b["n"])) + for tag in ("jpeg", "on", "off"): + st = o.get("straight_" + tag) + if st: + print(f" straightness {tag:4s}: worst line {st['max']:.2f} px, median line {st['median']:.2f} px ({st['lines']} lines)") + if o.get("fraction") is not None: + print(f" camera correction / LightCraft correction: {o['fraction']:.3f} (1 = same amount)") + + +def main(): + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("--cli", required=True) + ap.add_argument("--work", required=True) + ap.add_argument("--json") + ap.add_argument("dirs", nargs="+") + args = ap.parse_args() + os.makedirs(args.work, exist_ok=True) + arws = sorted(os.path.join(d, f) for d in args.dirs for f in os.listdir(d) if f.lower().endswith(".arw")) + results = [] + for arw in arws: + try: + o = measure(args.cli, args.work, arw) + except Exception as e: # keep going: one bad file must not stop the batch + print(f"\n{arw}: {e}", file=sys.stderr) + continue + if o: + show(o) + results.append(o) + if args.json: + with open(args.json, "w") as f: + json.dump(results, f, indent=1) + + +if __name__ == "__main__": + main() From 4db57c976b0493ff1e2f6a01ae89a5996d1a1e91 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 23:53:59 +0000 Subject: [PATCH 2/4] LR-EDIT-OPTICS-PROFILE: enable Sony ILCE-7M3 embedded distortion correction MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The A7 III's raw-IFD 0x7037 tables were refused until their geometry was checked. Measured against the camera's own JPEG of the same exposure (Lens Comp. Distortion: Auto) on 27 RAW+JPEG pairs from one body with the FE 16-35 F4 ZA, FE 28-70 and FE 50 F1.8 (strong barrel to strong pincushion, compressed and uncompressed, TV and monitor checkerboards): corrected board corners sit 0.06-0.44 px (median, 6000 px frame) from the JPEG's, against 0.8-26 px uncorrected; LightCraft applies the camera's amount of correction within 2 %; corrected rows and columns are as straight as the JPEG's. Sony's crop and the default crop agree on this body, so the warp is centred on the image. A unit test pins the warp from three of these tables to the camera's fitted geometry; the model boundary tests now accept ILCE-7M3 and still refuse its neighbours. RENDER_CACHE_VERSION is bumped. The measurement script handles screen moiré (X-corner check, duplicate corners, consensus lattice vectors). The corpus test's two ILCE-7M3 samples now expect one warp; raw.pixls.us is not reachable from this environment, so that test was skipped here. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015gRtdWF1E9358FfzhzYqCS --- crates/engine/src/media/source.rs | 2 +- crates/raw/src/vendor/arw_lens.rs | 53 ++++++++++++++++++++--- crates/raw/tests/it/corpus.rs | 10 ++--- docs/gaps.md | 2 +- docs/parity-checklist.md | 2 +- docs/raw-parity.md | 2 +- docs/sony-lens-corrections.md | 56 +++++++++++++++++++++--- docs/whats-new.md | 10 +++++ scripts/sony_distortion_check.py | 72 +++++++++++++++++++++++++------ 9 files changed, 174 insertions(+), 35 deletions(-) diff --git a/crates/engine/src/media/source.rs b/crates/engine/src/media/source.rs index 51c54c60a9..b8c1ec1542 100644 --- a/crates/engine/src/media/source.rs +++ b/crates/engine/src/media/source.rs @@ -1,7 +1,7 @@ use super::*; /// Bump when the pipeline's output changes, to invalidate cached thumbnails. -pub const RENDER_CACHE_VERSION: u64 = 70; +pub const RENDER_CACHE_VERSION: u64 = 71; /// Thumbnails render at one of these long edges (so window/cell size changes reuse the cache). pub const THUMB_SIZES: [usize; 4] = [128, 256, 384, 512]; diff --git a/crates/raw/src/vendor/arw_lens.rs b/crates/raw/src/vendor/arw_lens.rs index 473f5d9ffd..4cebf221ec 100644 --- a/crates/raw/src/vendor/arw_lens.rs +++ b/crates/raw/src/vendor/arw_lens.rs @@ -1,6 +1,6 @@ //! Sony's in-file lens-correction records (shading, lateral chromatic aberration, distortion): bounded decoding of //! the raw image IFD's fields and their encrypted `SR2SubIFD` copies into [`SonyLensCorrections`], and validated -//! ILCE-7RM4A and ILCE-7CR distortion tables into DNG warps for the shared optics pipeline. +//! ILCE-7RM4A, ILCE-7M3 and ILCE-7CR distortion tables into DNG warps for the shared optics pipeline. //! //! Tag identity/layout: https://exiftool.org/TagNames/EXIF.html (`0x7031` to `0x7037`, signed shorts) and //! https://exiftool.org/TagNames/Sony.html#SR2SubIFD (`0x797d`, `0x7980`, `0x7982`). The `SR2SubIFD` setting tags @@ -34,9 +34,9 @@ const DISTORTION: Tags = Tags { setting: (0x7036, 0x7981), table: (0x7037, 0x798 /// TIFF field types. const SHORT: u16 = 3; const SSHORT: u16 = 8; -/// Models using the validated A7R IVA conversion. The A7CR uses a separate conversion. +/// Models using the validated A7R IVA conversion (ILCE-7RM4A, ILCE-7M3). The A7CR uses a separate conversion. /// ILCE-7RM4 and ILCE-7RM4A are distinct models, not interchangeable aliases. -const DISTORTION_MODELS: &[&str] = &["ILCE-7RM4A"]; +const DISTORTION_MODELS: &[&str] = &["ILCE-7RM4A", "ILCE-7M3"]; /// Most directory entries scanned: a classic TIFF directory's largest count, also bounding a BigTIFF one. const MAX_ENTRIES: usize = 1 << 16; const SAMPLES: usize = 1024; @@ -1397,6 +1397,47 @@ mod tests { } } + // ILCE-7M3 raw-IFD tables (FE 16-35mm F4 ZA OSS at 16 and 35 mm, FE 28-70mm F3.5-5.6 OSS at 70 mm) and the + // geometry of the camera's own JPEG of the same exposure (Lens Comp. Distortion: Auto): checkerboard corners of + // that JPEG matched with the uncorrected raw and fitted with the warp's polynomial over the 6000×4000 frame (rms + // 0.11–0.25 px). See docs/sony-lens-corrections.md. + const A7M3: [([i16; 16], [f64; 4]); 3] = [ + ( + [32, 2, -38, -83, -138, -199, -270, -336, -402, -462, -519, -568, -611, -643, -670, -690], + [1.0247000859, -0.1092847508, 0.1061422243, -0.0397989678], + ), + ([2, 2, 4, 9, 18, 29, 45, 65, 92, 124, 164, 210, 264, 329, 403, 489], [0.9708150714, 0.0157256288, 0.0175613359, -0.004107544]), + ([4, 7, 18, 40, 68, 108, 155, 212, 280, 359, 453, 557, 679, 819, 978, 1161], [0.9342002611, 0.0560486347, 0.0076184603, 0.0021497933]), + ]; + + #[test] + fn ilce_7m3_matches_the_cameras_own_jpeg_geometry() { + let frame = Rect::new(0, 0, 6000, 4000); + let evaluate = |k: &[f64], r: f64| r * (k[0] + r * r * (k[1] + r * r * (k[2] + r * r * k[3]))); + for (values, reference) in A7M3 { + let Opcode::WarpRectilinear { planes, center } = distortion("ILCE-7M3", &values, frame, frame).unwrap() else { panic!("warp") }; + assert_eq!(center, [0.5, 0.5]); + // The camera fills its frame with its own zoom; compare the shape over the measured radii (to 0.97). + let radii: Vec = (1..=97).map(|i| i as f64 / 100.0).collect(); + let (ours, camera): (Vec, Vec) = radii.iter().map(|&r| (evaluate(&planes[0], r), evaluate(&reference, r))).unzip(); + let worst = |ours: &[f64]| { + let zoom = ours.iter().zip(&camera).map(|(a, b)| a * b).sum::() / ours.iter().map(|a| a * a).sum::(); + ours.iter().zip(&camera).map(|(a, b)| (a * zoom - b).abs()).fold(0.0, f64::max) + }; + // 0.0008 of the half diagonal is 2.9 px on the 6000 px frame (measured: 0.4–2.4 px); uncorrected is 10×+ off. + let (corrected, uncorrected) = (worst(&ours), worst(&radii)); + assert!(corrected < 0.0008 && uncorrected > 10.0 * corrected, "{values:?}: {corrected} vs {uncorrected}"); + } + // Sony's crop and the default crop agree on this body (12, 12, 6000×4000 of 6048×4024), so the warp sits on + // the image centre. + let Opcode::WarpRectilinear { center, .. } = + distortion("ILCE-7M3", &A7M3[0].0, Rect::new(0, 0, 6048, 4024), Rect::new(12, 12, 6000, 4000)).unwrap() + else { + panic!("warp") + }; + assert!((center[0] * 6047.0 - 3011.5).abs() < 1e-9 && (center[1] * 4023.0 - 2011.5).abs() < 1e-9, "{center:?}"); + } + #[test] fn barrel_framing_and_offset_crop_keep_the_same_geometry() { let crop = Rect::new(32, 20, 9504, 6336); @@ -1427,14 +1468,16 @@ mod tests { #[test] fn refuses_unvalidated_models_even_with_a_valid_table() { assert!(distortion("ILCE-7RM4A", &TELE, AREA, AREA).is_some()); - for model in ["", "ILCE-7M3", "ILCE-7M4", "ILCE-7RM4", "ILCE-7RM5", "ILCE-9M2", "DSC-RX100M3", "ILCE-7RM4A unknown", "ILCE-7CR"] { + assert!(distortion("ILCE-7M3", &TELE, AREA, AREA).is_some()); + for model in ["", "ILCE-7M4", "ILCE-7RM4", "ILCE-7RM5", "ILCE-9M2", "DSC-RX100M3", "ILCE-7RM4A unknown", "ILCE-7CR", "ILCE-7M3 ", "ILCE-7SM3"] + { assert!(distortion(model, &TELE, AREA, AREA).is_none(), "{model}"); } } #[test] fn header_and_full_decode_preserve_correction_through_dng() { - for (model, expected) in [("ILCE-7RM4A", 1), ("ILCE-7RM4", 0), ("ILCE-7M3", 0), ("", 0)] { + for (model, expected) in [("ILCE-7RM4A", 1), ("ILCE-7RM4", 0), ("ILCE-7M3", 1), ("ILCE-7M4", 0), ("", 0)] { for (height, expected) in [(20, expected), (16, 0)] { for order in [ByteOrder::Little, ByteOrder::Big] { let mut raw = IfdBuilder::new(); diff --git a/crates/raw/tests/it/corpus.rs b/crates/raw/tests/it/corpus.rs index 7f7074f911..62a14faf9f 100644 --- a/crates/raw/tests/it/corpus.rs +++ b/crates/raw/tests/it/corpus.rs @@ -1069,8 +1069,8 @@ fn sony_embedded_distortion_is_limited_to_validated_models() { for (name, model, expected) in [ ("arw-sony-a7rm4a-compressed.arw", "ILCE-7RM4A", 1), ("arw-sony-a9m2-compressed.arw", "ILCE-9M2", 0), - ("arw-sony-a7m3-compressed.arw", "ILCE-7M3", 0), - ("arw-sony-a7m3-uncompressed.arw", "ILCE-7M3", 0), + ("arw-sony-a7m3-compressed.arw", "ILCE-7M3", 1), + ("arw-sony-a7m3-uncompressed.arw", "ILCE-7M3", 1), ("arw-sony-a7m4-14bit.arw", "ILCE-7M4", 0), ("arw-sony-a7m4-lossless-l.arw", "ILCE-7M4", 0), ("arw-sony-a7m4-lossless-m.arw", "ILCE-7M4", 0), @@ -1227,7 +1227,7 @@ fn a_sony_fixture_that_differs_from_its_pin_fails() { /// Sony's lens-correction records (`lightcraft_raw::lens_metadata`, `crates/raw/src/vendor/arw_lens.rs`) on the public /// samples: shading, CA and distortion decoded from the raw IFD with their settings, equal to their `SR2SubIFD` copies, -/// the same from header and full decode, and nothing applied beyond the validated ILCE-7RM4A distortion. Expected +/// the same from header and full decode, and nothing applied beyond the validated ILCE-7RM4A and ILCE-7M3 distortion. Expected /// tables and settings: what ExifTool, run as a black-box tool, prints for these files. Every file is checked against /// its pinned SHA-256 before it is decoded; absent files are skipped. #[test] @@ -1351,13 +1351,13 @@ fn sony_lens_records_of_the_public_samples() { eprintln!("{name}: shading, CA and distortion decoded; distortion {status:?}"); checked += 1; } - // every Sony corpus file: only the ILCE-7RM4A's distortion is ever applied, and an applied status is an opcode + // every Sony corpus file: only the ILCE-7RM4A's and ILCE-7M3's distortion is ever applied, and an applied status is an opcode for (name, _) in SONY_SAMPLES { let Some(bytes) = pinned_sony(&root, name) else { continue }; let info = probe_info(&bytes).unwrap_or_else(|e| panic!("{name}: {e}")); let Some(s) = &info.lens_metadata.sony else { continue }; let applied = s.distortion.status == SonyLensStatus::Applied; - assert_eq!(applied, info.metadata.model.as_deref() == Some("ILCE-7RM4A"), "{name}"); + assert_eq!(applied, matches!(info.metadata.model.as_deref(), Some("ILCE-7RM4A" | "ILCE-7M3")), "{name}"); assert_eq!(info.opcodes.list3.len(), usize::from(applied), "{name}"); assert!(![s.shading.status, s.chromatic_aberration.status].contains(&SonyLensStatus::Applied), "{name}"); checked += 1; diff --git a/docs/gaps.md b/docs/gaps.md index 42d9d437b6..b1d4679f4f 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -22,7 +22,7 @@ Hours are Opus 5.5 agent wall-clock hours (see [target-app-parity.md](target-app | 5 B | **AI masks: Subject, Sky, People, Background, Landscape** are heuristics; Object / Describe run SAM 3 but its download has no mirror configured | `crates/segment`; ai-masks.md; MASK rows 67% | masking is how most Lightroom users edit today | 40–70 + model decision | [target-app-parity](target-app-parity.md#ai) | | 6 B | **Compressed ORF** (every Olympus / OM body since ~2008) | measured: 66 of 78 Olympus / OM models preview-only; `orf.rs` refuses; OM bucket 3% of photographers, 3% of them fully work | +2.6 points; best gain per hour of any raw gap (~0.2) | 8–15 | [raw-parity](raw-parity.md#compressed-orf-a-clean-room-starting-point) (the two Olympus patents that describe the method) | | 7 | **Nikon High Efficiency NEF** (HE / HE★ on Z 8, Z 9, Z 6III, Z f, Z50II, Z5II when set to HE) | named and preview only (#193); needs a pure-Rust JPEG XS decoder | +1.1 points (only shots taken in HE; lossless works on the same bodies); low gain per hour (~0.04), so not a beta blocker | 20–40 | [raw-parity](raw-parity.md) | -| 8 B | **No lens profile database** (LR-EDIT-OPTICS-PROFILE): only DNG opcodes, RW2 in-file distortion, Sony ILCE-7RM4A, full-frame ILCE-7CR distortion (Auto only) and ILCE-7RM6 distortion (`docs/sony-ilce7rm6-lens-corrections.md`) and Nikon Z 6II / Z 8 / Z f distortion (`docs/nikon-lens-corrections.md`) | Adobe ships 3,635 lens profiles; we never use them | distortion / vignetting correction is a default step for many | 40–80 + calibration shots | [raw-parity](raw-parity.md#lens-profiles) | +| 8 B | **No lens profile database** (LR-EDIT-OPTICS-PROFILE): only DNG opcodes, RW2 in-file distortion, Sony ILCE-7RM4A, ILCE-7M3, full-frame ILCE-7CR distortion (Auto only) and ILCE-7RM6 distortion (`docs/sony-ilce7rm6-lens-corrections.md`) and Nikon Z 6II / Z 8 / Z f distortion (`docs/nikon-lens-corrections.md`) | Adobe ships 3,635 lens profiles; we never use them | distortion / vignetting correction is a default step for many | 40–80 + calibration shots | [raw-parity](raw-parity.md#lens-profiles) | | 9 B | **Tests don't run in CI on macOS or Windows**: Linux x64 runs `cargo xtask ci` on every PR and push to main (`.github/workflows/ci.yml`) and FreeBSD runs `cargo test`; the others build packages | `.github/workflows/` (ci, freebsd, packaging-lint, release, windows-arm64); the linux-riscv64 release job added in 0.6.0 (#844) runs only `lightcraft-cli --version` under QEMU; macOS / Windows jobs: #1148 | regressions in `cfg(target_os)` code reach macOS and Windows users | 6–12 | [target-app-parity](target-app-parity.md#by-dimension) | | 10 B | **Per-model verification thin, plus cheap per-body decode fixes**: 551 of 1,446 Adobe models verified (38%), ~85% of photographers on a verified body; Nikon 5 bodies verified, Canon 34, Leica 14 (the Q3 by a recorded check of 38 private DNGs). Cheap fixes: Z 6II packed 14-bit NEF (#769, PR #671), Sony A100 regression (#702); F828 SRF now discovered and imported as preview-only, sensor decoding still missing, DSLR-A200…A390 / A850 12-bit ARW (#535) | measured: [raw/coverage.tsv](raw/coverage.tsv) | per-body bugs (levels, crops, WB) surface only from users | 25–45 | [raw-parity](raw-parity.md#by-maker-measured) | | 11 | **Enhance: Raw Details, Super Resolution; AI denoise without shippable weights or X-Trans** | ENH rows 0%; denoise Bayer only, RawNIND weights GPL and opt-in | Fujifilm users get no AI denoise; nobody gets it out of the box | 30–60 + model decision | [raw-parity](raw-parity.md#demosaic-levels-crops-and-lens-metadata) | diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md index 90cfc248f6..b644760449 100644 --- a/docs/parity-checklist.md +++ b/docs/parity-checklist.md @@ -212,7 +212,7 @@ differences and missing bindings are in [ui-parity.md](ui-parity.md#shortcuts). | LR-EDIT-DETAIL-SUPERRES | Super resolution | P2 | ⬜ | | | | LR-EDIT-DETAIL-AISHARPEN | AI sharpen | OOS | 🚫 | | | | LR-EDIT-OPTICS-CA | Remove chromatic aberration | P1 | ✅ | `crates/ui-egui/src/panels/edit.rs` (checkbox), `ctl:optics.caRed`, `ctl:optics.caBlue` | | -| LR-EDIT-OPTICS-PROFILE | Lens profile corrections | P1 | 🟡 | `ctl:optics.profileDistortion`, `ctl:optics.profileVignetting`, `crates/pipeline/src/optics.rs`, `crates/raw/src/vendor/rw2.rs`, `crates/raw/src/vendor/raf_lens.rs`, `crates/engine/src/crs.rs` | uses corrections embedded in the file: DNG `WarpRectilinear` / `WarpRectilinear2` (opcode 14, DNG 1.6: degree-14 radial polynomial, valid-radius clamp, reciprocal option, applied in list order with the spec's skip rule for a `WarpRectilinear` after an optional one, so Pixel DNGs' two-stage warp is corrected; up to 3 chained stages, sampled on the CPU because the polynomials need `f64`; issue #635) / `FixVignetteRadial`, and the camera's own distortion correction in Panasonic / Leica RW2 / RWL files (tag `0x0119`, read as the equivalent `WarpRectilinear`; on 79 photos from 13 bodies and 11 lenses the corrected render lines up with the camera JPEG within 0.75 px at 1440 px at the corners, from up to 13 % of the half diagonal uncorrected; issue #256); an imported preset's `LensProfileEnable=0` leaves them on, as Lightroom applies built-in corrections regardless (inferred); Sony ILCE-7RM4A Bayer ARW raw-IFD distortion tables (`0x7037`, 16-sample layout, native 3:2 framing) use the same warp path, enabled for the independently validated ILCE-7RM4A with FE 24–105 and FE 200–600 lenses, and ILCE-7CR full-frame Bayer 3:2 files with correction Auto or forced Auto (a separate corrected-radius conversion validated against camera JPEGs with FE 24-50mm, FE 16-25mm and FE 50mm lenses); A7CR Off, APS-C, aspect crops and lossless M/S remain uncorrected; ILCE-7RM6 verified against the camera JPEG on 54 photos with three lenses (`docs/sony-ilce7rm6-lens-corrections.md`); other Sony models remain uncorrected (see `docs/sony-lens-corrections.md`); Nikon NEF distortion from NikonNEFInfo (`0xc7d5`: polynomial, frame-filling zoom and the optical-centre offset left by in-body stabilisation; `crates/raw/src/vendor/nef_lens.rs`, `docs/nikon-lens-corrections.md`) for the Z 6II, Z 8 and Z f, full-frame image area only: F-mount lenses on the FTZ match the camera JPEG within 0.2 px median, Z lenses within 0.5–1.5 px except the 24-70 f/4's wide end, where the camera applies a further correction that is not in the readable data (7 px median at 24 mm, from 16 px / 106 px p95 uncorrected); Fujifilm RAF raw-IFD tables (`0xf00b` distortion, `0xf010` vignetting; `crates/raw/src/vendor/raf_lens.rs`, `docs/fuji-lens-corrections.md`) become a `WarpRectilinear` with the camera's frame-filling zoom and a `FixVignetteRadial` gain for 59 body models with sample files checked against the camera JPEG (the table indexed by the source radius with last knot at the corner; on 67 body/lens combinations the corrected render's radial shape error against the camera JPEG falls from a median of 0.72 % to 0.05 % of the half diagonal, largest 0.42 %, and the vignetting gain of the JPEG tracks the table at a median correlation of 0.987); files whose table scale is not the recorded image's half diagonal (X-S20, X-T30 III, X-M5, X-T5 crops) and six unmatched bodies stay uncorrected; Fujifilm's lateral CA table (`0xf00f`) is real but is not applied, because our demosaic already registers the planes and the stored shift over-corrects; vignetting and lateral CA data of Olympus raws not read yet; Sony ARW shading, lateral CA and distortion tables (raw IFD `0x7031`–`0x7037`, with the encrypted `SR2SubIFD` copies as a checked fallback) are decoded with their camera settings, provenance and framing evidence for every body that records them (`crates/raw/src/lens_metadata.rs`), but only the ILCE-7RM4A, ILCE-7RM6 and ILCE-7CR use the separate distortion conversions above; Sony shading and CA semantics are not validated beyond the ILCE-7RM6's (lateral CA off) (`docs/sony-lens-corrections.md`); Reload from Disk reads the file's lens data for photos catalogued without it and turns the correction on for those still at import settings (issue #314); lens-profile database: a lensfun-format XML database in `LIGHTCRAFT_LENSFUN_DIR` (none is bundled) supplies distortion (poly3 / poly5 / PTLens), TCA and vignetting for lenses it lists (`crates/lensdb`, `crates/engine/src/lens_profiles.rs`, `docs/lens-profiles.md`); raws that name no lens model (Nikon DSLRs: maker-note lens specification only) look it up by a name built from the specification (`24-70mm f/2.8`) and take only a profile named exactly that; no settings switch or bundled database yet | +| LR-EDIT-OPTICS-PROFILE | Lens profile corrections | P1 | 🟡 | `ctl:optics.profileDistortion`, `ctl:optics.profileVignetting`, `crates/pipeline/src/optics.rs`, `crates/raw/src/vendor/rw2.rs`, `crates/raw/src/vendor/raf_lens.rs`, `crates/engine/src/crs.rs` | uses corrections embedded in the file: DNG `WarpRectilinear` / `WarpRectilinear2` (opcode 14, DNG 1.6: degree-14 radial polynomial, valid-radius clamp, reciprocal option, applied in list order with the spec's skip rule for a `WarpRectilinear` after an optional one, so Pixel DNGs' two-stage warp is corrected; up to 3 chained stages, sampled on the CPU because the polynomials need `f64`; issue #635) / `FixVignetteRadial`, and the camera's own distortion correction in Panasonic / Leica RW2 / RWL files (tag `0x0119`, read as the equivalent `WarpRectilinear`; on 79 photos from 13 bodies and 11 lenses the corrected render lines up with the camera JPEG within 0.75 px at 1440 px at the corners, from up to 13 % of the half diagonal uncorrected; issue #256); an imported preset's `LensProfileEnable=0` leaves them on, as Lightroom applies built-in corrections regardless (inferred); Sony ILCE-7RM4A Bayer ARW raw-IFD distortion tables (`0x7037`, 16-sample layout, native 3:2 framing) use the same warp path, enabled for the independently validated ILCE-7RM4A with FE 24–105 and FE 200–600 lenses, ILCE-7M3 (FE 16–35 F4 ZA, FE 28–70, FE 50 F1.8; 27 shots within 0.06–0.44 px median of the camera JPEG at 6000 px, from up to 26 px uncorrected), and ILCE-7CR full-frame Bayer 3:2 files with correction Auto or forced Auto (a separate corrected-radius conversion validated against camera JPEGs with FE 24-50mm, FE 16-25mm and FE 50mm lenses); A7CR Off, APS-C, aspect crops and lossless M/S remain uncorrected; ILCE-7RM6 verified against the camera JPEG on 54 photos with three lenses (`docs/sony-ilce7rm6-lens-corrections.md`); other Sony models remain uncorrected (see `docs/sony-lens-corrections.md`); Nikon NEF distortion from NikonNEFInfo (`0xc7d5`: polynomial, frame-filling zoom and the optical-centre offset left by in-body stabilisation; `crates/raw/src/vendor/nef_lens.rs`, `docs/nikon-lens-corrections.md`) for the Z 6II, Z 8 and Z f, full-frame image area only: F-mount lenses on the FTZ match the camera JPEG within 0.2 px median, Z lenses within 0.5–1.5 px except the 24-70 f/4's wide end, where the camera applies a further correction that is not in the readable data (7 px median at 24 mm, from 16 px / 106 px p95 uncorrected); Fujifilm RAF raw-IFD tables (`0xf00b` distortion, `0xf010` vignetting; `crates/raw/src/vendor/raf_lens.rs`, `docs/fuji-lens-corrections.md`) become a `WarpRectilinear` with the camera's frame-filling zoom and a `FixVignetteRadial` gain for 59 body models with sample files checked against the camera JPEG (the table indexed by the source radius with last knot at the corner; on 67 body/lens combinations the corrected render's radial shape error against the camera JPEG falls from a median of 0.72 % to 0.05 % of the half diagonal, largest 0.42 %, and the vignetting gain of the JPEG tracks the table at a median correlation of 0.987); files whose table scale is not the recorded image's half diagonal (X-S20, X-T30 III, X-M5, X-T5 crops) and six unmatched bodies stay uncorrected; Fujifilm's lateral CA table (`0xf00f`) is real but is not applied, because our demosaic already registers the planes and the stored shift over-corrects; vignetting and lateral CA data of Olympus raws not read yet; Sony ARW shading, lateral CA and distortion tables (raw IFD `0x7031`–`0x7037`, with the encrypted `SR2SubIFD` copies as a checked fallback) are decoded with their camera settings, provenance and framing evidence for every body that records them (`crates/raw/src/lens_metadata.rs`), but only the ILCE-7RM4A, ILCE-7RM6 and ILCE-7CR use the separate distortion conversions above; Sony shading and CA semantics are not validated beyond the ILCE-7RM6's (lateral CA off) (`docs/sony-lens-corrections.md`); Reload from Disk reads the file's lens data for photos catalogued without it and turns the correction on for those still at import settings (issue #314); lens-profile database: a lensfun-format XML database in `LIGHTCRAFT_LENSFUN_DIR` (none is bundled) supplies distortion (poly3 / poly5 / PTLens), TCA and vignetting for lenses it lists (`crates/lensdb`, `crates/engine/src/lens_profiles.rs`, `docs/lens-profiles.md`); raws that name no lens model (Nikon DSLRs: maker-note lens specification only) look it up by a name built from the specification (`24-70mm f/2.8`) and take only a profile named exactly that; no settings switch or bundled database yet | ) | LR-EDIT-OPTICS-DEFRINGE | Defringe | P1 | ✅ | `ctl:optics.defringe*` | no fringe eyedropper | | LR-EDIT-OPTICS-MANUAL | Manual distortion / vignetting | P1 | ✅ | `ctl:optics.distortion`, `ctl:optics.vignetting`, `ctl:optics.vignettingMidpoint` | | diff --git a/docs/raw-parity.md b/docs/raw-parity.md index bd17a3d32b..2589a29176 100644 --- a/docs/raw-parity.md +++ b/docs/raw-parity.md @@ -243,7 +243,7 @@ essentials user (the default look is what they keep). | Item | Adobe | LightCraft | |---|---|---| | Profile database | 3,635 profile files, 56 makers, auto-selected | **0** (Adobe LCPs never used; no database of our own) | -| In-file corrections | ✅ | DNG opcodes (WarpRectilinear, FixVignetteRadial, GainMap…) applied; Panasonic / Leica RW2 distortion (79 photos, 13 bodies, 11 lenses); Sony tag 0x7037 distortion for the ILCE-7RM4A (2 lenses), full-frame Bayer 3:2 ILCE-7CR files with correction Auto or forced Auto (3 lenses; see sony-lens-corrections.md for residuals and limits) and the ILCE-7RM6 (3 lenses, 54 photos; `sony-ilce7rm6-lens-corrections.md`); Nikon NikonNEFInfo distortion (tag `0xc7d5`, about the sensor-shifted optical centre) for the Z 6II and Z f: F-mount lenses on the FTZ within 0.2 px of the camera JPEG, Z lenses within 0.5–1.5 px except the 24-70's wide end (7 px median; `docs/nikon-lens-corrections.md`) | +| In-file corrections | ✅ | DNG opcodes (WarpRectilinear, FixVignetteRadial, GainMap…) applied; Panasonic / Leica RW2 distortion (79 photos, 13 bodies, 11 lenses); Sony tag 0x7037 distortion for the ILCE-7RM4A (2 lenses) and ILCE-7M3 (3 lenses), full-frame Bayer 3:2 ILCE-7CR files with correction Auto or forced Auto (3 lenses; see sony-lens-corrections.md for residuals and limits) and the ILCE-7RM6 (3 lenses, 54 photos; `sony-ilce7rm6-lens-corrections.md`); Nikon NikonNEFInfo distortion (tag `0xc7d5`, about the sensor-shifted optical centre) for the Z 6II and Z f: F-mount lenses on the FTZ within 0.2 px of the camera JPEG, Z lenses within 0.5–1.5 px except the 24-70's wide end (7 px median; `docs/nikon-lens-corrections.md`) | | Vignetting / lateral CA from maker notes | ✅ | ⬜ | | Manual distortion, vignetting, CA, defringe | ✅ | ✅ | diff --git a/docs/sony-lens-corrections.md b/docs/sony-lens-corrections.md index 0252151cde..8b91d8395b 100644 --- a/docs/sony-lens-corrections.md +++ b/docs/sony-lens-corrections.md @@ -7,9 +7,10 @@ convention; that page's *Two conventions* section has the comparison and what wo Sony ARWs record three lens corrections per shot in the raw image IFD: shading (vignetting), lateral chromatic aberration (CA) and distortion, each as a camera setting and a radial table, with copies in the encrypted -`SR2SubIFD`. LightCraft **decodes all three** wherever a file carries them and applies distortion here on two validated -bodies: **ILCE-7RM4A (A7R IVA)** and **ILCE-7CR (A7CR)**. The A7R IVA keeps its existing Bayer 3:2 conversion, -validated with the FE 24-105mm F4 G OSS and FE 200-600mm F5.6-6.3 G OSS. The A7CR uses a separate conversion, +`SR2SubIFD`. LightCraft **decodes all three** wherever a file carries them and applies distortion here on three validated +bodies: **ILCE-7RM4A (A7R IVA)**, **ILCE-7M3 (A7 III)** and **ILCE-7CR (A7CR)**. The A7R IVA keeps its existing Bayer 3:2 conversion, +validated with the FE 24-105mm F4 G OSS and FE 200-600mm F5.6-6.3 G OSS; the A7 III uses the same conversion, validated +with the FE 16-35mm F4 ZA OSS, FE 28-70mm F3.5-5.6 OSS and FE 50mm F1.8 ([ILCE-7M3 validation](#ilce-7m3-validation)). The A7CR uses a separate conversion, limited to full-frame Bayer 3:2 files with distortion Auto or forced Auto. Apart from the separate ILCE-7RM6 converter, other models and shading and CA on every model are decoded only: no warp, vignetting or CA correction is added for them. The decoded record stays with the image (`RawInfo::lens_metadata` / `RawImage::lens_metadata`, types in `crates/raw/src/lens_metadata.rs`, decoder in @@ -289,9 +290,50 @@ decode or fail without a panic. `tests/sr2_heap.rs` measures the peak heap of de `SR2Private` directory holds eight fields aliasing the whole file: 37 kB, against 134 MB when those fields were decoded. No private photographs or reference TIFFs are committed. +## ILCE-7M3 validation + +Checked on 2026-10-12 against the camera's own JPEG of the same exposure, which is an independent renderer +that applied the correction (RAW+JPEG, Lens Comp. ▸ Distortion Comp.: Auto). 27 RAW+JPEG pairs from one +ILCE-7M3: a checkerboard filling the frame on a TV (handheld) and on a desktop monitor (tripod), compressed and +uncompressed raws, apertures from wide open to f/8, plus one textured wall. Tables covered strong barrel (16 mm, +−690 at the corner), strong pincushion (70 mm, +1161) and the sign change between them. + +Method (`tools/sony_distortion_check.py`): LightCraft renders each ARW at full size with the profile correction +on and off; sub-pixel board corners (Hessian saddle points refined with `cornerSubPix`, kept only where the four +quadrants alternate, labelled into rows and columns) are matched with the JPEG's by grid position, with the +match fixed by the central corners before any fit, because a board is periodic. A similarity (zoom, rotation, +shift) is fitted, as the camera fills its frame with its own zoom; no lens coefficient is fitted. The textured wall +uses SIFT matches instead. The script was checked on synthetic boards with a known radial distortion. + +| Lens / focal length | Shots | Corrected vs JPEG: median / p95 (px at 6000) | Uncorrected median | Corner (r > 0.9) | Camera / LightCraft correction | +|---|---:|---|---:|---:|---:| +| FE 16–35 F4 ZA / 16 mm | 10 | 0.33–0.38 / 1.01–1.15 | 16.7–17.0 | 1.40–1.56 px | 1.02 | +| FE 16–35 F4 ZA / 20 mm | 4 | 0.16–0.24 / 0.34–0.50 | 3.9–4.4 | 0.15–0.24 px | 0.98 | +| FE 16–35 F4 ZA / 35 mm | 2 | 0.18–0.21 / 0.39–0.44 | 11.0–11.1 | 0.18–0.26 px | 1.01–1.02 | +| FE 28–70 / 28 mm | 2 | 0.24–0.25 / 0.59–0.64 | 13.2–13.4 | 0.92 px | 1.02 | +| FE 28–70 / 33 mm | 1 | 0.07 / 0.16 | 0.8 | 0.07 px | 1.00 | +| FE 28–70 / 50 mm | 1 | 0.30 / 0.69 | 20.8 | 1.24 px | 1.01 | +| FE 28–70 / 70 mm | 1 | 0.44 / 0.93 | 26.4 | 1.49 px | 1.01 | +| FE 50 F1.8 / 50 mm | 4 | 0.06–0.12 / 0.15–0.31 | 2.8–3.0 | 0.08–0.14 px | 1.00–1.01 | +| Wall, 16 mm (SIFT) | 1 | 0.37 / 1.06 | 5.6 | 1.22 px | — | + +Residuals are in pixels of the 6000×4000 JPEG; at the 2376 px exports used above for the ILCE-7RM4A, the +board medians are 0.02–0.17 px and the p95 at most 0.46 px. The last column fits JPEG ≈ uncorrected + +α·(corrected − uncorrected) radially: LightCraft applies the camera's amount of correction within 2 %, slightly +less for strong barrel and slightly more at 20 mm, which is what remains at the 16 mm corners (about 1.5 px of a +35 px correction). Rows and columns of corrected boards are as straight as in the JPEG in every shot (largest +bow 0.8–7.8 px in both, from the screens), against 7–55 px uncorrected. Compressed and uncompressed raws, +the TV and the monitor, and wide open and f/8 agree. Two 16 mm board shots whose board stopped short of the +corners (reach 0.8 of the half diagonal) gave 0.85 px medians and are left out of the table. + +On this body Sony's crop tags and the default crop agree (origin 12, 12, 6000×4000 of 6048×4024), so the +warp sits on the image centre; fitted against the camera, the centre is within 0.3 px. Unit tests keep the warp from +three of these tables within 0.0008 of the half diagonal (2.9 px at 6000 px) of the camera's fitted geometry. +The photographs stay with their owner; none is committed. + ## Camera coverage and regression boundary -The model check is exact: `ILCE-7RM4` (A7R IV without the A suffix), `ILCE-7M3`, unknown/missing +The model check is exact: `ILCE-7RM4` (A7R IV without the A suffix), unknown/missing model names, and every other model remain unsupported by this distortion decoder. Matching tag numbers and table lengths do not establish the scale, interpolation or crop normalization on another body. Support can expand after independent geometry validation; do not add model-name prefix matching. @@ -309,7 +351,7 @@ fail on any absent pinned file instead. |---|---|---|---| | ILCE-7RM4A | Compressed (4822) | All three tables; 257 / 1 / 17 | One distortion warp | | ILCE-9M2 | Compressed (3989) | All three; 257 / 1 / 0 | None | -| ILCE-7M3 | Compressed, uncompressed | All three; 257 / 1 / 0 | None | +| ILCE-7M3 | Compressed, uncompressed | All three; 257 / 1 / 0 | One distortion warp | | ILCE-7M4 | 14-bit, lossless L/M/S | L/M/S: all three, 272 / 1 / 17; the 14-bit file (APS-C framing, 4608 × 3072): settings only, its 11-sample tables are not interpreted | None | | ILCE-7RM2 | 12-bit uncompressed | All three; 256 / 0 / 1 | None | | DSC-RX100 | One | Shading, from the `SR2SubIFD` (the raw IFD has no tables); CA and distortion in the 11-sample layout | None | @@ -324,8 +366,8 @@ fail on any absent pinned file instead. These are **model-boundary regression checks, not new geometric validation of those models**. `sony_lens_records_of_the_public_samples` also checks the exact tables, settings, provenance and framing evidence of the three A7CR codings and the A7R IVA sample, and that across the Sony corpus only the A7R IVA's distortion is ever -applied. In particular, -refusing the A7 III tables resolves the unverified corner warp identified in review. The lossless M/S +applied, besides the A7 III's. The A7 III tables were refused at first because their corner warp was unverified; +the [ILCE-7M3 validation](#ilce-7m3-validation) measured it against the camera's own JPEGs and enabled the body. The lossless M/S files are linear YCbCr and remain excluded independently of the model check. Header and full decode must agree for every sample. Synthetic tests also verify both TIFF byte orders, exact model matching, that the warp is centred on the standard default crop while the image keeps Sony's crop, and that DNG export preserves an accepted warp without adding one to rejected diff --git a/docs/whats-new.md b/docs/whats-new.md index c6c2592003..b794069769 100644 --- a/docs/whats-new.md +++ b/docs/whats-new.md @@ -1,5 +1,15 @@ # What's new in LightCraft +## 2026-10-26 + +### Lens distortion correction for the Sony A7 III +- Raws from the Sony A7 III (ILCE-7M3) now get the camera's own distortion correction, read from the file, like + the A7R IVA's: straight lines stay straight at wide angles (the FE 16–35 F4 ZA at 16 mm shifts detail near the + corners by up to about 40 px on a 24 MP photo) and at long ones (the FE 28–70 at 70 mm). It lines up with the + camera's JPEG to well under a pixel. Optics ▸ Enable Lens Corrections turns it off and Profile Distortion scales + it; photos imported before this pick it up with Photo ▸ Reload from Disk. Vignetting and chromatic aberration + from Sony files are not applied yet. + ## 2026-10-24 ### Relative-date filters and smart albums follow the clock diff --git a/scripts/sony_distortion_check.py b/scripts/sony_distortion_check.py index ee81a118cd..9b740b17d9 100755 --- a/scripts/sony_distortion_check.py +++ b/scripts/sony_distortion_check.py @@ -69,24 +69,67 @@ def detect_corners(gray): if len(pts) == 0: return pts.reshape(-1, 2) crit = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 50, 0.005) - pts = cv2.cornerSubPix(gray, pts, (11, 11), (-1, -1), crit) - return pts.reshape(-1, 2).astype(np.float64) + pts = cv2.cornerSubPix(gray, pts, (11, 11), (-1, -1), crit).reshape(-1, 2).astype(np.float64) + # Two peaks near one corner can refine to the same point; keep one of each such pair. + drop = {j for _, j in cKDTree(pts).query_pairs(3.0)} + pts = pts[[i for i in range(len(pts)) if i not in drop]] + return pts[[is_x_corner(g, p) for p in pts]] + + +def is_x_corner(g, p, r=12): + """A board corner has alternating quadrants: equal diagonals, contrasting neighbours. + A point on a straight edge (screen texture can make one look like a saddle) does not.""" + h, w = g.shape + x, y = int(round(p[0])), int(round(p[1])) + if not (r <= x < w - r and r <= y < h - r): + return False + a, c = g[y + r, x + r], g[y - r, x - r] + b, d = g[y - r, x + r], g[y + r, x - r] + contrast = abs((a + c) - (b + d)) / 2 + return contrast > 15 and contrast > 2 * max(abs(a - c), abs(b - d)) def label_lattice(pts, centre): - """Integer (i, j) grid labels for corners connected to the one nearest the centre. - i grows along +x, j along +y; local lattice vectors follow the distortion gradually.""" + """Integer (i, j) grid labels for corners connected to one near the centre. + i grows along +x, j along +y; local lattice vectors follow the distortion gradually. + The starting vectors are the consensus of many central corners, so a stray corner (screen + moiré) next to the start can't derail it; a few starts are tried, the largest result kept.""" if len(pts) < 20: return {} tree = cKDTree(pts) - start = int(tree.query(centre)[1]) - d, idx = tree.query(pts[start], k=5) - offsets = pts[idx[1:]] - pts[start] - spacing = float(np.median(d[1:])) - a = offsets[np.argmax(offsets @ np.array([1.0, 0.0]))] - b = offsets[np.argmax(offsets @ np.array([0.0, 1.0]))] - if abs(np.dot(a, b)) > 0.5 * np.linalg.norm(a) * np.linalg.norm(b): + vectors = lattice_vectors(pts, tree, centre) + if vectors is None: return {} + best = {} + for start in tree.query(centre, k=min(9, len(pts)))[1]: + labels = grow_lattice(pts, tree, int(start), *vectors) + if len(labels) > len(best): + best = labels + if len(best) > 0.8 * len(pts): + break + return best if len(best) > 50 else {} + + +def lattice_vectors(pts, tree, centre): + """Median neighbour offsets near +x and +y among the corners nearest the centre.""" + k = min(9, len(pts)) + offsets = [] + for i in tree.query(centre, k=min(60, len(pts)))[1]: + nn = tree.query(pts[i], k=k)[1] + offsets.extend(pts[nn[1:]] - pts[i]) + offsets = np.array(offsets) + length = np.linalg.norm(offsets, axis=1) + spacing = np.median(np.sort(length.reshape(-1, k - 1), axis=1)[:, :4]) + offsets = offsets[np.abs(length - spacing) < 0.25 * spacing] + angle = np.arctan2(offsets[:, 1], offsets[:, 0]) + near_x = np.abs(np.angle(np.exp(1j * angle))) < np.pi / 4 + near_y = np.abs(np.angle(np.exp(1j * (angle - np.pi / 2)))) < np.pi / 4 + if near_x.sum() < 10 or near_y.sum() < 10: + return None + return np.median(offsets[near_x], axis=0), np.median(offsets[near_y], axis=0) + + +def grow_lattice(pts, tree, start, a, b): labels = {start: (0, 0)} taken = {(0, 0): start} vec = {start: (a, b)} @@ -109,7 +152,7 @@ def label_lattice(pts, centre): taken[key] = q vec[q] = (na, nb) queue.append(q) - return labels if len(labels) > 50 else {} + return labels def board(path): @@ -305,8 +348,9 @@ def measure(cli, work, arw): s, d = match_boards(grid, (size[0] * k, size[1] * k), jgrid, jsize) else: s, d = sift_pairs(path, jpg) - if s is not None: - out["vs_jpeg_" + tag] = agreement(s, d, jsize) + a = agreement(s, d, jsize) if s is not None else None + if a: + out["vs_jpeg_" + tag] = a if "vs_jpeg_on" in out and "vs_jpeg_off" in out and out["kind"] == "board": out["fraction"] = correction_fraction(out["vs_jpeg_on"], out["vs_jpeg_off"], jsize) for tag in ("on", "off"): From 03eda4840218ee9f5a1d12e9077387c6ed1afa62 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 13 Oct 2026 00:01:10 +0000 Subject: [PATCH 3/4] LR-EDIT-OPTICS-PROFILE: keep the distortion check with the other Python tools Moves it to tools/ with a pinned requirements file, as tools/spectral_camera_table.py does. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015gRtdWF1E9358FfzhzYqCS --- tools/requirements-sony-distortion-check.txt | 6 ++++++ {scripts => tools}/sony_distortion_check.py | 8 +++++--- 2 files changed, 11 insertions(+), 3 deletions(-) create mode 100644 tools/requirements-sony-distortion-check.txt rename {scripts => tools}/sony_distortion_check.py (97%) diff --git a/tools/requirements-sony-distortion-check.txt b/tools/requirements-sony-distortion-check.txt new file mode 100644 index 0000000000..56ab4f9e23 --- /dev/null +++ b/tools/requirements-sony-distortion-check.txt @@ -0,0 +1,6 @@ +# Python packages for tools/sony_distortion_check.py (docs/sony-lens-corrections.md). +# python3 -m venv .venv-distortion && .venv-distortion/bin/pip install -r tools/requirements-sony-distortion-check.txt +numpy==2.5.3 +scipy==1.18.1 +opencv-python-headless==5.0.0.93 +Pillow==12.3.0 diff --git a/scripts/sony_distortion_check.py b/tools/sony_distortion_check.py similarity index 97% rename from scripts/sony_distortion_check.py rename to tools/sony_distortion_check.py index 9b740b17d9..0cdc6f003a 100755 --- a/scripts/sony_distortion_check.py +++ b/tools/sony_distortion_check.py @@ -1,7 +1,9 @@ #!/usr/bin/env python3 """Compare LightCraft's Sony embedded distortion correction with the camera's own JPEG. - sony_distortion_check.py --cli target/release/lightcraft-cli --work WORKDIR PHOTO_DIR [PHOTO_DIR…] + python3 -m venv .venv-distortion && .venv-distortion/bin/pip install -r tools/requirements-sony-distortion-check.txt + .venv-distortion/bin/python tools/sony_distortion_check.py --cli target/release/lightcraft-cli \ + --work WORKDIR [--json results.json] PHOTO_DIR [PHOTO_DIR…] Every ARW with a JPG of the same name is rendered by LightCraft twice, embedded correction on and off, and measured against the camera JPEG (shot with Lens Comp. Distortion on Auto): @@ -12,8 +14,8 @@ and off, and measured against the camera JPEG (shot with Lens Comp. Distortion o Checkerboard shots use the board's corners (sub-pixel), other shots SIFT features (agreement only). Offsets are in pixels of the camera JPEG (6000 px wide on the A7 III); the "@2376" -columns rescale them to the 2376 px exports docs/sony-lens-corrections.md reports. -Needs numpy, scipy and opencv-python-headless. +columns rescale them to the 2376 px exports docs/sony-lens-corrections.md reports (method and results +there, under "ILCE-7M3 validation"). """ import argparse From 453a0f2a3b37240c4304667ac25e7b11515eabc3 Mon Sep 17 00:00:00 2001 From: Janick Martinez Esturo Date: Tue, 27 Oct 2026 11:11:28 +0100 Subject: [PATCH 4/4] LR-EDIT-OPTICS-PROFILE: address review on the ILCE-7M3 distortion PR - docs/parity-checklist.md: the row's closing summary also lists the ILCE-7M3. - docs/sony-lens-corrections.md, parity-checklist.md: state the validation set as the 26 tabled shots plus the two left out, instead of a total that did not add up. - docs/whats-new.md: the sub-pixel claim is the median; corners reach about 1.5 px. - tools/sony_distortion_check.py: re-render when the CLI or ARW is newer than the output, report the CLI's stderr on failure, keep renders of same-named files from different folders apart, and docstrings for every function. --- docs/parity-checklist.md | 2 +- docs/sony-lens-corrections.md | 4 ++-- docs/whats-new.md | 4 ++-- tools/sony_distortion_check.py | 27 +++++++++++++++++++++++---- 4 files changed, 28 insertions(+), 9 deletions(-) diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md index b644760449..8438a9b346 100644 --- a/docs/parity-checklist.md +++ b/docs/parity-checklist.md @@ -212,7 +212,7 @@ differences and missing bindings are in [ui-parity.md](ui-parity.md#shortcuts). | LR-EDIT-DETAIL-SUPERRES | Super resolution | P2 | ⬜ | | | | LR-EDIT-DETAIL-AISHARPEN | AI sharpen | OOS | 🚫 | | | | LR-EDIT-OPTICS-CA | Remove chromatic aberration | P1 | ✅ | `crates/ui-egui/src/panels/edit.rs` (checkbox), `ctl:optics.caRed`, `ctl:optics.caBlue` | | -| LR-EDIT-OPTICS-PROFILE | Lens profile corrections | P1 | 🟡 | `ctl:optics.profileDistortion`, `ctl:optics.profileVignetting`, `crates/pipeline/src/optics.rs`, `crates/raw/src/vendor/rw2.rs`, `crates/raw/src/vendor/raf_lens.rs`, `crates/engine/src/crs.rs` | uses corrections embedded in the file: DNG `WarpRectilinear` / `WarpRectilinear2` (opcode 14, DNG 1.6: degree-14 radial polynomial, valid-radius clamp, reciprocal option, applied in list order with the spec's skip rule for a `WarpRectilinear` after an optional one, so Pixel DNGs' two-stage warp is corrected; up to 3 chained stages, sampled on the CPU because the polynomials need `f64`; issue #635) / `FixVignetteRadial`, and the camera's own distortion correction in Panasonic / Leica RW2 / RWL files (tag `0x0119`, read as the equivalent `WarpRectilinear`; on 79 photos from 13 bodies and 11 lenses the corrected render lines up with the camera JPEG within 0.75 px at 1440 px at the corners, from up to 13 % of the half diagonal uncorrected; issue #256); an imported preset's `LensProfileEnable=0` leaves them on, as Lightroom applies built-in corrections regardless (inferred); Sony ILCE-7RM4A Bayer ARW raw-IFD distortion tables (`0x7037`, 16-sample layout, native 3:2 framing) use the same warp path, enabled for the independently validated ILCE-7RM4A with FE 24–105 and FE 200–600 lenses, ILCE-7M3 (FE 16–35 F4 ZA, FE 28–70, FE 50 F1.8; 27 shots within 0.06–0.44 px median of the camera JPEG at 6000 px, from up to 26 px uncorrected), and ILCE-7CR full-frame Bayer 3:2 files with correction Auto or forced Auto (a separate corrected-radius conversion validated against camera JPEGs with FE 24-50mm, FE 16-25mm and FE 50mm lenses); A7CR Off, APS-C, aspect crops and lossless M/S remain uncorrected; ILCE-7RM6 verified against the camera JPEG on 54 photos with three lenses (`docs/sony-ilce7rm6-lens-corrections.md`); other Sony models remain uncorrected (see `docs/sony-lens-corrections.md`); Nikon NEF distortion from NikonNEFInfo (`0xc7d5`: polynomial, frame-filling zoom and the optical-centre offset left by in-body stabilisation; `crates/raw/src/vendor/nef_lens.rs`, `docs/nikon-lens-corrections.md`) for the Z 6II, Z 8 and Z f, full-frame image area only: F-mount lenses on the FTZ match the camera JPEG within 0.2 px median, Z lenses within 0.5–1.5 px except the 24-70 f/4's wide end, where the camera applies a further correction that is not in the readable data (7 px median at 24 mm, from 16 px / 106 px p95 uncorrected); Fujifilm RAF raw-IFD tables (`0xf00b` distortion, `0xf010` vignetting; `crates/raw/src/vendor/raf_lens.rs`, `docs/fuji-lens-corrections.md`) become a `WarpRectilinear` with the camera's frame-filling zoom and a `FixVignetteRadial` gain for 59 body models with sample files checked against the camera JPEG (the table indexed by the source radius with last knot at the corner; on 67 body/lens combinations the corrected render's radial shape error against the camera JPEG falls from a median of 0.72 % to 0.05 % of the half diagonal, largest 0.42 %, and the vignetting gain of the JPEG tracks the table at a median correlation of 0.987); files whose table scale is not the recorded image's half diagonal (X-S20, X-T30 III, X-M5, X-T5 crops) and six unmatched bodies stay uncorrected; Fujifilm's lateral CA table (`0xf00f`) is real but is not applied, because our demosaic already registers the planes and the stored shift over-corrects; vignetting and lateral CA data of Olympus raws not read yet; Sony ARW shading, lateral CA and distortion tables (raw IFD `0x7031`–`0x7037`, with the encrypted `SR2SubIFD` copies as a checked fallback) are decoded with their camera settings, provenance and framing evidence for every body that records them (`crates/raw/src/lens_metadata.rs`), but only the ILCE-7RM4A, ILCE-7RM6 and ILCE-7CR use the separate distortion conversions above; Sony shading and CA semantics are not validated beyond the ILCE-7RM6's (lateral CA off) (`docs/sony-lens-corrections.md`); Reload from Disk reads the file's lens data for photos catalogued without it and turns the correction on for those still at import settings (issue #314); lens-profile database: a lensfun-format XML database in `LIGHTCRAFT_LENSFUN_DIR` (none is bundled) supplies distortion (poly3 / poly5 / PTLens), TCA and vignetting for lenses it lists (`crates/lensdb`, `crates/engine/src/lens_profiles.rs`, `docs/lens-profiles.md`); raws that name no lens model (Nikon DSLRs: maker-note lens specification only) look it up by a name built from the specification (`24-70mm f/2.8`) and take only a profile named exactly that; no settings switch or bundled database yet | +| LR-EDIT-OPTICS-PROFILE | Lens profile corrections | P1 | 🟡 | `ctl:optics.profileDistortion`, `ctl:optics.profileVignetting`, `crates/pipeline/src/optics.rs`, `crates/raw/src/vendor/rw2.rs`, `crates/raw/src/vendor/raf_lens.rs`, `crates/engine/src/crs.rs` | uses corrections embedded in the file: DNG `WarpRectilinear` / `WarpRectilinear2` (opcode 14, DNG 1.6: degree-14 radial polynomial, valid-radius clamp, reciprocal option, applied in list order with the spec's skip rule for a `WarpRectilinear` after an optional one, so Pixel DNGs' two-stage warp is corrected; up to 3 chained stages, sampled on the CPU because the polynomials need `f64`; issue #635) / `FixVignetteRadial`, and the camera's own distortion correction in Panasonic / Leica RW2 / RWL files (tag `0x0119`, read as the equivalent `WarpRectilinear`; on 79 photos from 13 bodies and 11 lenses the corrected render lines up with the camera JPEG within 0.75 px at 1440 px at the corners, from up to 13 % of the half diagonal uncorrected; issue #256); an imported preset's `LensProfileEnable=0` leaves them on, as Lightroom applies built-in corrections regardless (inferred); Sony ILCE-7RM4A Bayer ARW raw-IFD distortion tables (`0x7037`, 16-sample layout, native 3:2 framing) use the same warp path, enabled for the independently validated ILCE-7RM4A with FE 24–105 and FE 200–600 lenses, ILCE-7M3 (FE 16–35 F4 ZA, FE 28–70, FE 50 F1.8; 26 shots within 0.06–0.44 px median of the camera JPEG at 6000 px, from up to 26 px uncorrected), and ILCE-7CR full-frame Bayer 3:2 files with correction Auto or forced Auto (a separate corrected-radius conversion validated against camera JPEGs with FE 24-50mm, FE 16-25mm and FE 50mm lenses); A7CR Off, APS-C, aspect crops and lossless M/S remain uncorrected; ILCE-7RM6 verified against the camera JPEG on 54 photos with three lenses (`docs/sony-ilce7rm6-lens-corrections.md`); other Sony models remain uncorrected (see `docs/sony-lens-corrections.md`); Nikon NEF distortion from NikonNEFInfo (`0xc7d5`: polynomial, frame-filling zoom and the optical-centre offset left by in-body stabilisation; `crates/raw/src/vendor/nef_lens.rs`, `docs/nikon-lens-corrections.md`) for the Z 6II, Z 8 and Z f, full-frame image area only: F-mount lenses on the FTZ match the camera JPEG within 0.2 px median, Z lenses within 0.5–1.5 px except the 24-70 f/4's wide end, where the camera applies a further correction that is not in the readable data (7 px median at 24 mm, from 16 px / 106 px p95 uncorrected); Fujifilm RAF raw-IFD tables (`0xf00b` distortion, `0xf010` vignetting; `crates/raw/src/vendor/raf_lens.rs`, `docs/fuji-lens-corrections.md`) become a `WarpRectilinear` with the camera's frame-filling zoom and a `FixVignetteRadial` gain for 59 body models with sample files checked against the camera JPEG (the table indexed by the source radius with last knot at the corner; on 67 body/lens combinations the corrected render's radial shape error against the camera JPEG falls from a median of 0.72 % to 0.05 % of the half diagonal, largest 0.42 %, and the vignetting gain of the JPEG tracks the table at a median correlation of 0.987); files whose table scale is not the recorded image's half diagonal (X-S20, X-T30 III, X-M5, X-T5 crops) and six unmatched bodies stay uncorrected; Fujifilm's lateral CA table (`0xf00f`) is real but is not applied, because our demosaic already registers the planes and the stored shift over-corrects; vignetting and lateral CA data of Olympus raws not read yet; Sony ARW shading, lateral CA and distortion tables (raw IFD `0x7031`–`0x7037`, with the encrypted `SR2SubIFD` copies as a checked fallback) are decoded with their camera settings, provenance and framing evidence for every body that records them (`crates/raw/src/lens_metadata.rs`), but only the ILCE-7RM4A, ILCE-7M3, ILCE-7RM6 and ILCE-7CR use the separate distortion conversions above; Sony shading and CA semantics are not validated beyond the ILCE-7RM6's (lateral CA off) (`docs/sony-lens-corrections.md`); Reload from Disk reads the file's lens data for photos catalogued without it and turns the correction on for those still at import settings (issue #314); lens-profile database: a lensfun-format XML database in `LIGHTCRAFT_LENSFUN_DIR` (none is bundled) supplies distortion (poly3 / poly5 / PTLens), TCA and vignetting for lenses it lists (`crates/lensdb`, `crates/engine/src/lens_profiles.rs`, `docs/lens-profiles.md`); raws that name no lens model (Nikon DSLRs: maker-note lens specification only) look it up by a name built from the specification (`24-70mm f/2.8`) and take only a profile named exactly that; no settings switch or bundled database yet | ) | LR-EDIT-OPTICS-DEFRINGE | Defringe | P1 | ✅ | `ctl:optics.defringe*` | no fringe eyedropper | | LR-EDIT-OPTICS-MANUAL | Manual distortion / vignetting | P1 | ✅ | `ctl:optics.distortion`, `ctl:optics.vignetting`, `ctl:optics.vignettingMidpoint` | | diff --git a/docs/sony-lens-corrections.md b/docs/sony-lens-corrections.md index 8b91d8395b..87f141a5d2 100644 --- a/docs/sony-lens-corrections.md +++ b/docs/sony-lens-corrections.md @@ -293,8 +293,8 @@ decoded. No private photographs or reference TIFFs are committed. ## ILCE-7M3 validation Checked on 2026-10-12 against the camera's own JPEG of the same exposure, which is an independent renderer -that applied the correction (RAW+JPEG, Lens Comp. ▸ Distortion Comp.: Auto). 27 RAW+JPEG pairs from one -ILCE-7M3: a checkerboard filling the frame on a TV (handheld) and on a desktop monitor (tripod), compressed and +that applied the correction (RAW+JPEG, Lens Comp. ▸ Distortion Comp.: Auto). RAW+JPEG pairs from one +ILCE-7M3 (26 in the table below, plus two left out as explained under it): a checkerboard filling the frame on a TV (handheld) and on a desktop monitor (tripod), compressed and uncompressed raws, apertures from wide open to f/8, plus one textured wall. Tables covered strong barrel (16 mm, −690 at the corner), strong pincushion (70 mm, +1161) and the sign change between them. diff --git a/docs/whats-new.md b/docs/whats-new.md index b794069769..fb44b58441 100644 --- a/docs/whats-new.md +++ b/docs/whats-new.md @@ -5,8 +5,8 @@ ### Lens distortion correction for the Sony A7 III - Raws from the Sony A7 III (ILCE-7M3) now get the camera's own distortion correction, read from the file, like the A7R IVA's: straight lines stay straight at wide angles (the FE 16–35 F4 ZA at 16 mm shifts detail near the - corners by up to about 40 px on a 24 MP photo) and at long ones (the FE 28–70 at 70 mm). It lines up with the - camera's JPEG to well under a pixel. Optics ▸ Enable Lens Corrections turns it off and Profile Distortion scales + corners by up to about 40 px on a 24 MP photo) and at long ones (the FE 28–70 at 70 mm). Measured against the + camera's JPEG, the median error is well under a pixel (up to about 1.5 px in the 16 mm corners). Optics ▸ Enable Lens Corrections turns it off and Profile Distortion scales it; photos imported before this pick it up with Photo ▸ Reload from Disk. Vignetting and chromatic aberration from Sony files are not applied yet. diff --git a/tools/sony_distortion_check.py b/tools/sony_distortion_check.py index 0cdc6f003a..ad76c12676 100755 --- a/tools/sony_distortion_check.py +++ b/tools/sony_distortion_check.py @@ -19,8 +19,10 @@ there, under "ILCE-7M3 validation"). """ import argparse +import hashlib import json import os +import shutil import subprocess import sys @@ -34,11 +36,17 @@ REPORT_WIDTH = 2376 def render(cli, arw, out, on): + """Render `arw` with the profile correction `on` or off to `out`, reusing an output newer than the CLI and ARW.""" settings = out + ".settings.json" with open(settings, "w") as f: json.dump({"optics": {"lens_profile": on, "profile_distortion": 100}}, f) - if not os.path.exists(out): - subprocess.run([cli, "render", arw, "-o", out, "--settings", settings], check=True, capture_output=True) + exe = shutil.which(cli) or cli + current = os.path.exists(out) and os.path.getmtime(out) >= max(os.path.getmtime(exe), os.path.getmtime(arw)) + if not current: + r = subprocess.run([exe, "render", arw, "-o", out, "--settings", settings], capture_output=True) + if r.returncode != 0: + err = r.stderr.decode(errors="replace").strip() + raise RuntimeError(f"render failed ({r.returncode}) for {arw}: {err[-500:]}") return out @@ -132,6 +140,7 @@ def lattice_vectors(pts, tree, centre): def grow_lattice(pts, tree, start, a, b): + """Label corners (row, column) by stepping lattice vectors `a` and `b` out from corner `start`.""" labels = {start: (0, 0)} taken = {(0, 0): start} vec = {start: (a, b)} @@ -158,6 +167,7 @@ def grow_lattice(pts, tree, start, a, b): def board(path): + """Checkerboard corners of image `path`, keyed by (row, column), in its full-size pixels, and its size.""" gray, back, size = load_gray(path) pts = detect_corners(gray) labels = label_lattice(pts, np.array(gray.shape[::-1]) / 2.0) @@ -236,6 +246,7 @@ def sift_pairs(src_path, dst_path): # ---------------------------------------------------------------- geometry def fit_similarity(s, d): + """Least-squares similarity (zoom, rotation, shift) mapping points `s` onto `d`, as complex (scale, offset).""" zs = s[:, 0] + 1j * s[:, 1] zd = d[:, 0] + 1j * d[:, 1] ms, md = zs.mean(), zd.mean() @@ -244,6 +255,7 @@ def fit_similarity(s, d): def apply(model, p): + """Points `p` mapped by a `fit_similarity` model.""" c, t = model z = c * (p[:, 0] + 1j * p[:, 1]) + t return np.stack([z.real, z.imag], 1) @@ -311,6 +323,7 @@ def correction_fraction(on, off, size): # ---------------------------------------------------------------- driver def jpeg_for(arw): + """The camera JPEG next to `arw` (same stem), or None.""" stem = os.path.splitext(arw)[0] for ext in (".JPG", ".jpg", ".JPEG", ".jpeg"): if os.path.exists(stem + ext): @@ -319,6 +332,7 @@ def jpeg_for(arw): def exif_summary(jpg): + """Lens, focal length and aperture of `jpg` from its Exif, for the report.""" from PIL import Image tags = Image.open(jpg).getexif().get_ifd(0x8769) lens = tags.get(0xA434, "?") @@ -328,12 +342,15 @@ def exif_summary(jpg): def measure(cli, work, arw): + """Render `arw` corrected and uncorrected and measure both against its camera JPEG (None without one).""" jpg = jpeg_for(arw) if not jpg: return None name = os.path.splitext(os.path.basename(arw))[0] - on = render(cli, arw, os.path.join(work, name + ".on.png"), True) - off = render(cli, arw, os.path.join(work, name + ".off.png"), False) + # cards repeat names (DSC00001.ARW): the path's hash keeps renders of different folders apart + uid = hashlib.sha1(os.path.abspath(arw).encode()).hexdigest()[:8] + on = render(cli, arw, os.path.join(work, f"{name}.{uid}.on.png"), True) + off = render(cli, arw, os.path.join(work, f"{name}.{uid}.off.png"), False) out = {"file": name, "shot": exif_summary(jpg)} jgrid, jsize = board(jpg) out["kind"] = "board" if jgrid else "scene" @@ -362,6 +379,7 @@ def measure(cli, work, arw): def show(o): + """Print one file's measurements.""" k = REPORT_WIDTH / o["jpeg_width"] print(f"\n{o['file']} {o['shot']} [{o['kind']}]") for tag, label in (("on", "LightCraft corrected"), ("off", "LightCraft uncorrected")): @@ -380,6 +398,7 @@ def show(o): def main(): + """Measure every ARW with a camera JPEG in the given folders and print (and optionally save) the results.""" ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("--cli", required=True) ap.add_argument("--work", required=True)