LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LR-REM-DUST: Find Dust Spots
Brandon Thomas8d40b3e37270
diff --git a/crates/engine/src/cmd/masks.rs b/crates/engine/src/cmd/masks.rsindex 860c14331..a0a05f521 100644--- a/crates/engine/src/cmd/masks.rs+++ b/crates/engine/src/cmd/masks.rs@@ -320,6 +320,42 @@ pub fn specs() -> Vec<CommandSpec> {})}),// ---- Remove tool (spots)+ cmd!(+ "spot.findDust",+ "Find Dust Spots",+ [],+ None,+ "{sensitivity?: 0..100 (50), add?: bool (true)} — find sensor-dust spots (small soft dark spots on smooth areas) and add a heal spot on each (one undo step) → {spots: [{x, y, size}], added}",+ has_active,+ |s, p| {+ let c = "spot.findDust";+ let id = s.active().ok_or_else(|| bad(c, "no active photo"))?;+ // the uncropped photo, so positions are the spots' own coordinates+ let job = s.render_job(id, 1600, 1600, false, false).ok_or_else(|| bad(c, "no photo"))?;+ let img = job.run().rendered.map_err(|e| bad(c, e))?.image;+ let found = lightcraft_pipeline::dust::detect(&img, f64_or(p, "sensitivity", 50.0) as f32);+ let out: Vec<Value> = found.iter().map(|d| json!({"x": d.x, "y": d.y, "size": d.radius})).collect();+ if !p.get("add").and_then(Value::as_bool).unwrap_or(true) || found.is_empty() {+ return Ok(json!({"spots": out, "added": 0}));+ }+ let mut dd = (*s.develop_of(id).unwrap_or_default()).clone();+ let base = Spot::default();+ for d in &found {+ let mut spot = Spot {+ mode: SpotMode::Heal,+ points: vec![Point::new(d.x, d.y)],+ size: d.radius.clamp(SPOT_SIZE.0, SPOT_SIZE.1),+ feather: base.feather,+ opacity: 100.0,+ source_offset: None,+ };+ spot.source_offset = pick_source(s, id, &dd, &spot, None);+ dd.spots.push(spot);+ }+ s.set_develop(id, dd, "Find Dust Spots")?;+ Ok(json!({"spots": out, "added": found.len()}))+ }+ ),cmd!("spot.add","Add Remove Spot",diff --git a/crates/engine/src/tests_import.rs b/crates/engine/src/tests_import.rsindex 0d8ee7e7c..bfdacd1f1 100644--- a/crates/engine/src/tests_import.rs+++ b/crates/engine/src/tests_import.rs@@ -482,3 +482,42 @@ fn assisted_culling_groups_bursts_and_scores_focus() {assert!(vis.contains(&by_name(&s, "b_sharp.png")) && !vis.contains(&by_name(&s, "a_soft.png")) && vis.contains(&other));let _ = std::fs::remove_dir_all(&dir);}++/// Find Dust Spots: soft dark spots on a smooth sky are found and healed (one undo step).+#[test]+fn dust_spots_are_found_and_healed() {+ let dir = temp_dir("dust");+ let (w, h) = (900usize, 600usize);+ let spots = [(180.0f32, 140.0f32), (600.0, 300.0)];+ let data: Vec<[u8; 4]> = (0..w * h)+ .map(|i| {+ let (x, y) = ((i % w) as f32, (i / w) as f32);+ let mut v = 0.5 + 0.3 * (y / h as f32);+ for (cx, cy) in spots {+ v -= 0.07 * (-((x - cx).powi(2) + (y - cy).powi(2)) / (2.0 * 25.0)).exp();+ }+ let b = (v * 255.0) as u8;+ [b, b, (b as f32 * 1.15).min(255.0) as u8, 255]+ })+ .collect();+ let png = lightcraft_codecs::encode_png(+ &lightcraft_codecs::EncodeImage::rgba8(&lightcraft_raster::Rgba8 { width: w, height: h, data }),+ &Default::default(),+ )+ .unwrap();+ std::fs::write(dir.join("sky.png"), png).unwrap();+ let mut s = Session::new().with_fs();+ s.execute("library.import", &json!({"paths": [dir.join("sky.png").to_string_lossy()]})).unwrap();+ let id = s.active().unwrap();+ let before = s.render_now(id, 900, 600).unwrap().image;+ let r = s.execute("spot.findDust", &json!({})).unwrap();+ assert_eq!(r["added"], 2, "{r}");+ let after = s.render_now(id, 900, 600).unwrap().image;+ let at = |img: &lightcraft_raster::Rgba8, x: usize, y: usize| img.data[y * 900 + x][0] as i32;+ for (cx, cy) in spots {+ assert!(at(&after, cx as usize, cy as usize) > at(&before, cx as usize, cy as usize) + 6, "the spot at {cx},{cy} is lifted");+ }+ s.execute("edit.undo", &json!({})).unwrap();+ assert!(s.develop_of(id).unwrap().spots.is_empty(), "one undo step");+ let _ = std::fs::remove_dir_all(&dir);+}diff --git a/crates/pipeline/src/dust.rs b/crates/pipeline/src/dust.rsnew file mode 100644index 000000000..165e94b60--- /dev/null+++ b/crates/pipeline/src/dust.rs@@ -0,0 +1,128 @@+//! Dust-spot detection: sensor dust shows as small, soft, darker-than-surroundings round spots+//! on smooth areas (sky, walls). Classical: a blurred copy gives the surroundings, the darkening+//! is compared with the local texture so detail doesn't trigger it, and each candidate blob+//! must be small and roughly round.++use lightcraft_raster::{Plane, Rgba8, blur::gaussian};++/// A found spot: centre (0..1 of the image's width / height) and radius (fraction of the long+/// edge), with how much darker it is (0..1).+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct DustSpot {+ pub x: f64,+ pub y: f64,+ pub radius: f64,+ pub strength: f32,+}++/// Dust spots in a rendered image; `sensitivity` 0..100 (higher finds fainter spots).+pub fn detect(img: &Rgba8, sensitivity: f32) -> Vec<DustSpot> {+ let (w, h) = (img.width, img.height);+ if w < 32 || h < 32 {+ return Vec::new();+ }+ let long = w.max(h) as f32;+ let l = Plane::from_fn(w, h, |x, y| {+ let p = img.data[y * w + x];+ (0.2126 * p[0] as f32 + 0.7152 * p[1] as f32 + 0.0722 * p[2] as f32) / 255.0+ });+ let around = gaussian(&l, (0.012 * long).max(2.0));+ // texture: local mean of the fine detail (what isn't explained by the surroundings)+ let detail = Plane::from_fn(w, h, |x, y| (l.data[y * w + x] - around.data[y * w + x]).abs());+ let texture = gaussian(&detail, (0.02 * long).max(3.0));+ let min_dark = 0.03 - 0.022 * (sensitivity / 100.0).clamp(0.0, 1.0);+ let dark: Vec<f32> = (0..w * h).map(|i| (around.data[i] - l.data[i]).max(0.0)).collect();+ let candidate = |i: usize| dark[i] > min_dark && dark[i] > 3.0 * texture.data[i] && l.data[i] > 0.08;+ // blobs of candidate pixels (4-connected)+ let mut seen = vec![false; w * h];+ let mut out = Vec::new();+ let (rmin, rmax) = (0.0015 * long, 0.02 * long);+ for start in 0..w * h {+ if seen[start] || !candidate(start) {+ continue;+ }+ let mut stack = vec![start];+ seen[start] = true;+ let (mut n, mut sx, mut sy, mut peak) = (0usize, 0.0f64, 0.0f64, 0.0f32);+ let (mut x0, mut x1, mut y0, mut y1) = (w, 0, h, 0);+ while let Some(i) = stack.pop() {+ let (x, y) = (i % w, i / w);+ n += 1;+ sx += x as f64;+ sy += y as f64;+ peak = peak.max(dark[i]);+ (x0, x1, y0, y1) = (x0.min(x), x1.max(x), y0.min(y), y1.max(y));+ if n > (rmax * rmax * 4.0) as usize {+ break; // too big to be dust: stop growing+ }+ for j in [i.wrapping_sub(1), i + 1, i.wrapping_sub(w), i + w] {+ let ok = j < w * h && !seen[j] && ((j % w).abs_diff(x) <= 1);+ if ok && candidate(j) {+ seen[j] = true;+ stack.push(j);+ }+ }+ }+ let (bw, bh) = ((x1 - x0 + 1) as f32, (y1 - y0 + 1) as f32);+ let r = (bw.max(bh)) / 2.0;+ let round = bw.max(bh) / bw.min(bh) <= 1.8 && n as f32 >= 0.45 * bw * bh;+ if r >= rmin && r <= rmax && round {+ out.push(DustSpot {+ x: (sx / n as f64 + 0.5) / w as f64,+ y: (sy / n as f64 + 0.5) / h as f64,+ radius: (r / long) as f64 * 1.6,+ strength: peak,+ });+ }+ }+ out.sort_by(|a, b| b.strength.total_cmp(&a.strength));+ out.truncate(60);+ out+}++#[cfg(test)]+mod tests {+ use super::*;++ /// A smooth sky gradient with three soft dark spots: all found, nothing else.+ #[test]+ fn finds_spots_on_smooth_areas() {+ let (w, h) = (600usize, 400usize);+ let spots = [(120.0f32, 90.0f32, 4.0f32), (400.0, 200.0, 6.0), (500.0, 330.0, 3.0)];+ let data: Vec<[u8; 4]> = (0..w * h)+ .map(|i| {+ let (x, y) = ((i % w) as f32, (i / w) as f32);+ let mut v = 0.55 + 0.25 * (y / h as f32) + 0.05 * (x / w as f32);+ for (cx, cy, r) in spots {+ let d2 = (x - cx).powi(2) + (y - cy).powi(2);+ v -= 0.06 * (-d2 / (2.0 * r * r)).exp();+ }+ let b = (v * 255.0) as u8;+ [b, b, (b as f32 * 1.1).min(255.0) as u8, 255]+ })+ .collect();+ let found = detect(&Rgba8 { width: w, height: h, data }, 50.0);+ assert_eq!(found.len(), 3, "{found:?}");+ for (cx, cy, _) in spots {+ assert!(+ found.iter().any(|s| (s.x * w as f64 - cx as f64).abs() < 3.0 && (s.y * h as f64 - cy as f64).abs() < 3.0),+ "{cx},{cy}: {found:?}"+ );+ }+ }++ #[test]+ fn textured_scenes_give_few_false_spots() {+ let img = lightcraft_scenes::demo_library()[2].render(600, 400);+ let data = img+ .data+ .iter()+ .map(|c| {+ let e = |v: f32| (lightcraft_color::transfer::linear_to_srgb(v.clamp(0.0, 1.0)) * 255.0) as u8;+ [e(c[0]), e(c[1]), e(c[2]), 255]+ })+ .collect();+ let found = detect(&Rgba8 { width: 600, height: 400, data }, 50.0);+ assert!(found.len() <= 3, "{} false spots", found.len());+ }+}diff --git a/crates/pipeline/src/lib.rs b/crates/pipeline/src/lib.rsindex 8c1289b19..d34a9843a 100644--- a/crates/pipeline/src/lib.rs+++ b/crates/pipeline/src/lib.rs@@ -25,6 +25,7 @@pub mod auto;pub mod colorops;pub mod cull;+pub mod dust;pub mod finish;pub mod geometry;pub mod local;diff --git a/crates/ui-egui/src/panels/right.rs b/crates/ui-egui/src/panels/right.rsindex 99deb9a8b..3748aacf9 100644--- a/crates/ui-egui/src/panels/right.rs+++ b/crates/ui-egui/src/panels/right.rs@@ -224,6 +224,22 @@ fn remove(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {ui.add_space(8.0);ui.label(format!("{} spot(s) on this photo", d.spots.len()));ui.add_space(4.0);+ if text_button(ui, "findDust", "Find Dust Spots", false)+ .on_hover_text("Heal the small, soft dark spots sensor dust leaves on smooth areas")+ .clicked()+ {+ match app.run("spot.findDust", json!({})) {+ Ok(r) => {+ let n = r["added"].as_u64().unwrap_or(0);+ app.toast(+ ui.ctx(),+ if n == 0 { "No dust spots found".to_string() } else { format!("Healed {n} dust spot{}", if n == 1 { "" } else { "s" }) },+ );+ }+ Err(e) => app.toast(ui.ctx(), e),+ }+ }+ ui.add_space(4.0);ui.label(egui::RichText::new("Paint over a distraction on the photo to remove it.").color(Tokens::get(ui.ctx()).text_dim));});// brush settings; with a spot selected they edit that spot toodiff --git a/docs/parity.md b/docs/parity.mdindex abaa1a571..2c764796d 100644--- a/docs/parity.md+++ b/docs/parity.md@@ -29,7 +29,7 @@ and prints the summary; `cargo xtask parity --write` refreshes the summary table| F. Edit panel — global adjustments (EDIT) | 42 | 1 | 5 | 1 | 28/28 (100%) | 13/14 (93%) || G. Profiles (PROF) | 6 | 1 | 3 | 0 | 3/3 (100%) | 2/3 (67%) || H. Crop & rotate (CROP) | 9 | 0 | 0 | 1 | 6/6 (100%) | 3/3 (100%) |-| I. Remove / healing (REM) | 6 | 1 | 3 | 2 | 4/4 (100%) | 2/3 (67%) |+| I. Remove / healing (REM) | 7 | 1 | 2 | 2 | 4/4 (100%) | 2/3 (67%) || J. Red eye (EYE) | 2 | 0 | 0 | 0 | — | 1/1 (100%) || K. Masking (MASK) | 13 | 3 | 7 | 0 | 8/8 (100%) | 5/5 (100%) || L. Presets (PRE) | 6 | 0 | 1 | 1 | 2/2 (100%) | 2/2 (100%) |@@ -48,9 +48,9 @@ and prints the summary; `cargo xtask parity --write` refreshes the summary table| Y. Menus | 80 | 1 | 4 | 8 | 46/47 (98%) | 23/23 (100%) || Z. Keyboard shortcuts (desktop) | 74 | 3 | 3 | 1 | 49/52 (94%) | 22/23 (96%) || Lightroom Classic extras | 24 | 8 | 47 | 9 | — | 20/21 (95%) |-| **Total** | 375 | 25 | 100 | 37 | 193/198 (97%) | 136/144 (94%) |+| **Total** | 376 | 25 | 99 | 37 | 193/198 (97%) | 136/144 (94%) |-Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **77.5%** of 500 in-scope rows — P0 98.7% of 198 · P1 96.2% of 144 · P2 33.9% of 158.+Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **77.7%** of 500 in-scope rows — P0 98.7% of 198 · P1 96.2% of 144 · P2 34.5% of 158.<!-- /parity:summary -->## Top gaps@@ -294,7 +294,7 @@ under the UI command that wraps it (a no-op error); the UI command now wins.| LR-REM-VISUALIZE | Visualize spots | P1 | ✅ | `cmd:view.visualizeSpots` | || LR-REM-PEOPLE | Remove people (generative) | OOS | 🚫 | | || LR-REM-REFLECT | Remove reflections | P2 | ⬜ | | |-| LR-REM-DUST | Dust detection | P2 | ⬜ | | |+| LR-REM-DUST | Dust detection | P2 | ✅ | `cmd:spot.findDust`, `crates/pipeline/src/dust.rs` | Remove panel ▸ Find Dust Spots: small, soft, round dark spots on smooth areas become heal spots (sensitivity; one undo step); Visualize Spots for checking by eye || LR-REM-SYNC | Sync spots | P1 | ✅ | `cmd:develop.copy` (`groups`), `crates/develop/src/presets.rs` | |## J. Red eye (EYE)