LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LR-MASK-BRUSH + LR-MASK-SLIDERS: Auto Mask brush and local Noise / Moiré / Defringe on CPU and GPU
Brandon Thomas8c1c7282b2ac
diff --git a/crates/gpu/src/ctx.rs b/crates/gpu/src/ctx.rsindex 010ff7ba0..b415d312a 100644--- a/crates/gpu/src/ctx.rs+++ b/crates/gpu/src/ctx.rs@@ -37,7 +37,22 @@ const MODULES: &[Module] = &[Module {src: include_str!("wgsl/map.wgsl"),bindings: &[("a", false, "f32"), ("b", false, "f32"), ("c", false, "f32"), ("dst", true, "f32")],- entries: &["log_lum_k", "dark_k", "guided_pre", "guided_ab", "guided_apply", "wb_k", "nr_lum", "chroma_k", "nr_col", "subsample", "redeye_k"],+ entries: &[+ "log_lum_k",+ "dark_k",+ "guided_pre",+ "guided_ab",+ "guided_apply",+ "wb_k",+ "nr_lum",+ "chroma_k",+ "nr_col",+ "subsample",+ "redeye_k",+ "xguided_pre",+ "xguided_ab",+ "xguided_apply",+ ],},Module {src: include_str!("wgsl/mask.wgsl"),@@ -121,7 +136,7 @@ pub struct Gpu {/// WGSL constants shared by every module (generated from the CPU pipeline's values).fn constants() -> String {- use lightcraft_pipeline::finish::{GRAIN_HASH, MASK_TERMS, SRGB_LUT_N};+ use lightcraft_pipeline::finish::{GRAIN_HASH, MASK_SUMS, MASK_TERMS, SRGB_LUT_N};use lightcraft_pipeline::tone::{LUT_MAX_EV, LUT_MIN_EV, LUT_N};let mut s = String::new();let [to_lms, from_lms, to_lab, from_lab] = lightcraft_color::perceptual::oklab_matrices();@@ -134,9 +149,14 @@ fn constants() -> String {s += &format!("const TONE_MIN_GAIN: f32 = {:?};\n", 2f32.powf(LUT_MIN_EV));let b = lightcraft_pipeline::geometry::BLANK;s += &format!("const BLANK_R: f32 = {:?};\nconst BLANK_G: f32 = {:?};\nconst BLANK_B: f32 = {:?};\n", b[0], b[1], b[2]);- s += &format!("const SRGB_N: u32 = {SRGB_LUT_N}u;\nconst CURVE_N: u32 = {}u;\nconst MASK_TERMS: u32 = {MASK_TERMS}u;\n", crate::params::CURVE_N);+ s += &format!(+ "const SRGB_N: u32 = {SRGB_LUT_N}u;\nconst CURVE_N: u32 = {}u;\nconst MASK_TERMS: u32 = {MASK_TERMS}u;\nconst MASK_SUMS: u32 = {MASK_SUMS}u;\n",+ crate::params::CURVE_N+ );s += &format!("const POINT_WORDS: u32 = {}u;\n", lightcraft_pipeline::colorops::POINT_WORDS);s += &format!("const EYE_WORDS: u32 = {}u;\n", lightcraft_pipeline::redeye::EYE_WORDS);+ use lightcraft_pipeline::masks::{AUTO_TOL_CHROMA, AUTO_TOL_EV};+ s += &format!("const AUTO_TOL_EV: f32 = {AUTO_TOL_EV:?};\nconst AUTO_TOL_CHROMA: f32 = {AUTO_TOL_CHROMA:?};\n");s += &format!("const SHADOW_TINT_K: f32 = {:?};\n", lightcraft_pipeline::colorops::SHADOW_TINT);for (i, h) in GRAIN_HASH.iter().enumerate() {s += &format!("const GRAIN_H{i}: u32 = {h}u;\n");diff --git a/crates/gpu/src/params.rs b/crates/gpu/src/params.rsindex b18461a2e..00ae96ba0 100644--- a/crates/gpu/src/params.rs+++ b/crates/gpu/src/params.rs@@ -31,6 +31,7 @@ const FIELDS: &[(&str, usize)] = &[("HAS_CLAR", 1),("HAS_TEX", 1),("HAS_DARK", 1),+ ("HAS_CHROMA", 1),("OPS_IDENTITY", 1),("VIBRANCE", 1),("SATURATION", 1),@@ -123,6 +124,8 @@ pub struct Present {pub clarity: bool,pub texture: bool,pub dark: bool,+ /// The blurred chromaticity follows the mask planes in the `masks` buffer.+ pub chroma: bool,}/// The `finish` kernel's parameter block and auxiliary table (tone LUT | sRGB LUT | curve LUTs |@@ -166,6 +169,7 @@ pub fn finish_block(fp: &FinishParams, masks: &[[f32; MASK_TERMS]], present: &Prp.b("HAS_CLAR", present.clarity);p.b("HAS_TEX", present.texture);p.b("HAS_DARK", present.dark);+ p.b("HAS_CHROMA", present.chroma);let ops = &fp.ops;p.b("OPS_IDENTITY", ops.is_identity());diff --git a/crates/gpu/src/render.rs b/crates/gpu/src/render.rsindex 59a5370a7..492cb38c7 100644--- a/crates/gpu/src/render.rs+++ b/crates/gpu/src/render.rs@@ -44,6 +44,7 @@ struct Planes {clarity: Option<(u32, Arc<Buf>)>,texture: Option<(u32, Arc<Buf>)>,dark: Option<(u32, Arc<Buf>, f32)>,+ chroma: Option<(u32, Arc<Buf>)>,}impl GpuStages {@@ -143,6 +144,12 @@ impl<'a> Cx<'a> {out}+ /// Copy all of `src` into `dst` at `offset` (32-bit words; recorded).+ pub fn copy_into(&mut self, src: &Buf, dst: &Buf, offset: usize) {+ let enc = self.enc.get_or_insert_with(|| self.gpu.encoder());+ enc.copy_buffer_to_buffer(src.raw(), 0, dst.raw(), (offset * 4) as u64, (src.len * 4) as u64);+ }+pub fn read_rgb(&mut self, b: &Buf, w: usize, h: usize) -> Rgb32f {Rgb32f { width: w, height: h, data: self.read(b, w * h * 3) }}@@ -469,7 +476,12 @@ pub fn render(// 5. per-pixel stagelet fp = FinishParams::new(s, &plan.frame, info, w, h, plan.px_per_long, prep.air);- let present = Present { clarity: prep.clarity.is_some(), texture: prep.texture.is_some(), dark: prep.dark.is_some() };+ let present = Present {+ clarity: prep.clarity.is_some(),+ texture: prep.texture.is_some(),+ dark: prep.dark.is_some(),+ chroma: masks.is_some() && prep.chroma.is_some(),+ };let (p, aux) = finish_block(&fp, &terms, &present);let aux = gpu.upload(&aux);let out = gpu.buffer(n);@@ -580,6 +592,8 @@ struct Prep {clarity: Option<Arc<Buf>>,texture: Option<Arc<Buf>>,dark: Option<Arc<Buf>>,+ /// Blurred chromaticity (local Moiré / Noise).+ chroma: Option<Arc<Buf>>,air: f32,}@@ -634,14 +648,58 @@ fn prepare(cx: &mut Cx<'_>, lin: &Buf, plan: &Plan<'_>, req: &RenderRequest, pla}},};- Prep { log_l, base, clarity, texture, dark, air }+ let chroma = sig.chroma.map(|sg| {+ plane_at(&mut planes.chroma, sg, || {+ let ch = cx.gpu.buffer(n * 3);+ map(cx, "chroma_k", n, &[], [Some(lin), None, None], &ch);+ gaussian(cx, &ch, w, h, 3, sg)+ })+ });+ Prep { log_l, base, clarity, texture, dark, chroma, air }}/// Most brush dabs the mask kernel evaluates per pixel (more: the CPU rasterizes the brush).const MAX_DABS: usize = 4096;-/// Evaluate the masks (`lightcraft_pipeline::masks::evaluate`): their alpha planes (concatenated)-/// and their adjustment terms. Shapes without a kernel (Sky, Subject, …) run on the CPU.+/// The `shape` kernel's brush data for `dabs`: stroke records (12 words: dab offset, dab count,+/// r, hard, flow, density, erase, bbox x0 y0 x1 y1, auto) then the dab centres.+fn brush_aux(dabs: &[&lightcraft_pipeline::masks::BrushDabs], erase: bool) -> Vec<f32> {+ let mut aux = Vec::new();+ let mut off = 12 * dabs.len();+ for d in dabs {+ let (mut x0, mut y0, mut x1, mut y1) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);+ for q in &d.dabs {+ (x0, y0, x1, y1) = (x0.min(q.x - d.r), y0.min(q.y - d.r), x1.max(q.x + d.r), y1.max(q.y + d.r));+ }+ aux.extend([off as f32, d.dabs.len() as f32, d.r as f32, d.hard as f32, d.flow, d.density, (erase && d.erase) as u8 as f32]);+ aux.extend([x0, y0, x1, y1].map(|v| v as f32));+ aux.push(d.auto as u8 as f32);+ off += 2 * d.dabs.len();+ }+ for d in dabs {+ aux.extend(d.dabs.iter().flat_map(|q| [q.x as f32, q.y as f32]));+ }+ aux+}++/// Cross guided filter (`masks::guided_cross`) of `p` steered by `guide`, max-combined with `p`.+fn guided_cross_max(cx: &mut Cx<'_>, guide: &Buf, p: &Buf, w: usize, h: usize, sigma: f32, eps: f32) -> Buf {+ let n = w * h;+ let (m0, m1) = (cx.gpu.buffer(2 * n), cx.gpu.buffer(2 * n));+ map(cx, "xguided_pre", n, &[0], [Some(guide), Some(p), None], &m0);+ map(cx, "xguided_pre", n, &[1], [Some(guide), Some(p), None], &m1);+ let (b0, b1) = (gaussian(cx, &m0, w, h, 2, sigma), gaussian(cx, &m1, w, h, 2, sigma));+ let ab = cx.gpu.buffer(2 * n);+ map(cx, "xguided_ab", n, &[eps.to_bits()], [Some(&b0), Some(&b1), None], &ab);+ let ab = gaussian(cx, &ab, w, h, 2, sigma);+ let q = cx.gpu.buffer(n);+ map(cx, "xguided_apply", n, &[], [Some(guide), Some(&ab), Some(p)], &q);+ q+}++/// Evaluate the masks (`lightcraft_pipeline::masks::evaluate`): their alpha planes (concatenated,+/// followed by the blurred chromaticity when local Moiré / Noise need it) and their adjustment+/// terms. Shapes without a kernel (Sky, Subject, …) run on the CPU.fn masks(cx: &mut Cx<'_>, lin: &Buf, prep: &Prep, plan: &Plan<'_>, host: &mut Host) -> (Option<Buf>, Vec<[f32; MASK_TERMS]>) {use lightcraft_develop::{MaskOp, MaskShape};let s = &*plan.settings;@@ -657,7 +715,10 @@ fn masks(cx: &mut Cx<'_>, lin: &Buf, prep: &Prep, plan: &Plan<'_>, host: &mut Holet [a, b, c, d, e, f] = frame.out_to_norm(w, h).0;let (kx, ky) = (frame.ow / long, frame.oh / long);let aff = [a * kx, b * ky, c * kx, d * ky, e * kx, f * ky].map(|v| (v as f32).to_bits());- let alpha = cx.zeroed(n * list.len());+ let alpha = cx.zeroed(n * list.len() + if prep.chroma.is_some() { 3 * n } else { 0 });+ if let Some(ch) = &prep.chroma {+ cx.copy_into(ch, &alpha, n * list.len());+ }let comp_plane = cx.gpu.buffer(n);for (mi, m) in list.iter().enumerate() {let mut first = true;@@ -673,6 +734,7 @@ fn masks(cx: &mut Cx<'_>, lin: &Buf, prep: &Prep, plan: &Plan<'_>, host: &mut Hop.extend_from_slice(&aff);let f32s = |v: &[f64]| v.iter().map(|x| (*x as f32).to_bits()).collect::<Vec<u32>>();let mut aux: Vec<f32> = Vec::new();+ let mut own: Option<Buf> = None;let kind = match &comp.shape {MaskShape::Linear { start, end } => {let (a, b) = (frame.norm_to_long(*start), frame.norm_to_long(*end));@@ -700,29 +762,46 @@ fn masks(cx: &mut Cx<'_>, lin: &Buf, prep: &Prep, plan: &Plan<'_>, host: &mut Ho}MaskShape::Brush { strokes } => {let dabs: Vec<_> = strokes.iter().map(|st| lightcraft_pipeline::masks::brush_dabs(st, frame, w, h)).collect();- if dabs.iter().map(|d| d.dabs.len()).sum::<usize>() <= MAX_DABS {- p.push(dabs.len() as u32);- let mut off = 11 * dabs.len();+ if dabs.iter().map(|d| d.dabs.len()).sum::<usize>() > MAX_DABS {+ None+ } else if dabs.iter().any(|d| d.auto) {+ // Auto Mask: stroke by stroke (each one refined before it's combined)+ let brush = cx.zeroed(n);+ let stroke = cx.gpu.buffer(n);for d in &dabs {- let (mut x0, mut y0, mut x1, mut y1) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);- for q in &d.dabs {- (x0, y0, x1, y1) = (x0.min(q.x - d.r), y0.min(q.y - d.r), x1.max(q.x + d.r), y1.max(q.y + d.r));- }- aux.extend([off as f32, d.dabs.len() as f32, d.r as f32, d.hard as f32, d.flow, d.density, d.erase as u8 as f32]);- aux.extend([x0, y0, x1, y1].map(|v| v as f32));- off += 2 * d.dabs.len();+ let mut q = p.clone();+ q[2] = 4;+ q[3] = 0;+ q.push(1);+ let aux = cx.gpu.upload(&brush_aux(&[d], false));+ cx.run("shape", &q, &[Some(lin), Some(&prep.log_l), Some(&aux), Some(&stroke), Some(&brush)], groups2(w, h, [16, 16]));+ let refined = d.auto.then(|| {+ let (sigma, eps) = lightcraft_pipeline::masks::auto_refine(d.r);+ guided_cross_max(cx, &prep.log_l, &stroke, w, h, sigma, eps)+ });+ let op = if d.erase { 2 } else { 1 };+ cx.run(+ "combine",+ &[n as u32, 0, 0, op],+ &[None, None, None, Some(refined.as_ref().unwrap_or(&stroke)), Some(&brush)],+ groups1(n),+ );}- for d in &dabs {- aux.extend(d.dabs.iter().flat_map(|q| [q.x as f32, q.y as f32]));+ if comp.invert {+ cx.run("finalize", &[n as u32, 0, 0, 1, 1f32.to_bits()], &[None, None, None, Some(&stroke), Some(&brush)], groups1(n));}- Some(4)- } else {+ own = Some(brush);None+ } else {+ p.push(dabs.len() as u32);+ aux = brush_aux(&dabs.iter().collect::<Vec<_>>(), true);+ Some(4)}}_ => None,};let plane = match kind {+ _ if own.is_some() => own,Some(k) => {p[2] = k;let aux = (!aux.is_empty()).then(|| cx.gpu.upload(&aux));diff --git a/crates/gpu/src/wgsl/finish.wgsl b/crates/gpu/src/wgsl/finish.wgslindex d405e9495..2ddda1b66 100644--- a/crates/gpu/src/wgsl/finish.wgsl+++ b/crates/gpu/src/wgsl/finish.wgsl@@ -1,5 +1,6 @@// The per-pixel stage: a straight port of `lightcraft_pipeline::finish` (keep in step with it).-// Bindings: img (rgb, pre-exposure), log_l, base, clar, tex, dark, masks (NMASK planes), aux+// Bindings: img (rgb, pre-exposure), log_l, base, clar, tex, dark, masks (NMASK planes, then the+// blurred chromaticity when HAS_CHROMA), aux// (tone LUT | sRGB LUT | curve LUTs | mask terms), out (packed RGBA8).fn tone_apply(y: f32) -> f32 {@@ -239,7 +240,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {let l0 = l_pre + ev;// --- local (mask) contributions- var lt: array<f32, 14>;+ var lt: array<f32, MASK_SUMS>;var tint_on = false;var tint_dir = vec2<f32>(0.0, 0.0);var tint_amt = 0.0;@@ -250,18 +251,42 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {continue;}let t = pu(F_MASK_OFF) + m * MASK_TERMS;- for (var k = 0u; k < 14u; k++) {+ for (var k = 0u; k < MASK_SUMS; k++) {lt[k] += a * aux[t + k];}- if (aux[t + 14u] > 0.0) {+ if (aux[t + MASK_SUMS] > 0.0) {tint_on = true;- tint_dir = vec2<f32>(aux[t + 15u], aux[t + 16u]);- tint_amt = a * aux[t + 17u];+ tint_dir = vec2<f32>(aux[t + MASK_SUMS + 1u], aux[t + MASK_SUMS + 2u]);+ tint_amt = a * aux[t + MASK_SUMS + 3u];}}let l_exp = lt[0];let l_temp = lt[1];let l_tint = lt[2];+ let l_noise = lt[14];++ // --- local Moiré (and the colour part of Noise): chromaticity towards its blur+ let mt = clamp(lt[15] + 0.5 * max(l_noise, 0.0), -1.0, 1.0);+ if (mt != 0.0 && pu(F_HAS_CHROMA) != 0u) {+ let raw = vec3<f32>(img[3u * i], img[3u * i + 1u], img[3u * i + 2u]);+ let y = lum2020(c);+ let ch0 = raw / max(lum2020(raw), 1e-6);+ let o = nm * n + 3u * i;+ let cb = vec3<f32>(masks[o], masks[o + 1u], masks[o + 2u]);+ c = max((ch0 + (cb - ch0) * mt) * y, vec3<f32>(0.0));+ }+ // --- local Defringe: desaturate purple / green fringes along edges+ let df = clamp(lt[16], 0.0, 1.0);+ if (df > 0.0 && pu(F_HAS_TEX) != 0u) {+ let yd = max(lum2020(c), 1e-6);+ let purple = (min(c.x, c.z) - c.y) / yd;+ let green = (c.y - max(c.x, c.z)) / yd;+ let k = df * sstep(0.04, 0.3, abs(l_pre - tex[i])) * max(sstep(0.02, 0.2, purple), sstep(0.02, 0.2, green));+ if (k > 0.0) {+ let y = lum2020(c);+ c = c + (y - c) * k;+ }+ }// --- dehaze (scene linear)let dz = pf(F_DEHAZE) + lt[10];@@ -334,6 +359,11 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {delta += sp * 1.3 * clamp(det, -0.8, 0.8) * mk;}}+ // local Noise: smooth (or, negative, boost) small-amplitude detail, keep edges+ if (l_noise != 0.0 && pu(F_HAS_TEX) != 0u) {+ let det = l_pre - tex[i];+ delta -= clamp(l_noise, -1.0, 1.0) * 0.9 * det * (1.0 - sstep(0.1, 0.5, abs(det)));+ }if (delta != 0.0) {c = c * exp2(delta);}diff --git a/crates/gpu/src/wgsl/map.wgsl b/crates/gpu/src/wgsl/map.wgslindex 9a54e7f66..fc8eebecf 100644--- a/crates/gpu/src/wgsl/map.wgsl+++ b/crates/gpu/src/wgsl/map.wgsl@@ -70,6 +70,51 @@ fn guided_apply(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgrdst[i] = b[2u * i] * a[i] + b[2u * i + 1u];}+// Cross guided filter (`masks::guided_cross`), a: guide, b: input. P[1] = 0: (guide, input);+// 1: (guide·input, guide²).+@compute @workgroup_size(256)+fn xguided_pre(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {+ let i = lin_index(g, nw);+ if (i >= pu(0u)) {+ return;+ }+ let gi = a[i];+ let p = b[i];+ if (pu(1u) == 0u) {+ dst[2u * i] = gi;+ dst[2u * i + 1u] = p;+ } else {+ dst[2u * i] = gi * p;+ dst[2u * i + 1u] = gi * gi;+ }+}++// Coefficients (a, b) from blurred means (a: guide, input) and correlations (b: guide·input,+// guide²). P[1] = eps.+@compute @workgroup_size(256)+fn xguided_ab(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {+ let i = lin_index(g, nw);+ if (i >= pu(0u)) {+ return;+ }+ let mi = a[2u * i];+ let mp = a[2u * i + 1u];+ let v = max(b[2u * i + 1u] - mi * mi, 0.0);+ let k = (b[2u * i] - mi * mp) / (v + pf(1u));+ dst[2u * i] = k;+ dst[2u * i + 1u] = mp - k * mi;+}++// `max(p, clamp(a·guide + b, 0, 1))` (a: guide, b: blurred coefficients, c: the input p).+@compute @workgroup_size(256)+fn xguided_apply(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {+ let i = lin_index(g, nw);+ if (i >= pu(0u)) {+ return;+ }+ dst[i] = max(c[i], clamp(b[2u * i] * a[i] + b[2u * i + 1u], 0.0, 1.0));+}+// White balance: 3×3 matrix (P[1] = has matrix, P[2..11] row-major), clamped at 0.@compute @workgroup_size(256)fn wb_k(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {diff --git a/crates/gpu/src/wgsl/mask.wgsl b/crates/gpu/src/wgsl/mask.wgslindex 2075e186a..c2d15b64a 100644--- a/crates/gpu/src/wgsl/mask.wgsl+++ b/crates/gpu/src/wgsl/mask.wgsl@@ -13,6 +13,19 @@ fn pos(x: u32, y: u32) -> vec2<f32> {// 2 luminance range: lo, hi, lo feather, hi feather, ev// 3 colour range: tol, gain, sample count (OkLab triples in aux)// 4 brush: stroke count (stroke records + dabs in aux)+// `masks::chromaticity` of pixel i.+fn chroma_at(i: u32) -> vec3<f32> {+ let c = vec3<f32>(img[3u * i], img[3u * i + 1u], img[3u * i + 2u]);+ return c / max(lum2020(c), 1e-6);+}++// `masks::auto_similarity`.+fn auto_similarity(l: f32, ch: vec3<f32>, rl: f32, rch: vec3<f32>) -> f32 {+ let dl = (l - rl) / AUTO_TOL_EV;+ let dc = length(ch - rch) / AUTO_TOL_CHROMA;+ return 1.0 - sstep(0.5, 1.0, sqrt(dl * dl + dc * dc));+}+@compute @workgroup_size(16, 16)fn shape(@builtin(global_invocation_id) g: vec3<u32>) {let w = pu(0u);@@ -64,11 +77,14 @@ fn shape(@builtin(global_invocation_id) g: vec3<u32>) {}v = 1.0 - sstep(tol * 0.5, tol, best);} else if (kind == 4u) {- // stroke record: dab offset, dab count, r, hard, flow, density, erase, bbox x0 y0 x1 y1+ // stroke record: dab offset, dab count, r, hard, flow, density, erase, bbox x0 y0 x1 y1, autolet px = f32(g.x) + 0.5;let py = f32(g.y) + 0.5;+ let lp = log_l[i];+ let chp = chroma_at(i);for (var k = 0u; k < pu(10u); k++) {- let o = 11u * k;+ let o = 12u * k;+ let auto_mask = aux[o + 11u] != 0.0;if (px < aux[o + 7u] || py < aux[o + 8u] || px > aux[o + 9u] || py > aux[o + 10u]) {continue;}@@ -89,6 +105,12 @@ fn shape(@builtin(global_invocation_id) g: vec3<u32>) {if (dd > hard) {a = 1.0 - sstep(hard, r, dd);}+ if (auto_mask) {+ let rx = min(u32(max(floor(aux[off + 2u * j]), 0.0)), w - 1u);+ let ry = min(u32(max(floor(aux[off + 2u * j + 1u]), 0.0)), h - 1u);+ let ri = ry * w + rx;+ a *= auto_similarity(lp, chp, log_l[ri], chroma_at(ri));+ }keep *= 1.0 - a * flow;}let sa = min(1.0 - keep, aux[o + 5u]);diff --git a/crates/gpu/tests/equivalence.rs b/crates/gpu/tests/equivalence.rsindex 0a15922cf..349c82e19 100644--- a/crates/gpu/tests/equivalence.rs+++ b/crates/gpu/tests/equivalence.rs@@ -275,6 +275,37 @@ fn cases() -> Vec<(&'static str, Edit)> {},];}),+ ("masks (local noise, moiré, defringe)", |s| {+ let radial = MaskShape::Radial { center: Point::new(0.4, 0.6), rx: 0.3, ry: 0.25, angle: 0.0, feather: 50.0, invert: false };+ let linear = MaskShape::Linear { start: Point::new(0.5, 0.0), end: Point::new(0.5, 0.7) };+ let m = |shape, adjust| Mask { components: vec![MaskComponent { op: MaskOp::Add, invert: false, shape }], adjust, ..Default::default() };+ use lightcraft_develop::LocalAdjustments as L;+ s.masks = vec![+ m(radial, L { noise: 80.0, moire: 60.0, defringe: 100.0, ..Default::default() }),+ m(linear, L { noise: -60.0, moire: -40.0, ..Default::default() }),+ ];+ }),+ ("masks (auto mask brush)", |s| {+ let st = |pts: &[(f64, f64)], auto_mask, erase| BrushStroke {+ points: pts.iter().map(|p| Point::new(p.0, p.1)).collect(),+ size: 0.06,+ feather: 40.0,+ flow: 80.0,+ auto_mask,+ erase,+ ..Default::default()+ };+ let strokes = vec![+ st(&[(0.2, 0.55), (0.5, 0.6), (0.8, 0.5)], true, false),+ st(&[(0.3, 0.2), (0.6, 0.25)], false, false),+ st(&[(0.5, 0.58)], true, true),+ ];+ s.masks = vec![Mask {+ components: vec![MaskComponent { op: MaskOp::Add, invert: false, shape: MaskShape::Brush { strokes } }],+ adjust: lightcraft_develop::LocalAdjustments { exposure: 1.0, saturation: -50.0, ..Default::default() },+ ..Default::default()+ }];+ }),("calibration", |s| {s.calibration.shadows_tint = 40.0;s.calibration.red_hue = 50.0;diff --git a/crates/pipeline/src/finish.rs b/crates/pipeline/src/finish.rsindex 0ab6199e4..8eb6a6376 100644--- a/crates/pipeline/src/finish.rs+++ b/crates/pipeline/src/finish.rs@@ -105,12 +105,15 @@ fn grain_noise(x: f32, y: f32, seed: u32) -> f32 {}/// Number of per-mask terms in [`mask_terms`].-pub const MASK_TERMS: usize = 18;+pub const MASK_TERMS: usize = 21;++/// Number of alpha-weighted terms at the start of [`mask_terms`].+pub const MASK_SUMS: usize = 17;/// A mask's local adjustments as the per-pixel stage uses them (alpha-weighted sums), in order:/// exposure, temp, tint, contrast, highlights, shadows, whites, blacks, texture, clarity, dehaze,-/// saturation, hue, sharpness, then the colour overlay: on (0/1), cos and sin of its OkLCh hue, and-/// its strength.+/// saturation, hue, sharpness, noise, moiré, defringe, then the colour overlay: on (0/1), cos and+/// sin of its OkLCh hue, and its strength.pub fn mask_terms(j: &LocalAdjustments) -> [f32; MASK_TERMS] {let (on, cos, sin, amt) = if j.color_sat > 0.0 {let hue = crate::colorops::oklch_hue_of_srgb_hue(j.color_hue);@@ -133,6 +136,9 @@ pub fn mask_terms(j: &LocalAdjustments) -> [f32; MASK_TERMS] {(j.saturation / 100.0) as f32,(j.hue / 100.0) as f32 * 0.6,(j.sharpness / 100.0) as f32,+ (j.noise / 100.0) as f32,+ (j.moire / 100.0) as f32,+ (j.defringe / 100.0) as f32,on,cos,sin,@@ -250,21 +256,42 @@ pub(crate) fn finish(p: &Prepared, s: &DevelopSettings, frame: &Frame, info: &Solet l0 = l_pre + ev;// --- local (mask) contributions: alpha-weighted sums of the masks' terms- let mut l = [0.0f32; 14];+ let mut l = [0.0f32; MASK_SUMS];let mut tint_col: Option<([f32; 3], f32)> = None;for (m, t) in p.masks.iter().zip(&terms) {let a = m.alpha.data[i];if a <= 0.0 {continue;}- for k in 0..14 {+ for k in 0..MASK_SUMS {l[k] += a * t[k];}- if t[14] > 0.0 {- tint_col = Some(([t[15], t[16], 0.0], a * t[17]));+ if t[MASK_SUMS] > 0.0 {+ tint_col = Some(([t[MASK_SUMS + 1], t[MASK_SUMS + 2], 0.0], a * t[MASK_SUMS + 3]));+ }+ }+ let [l_exp, l_temp, l_tint, l_con, l_hl, l_sh, l_wh, l_bl, l_tex, l_clar, l_dehaze, l_sat, l_hue, l_sharp, l_noise, l_moire, l_defringe] =+ l;++ // --- local Moiré (and the colour part of Noise): chromaticity towards its blur+ let mt = (l_moire + 0.5 * l_noise.max(0.0)).clamp(-1.0, 1.0);+ if mt != 0.0+ && let Some(cb) = &p.chroma_blur+ {+ let (y, ch0, cb) = (luminance_2020(c), crate::masks::chromaticity(raw), cb.data[i]);+ c = std::array::from_fn(|k| ((ch0[k] + (cb[k] - ch0[k]) * mt) * y).max(0.0));+ }+ // --- local Defringe: desaturate purple / green fringes along edges+ let df = l_defringe.clamp(0.0, 1.0);+ if df > 0.0+ && let Some(b) = &p.texture_blur+ {+ let k = df * defringe_weight(c, p.log_l.data[i] - b.data[i]);+ if k > 0.0 {+ let y = luminance_2020(c);+ c = c.map(|v| v + (y - v) * k);}}- let [l_exp, l_temp, l_tint, l_con, l_hl, l_sh, l_wh, l_bl, l_tex, l_clar, l_dehaze, l_sat, l_hue, l_sharp] = l;// --- dehaze (scene linear)let dz = dehaze + l_dehaze;@@ -334,6 +361,13 @@ pub(crate) fn finish(p: &Prepared, s: &DevelopSettings, frame: &Frame, info: &Sodelta += sp * 1.3 * det.clamp(-0.8, 0.8) * m;}}+ // local Noise: smooth (or, negative, boost) small-amplitude detail, keep edges+ if l_noise != 0.0+ && let Some(b) = &p.texture_blur+ {+ let det = l_pre - b.data[i];+ delta -= l_noise.clamp(-1.0, 1.0) * 0.9 * det * (1.0 - smooth(0.1, 0.5, det.abs()));+ }if delta != 0.0 {let g = delta.exp2();c = c.map(|v| v * g);@@ -433,6 +467,16 @@ pub(crate) fn finish(p: &Prepared, s: &DevelopSettings, frame: &Frame, info: &Soout}+/// Local Defringe weight of a scene-linear colour `c` whose log luminance differs by `det` from+/// its fine blur: high on strong edges with a purple or green cast.+#[inline]+pub fn defringe_weight(c: [f32; 3], det: f32) -> f32 {+ let y = luminance_2020(c).max(1e-6);+ let purple = (c[0].min(c[2]) - c[1]) / y;+ let green = (c[1] - c[0].max(c[2])) / y;+ smooth(0.04, 0.3, det.abs()) * smooth(0.02, 0.2, purple).max(smooth(0.02, 0.2, green))+}+/// Refine Saturation: scale the curved colour's chroma (around its luma, encoded values) so its/// saturation (chroma / luma) moves from the curve's towards the pre-curve one: the ratio is/// `(s_curve / s_before)^refine`, so 1 keeps the curve, 0 restores the original saturation.diff --git a/crates/pipeline/src/lib.rs b/crates/pipeline/src/lib.rsindex ad6b56e70..20fcbb86b 100644--- a/crates/pipeline/src/lib.rs+++ b/crates/pipeline/src/lib.rs@@ -110,6 +110,8 @@ pub(crate) struct Prepared {pub clarity_blur: Option<Arc<Plane>>,pub texture_blur: Option<Arc<Plane>>,pub dark: Option<Arc<Plane>>,+ /// Blurred chromaticity (`rgb / Y`) for local Moiré / Noise.+ pub chroma_blur: Option<Arc<Rgb32f>>,/// Airlight of `dark` (before exposure).pub air: f32,pub masks: Vec<masks::Evaluated>,@@ -402,3 +404,5 @@ pub(crate) fn for_rows<T: Send>(data: &mut [T], w: usize, f: impl Fn(usize, &mutmod tests;#[cfg(test)]mod tests_geometry;+#[cfg(test)]+mod tests_local;diff --git a/crates/pipeline/src/local.rs b/crates/pipeline/src/local.rsindex 8efb41269..ae26888c7 100644--- a/crates/pipeline/src/local.rs+++ b/crates/pipeline/src/local.rs@@ -208,6 +208,8 @@ pub(crate) struct Planes {pub texture: Option<(u32, Arc<Plane>)>,/// Dark channel and its airlight.pub dark: Option<(u32, Arc<Plane>, f32)>,+ /// Blurred chromaticity (local Moiré / Noise).+ pub chroma: Option<(u32, Arc<Rgb32f>)>,}/// Reuse `slot` if it was computed at `sigma`, else compute and store it.@@ -232,6 +234,9 @@ pub fn dark_of(c: [f32; 3]) -> f32 {c[0].min(c[1]).min(c[2])}+/// Radius of the local Moiré / colour-noise chromaticity blur, as a fraction of the long edge.+pub const CHROMA_SIGMA: f32 = 0.004;+/// Radii (px) of the spatial planes the settings need (`None` = not needed).#[derive(Clone, Copy, Debug, Default, PartialEq)]pub struct PlaneSigmas {@@ -243,6 +248,8 @@ pub struct PlaneSigmas {pub texture: Option<f32>,/// Dehaze dark channel (Gaussian).pub dark: Option<f32>,+ /// Chromaticity blur for local Moiré / colour noise (Gaussian).+ pub chroma: Option<f32>,}pub fn plane_sigmas(s: &DevelopSettings, px_per_long: f64, q: Quality) -> PlaneSigmas {@@ -256,10 +263,17 @@ pub fn plane_sigmas(s: &DevelopSettings, px_per_long: f64, q: Quality) -> PlaneSif q == Quality::Draft { sigma.min(24.0) } else { sigma }});let clarity = (s.effects.clarity != 0.0 || local_any(|a| a.clarity)).then(|| (0.012 * ppl).max(1.0));- let texture = (s.effects.texture != 0.0 || s.detail.sharpen_amount != 0.0 || local_any(|a| a.texture) || local_any(|a| a.sharpness))- .then(|| (0.0018 * ppl).max(0.6));+ // local Noise and Defringe read the fine detail band too+ let texture = (s.effects.texture != 0.0+ || s.detail.sharpen_amount != 0.0+ || local_any(|a| a.texture)+ || local_any(|a| a.sharpness)+ || local_any(|a| a.noise)+ || s.masks.iter().any(|m| m.adjust.defringe > 0.0))+ .then(|| (0.0018 * ppl).max(0.6));let dark = (s.effects.dehaze != 0.0 || local_any(|a| a.dehaze)).then(|| (0.02 * ppl).max(1.0));- PlaneSigmas { base, clarity, texture, dark }+ let chroma = (local_any(|a| a.moire) || s.masks.iter().any(|m| m.adjust.noise > 0.0)).then(|| (CHROMA_SIGMA * ppl).max(1.0));+ PlaneSigmas { base, clarity, texture, dark, chroma }}/// The spatial planes the per-pixel stage needs for `img` (white-balanced, before exposure),@@ -267,9 +281,18 @@ pub fn plane_sigmas(s: &DevelopSettings, px_per_long: f64, q: Quality) -> PlaneS/// one alone scales poorly: the guided filters work on small subsampled grids).pub(crate) fn prepare(img: Arc<Rgb32f>, s: &DevelopSettings, frame: &Frame, px_per_long: f64, q: Quality, planes: &mut Planes) -> Prepared {let log_l = planes.log_l.get_or_insert_with(|| Arc::new(timed("log_l", || img.map(log_lum)))).clone();- let PlaneSigmas { base: base_sigma, clarity: clarity_sigma, texture: texture_sigma, dark: dark_sigma } = plane_sigmas(s, px_per_long, q);+ let PlaneSigmas { base: base_sigma, clarity: clarity_sigma, texture: texture_sigma, dark: dark_sigma, chroma: chroma_sigma } =+ plane_sigmas(s, px_per_long, q);- let Planes { base: sb, clarity: sc, texture: st, dark: sd, .. } = planes;+ let Planes { base: sb, clarity: sc, texture: st, dark: sd, chroma: sch, .. } = planes;+ let chroma_blur = chroma_sigma.map(|sg| match sch {+ Some((k, c)) if *k == sg.to_bits() => c.clone(),+ _ => {+ let c = timed("chroma", || Arc::new(gaussian(&img.map(masks::chromaticity), sg)));+ *sch = Some((sg.to_bits(), c.clone()));+ c+ }+ });let l = &log_l;let (base, (clarity_blur, (texture_blur, dark))) = par_join(|| base_sigma.map(|sg| plane_at(sb, sg, || timed("base", || guided_fast(l, sg, BASE_EPS)))),@@ -302,7 +325,7 @@ pub(crate) fn prepare(img: Arc<Rgb32f>, s: &DevelopSettings, frame: &Frame, px_p};let ev = s.light.exposure as f32;let masks = timed("masks", || masks::evaluate(&s.masks, frame, img.width, img.height, &img, &log_l, ev));- Prepared { img, log_l, base, clarity_blur, texture_blur, dark, air, masks, px_per_long }+ Prepared { img, log_l, base, clarity_blur, texture_blur, dark, chroma_blur, air, masks, px_per_long }}/// The airlight is estimated from every `AIRLIGHT_STEP`-th value of the dark channel.diff --git a/crates/pipeline/src/masks.rs b/crates/pipeline/src/masks.rsindex 33af94d39..f02185f8a 100644--- a/crates/pipeline/src/masks.rs+++ b/crates/pipeline/src/masks.rs@@ -107,7 +107,7 @@ pub fn shape_alpha(shape: &MaskShape, frame: &Frame, w: usize, h: usize, img: &Rif inv { 1.0 - a } else { a }});}- MaskShape::Brush { strokes } => rasterize_brush(strokes, frame, w, h, &mut out),+ MaskShape::Brush { strokes } => rasterize_brush(strokes, frame, w, h, img, log_l, &mut out),MaskShape::LuminanceRange { lo, hi, lo_feather, hi_feather } => {let (lo, hi, lf, hf) = (*lo as f32, *hi as f32, (*lo_feather as f32).max(1e-3), (*hi_feather as f32).max(1e-3));for (v, l) in out.data.iter_mut().zip(&log_l.data) {@@ -188,6 +188,8 @@ pub struct BrushDabs {pub flow: f32,pub density: f32,pub erase: bool,+ /// Auto Mask: paint only pixels like the one under each dab, then snap to edges.+ pub auto: bool,}/// The dabs of stroke `s` in a `w × h` output.@@ -210,15 +212,90 @@ pub fn brush_dabs(s: &BrushStroke, frame: &Frame, w: usize, h: usize) -> BrushDa}dabs.push(q);}- BrushDabs { dabs, r, hard, flow: (s.flow / 100.0).clamp(0.0, 1.0) as f32, density: (s.density / 100.0).clamp(0.0, 1.0) as f32, erase: s.erase }+ BrushDabs {+ dabs,+ r,+ hard,+ flow: (s.flow / 100.0).clamp(0.0, 1.0) as f32,+ density: (s.density / 100.0).clamp(0.0, 1.0) as f32,+ erase: s.erase,+ auto: s.auto_mask,+ }+}++/// Auto Mask tolerances: a pixel takes a dab's paint fully up to half of these from the colour+/// under the dab centre, none beyond them (log2 luminance, chromaticity `rgb / Y`).+pub const AUTO_TOL_EV: f32 = 0.5;+pub const AUTO_TOL_CHROMA: f32 = 0.25;++/// Chromaticity `rgb / Y` (as colour noise reduction uses it).+#[inline]+pub fn chromaticity(c: [f32; 3]) -> [f32; 3] {+ let y = lightcraft_color::luminance_2020(c).max(1e-6);+ [c[0] / y, c[1] / y, c[2] / y]+}++/// Auto Mask: how much a pixel (log luminance `l`, chromaticity `ch`) is like the reference.+#[inline]+pub fn auto_similarity(l: f32, ch: [f32; 3], rl: f32, rch: [f32; 3]) -> f32 {+ let dl = (l - rl) / AUTO_TOL_EV;+ let dc = ((ch[0] - rch[0]).powi(2) + (ch[1] - rch[1]).powi(2) + (ch[2] - rch[2]).powi(2)).sqrt() / AUTO_TOL_CHROMA;+ 1.0 - smooth(0.5, 1.0, (dl * dl + dc * dc).sqrt())+}++/// The output pixel a dab at `d` samples its reference colour from.+#[inline]+pub fn dab_pixel(d: Point, w: usize, h: usize) -> usize {+ let x = (d.x.floor().max(0.0) as usize).min(w - 1);+ let y = (d.y.floor().max(0.0) as usize).min(h - 1);+ y * w + x+}++/// Guided-filter refinement of an Auto Mask stroke of radius `r` px: (sigma px, epsilon EV²). The+/// stroke keeps the larger of its own and the refined alpha.+pub fn auto_refine(r: f64) -> (f32, f32) {+ ((0.25 * r).max(1.0) as f32, 0.02)}-/// Stamp brush strokes into `out` (max-combine; erase strokes subtract).-fn rasterize_brush(strokes: &[BrushStroke], frame: &Frame, w: usize, h: usize, out: &mut Plane) {+/// Guided filter of `p` steered by `guide` (He et al.), clamped to 0..1: `p`'s edges snap to the+/// guide's.+pub fn guided_cross(guide: &Plane, p: &Plane, sigma: f32, eps: f32) -> Plane {+ use lightcraft_raster::blur::gaussian;+ let mi = gaussian(guide, sigma);+ let mp = gaussian(p, sigma);+ let cip = gaussian(&guide.zip_map(p, |a, b| a * b), sigma);+ let cii = gaussian(&guide.map(|a| a * a), sigma);+ let mut a = Plane::new(p.width, p.height);+ let mut b = Plane::new(p.width, p.height);+ for i in 0..p.data.len() {+ let var = (cii.data[i] - mi.data[i] * mi.data[i]).max(0.0);+ let k = (cip.data[i] - mi.data[i] * mp.data[i]) / (var + eps);+ a.data[i] = k;+ b.data[i] = mp.data[i] - k * mi.data[i];+ }+ let (ma, mb) = (gaussian(&a, sigma), gaussian(&b, sigma));+ let mut q = Plane::new(p.width, p.height);+ for i in 0..q.data.len() {+ q.data[i] = (ma.data[i] * guide.data[i] + mb.data[i]).clamp(0.0, 1.0);+ }+ q+}++/// Stamp brush strokes into `out` (max-combine; erase strokes subtract). Auto Mask strokes weight+/// each dab by [`auto_similarity`] to the pixel under its centre and are refined with+/// [`guided_cross`] on log luminance.+fn rasterize_brush(strokes: &[BrushStroke], frame: &Frame, w: usize, h: usize, img: &Rgb32f, log_l: &Plane, out: &mut Plane) {+ if w == 0 || h == 0 {+ return;+ }for s in strokes {- let BrushDabs { dabs, r, hard, flow, density: dens, erase } = brush_dabs(s, frame, w, h);+ let BrushDabs { dabs, r, hard, flow, density: dens, erase, auto } = brush_dabs(s, frame, w, h);let mut stroke_alpha = Plane::new(w, h);for d in &dabs {+ let refc = auto.then(|| {+ let j = dab_pixel(*d, w, h);+ (log_l.data[j], chromaticity(img.data[j]))+ });let (x0, x1) = (((d.x - r).floor().max(0.0)) as usize, ((d.x + r).ceil().max(0.0) as usize).min(w));let (y0, y1) = (((d.y - r).floor().max(0.0)) as usize, ((d.y + r).ceil().max(0.0) as usize).min(h));for y in y0..y1 {@@ -227,13 +304,23 @@ fn rasterize_brush(strokes: &[BrushStroke], frame: &Frame, w: usize, h: usize, oif dd > r {continue;}- let a = if dd <= hard { 1.0 } else { 1.0 - smooth(hard as f32, r as f32, dd as f32) };- let v = &mut stroke_alpha.data[y * w + x];+ let mut a = if dd <= hard { 1.0 } else { 1.0 - smooth(hard as f32, r as f32, dd as f32) };+ let i = y * w + x;+ if let Some((rl, rch)) = refc {+ a *= auto_similarity(log_l.data[i], chromaticity(img.data[i]), rl, rch);+ }+ let v = &mut stroke_alpha.data[i];// flow accumulates within a stroke up to density*v = (*v + a * flow * (1.0 - *v)).min(dens);}}}+ if auto {+ let (sigma, eps) = auto_refine(r);+ let q = guided_cross(log_l, &stroke_alpha, sigma, eps);+ // the refinement fills gaps along edges; it never takes paint away+ stroke_alpha = stroke_alpha.zip_map(&q, f32::max);+ }for (o, a) in out.data.iter_mut().zip(&stroke_alpha.data) {*o = if erase { *o * (1.0 - a) } else { o.max(*a) };}@@ -289,4 +376,35 @@ mod tests {assert!(a.get(100, 50) < 0.05, "erased centre {}", a.get(100, 50));assert!(a.get(40, 5) < 0.01);}++ #[test]+ fn auto_mask_stops_at_edges() {+ // dark left half, bright right half; a stroke along the boundary, centred on the dark side+ let (w, h) = (200, 100);+ let f = frame(w, h);+ let img = Rgb32f::from_fn(w, h, |x, _| if x < 100 { [0.03; 3] } else { [0.6, 0.5, 0.4] });+ let l = img.map(crate::local::log_lum);+ let stroke = |auto_mask| BrushStroke {+ points: vec![Point::new(0.47, 0.2), Point::new(0.47, 0.8)],+ size: 0.08,+ feather: 0.0,+ auto_mask,+ ..Default::default()+ };+ let comp = |auto| MaskShape::Brush { strokes: vec![stroke(auto)] };+ let plain = shape_alpha(&comp(false), &f, w, h, &img, &l, 0.0);+ let auto = shape_alpha(&comp(true), &f, w, h, &img, &l, 0.0);+ // without Auto Mask the brush spills over the edge; with it, it stays on the dark side+ assert!(plain.get(105, 50) > 0.9, "{}", plain.get(105, 50));+ assert!(auto.get(105, 50) < 0.05, "spill {}", auto.get(105, 50));+ assert!(auto.get(110, 50) < 0.02);+ assert!(auto.get(90, 50) > 0.9, "painted side {}", auto.get(90, 50));+ assert!(auto.get(99, 50) > 0.8, "up to the edge {}", auto.get(99, 50));+ // on a flat area Auto Mask paints like the plain brush+ let flat = Rgb32f::from_fn(w, h, |_, _| [0.2; 3]);+ let fl = flat.map(crate::local::log_lum);+ let a = shape_alpha(&comp(true), &f, w, h, &flat, &fl, 0.0);+ let b = shape_alpha(&comp(false), &f, w, h, &flat, &fl, 0.0);+ assert!((a.get(94, 50) - b.get(94, 50)).abs() < 0.02, "{} vs {}", a.get(94, 50), b.get(94, 50));+ }}diff --git a/crates/pipeline/src/tests_local.rs b/crates/pipeline/src/tests_local.rsnew file mode 100644index 000000000..3ccf961b5--- /dev/null+++ b/crates/pipeline/src/tests_local.rs@@ -0,0 +1,109 @@+//! Pixel tests of the local (mask) Noise, Moiré and Defringe sliders.++use lightcraft_develop::{DevelopSettings, LocalAdjustments, Mask, MaskComponent, MaskOp, MaskShape};+use lightcraft_geom::Point;+use lightcraft_raster::{Rgb32f, Rgba8};++use crate::{RenderRequest, SourceInfo, render};++const W: usize = 240;+const H: usize = 120;++/// A deterministic hash in −1..1.+fn noise(x: usize, y: usize, k: u32) -> f32 {+ let mut v = (x as u32).wrapping_mul(0x8da6_b343) ^ (y as u32).wrapping_mul(0xd816_3841) ^ k.wrapping_mul(0xcb1a_b31f);+ v ^= v >> 13;+ v = v.wrapping_mul(0x5bd1_e995);+ v ^= v >> 15;+ (v & 0xffff) as f32 / 32768.0 - 1.0+}++/// Settings with one mask covering the left half (x < 0.45), with `adjust`.+fn left_mask(adjust: LocalAdjustments) -> DevelopSettings {+ let shape = MaskShape::Linear { start: Point::new(0.45, 0.5), end: Point::new(0.46, 0.5) };+ let mut s = DevelopSettings::default();+ s.masks.push(Mask { id: 1, components: vec![MaskComponent { op: MaskOp::Add, invert: false, shape }], adjust, ..Default::default() });+ s+}++fn shot(src: &Rgb32f, s: &DevelopSettings) -> Rgba8 {+ render(src, &SourceInfo::default(), s, &RenderRequest::fit(W, H)).image+}++/// Standard deviation of `f(pixel)` over columns `x0..x1` (rows 4..H-4).+fn spread(img: &Rgba8, x0: usize, x1: usize, f: impl Fn([u8; 4]) -> f32) -> f32 {+ let v: Vec<f32> = (4..H - 4).flat_map(|y| (x0..x1).map(move |x| (x, y))).map(|(x, y)| f(img.data[y * W + x])).collect();+ let m = v.iter().sum::<f32>() / v.len() as f32;+ (v.iter().map(|a| (a - m).powi(2)).sum::<f32>() / v.len() as f32).sqrt()+}++fn luma(p: [u8; 4]) -> f32 {+ 0.2126 * p[0] as f32 + 0.7152 * p[1] as f32 + 0.0722 * p[2] as f32+}++fn chroma(p: [u8; 4]) -> f32 {+ p[0] as f32 - p[2] as f32+}++#[test]+fn local_noise_smooths_luminance_noise_inside_the_mask() {+ let src = Rgb32f::from_fn(W, H, |x, y| [0.18 * (1.0 + 0.12 * noise(x, y, 1)); 3]);+ let plain = shot(&src, &DevelopSettings::default());+ let base = spread(&plain, 10, 90, luma);+ let on = shot(&src, &left_mask(LocalAdjustments { noise: 100.0, ..Default::default() }));+ let off = shot(&src, &left_mask(LocalAdjustments { noise: -100.0, ..Default::default() }));+ let (smoothed, boosted) = (spread(&on, 10, 90, luma), spread(&off, 10, 90, luma));+ assert!(smoothed < 0.6 * base, "noise +100: {smoothed} vs {base}");+ assert!(boosted > 1.2 * base, "noise −100: {boosted} vs {base}");+ // outside the mask nothing changes+ assert_eq!(spread(&on, 150, 230, luma), spread(&plain, 150, 230, luma));+ // the mean brightness is kept+ let mean = |img: &Rgba8| (4..H - 4).flat_map(|y| (10..90).map(move |x| luma(img.data[y * W + x]))).sum::<f32>() / (80 * (H - 8)) as f32;+ assert!((mean(&on) - mean(&plain)).abs() < 2.0);+}++#[test]+fn local_moire_removes_colour_speckle_inside_the_mask() {+ let src = Rgb32f::from_fn(W, H, |x, y| {+ let n = 0.25 * noise(x, y, 2);+ [0.18 * (1.0 + n), 0.18, 0.18 * (1.0 - n)]+ });+ let plain = shot(&src, &DevelopSettings::default());+ let base = spread(&plain, 10, 90, chroma);+ let on = shot(&src, &left_mask(LocalAdjustments { moire: 100.0, ..Default::default() }));+ let reduced = spread(&on, 10, 90, chroma);+ assert!(reduced < 0.4 * base, "moiré +100: {reduced} vs {base}");+ assert_eq!(spread(&on, 150, 230, chroma), spread(&plain, 150, 230, chroma));+ // luminance is kept+ assert!((spread(&on, 10, 90, luma) - spread(&plain, 10, 90, luma)).abs() < 1.0);+ // positive Noise also calms colour noise (less than Moiré)+ let n = spread(&shot(&src, &left_mask(LocalAdjustments { noise: 100.0, ..Default::default() })), 10, 90, chroma);+ assert!(n < 0.8 * base && n > reduced, "{n}");+}++#[test]+fn local_defringe_desaturates_purple_edges_only() {+ // dark | bright edge at x = 40 (inside the mask) and x = 200 (outside), each with a purple+ // fringe column; a flat purple patch (no edge) at x 60..80+ let src = Rgb32f::from_fn(W, H, |x, _| {+ let fringe = x == 39 || x == 40 || x == 199 || x == 200;+ if fringe {+ [0.25, 0.04, 0.3]+ } else if (60..80).contains(&x) {+ [0.2, 0.08, 0.22]+ } else if (40..120).contains(&x) || x >= 200 {+ [0.7; 3]+ } else {+ [0.02; 3]+ }+ });+ let s = left_mask(LocalAdjustments { defringe: 100.0, ..Default::default() });+ let (plain, on) = (shot(&src, &DevelopSettings::default()), shot(&src, &s));+ let sat = |p: [u8; 4]| p[0].max(p[2]) as f32 - p[1] as f32;+ let at = |img: &Rgba8, x: usize| img.data[60 * W + x];+ assert!(sat(at(&plain, 40)) > 40.0, "a purple fringe to start with: {:?}", at(&plain, 40));+ assert!(sat(at(&on, 40)) < 0.5 * sat(at(&plain, 40)), "fringe in the mask: {:?} vs {:?}", at(&on, 40), at(&plain, 40));+ assert_eq!(at(&on, 200), at(&plain, 200), "outside the mask");+ let flat = |img: &Rgba8| sat(at(img, 70));+ assert!((flat(&on) - flat(&plain)).abs() <= 2.0, "flat purple kept: {} vs {}", flat(&on), flat(&plain));+}diff --git a/crates/ui-egui/src/panels/masking.rs b/crates/ui-egui/src/panels/masking.rsindex 7c4c2500f..2aad39ffc 100644--- a/crates/ui-egui/src/panels/masking.rs+++ b/crates/ui-egui/src/panels/masking.rs@@ -33,6 +33,8 @@ pub const LOCAL: &[ControlSpec] = &[spec("saturation", "Saturation", -100.0, 100.0, 1.0, 0, Track::Gradient { from: "#7a7a7a", to: "#e04a3a" }),spec("sharpness", "Sharpness", -100.0, 100.0, 1.0, 0, Track::Centered),spec("noise", "Noise", -100.0, 100.0, 1.0, 0, Track::Centered),+ spec("moire", "Moiré", -100.0, 100.0, 1.0, 0, Track::Centered),+ spec("defringe", "Defringe", -100.0, 100.0, 1.0, 0, Track::Centered),];pub fn local_get(a: &LocalAdjustments, key: &str) -> f64 {@@ -294,6 +296,10 @@ fn brush_settings(app: &mut LightcraftApp, ui: &mut egui::Ui) {app.ui.brush_erase = true;}});+ let mut auto = app.ui.brush_auto_mask;+ if ui.checkbox(&mut auto, "Auto Mask").on_hover_text("Paint only areas like the one under the brush").changed() {+ app.ui.brush_auto_mask = auto;+ }});for (id, label, min, max, get) in [("ui.brushSize", "Size", 1.0, 100.0, (app.ui.brush_size * 400.0) as f64),diff --git a/crates/ui-egui/src/tests_masking.rs b/crates/ui-egui/src/tests_masking.rsindex ca60889b0..74b360f28 100644--- a/crates/ui-egui/src/tests_masking.rs+++ b/crates/ui-egui/src/tests_masking.rs@@ -89,3 +89,20 @@ fn mask_overlay_keys_and_pins() {assert_eq!(h.app.session.active_mask, Some(2));h.settle(SETTLE);}++#[test]+fn brush_strokes_carry_auto_mask() {+ let mut h = detail("panel.masking");+ let r = h.request("ui.set", json!({"brushAutoMask": true}), T);+ assert_eq!(r["ok"], true, "{r}");+ exec(&mut h, "tool.brush", json!({}));+ assert_eq!(h.app.ui.tool, "brush");+ pointer(+ &mut h,+ json!([{"kind": "down", "x": 0.3, "y": 0.5}, {"kind": "drag", "x": 0.4, "y": 0.5}, {"kind": "drag", "x": 0.5, "y": 0.5}, {"kind": "up", "x": 0.5, "y": 0.5}]),+ );+ let d = develop(&h);+ let MaskShape::Brush { strokes } = &d.masks[0].components[0].shape else { panic!("brush") };+ assert!(strokes[0].auto_mask && strokes[0].points.len() >= 2, "{strokes:?}");+ h.settle(SETTLE);+}diff --git a/docs/parity.md b/docs/parity.mdindex 489a445ea..756e3f421 100644--- a/docs/parity.md+++ b/docs/parity.md@@ -31,7 +31,7 @@ and prints the summary; `cargo xtask parity --write` refreshes the summary table| H. Crop & rotate (CROP) | 7 | 2 | 0 | 1 | 6/6 (100%) | 1/3 (33%) || I. Remove / healing (REM) | 3 | 3 | 4 | 2 | 2/4 (50%) | 1/3 (33%) || J. Red eye (EYE) | 0 | 0 | 2 | 0 | — | 0/1 (0%) |-| K. Masking (MASK) | 8 | 8 | 7 | 0 | 5/8 (63%) | 3/5 (60%) |+| K. Masking (MASK) | 10 | 6 | 7 | 0 | 7/8 (88%) | 3/5 (60%) || L. Presets (PRE) | 1 | 4 | 2 | 1 | 0/2 (0%) | 1/2 (50%) || M. Versions & history (VER) | 3 | 1 | 1 | 0 | 1/1 (100%) | 2/3 (67%) || N. Copy / paste / sync (SYNC) | 4 | 0 | 1 | 0 | 3/3 (100%) | 1/1 (100%) |@@ -48,7 +48,7 @@ and prints the summary; `cargo xtask parity --write` refreshes the summary table| Y. Menus | 46 | 18 | 21 | 8 | 37/47 (79%) | 7/23 (30%) || Z. Keyboard shortcuts (desktop) | 46 | 16 | 18 | 1 | 39/52 (75%) | 7/23 (30%) || Lightroom Classic extras | 4 | 19 | 56 | 9 | — | 3/21 (14%) |-| **Total** | 210 | 101 | 189 | 37 | 153/198 (77%) | 49/144 (34%) |+| **Total** | 212 | 99 | 189 | 37 | 155/198 (78%) | 49/144 (34%) |<!-- /parity:summary -->## Top gaps@@ -57,8 +57,6 @@ Ordered by tier, then user value, then (low) effort. Take the first one nobody i1. **LR-EXP-COLORSPACE** (P0) — export is sRGB only. Add Display P3 / Adobe RGB-compatible / ProPhoto-compatible /Rec.2020 output (our own primaries + ICC from `crates/codecs/src/icc.rs`). High value, low–medium effort.-3. **LR-MASK-BRUSH + LR-MASK-SLIDERS** (P0) — apply the stored Auto Mask flag (edge-aware brush) and the local- Noise / Moiré / Defringe sliders, which are stored but not rendered. High value, medium effort.4. **LR-REM-SPOT-EDIT + LR-REM-BRUSH-PARAMS** (P0) — select a spot pin, move target/source, delete with ⌫,feather/opacity sliders, `[`/`]` size keys. Medium effort.5. **LR-VIEW-PHOTOGRID** (P0) — group the justified grid by capture date with headers. Low–medium effort.@@ -335,7 +333,7 @@ under the UI command that wraps it (a no-op error); the UI command now wins.| LR-MASK-OBJECTS | Object selection | P2 | ⬜ | | shape exists (falls back to the subject heuristic); no UI || LR-MASK-PEOPLE | People parts | P2 | ⬜ | | || LR-MASK-LANDSCAPE | Landscape classes | P2 | ⬜ | | shape exists, evaluates empty |-| LR-MASK-BRUSH | Brush mask | P0 | 🟡 | `cmd:tool.brush`, `cmd:mask.brushStroke` | size/feather/flow/density/erase; Auto Mask flag not applied; no A/B brushes, no pressure |+| LR-MASK-BRUSH | Brush mask | P0 | ✅ | `cmd:tool.brush`, `cmd:mask.brushStroke` (`autoMask`), `crates/pipeline/src/masks.rs` | size/feather/flow/density/erase; Auto Mask: dabs weighted by similarity to the colour under the dab centre, refined by a guided filter on luminance (CPU + GPU); no A/B brushes, no pressure || LR-MASK-LINEAR | Linear gradient | P0 | ✅ | `cmd:tool.linear`, `cmd:mask.update` | || LR-MASK-RADIAL | Radial gradient | P0 | ✅ | `cmd:tool.radial`, `cmd:mask.update` | || LR-MASK-COLORRANGE | Colour range | P1 | 🟡 | `cmd:mask.add` (`colorRange`) | renders; sampling UX unverified |@@ -345,7 +343,7 @@ under the UI command that wraps it (a no-op error); the UI command now wins.| LR-MASK-INVERT | Invert | P0 | ✅ | `cmd:mask.invert` | || LR-MASK-AMOUNT | Mask amount | P1 | ✅ | `cmd:mask.adjust` (`amount`), `crates/ui-egui/src/panels/masking.rs` | || LR-MASK-FEATHER-EDGE | Refine mask edges | P2 | ⬜ | | |-| LR-MASK-SLIDERS | Local adjustment sliders | P0 | 🟡 | `cmd:mask.adjust`, `crates/pipeline/src/finish.rs` | noise / moiré / defringe stored but not rendered; no local curve or effect presets |+| LR-MASK-SLIDERS | Local adjustment sliders | P0 | ✅ | `cmd:mask.adjust`, `crates/pipeline/src/finish.rs` | every slider renders (CPU + GPU), incl. Noise, Moiré, Defringe (negative Defringe has no effect); no local curve or effect presets || LR-MASK-OVERLAY | Mask overlay | P0 | ✅ | `cmd:view.maskOverlay`, `cmd:view.maskOverlayMode`, `cmd:view.maskOverlayColor`, `crates/pipeline/src/visualize.rs` | rendered alpha of the selected mask (CPU + GPU): colour, colour on B&W, image on black/white, white on black; ⇧O cycles while masking; no auto-show on hover || LR-MASK-PINS | Pins | P1 | ✅ | `cmd:view.maskPins`, `crates/ui-egui/src/panels/detail.rs` | a pin per radial/linear/brush component: click selects its mask, drag moves it; no pins for range/AI components, no Auto mode || LR-MASK-UPDATE | Recompute AI masks | P2 | ⬜ | | |