Skip to content

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

Content-aware Remove: inpaint crate (PatchMatch completion) and a Fill spot mode

Andrew Frahnfe6d7b019267
diff --git a/Cargo.lock b/Cargo.lock
index 700f386fb..40a9988fc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3291,6 +3291,13 @@ dependencies = [
"rayon",
]
+[[package]]
+name = "lightcraft-inpaint"
+version = "0.5.0"
+dependencies = [
+ "rayon",
+]
+
[[package]]
name = "lightcraft-mcp"
version = "0.6.0"
@@ -3338,6 +3345,7 @@ dependencies = [
"lightcraft-color",
"lightcraft-develop",
"lightcraft-geom",
+ "lightcraft-inpaint",
"lightcraft-raster",
"lightcraft-raw",
"lightcraft-scenes",
diff --git a/Cargo.toml b/Cargo.toml
index b9a511e26..f5278446a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,6 +24,7 @@ lightcraft-raw = { path = "crates/raw" }
lightcraft-codecs = { path = "crates/codecs" }
lightcraft-meta = { path = "crates/meta" }
lightcraft-develop = { path = "crates/develop" }
+lightcraft-inpaint = { path = "crates/inpaint" }
lightcraft-scenes = { path = "crates/scenes" }
lightcraft-pipeline = { path = "crates/pipeline" }
lightcraft-gpu = { path = "crates/gpu" }
diff --git a/crates/develop/src/settings.rs b/crates/develop/src/settings.rs
index 54577bffc..8ff0c1316 100644
--- a/crates/develop/src/settings.rs
+++ b/crates/develop/src/settings.rs
@@ -963,6 +963,8 @@ pub enum SpotMode {
Remove,
Heal,
Clone,
+ /// Content-aware: the spot is rebuilt from patches of its surroundings (no single source).
+ Fill,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
diff --git a/crates/engine/src/cmd/masks.rs b/crates/engine/src/cmd/masks.rs
index 24a94cbc8..c463cdeee 100644
--- a/crates/engine/src/cmd/masks.rs
+++ b/crates/engine/src/cmd/masks.rs
@@ -695,7 +695,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Add Remove Spot",
[],
None,
- "{mode?: remove|heal|clone, points: [[x,y],…], size?: fraction of long edge, feather?, opacity?, source?: [dx,dy] (default: the best match nearby)} — selects the new spot; returns {index}",
+ "{mode?: remove|heal|clone|fill (content-aware), points: [[x,y],…], size?: fraction of long edge, feather?, opacity?, source?: [dx,dy] (default: the best match nearby)} — selects the new spot; returns {index}",
has_active,
|s, p| {
let mode: SpotMode =
@@ -719,7 +719,7 @@ pub fn specs() -> Vec<CommandSpec> {
};
let id = s.active().ok_or_else(|| bad("spot.add", "no active photo"))?;
let mut dd = (*s.develop_of(id).unwrap_or_default()).clone();
- if spot.source_offset.is_none() {
+ if spot.source_offset.is_none() && spot.mode != SpotMode::Fill {
// resolve the automatic source now: it gets a pin and stays put at every size
spot.source_offset = pick_source(s, id, &dd, &spot, None);
}
diff --git a/crates/engine/src/tests_spots.rs b/crates/engine/src/tests_spots.rs
index 16bfe52b9..25fd482b7 100644
--- a/crates/engine/src/tests_spots.rs
+++ b/crates/engine/src/tests_spots.rs
@@ -55,3 +55,13 @@ fn spots_select_move_edit_refresh_and_delete() {
s.execute("library.next", &json!({})).unwrap();
assert_eq!(s.active_spot, None);
}
+
+#[test]
+fn a_content_aware_spot_has_no_source() {
+ let mut s = Session::with_demo();
+ s.execute("spot.add", &json!({"mode": "fill", "points": [[0.4, 0.5]], "size": 0.03})).unwrap();
+ let sp = &spots(&s)[0];
+ assert_eq!((sp.mode, sp.source_offset), (lightcraft_develop::SpotMode::Fill, None));
+ assert_eq!(serde_json::to_value(sp).unwrap()["mode"], "fill");
+ assert!(s.execute("spot.update", &json!({"mode": "nonsense"})).is_err());
+}
diff --git a/crates/inpaint/Cargo.toml b/crates/inpaint/Cargo.toml
new file mode 100644
index 000000000..b2d111fba
--- /dev/null
+++ b/crates/inpaint/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "lightcraft-inpaint"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Content-aware hole filling: PatchMatch-based patch completion and membrane fill (L1). Ported from PhotoCraft"
+
+[lints]
+workspace = true
+
+[dependencies]
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+rayon = { workspace = true }
diff --git a/crates/inpaint/src/lib.rs b/crates/inpaint/src/lib.rs
new file mode 100644
index 000000000..fb76304af
--- /dev/null
+++ b/crates/inpaint/src/lib.rs
@@ -0,0 +1,61 @@
+//! Content-aware hole filling (inpainting) for the Remove tool.
+//!
+//! * [`complete`]: multi-scale patch-based completion (Wexler, Shechtman, Irani 2007) with the
+//! nearest-neighbour field found by PatchMatch (Barnes et al. 2009). See [`patchmatch`].
+//! * [`membrane_fill`]: smooth harmonic fill, used to seed the coarsest level and as a fallback.
+//!
+//! Buffers are interleaved `w × h × ch` floats in any colour model plus a `w × h` hole mask.
+//! Everything is deterministic (fixed-seed RNG, results independent of the thread count) and never
+//! panics on mismatched sizes: such calls return `None` or the input unchanged.
+//!
+//! Sources: C. Barnes, E. Shechtman, A. Finkelstein, D. B. Goldman, *PatchMatch: A Randomized
+//! Correspondence Algorithm for Structural Image Editing*, SIGGRAPH 2009; Y. Wexler, E. Shechtman,
+//! M. Irani, *Space-Time Completion of Video*, PAMI 2007.
+//!
+//! Ported from PhotoCraft (`crates/algo/src/inpaint.rs`, `poisson.rs`, MIT OR Apache-2.0, same
+//! organisation; see `NOTICE`).
+
+#![forbid(unsafe_code)]
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+
+pub mod membrane;
+pub mod patchmatch;
+
+pub use membrane::membrane_fill;
+pub use patchmatch::{CompleteParams, complete, complete_with};
+
+/// A cancelled [`complete_with`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Cancelled;
+
+impl std::fmt::Display for Cancelled {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str("cancelled")
+ }
+}
+
+impl std::error::Error for Cancelled {}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn hostile_sizes_do_not_panic() {
+ assert_eq!(complete(4, 4, 3, &[0.0; 5], &[true; 16], &CompleteParams::default()), None);
+ assert_eq!(complete(4, 4, 0, &[], &[true; 16], &CompleteParams::default()), None);
+ assert_eq!(complete(usize::MAX, 2, 3, &[0.0; 6], &[true; 2], &CompleteParams::default()), None);
+ assert_eq!(membrane_fill(4, 4, 1, &[0.5; 3], &[true; 16]), vec![0.5; 3]);
+ // A hole covering everything: nothing to copy from.
+ assert_eq!(complete(16, 16, 1, &[0.5; 256], &[true; 256], &CompleteParams::default()), None);
+ // A tiny image smaller than a patch.
+ let _ = complete(2, 2, 1, &[0.5; 4], &[true, false, false, false], &CompleteParams::default());
+ }
+
+ #[test]
+ fn cancellation_stops() {
+ let img = vec![0.5f32; 64 * 64];
+ let hole: Vec<bool> = (0..64 * 64usize).map(|i| (i % 64).abs_diff(32) < 4 && (i / 64).abs_diff(32) < 4).collect();
+ assert_eq!(complete_with(64, 64, 1, &img, &hole, &CompleteParams::default(), &|| true), Err(Cancelled));
+ }
+}
diff --git a/crates/inpaint/src/membrane.rs b/crates/inpaint/src/membrane.rs
new file mode 100644
index 000000000..1f259b02f
--- /dev/null
+++ b/crates/inpaint/src/membrane.rs
@@ -0,0 +1,197 @@
+//! Membrane (harmonic) fill: `Δv = 0` inside a hole with the known pixels as Dirichlet boundary.
+//! Used to initialise the coarsest level of [`crate::complete`] and as its fallback.
+//!
+//! Sources: the membrane interpolant of P. Pérez, M. Gangnet, A. Blake, *Poisson Image Editing*,
+//! ACM SIGGRAPH 2003 (§3), solved by successive over-relaxation on the 4-connected grid, accelerated
+//! cascadically (solve on a half-resolution grid, prolong bilinearly, a few SOR sweeps per level).
+//! Ported from PhotoCraft's `algo::poisson` (MIT OR Apache-2.0).
+
+/// Convergence threshold (max per-sweep update) for the SOR sweeps.
+const TOL: f32 = 2e-5;
+/// SOR sweeps (cap) and relaxation factor on every level above the coarsest: tuned so a 96×72 disc
+/// is within ~1e-3 of a fully converged Gauss–Seidel solve (below one 8-bit step).
+const FINE_ITERS: usize = 30;
+const FINE_OMEGA: f32 = 1.7;
+
+/// Solve `Δv = 0` on `unknown` pixels with Dirichlet values from the known pixels of `v`
+/// (out-of-grid neighbours are ignored, i.e. a Neumann boundary). `v` holds the known values on
+/// entry and the solution on exit. Cascadic multigrid + SOR.
+pub(crate) fn solve_membrane(w: usize, h: usize, unknown: &[bool], v: &mut [f32]) {
+ if unknown.len() != w * h || v.len() != w * h {
+ return;
+ }
+ solve_rec(w, h, unknown, v, 0, &|| false);
+}
+
+fn solve_rec(w: usize, h: usize, unknown: &[bool], v: &mut [f32], depth: usize, stop: &(dyn Fn() -> bool + Sync)) {
+ if stop() {
+ return;
+ }
+ let n_unknown = unknown.iter().filter(|u| **u).count();
+ if n_unknown == 0 {
+ return;
+ }
+ let known: Vec<f32> = v.iter().zip(unknown).filter(|(_, u)| !**u).map(|(x, _)| *x).collect();
+ if known.is_empty() {
+ return; // nothing to interpolate from
+ }
+ if w >= 8 && h >= 8 && n_unknown > 64 && depth < 16 {
+ // Restrict: a coarse pixel is known if any of its children is (value = mean of known children).
+ let (cw, chh) = (w.div_ceil(2), h.div_ceil(2));
+ let mut cu = vec![true; cw * chh];
+ let mut cv = vec![0.0f32; cw * chh];
+ for cy in 0..chh {
+ for cx in 0..cw {
+ let (mut s, mut n) = (0.0f32, 0u32);
+ for (dx, dy) in [(0, 0), (1, 0), (0, 1), (1, 1)] {
+ let (x, y) = (cx * 2 + dx, cy * 2 + dy);
+ if x < w && y < h && !unknown[y * w + x] {
+ s += v[y * w + x];
+ n += 1;
+ }
+ }
+ if n > 0 {
+ cu[cy * cw + cx] = false;
+ cv[cy * cw + cx] = s / n as f32;
+ }
+ }
+ }
+ solve_rec(cw, chh, &cu, &mut cv, depth + 1, stop);
+ // Prolong: bilinear sample of the coarse solution as the initial guess.
+ for y in 0..h {
+ let fy = ((y as f32 + 0.5) / 2.0 - 0.5).clamp(0.0, (chh - 1) as f32);
+ let y0 = fy.floor() as usize;
+ let y1 = (y0 + 1).min(chh - 1);
+ let ty = fy - y0 as f32;
+ for x in 0..w {
+ if !unknown[y * w + x] {
+ continue;
+ }
+ let fx = ((x as f32 + 0.5) / 2.0 - 0.5).clamp(0.0, (cw - 1) as f32);
+ let x0 = fx.floor() as usize;
+ let x1 = (x0 + 1).min(cw - 1);
+ let tx = fx - x0 as f32;
+ let a = cv[y0 * cw + x0] + (cv[y0 * cw + x1] - cv[y0 * cw + x0]) * tx;
+ let b = cv[y1 * cw + x0] + (cv[y1 * cw + x1] - cv[y1 * cw + x0]) * tx;
+ v[y * w + x] = a + (b - a) * ty;
+ }
+ }
+ sor(w, h, unknown, v, FINE_ITERS, FINE_OMEGA, stop);
+ } else {
+ let mean = known.iter().sum::<f32>() / known.len() as f32;
+ for (x, u) in v.iter_mut().zip(unknown) {
+ if *u {
+ *x = mean;
+ }
+ }
+ sor(w, h, unknown, v, 2000, 1.85, stop);
+ }
+}
+
+/// SOR sweeps over the unknown pixels until the largest update drops below [`TOL`].
+fn sor(w: usize, h: usize, unknown: &[bool], v: &mut [f32], max_iter: usize, omega: f32, stop: &(dyn Fn() -> bool + Sync)) {
+ // Precompute the unknown pixels and which neighbours exist.
+ let cells: Vec<(u32, u8)> = (0..w * h)
+ .filter(|&i| unknown[i])
+ .map(|i| {
+ let (x, y) = (i % w, i / w);
+ let m = u8::from(x > 0) | (u8::from(x + 1 < w) << 1) | (u8::from(y > 0) << 2) | (u8::from(y + 1 < h) << 3);
+ (i as u32, m)
+ })
+ .collect();
+ for _ in 0..max_iter {
+ if stop() {
+ return;
+ }
+ let mut max_d = 0.0f32;
+ for &(i, m) in &cells {
+ let i = i as usize;
+ let (s, n) = if m == 0b1111 {
+ (v[i - 1] + v[i + 1] + v[i - w] + v[i + w], 4.0)
+ } else {
+ let mut s = 0.0;
+ let mut n = 0.0;
+ if m & 1 != 0 {
+ s += v[i - 1];
+ n += 1.0;
+ }
+ if m & 2 != 0 {
+ s += v[i + 1];
+ n += 1.0;
+ }
+ if m & 4 != 0 {
+ s += v[i - w];
+ n += 1.0;
+ }
+ if m & 8 != 0 {
+ s += v[i + w];
+ n += 1.0;
+ }
+ if n == 0.0 {
+ continue;
+ }
+ (s, n)
+ };
+ let d = omega * (s / n - v[i]);
+ v[i] += d;
+ max_d = max_d.max(d.abs());
+ }
+ if max_d < TOL {
+ break;
+ }
+ }
+}
+
+/// Map `f` over the channels of an interleaved buffer as planar slices (parallel on native).
+fn per_channel(w: usize, h: usize, ch: usize, f: impl Fn(usize) -> Vec<f32> + Sync + Send) -> Vec<f32> {
+ #[cfg(not(target_arch = "wasm32"))]
+ let planes: Vec<Vec<f32>> = if w * h >= 64 * 64 {
+ use rayon::prelude::*;
+ (0..ch).into_par_iter().map(&f).collect()
+ } else {
+ (0..ch).map(&f).collect()
+ };
+ #[cfg(target_arch = "wasm32")]
+ let planes: Vec<Vec<f32>> = (0..ch).map(&f).collect();
+ let mut out = vec![0.0f32; w * h * ch];
+ for (c, p) in planes.iter().enumerate() {
+ for (i, v) in p.iter().enumerate() {
+ out[i * ch + c] = *v;
+ }
+ }
+ out
+}
+
+/// Membrane fill (no source texture): harmonic interpolation of the known pixels into `hole`.
+/// `img` is interleaved `w × h × ch`, `hole` has `w × h` entries; on a size mismatch `img` comes back
+/// unchanged.
+pub fn membrane_fill(w: usize, h: usize, ch: usize, img: &[f32], hole: &[bool]) -> Vec<f32> {
+ if Some(hole.len()) != w.checked_mul(h) || Some(img.len()) != hole.len().checked_mul(ch) {
+ return img.to_vec();
+ }
+ per_channel(w, h, ch, |c| {
+ let mut v: Vec<f32> = (0..w * h).map(|i| if hole[i] { 0.0 } else { img[i * ch + c] }).collect();
+ solve_membrane(w, h, hole, &mut v);
+ v
+ })
+}
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn disc(w: usize, h: usize, cx: f32, cy: f32, r: f32) -> Vec<bool> {
+ (0..w * h).map(|i| ((i % w) as f32 - cx).hypot((i / w) as f32 - cy) < r).collect()
+ }
+
+ #[test]
+ fn membrane_reproduces_linear_boundary() {
+ // A linear function is harmonic: the solve must reproduce it exactly inside the hole.
+ let (w, h) = (80, 60);
+ let unknown = disc(w, h, 40.0, 30.0, 20.0);
+ let truth: Vec<f32> = (0..w * h).map(|i| 0.2 + 0.005 * (i % w) as f32 + 0.003 * (i / w) as f32).collect();
+ let mut v: Vec<f32> = truth.iter().zip(&unknown).map(|(t, u)| if *u { 0.0 } else { *t }).collect();
+ solve_membrane(w, h, &unknown, &mut v);
+ let err = v.iter().zip(&truth).map(|(a, b)| (a - b).abs()).fold(0.0, f32::max);
+ assert!(err < 2e-3, "{err}");
+ }
+}
diff --git a/crates/inpaint/src/patchmatch.rs b/crates/inpaint/src/patchmatch.rs
new file mode 100644
index 000000000..ea69f38d8
--- /dev/null
+++ b/crates/inpaint/src/patchmatch.rs
@@ -0,0 +1,587 @@
+//! Hole filling for Spot Healing: patch-based completion, proximity match and texture synthesis.
+//!
+//! * [`complete`], content-aware fill: the multi-scale "space-time completion" EM scheme of
+//! Y. Wexler, E. Shechtman, M. Irani, *Space-Time Completion of Video*, IEEE TPAMI 2007, with the
+//! nearest-neighbour field computed by C. Barnes, E. Shechtman, A. Finkelstein, D. B. Goldman,
+//! *PatchMatch: A Randomized Correspondence Algorithm for Structural Image Editing*, SIGGRAPH 2009
+//! (random init, propagation, exponentially shrinking random search). Each EM iteration finds, for
+//! every patch overlapping the hole, its most similar fully-known patch, then re-estimates hole
+//! pixels by a similarity-weighted vote of the overlapping matches. Coarse-to-fine over an image
+//! pyramid (the coarsest level is initialised by membrane interpolation), so large holes stay cheap.
+//! * [`best_offset`], proximity match: the single displacement whose surrounding ring best matches the
+//! ring around the hole (sum of squared differences), i.e. an automatic Healing Brush source.
+//! * [`synthesize`], create texture: patch-based texture synthesis in the style of A. Efros,
+//! W. Freeman, *Image Quilting for Texture Synthesis and Transfer*, SIGGRAPH 2001 (blocks picked from
+//! random candidates by overlap error, feathered overlap instead of a min-cut seam).
+//!
+//! Ported from PhotoCraft's `algo::inpaint` (MIT OR Apache-2.0); its proximity match and texture
+//! synthesis are left out.
+//!
+//! All functions take interleaved `w × h × ch` normalised floats (any colour model/depth) and a
+//! `w × h` hole mask, and return a full buffer equal to the input outside the hole. They are
+//! deterministic (fixed-seed hash RNG, results independent of thread count).
+
+use crate::Cancelled;
+use crate::membrane::membrane_fill;
+
+/// Below this many grid cells a level runs single-threaded (thread hand-off costs more than it saves).
+#[cfg(not(target_arch = "wasm32"))]
+const PAR_MIN: usize = 128 * 128;
+
+/// SplitMix64: tiny deterministic RNG.
+#[derive(Clone)]
+struct Rng(u64);
+impl Rng {
+ fn new(seed: u64) -> Self {
+ Rng(seed ^ 0x9E37_79B9_7F4A_7C15)
+ }
+ fn next(&mut self) -> u64 {
+ self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
+ let mut z = self.0;
+ z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+ z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+ z ^ (z >> 31)
+ }
+ /// Uniform integer in `lo..=hi`.
+ fn range(&mut self, lo: i32, hi: i32) -> i32 {
+ if hi <= lo {
+ return lo;
+ }
+ lo + (self.next() % (hi - lo + 1) as u64) as i32
+ }
+}
+
+/// Parameters for [`complete`].
+#[derive(Clone, Debug, PartialEq)]
+pub struct CompleteParams {
+ /// Patch radius (patches are `2r+1` square).
+ pub patch_radius: usize,
+ /// EM iterations at the coarsest level (finer levels use fewer, down to `min_em_iters`).
+ pub em_iters: usize,
+ pub min_em_iters: usize,
+ /// PatchMatch passes per EM iteration.
+ pub pm_iters: usize,
+ /// Levels where the hole is wider than this (in that level's pixels) only *refine* the upsampled
+ /// match field (one local PatchMatch pass and one vote), which keeps big holes tractable: the
+ /// structure is decided at coarse scale, fine levels just add detail.
+ pub refine_extent: usize,
+ pub seed: u64,
+}
+
+impl Default for CompleteParams {
+ fn default() -> Self {
+ Self { patch_radius: 3, em_iters: 8, min_em_iters: 2, pm_iters: 2, refine_extent: 96, seed: 1 }
+ }
+}
+
+/// One pyramid level.
+#[derive(Clone)]
+struct Level {
+ w: usize,
+ h: usize,
+ img: Vec<f32>,
+ hole: Vec<bool>,
+}
+
+fn downsample(l: &Level, ch: usize) -> Level {
+ let (w, h) = (l.w.div_ceil(2), l.h.div_ceil(2));
+ let mut img = vec![0.0f32; w * h * ch];
+ let mut hole = vec![false; w * h];
+ for y in 0..h {
+ for x in 0..w {
+ let mut n = 0.0f32;
+ let o = (y * w + x) * ch;
+ for (dx, dy) in [(0, 0), (1, 0), (0, 1), (1, 1)] {
+ let (sx, sy) = (x * 2 + dx, y * 2 + dy);
+ if sx >= l.w || sy >= l.h {
+ continue;
+ }
+ let si = sy * l.w + sx;
+ if l.hole[si] {
+ hole[y * w + x] = true;
+ } else {
+ for c in 0..ch {
+ img[o + c] += l.img[si * ch + c];
+ }
+ n += 1.0;
+ }
+ }
+ if n > 0.0 {
+ for c in 0..ch {
+ img[o + c] /= n;
+ }
+ }
+ }
+ }
+ Level { w, h, img, hole }
+}
+
+/// Summed-area table of a boolean grid (`(w+1) × (h+1)`).
+fn integral(w: usize, h: usize, m: &[bool]) -> Vec<u32> {
+ let mut s = vec![0u32; (w + 1) * (h + 1)];
+ for y in 0..h {
+ let mut row = 0u32;
+ for x in 0..w {
+ row += u32::from(m[y * w + x]);
+ s[(y + 1) * (w + 1) + x + 1] = s[y * (w + 1) + x + 1] + row;
+ }
+ }
+ s
+}
+
+/// Count of set cells in the clipped window `[x0, x1) × [y0, y1)`.
+fn window_count(s: &[u32], gw: usize, gh: usize, x0: i32, y0: i32, x1: i32, y1: i32) -> u32 {
+ let (x0, y0) = (x0.max(0) as usize, y0.max(0) as usize);
+ let (x1, y1) = ((x1.max(0) as usize).min(gw), (y1.max(0) as usize).min(gh));
+ if x1 <= x0 || y1 <= y0 {
+ return 0;
+ }
+ let w1 = gw + 1;
+ s[y1 * w1 + x1] + s[y0 * w1 + x0] - s[y0 * w1 + x1] - s[y1 * w1 + x0]
+}
+
+fn hole_bbox(w: usize, h: usize, hole: &[bool]) -> Option<(usize, usize, usize, usize)> {
+ let mut b: Option<(usize, usize, usize, usize)> = None;
+ for y in 0..h {
+ for x in 0..w {
+ if hole[y * w + x] {
+ b = Some(match b {
+ None => (x, y, x + 1, y + 1),
+ Some((x0, y0, x1, y1)) => (x0.min(x), y0.min(y), x1.max(x + 1), y1.max(y + 1)),
+ });
+ }
+ }
+ }
+ b
+}
+
+/// Per-level PatchMatch/EM state.
+struct Solver<'a> {
+ w: usize,
+ h: usize,
+ ch: usize,
+ r: i32,
+ img: &'a mut Vec<f32>,
+ hole: &'a [bool],
+ /// Valid source centres: the whole patch is inside the grid and contains no hole pixel.
+ valid: Vec<bool>,
+ valid_list: Vec<(i32, i32)>,
+ /// Target centres (patch overlaps the hole), row-major.
+ targets: Vec<bool>,
+ /// Cancellation: checked per row band; a cancelled solve's output is discarded.
+ ctl: &'a (dyn Fn() -> bool + Sync),
+}
+
+impl Solver<'_> {
+ #[inline]
+ fn is_valid(&self, x: i32, y: i32) -> bool {
+ x >= 0 && y >= 0 && (x as usize) < self.w && (y as usize) < self.h && self.valid[y as usize * self.w + x as usize]
+ }
+
+ /// SSD between the (clipped) target patch at `t` and the source patch at `s`, per sample.
+ fn dist(&self, t: (i32, i32), s: (i32, i32), cutoff: f32) -> f32 {
+ let (w, h, ch, r) = (self.w as i32, self.h as i32, self.ch, self.r);
+ let full = ((2 * r + 1) * (2 * r + 1)) as f32 * ch as f32;
+ let mut sum = 0.0f32;
+ let mut n = 0usize;
+ for dy in -r..=r {
+ let ty = t.1 + dy;
+ if ty < 0 || ty >= h {
+ continue;
+ }
+ let sy = s.1 + dy;
+ for dx in -r..=r {
+ let tx = t.0 + dx;
+ if tx < 0 || tx >= w {
+ continue;
+ }
+ let ti = (ty as usize * self.w + tx as usize) * ch;
+ let si = (sy as usize * self.w + (s.0 + dx) as usize) * ch;
+ for c in 0..ch {
+ let d = self.img[ti + c] - self.img[si + c];
+ sum += d * d;
+ }
+ n += ch;
+ }
+ // Early out: the mean can only be ≥ sum / (full patch size).
+ if sum > cutoff * full {
+ return f32::INFINITY;
+ }
+ }
+ if n == 0 { f32::INFINITY } else { sum / n as f32 }
+ }
+
+ /// One PatchMatch pass over all target rows, in parallel bands (each band propagates within itself).
+ fn patchmatch(&self, nnf: &mut [(i32, i32)], cost: &mut [f32], pass: usize, seed: u64, search_radius: i32) {
+ const BAND: usize = 16;
+ let w = self.w;
+ let reverse = pass % 2 == 1;
+ let band_fn = |bi: usize, nn: &mut [(i32, i32)], co: &mut [f32]| {
+ if (self.ctl)() {
+ return;
+ }
+ let mut rng = Rng::new(seed ^ (bi as u64).wrapping_mul(0x2545_F491_4F6C_DD1D) ^ ((pass as u64) << 40));
+ let y0 = bi * BAND;
+ let rows = nn.len() / w;
+ let step: i32 = if reverse { -1 } else { 1 };
+ for ry in 0..rows {
+ let ly = if reverse { rows - 1 - ry } else { ry };
+ let y = y0 + ly;
+ for rx in 0..w {
+ let x = if reverse { w - 1 - rx } else { rx };
+ let li = ly * w + x;
+ if !self.targets[y * w + x] {
+ continue;
+ }
+ let t = (x as i32, y as i32);
+ let (mut best, mut bc) = (nn[li], co[li]);
+ // Propagation from the already-visited neighbours (within this band).
+ let nx = x as i32 - step;
+ if nx >= 0 && (nx as usize) < w {
+ let c = nn[ly * w + nx as usize];
+ let cand = (c.0 + step, c.1);
+ if self.is_valid(cand.0, cand.1) && cand != best {
+ let d = self.dist(t, cand, bc);
+ if d < bc {
+ (best, bc) = (cand, d);
+ }
+ }
+ }
+ let nly = ly as i32 - step;
+ if nly >= 0 && (nly as usize) < rows {
+ let c = nn[nly as usize * w + x];
+ let cand = (c.0, c.1 + step);
+ if self.is_valid(cand.0, cand.1) && cand != best {
+ let d = self.dist(t, cand, bc);
+ if d < bc {
+ (best, bc) = (cand, d);
+ }
+ }
+ }
+ // Random search in exponentially shrinking windows.
+ let mut rad = search_radius;
+ while rad >= 1 {
+ let cand = (best.0 + rng.range(-rad, rad), best.1 + rng.range(-rad, rad));
+ if self.is_valid(cand.0, cand.1) && cand != best {
+ let d = self.dist(t, cand, bc);
+ if d < bc {
+ (best, bc) = (cand, d);
+ }
+ }
+ rad /= 2;
+ }
+ nn[li] = best;
+ co[li] = bc;
+ }
+ }
+ };
+ #[cfg(not(target_arch = "wasm32"))]
+ if w * self.h >= PAR_MIN {
+ use rayon::prelude::*;
+ nnf.par_chunks_mut(BAND * w).zip(cost.par_chunks_mut(BAND * w)).enumerate().for_each(|(bi, (nn, co))| band_fn(bi, nn, co));
+ return;
+ }
+ for (bi, (nn, co)) in nnf.chunks_mut(BAND * w).zip(cost.chunks_mut(BAND * w)).enumerate() {
+ band_fn(bi, nn, co);
+ }
+ }
+
+ /// Re-estimate hole pixels by a similarity-weighted vote of all overlapping patch matches.
+ fn vote(&mut self, nnf: &[(i32, i32)], cost: &[f32]) {
+ let (w, h, ch, r) = (self.w, self.h, self.ch, self.r);
+ // σ² from the 75th percentile of match costs (Wexler et al. use a robust scale like this).
+ let mut cs: Vec<f32> = cost.iter().zip(&self.targets).filter(|(c, t)| **t && c.is_finite()).map(|(c, _)| *c).collect();
+ let sigma2 = if cs.is_empty() {
+ 1.0
+ } else {
+ let k = (cs.len() * 3 / 4).min(cs.len() - 1);
+ let (_, v, _) = cs.select_nth_unstable_by(k, |a, b| a.total_cmp(b));
+ v.max(1e-6)
+ };
+ let img = &*self.img;
+ let row = |y: usize| -> Vec<(usize, Vec<f32>)> {
+ let mut out = Vec::new();
+ if (self.ctl)() {
+ return out;
+ }
+ for x in 0..w {
+ if !self.hole[y * w + x] {
+ continue;
+ }
+ let mut acc = vec![0.0f32; ch];
+ let mut wsum = 0.0f32;
+ for dy in -r..=r {
+ let ty = y as i32 + dy;
+ if ty < 0 || ty as usize >= h {
+ continue;
+ }
+ for dx in -r..=r {
+ let tx = x as i32 + dx;
+ if tx < 0 || tx as usize >= w {
+ continue;
+ }
+ let ti = ty as usize * w + tx as usize;
+ if !self.targets[ti] || !cost[ti].is_finite() {
+ continue;
+ }
+ let s = nnf[ti];
+ let (sx, sy) = (s.0 - dx, s.1 - dy);
+ let wt = (-cost[ti] / (2.0 * sigma2)).exp().max(1e-8);
+ let si = (sy as usize * w + sx as usize) * ch;
+ for c in 0..ch {
+ acc[c] += img[si + c] * wt;
+ }
+ wsum += wt;
+ }
+ }
+ if wsum > 0.0 {
+ acc.iter_mut().for_each(|v| *v /= wsum);
+ out.push((x, acc));
+ }
+ }
+ out
+ };
+ #[cfg(not(target_arch = "wasm32"))]
+ let rows: Vec<Vec<(usize, Vec<f32>)>> = if w * h >= PAR_MIN {
+ use rayon::prelude::*;
+ (0..h).into_par_iter().map(row).collect()
+ } else {
+ (0..h).map(row).collect()
+ };
+ #[cfg(target_arch = "wasm32")]
+ let rows: Vec<Vec<(usize, Vec<f32>)>> = (0..h).map(row).collect();
+ for (y, r) in rows.into_iter().enumerate() {
+ for (x, v) in r {
+ self.img[(y * w + x) * ch..(y * w + x + 1) * ch].copy_from_slice(&v);
+ }
+ }
+ }
+}
+
+/// Content-aware completion of `hole` (see module docs). Returns `None` when there is no fully-known
+/// patch to copy from (the caller can fall back to [`membrane_fill`]).
+pub fn complete(w: usize, h: usize, ch: usize, img: &[f32], hole: &[bool], p: &CompleteParams) -> Option<Vec<f32>> {
+ // Never cancelled, so never `Err`.
+ complete_with(w, h, ch, img, hole, p, &|| false).unwrap_or(None)
+}
+
+/// [`complete`] that can be cancelled (checked per EM iteration, PatchMatch pass and row band)
+/// (`cancelled` is polled per EM iteration, PatchMatch pass and row band): `Err(Cancelled)` once it
+/// returned `true`. `Ok(None)` also for mismatched buffer sizes or `ch == 0`.
+pub fn complete_with(
+ w: usize,
+ h: usize,
+ ch: usize,
+ img: &[f32],
+ hole: &[bool],
+ p: &CompleteParams,
+ cancelled: &(dyn Fn() -> bool + Sync),
+) -> Result<Option<Vec<f32>>, Cancelled> {
+ let check = || if cancelled() { Err(Cancelled) } else { Ok(()) };
+ if ch == 0 || Some(hole.len()) != w.checked_mul(h) || Some(img.len()) != hole.len().checked_mul(ch) {
+ return Ok(None);
+ }
+ let Some((bx0, by0, bx1, by1)) = hole_bbox(w, h, hole) else { return Ok(Some(img.to_vec())) };
+ let r = p.patch_radius.max(1);
+ let psz = 2 * r + 1;
+ // Pyramid: shrink until the hole is a few patches across.
+ let mut levels = vec![Level { w, h, img: img.to_vec(), hole: hole.to_vec() }];
+ let mut ext = (bx1 - bx0).max(by1 - by0);
+ let mut exts = vec![ext];
+ while let Some(l) = levels.last() {
+ check()?;
+ if ext <= 2 * psz || l.w / 2 < 3 * psz || l.h / 2 < 3 * psz {
+ break;
+ }
+ let d = downsample(l, ch);
+ levels.push(d);
+ ext = ext.div_ceil(2);
+ exts.push(ext);
+ }
+ let nlev = levels.len();
+ let mut nnf: Vec<(i32, i32)> = Vec::new();
+ let mut prev: Option<(usize, usize, Vec<f32>)> = None;
+ for li in (0..nlev).rev() {
+ check()?;
+ let Level { w: lw, h: lh, img: mut limg, hole: lhole } = levels[li].clone();
+ // Initialise the hole: membrane at the coarsest level, upsampled result elsewhere.
+ match &prev {
+ None => limg = membrane_fill(lw, lh, ch, &limg, &lhole),
+ Some((pw, ph, pimg)) => {
+ for y in 0..lh {
+ for x in 0..lw {
+ if lhole[y * lw + x] {
+ let (sx, sy) = ((x / 2).min(pw - 1), (y / 2).min(ph - 1));
+ let (d, s) = ((y * lw + x) * ch, (sy * pw + sx) * ch);
+ limg[d..d + ch].copy_from_slice(&pimg[s..s + ch]);
+ }
+ }
+ }
+ }
+ }
+ let ri = r as i32;
+ let hs = integral(lw, lh, &lhole);
+ let mut valid = vec![false; lw * lh];
+ let mut valid_list = Vec::new();
+ let mut targets = vec![false; lw * lh];
+ for y in 0..lh as i32 {
+ if y % 32 == 0 {
+ check()?;
+ }
+ for x in 0..lw as i32 {
+ let cnt = window_count(&hs, lw, lh, x - ri, y - ri, x + ri + 1, y + ri + 1);
+ let inside = x >= ri && y >= ri && x + ri < lw as i32 && y + ri < lh as i32;
+ let i = y as usize * lw + x as usize;
+ if inside && cnt == 0 {
+ valid[i] = true;
+ valid_list.push((x, y));
+ }
+ targets[i] = cnt > 0;
+ }
+ }
+ if valid_list.is_empty() {
+ if li == 0 {
+ return Ok(None);
+ }
+ prev = Some((lw, lh, limg));
+ nnf.clear();
+ continue;
+ }
+ let mut solver = Solver { w: lw, h: lh, ch, r: ri, img: &mut limg, hole: &lhole, valid, valid_list, targets, ctl: cancelled };
+ // NNF init: upsampled from the coarser level where possible, random otherwise.
+ let mut rng = Rng::new(p.seed ^ (li as u64) << 20);
+ let pw_prev = prev.as_ref().map_or(0, |p| p.0);
+ let old = std::mem::take(&mut nnf);
+ let mut new_nnf = vec![(0i32, 0i32); lw * lh];
+ for y in 0..lh {
+ if y % 32 == 0 {
+ check()?;
+ }
+ for x in 0..lw {
+ if !solver.targets[y * lw + x] {
+ continue;
+ }
+ let mut cand = None;
+ if !old.is_empty() && pw_prev > 0 {
+ let pi = (y / 2) * pw_prev + (x / 2);
+ if let Some(&(sx, sy)) = old.get(pi) {
+ let c = (sx * 2 + (x % 2) as i32, sy * 2 + (y % 2) as i32);
+ if solver.is_valid(c.0, c.1) {
+ cand = Some(c);
+ }
+ }
+ }
+ new_nnf[y * lw + x] = cand.unwrap_or_else(|| solver.valid_list[(rng.next() % solver.valid_list.len() as u64) as usize]);
+ }
+ }
+ nnf = new_nnf;
+ let refine_only = li + 1 < nlev && exts[li] > p.refine_extent;
+ let em = if li + 1 == nlev {
+ p.em_iters
+ } else if refine_only {
+ 1
+ } else {
+ (p.em_iters >> (nlev - 1 - li)).max(p.min_em_iters)
+ };
+ let pm_iters = if refine_only { 1 } else { p.pm_iters };
+ let full_search = (lw.max(lh)) as i32;
+ let mut cost = vec![f32::INFINITY; lw * lh];
+ for it in 0..em {
+ // Costs change as hole pixels are re-estimated: refresh before each PatchMatch.
+ for (i, c) in cost.iter_mut().enumerate() {
+ if i % (lw * 32).max(1) == 0 {
+ check()?;
+ }
+ if solver.targets[i] {
+ *c = solver.dist(((i % lw) as i32, (i / lw) as i32), nnf[i], f32::INFINITY);
+ }
+ }
+ // Wide random search on coarse levels / first iteration, local refinement afterwards.
+ let radius = if refine_only {
+ 2
+ } else if li + 1 == nlev || it == 0 {
+ full_search
+ } else {
+ (4 * psz as i32).min(full_search)
+ };
+ for pass in 0..pm_iters {
+ check()?;
+ solver.patchmatch(&mut nnf, &mut cost, pass + it * pm_iters, p.seed.wrapping_add((li * 1000 + it) as u64), radius);
+ }
+ check()?;
+ solver.vote(&nnf, &cost);
+ check()?;
+ }
+ prev = Some((lw, lh, limg));
+ }
+ Ok(prev.map(|(_, _, img)| img))
+}
+
+/// Proximity match: the displacement `(dx, dy)` (within `max_radius`) whose surroundings best match the
+/// ring of `ring` pixels around the hole, with the displaced hole fully inside the grid and outside the
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ /// Smooth gradient plus deterministic fine noise.
+ fn texture(w: usize, h: usize) -> Vec<f32> {
+ let mut rng = Rng::new(7);
+ (0..w * h)
+ .flat_map(|i| {
+ let (x, y) = ((i % w) as f32, (i / w) as f32);
+ let n = (rng.next() % 1000) as f32 / 1000.0 * 0.04 - 0.02;
+ [0.3 + 0.004 * x + n, 0.5 + 0.002 * y + n, 0.4 + n]
+ })
+ .collect()
+ }
+
+ fn disc(w: usize, h: usize, cx: f32, cy: f32, r: f32) -> Vec<bool> {
+ (0..w * h).map(|i| ((i % w) as f32 - cx).hypot((i / w) as f32 - cy) < r).collect()
+ }
+
+ fn hole_rmse(a: &[f32], b: &[f32], hole: &[bool], ch: usize) -> f32 {
+ let (mut e, mut n) = (0.0f32, 0);
+ for (i, hh) in hole.iter().enumerate() {
+ if *hh {
+ for c in 0..ch {
+ e += (a[i * ch + c] - b[i * ch + c]).powi(2);
+ n += 1;
+ }
+ }
+ }
+ (e / n as f32).sqrt()
+ }
+
+ #[test]
+ fn completion_fills_blemish_from_texture() {
+ let (w, h, ch) = (96, 96, 3);
+ let clean = texture(w, h);
+ let hole = disc(w, h, 48.0, 48.0, 9.0);
+ let mut dirty = clean.clone();
+ for (i, hh) in hole.iter().enumerate() {
+ if *hh {
+ dirty[i * ch..i * ch + ch].copy_from_slice(&[0.02, 0.02, 0.02]);
+ }
+ }
+ let out = complete(w, h, ch, &dirty, &hole, &CompleteParams::default()).unwrap();
+ let before = hole_rmse(&dirty, &clean, &hole, ch);
+ let after = hole_rmse(&out, &clean, &hole, ch);
+ assert!(after < 0.06 && after < before * 0.15, "rmse before {before} after {after}");
+ // Outside the hole untouched.
+ assert!(out.iter().zip(&dirty).zip(hole.iter().flat_map(|h| [*h; 3])).all(|((a, b), h)| h || a == b));
+ // Deterministic.
+ assert_eq!(out, complete(w, h, ch, &dirty, &hole, &CompleteParams::default()).unwrap());
+ }
+
+ #[test]
+ fn completion_continues_structure() {
+ // Vertical stripes: the filled hole should keep the stripes (not a blur).
+ let (w, h, ch) = (80, 80, 1);
+ let clean: Vec<f32> = (0..w * h).map(|i| if (i % w / 4) % 2 == 0 { 0.2 } else { 0.8 }).collect();
+ let hole = disc(w, h, 40.0, 40.0, 7.0);
+ let dirty: Vec<f32> = clean.iter().zip(&hole).map(|(c, h)| if *h { 0.5 } else { *c }).collect();
+ let out = complete(w, h, ch, &dirty, &hole, &CompleteParams::default()).unwrap();
+ let err = hole_rmse(&out, &clean, &hole, ch);
+ assert!(err < 0.15, "{err}");
+ }
+}
diff --git a/crates/pipeline/Cargo.toml b/crates/pipeline/Cargo.toml
index c8219f025..197020e45 100644
--- a/crates/pipeline/Cargo.toml
+++ b/crates/pipeline/Cargo.toml
@@ -14,6 +14,7 @@ lightcraft-color = { workspace = true }
lightcraft-raster = { workspace = true }
lightcraft-develop = { workspace = true }
lightcraft-raw = { workspace = true }
+lightcraft-inpaint = { workspace = true }
rayon = { workspace = true }
serde = { workspace = true }
diff --git a/crates/pipeline/src/spots.rs b/crates/pipeline/src/spots.rs
index c50bcf799..483f83f3c 100644
--- a/crates/pipeline/src/spots.rs
+++ b/crates/pipeline/src/spots.rs
@@ -5,6 +5,10 @@
//! (frequency separation — a fast, stable approximation of gradient-domain healing).
//! - **Remove** is Heal with an automatically chosen source: candidate offsets on rings around the
//! spot are scored by how well the source's surrounding annulus matches the target's.
+//! - **Fill** (content-aware) rebuilds the spot from patches of its surroundings instead of one
+//! source: PatchMatch-based completion ([`lightcraft_inpaint::complete`]), coarse to fine, so the
+//! structure is chosen at a scale set by the spot's size (the same at preview and export size).
+//! Deterministic; the source offset is ignored.
use lightcraft_develop::{Spot, SpotMode};
use lightcraft_geom::Point;
@@ -235,6 +239,19 @@ pub fn window_for_reads_checked(
)
}
+/// Content-aware fill of the box: `src` becomes `tgt` with every pixel under the stroke (`alpha > 0`)
+/// rebuilt from the rest of the box. Falls back to a smooth membrane fill when the box holds no whole
+/// patch to copy from.
+fn fill_box(src: &mut [[f32; 3]], tgt: &[[f32; 3]], alpha: &[f32], bw: usize, bh: usize) {
+ let hole: Vec<bool> = alpha.iter().map(|a| *a > 0.0).collect();
+ let flat: Vec<f32> = tgt.iter().flatten().copied().collect();
+ let out = lightcraft_inpaint::complete(bw, bh, 3, &flat, &hole, &lightcraft_inpaint::CompleteParams::default())
+ .unwrap_or_else(|| lightcraft_inpaint::membrane_fill(bw, bh, 3, &flat, &hole));
+ for (d, v) in src.iter_mut().zip(out.chunks_exact(3)) {
+ *d = [v[0], v[1], v[2]];
+ }
+}
+
/// Apply all spots to `img` (output resolution). `ppl` = output pixels per long-edge unit.
pub fn apply(img: &mut Rgb32f, spots: &[Spot], frame: &Frame, ppl: f64) {
if spots.is_empty() {
@@ -253,7 +270,9 @@ pub fn apply(img: &mut Rgb32f, spots: &[Spot], frame: &Frame, ppl: f64) {
})
.collect();
let Some(&first) = pts.first() else { continue };
+ let fill = spot.mode == SpotMode::Fill;
let offset = match spot.source_offset {
+ _ if fill => (0.0, 0.0),
Some(o) => {
let a = to_out.apply(Point::new(0.0, 0.0));
let b = to_out.apply(o);
@@ -269,7 +288,8 @@ pub fn apply(img: &mut Rgb32f, spots: &[Spot], frame: &Frame, ppl: f64) {
x1 = x1.max(p.0 + r);
y1 = y1.max(p.1 + r);
}
- let pad = r;
+ // content-aware fill reads the spot's surroundings (the window holds 2 radii around it)
+ let pad = if fill { 2.0 * r } else { r };
let (bx0, by0) = (((x0 - pad).floor().max(0.0)) as usize, ((y0 - pad).floor().max(0.0)) as usize);
let (bx1, by1) = (((x1 + pad).ceil() as usize).min(w), ((y1 + pad).ceil() as usize).min(h));
if bx1 <= bx0 || by1 <= by0 {
@@ -292,7 +312,10 @@ pub fn apply(img: &mut Rgb32f, spots: &[Spot], frame: &Frame, ppl: f64) {
tgt[y * bw + x] = img.get(bx0 + x, by0 + y);
}
}
- let heal = spot.mode != SpotMode::Clone;
+ if fill {
+ fill_box(&mut src, &tgt, &alpha, bw, bh);
+ }
+ let heal = matches!(spot.mode, SpotMode::Remove | SpotMode::Heal);
let low = if heal {
// Tone correction from the spot's *surroundings* only: normalized convolution of
// (target − source) over pixels outside the stroke (a membrane-like interpolation).
@@ -361,6 +384,79 @@ mod tests {
assert!((c[0] - 0.26).abs() < 0.03, "{c:?}");
}
+ /// Vertical stripes (period `period` px) with a black blot over the middle.
+ fn striped_with_blot(w: usize, h: usize, period: usize) -> Rgb32f {
+ let mut img = Rgb32f::from_fn(w, h, |x, _| if (x / period).is_multiple_of(2) { [0.2; 3] } else { [0.7; 3] });
+ let (cx, cy, r) = (w as f32 / 2.0, h as f32 / 2.0, w as f32 * 0.04);
+ for y in 0..h {
+ for x in 0..w {
+ if (x as f32 + 0.5 - cx).hypot(y as f32 + 0.5 - cy) < r {
+ img.set(x, y, [0.0; 3]);
+ }
+ }
+ }
+ img
+ }
+
+ fn fill_spot() -> Spot {
+ // a source offset is ignored by Fill
+ Spot {
+ mode: SpotMode::Fill,
+ points: vec![Point::new(0.5, 0.5)],
+ size: 0.06,
+ feather: 0.0,
+ source_offset: Some(Point::new(0.3, 0.0)),
+ ..Default::default()
+ }
+ }
+
+ #[test]
+ fn fill_rebuilds_structure_deterministically() {
+ let (w, h) = (200, 160);
+ let mut img = striped_with_blot(w, h, 8);
+ let frame = Frame::new(w, h, &DevelopSettings::default(), true);
+ apply(&mut img, &[fill_spot()], &frame, frame.px_per_long(w));
+ // the blot is gone and the stripes continue through it
+ let mut err = 0.0f32;
+ for x in 90..110 {
+ let want = if (x / 8) % 2 == 0 { 0.2 } else { 0.7 };
+ err += (img.get(x, 80)[0] - want).abs();
+ }
+ assert!(err / 20.0 < 0.12, "mean error {}", err / 20.0);
+ let mut again = striped_with_blot(w, h, 8);
+ apply(&mut again, &[fill_spot()], &frame, frame.px_per_long(w));
+ assert_eq!(img.data, again.data);
+ }
+
+ #[test]
+ fn fill_matches_between_preview_and_export_size() {
+ // the same photo at two sizes: the half-size fill matches the full-size one, downsampled
+ let (mut big, mut small) = (striped_with_blot(320, 240, 16), striped_with_blot(160, 120, 8));
+ let (fb, fs) = (Frame::new(320, 240, &DevelopSettings::default(), true), Frame::new(160, 120, &DevelopSettings::default(), true));
+ apply(&mut big, &[fill_spot()], &fb, fb.px_per_long(320));
+ apply(&mut small, &[fill_spot()], &fs, fs.px_per_long(160));
+ let (mut err, mut n) = (0.0f32, 0);
+ for y in 50..70 {
+ for x in 70..90 {
+ let b: f32 = [(0, 0), (1, 0), (0, 1), (1, 1)].iter().map(|(dx, dy)| big.get(2 * x + dx, 2 * y + dy)[0]).sum::<f32>() / 4.0;
+ err += (b - small.get(x, y)[0]).abs();
+ n += 1;
+ }
+ }
+ assert!(err / n as f32 <= 0.08, "mean difference {}", err / n as f32);
+ }
+
+ #[test]
+ fn fill_survives_hostile_spots() {
+ let frame = Frame::new(40, 30, &DevelopSettings::default(), true);
+ for (p, size) in [((0.0, 0.0), 2.0), ((-5.0, 9.0), 0.1), ((0.5, 0.5), 0.0), ((f64::NAN, 0.5), 0.1), ((0.5, 0.5), f64::INFINITY)] {
+ let mut img = Rgb32f::from_fn(40, 30, |x, _| [x as f32 / 40.0; 3]);
+ let spot = Spot { mode: SpotMode::Fill, points: vec![Point::new(p.0, p.1)], size, ..Default::default() };
+ apply(&mut img, &[spot], &frame, frame.px_per_long(40));
+ assert!(img.data.iter().flatten().all(|v| v.is_finite()));
+ }
+ }
+
#[test]
fn clone_copies_source() {
let mut img = Rgb32f::from_fn(100, 100, |x, _| if x < 50 { [0.1; 3] } else { [0.9; 3] });
diff --git a/crates/ui-egui/locales/de.json b/crates/ui-egui/locales/de.json
index 6520fb3e3..a4169bad1 100644
--- a/crates/ui-egui/locales/de.json
+++ b/crates/ui-egui/locales/de.json
@@ -2039,5 +2039,6 @@
"Downloading model": "Modell wird heruntergeladen",
"Finding faces": "Gesichter werden gesucht",
"Synchronizing folder": "Ordner wird synchronisiert",
- "Looking for changes": "Änderungen werden gesucht"
+ "Looking for changes": "Änderungen werden gesucht",
+ "Content-Aware": "Inhaltsbasiert"
}
diff --git a/crates/ui-egui/locales/es.json b/crates/ui-egui/locales/es.json
index fc53b6392..9920b9e61 100644
--- a/crates/ui-egui/locales/es.json
+++ b/crates/ui-egui/locales/es.json
@@ -1884,5 +1884,6 @@
"Downloading model": "Descargando modelo",
"Finding faces": "Buscando caras",
"Synchronizing folder": "Sincronizando carpeta",
- "Looking for changes": "Buscando cambios"
+ "Looking for changes": "Buscando cambios",
+ "Content-Aware": "Según el contenido"
}
diff --git a/crates/ui-egui/locales/fr.json b/crates/ui-egui/locales/fr.json
index 53509a503..bbea4b894 100644
--- a/crates/ui-egui/locales/fr.json
+++ b/crates/ui-egui/locales/fr.json
@@ -1884,5 +1884,6 @@
"Panels": "Panels",
"Reset Panel Layout": "Reset Panel Layout",
"Resize panel window": "Resize panel window",
- "Resize panels": "Resize panels"
+ "Resize panels": "Resize panels",
+ "Content-Aware": "Contenu pris en compte"
}
diff --git a/crates/ui-egui/locales/ja.json b/crates/ui-egui/locales/ja.json
index 2babd30b6..9556aa280 100644
--- a/crates/ui-egui/locales/ja.json
+++ b/crates/ui-egui/locales/ja.json
@@ -1886,5 +1886,6 @@
"Downloading model": "モデルをダウンロード中",
"Finding faces": "顔を検索中",
"Synchronizing folder": "フォルダを同期中",
- "Looking for changes": "変更を確認中"
+ "Looking for changes": "変更を確認中",
+ "Content-Aware": "コンテンツに応じる"
}
diff --git a/crates/ui-egui/locales/pt-br.json b/crates/ui-egui/locales/pt-br.json
index dfe472818..b4ac44cc5 100644
--- a/crates/ui-egui/locales/pt-br.json
+++ b/crates/ui-egui/locales/pt-br.json
@@ -1884,5 +1884,6 @@
"Downloading model": "Baixando modelo",
"Finding faces": "Procurando rostos",
"Synchronizing folder": "Sincronizando pasta",
- "Looking for changes": "Procurando alterações"
+ "Looking for changes": "Procurando alterações",
+ "Content-Aware": "Sensível ao conteúdo"
}
diff --git a/crates/ui-egui/locales/ru.json b/crates/ui-egui/locales/ru.json
index fafb65a14..d1331062f 100644
--- a/crates/ui-egui/locales/ru.json
+++ b/crates/ui-egui/locales/ru.json
@@ -1598,5 +1598,6 @@
"Finding faces": "Поиск лиц",
"Quit Anyway": "Всё равно выйти",
"Synchronizing folder": "Синхронизация папки",
- "Looking for changes": "Поиск изменений"
+ "Looking for changes": "Поиск изменений",
+ "Content-Aware": "С учётом содержимого"
}
diff --git a/crates/ui-egui/locales/uk.json b/crates/ui-egui/locales/uk.json
index 7ebad5b10..f09bee86a 100644
--- a/crates/ui-egui/locales/uk.json
+++ b/crates/ui-egui/locales/uk.json
@@ -2078,5 +2078,6 @@
"Panels": "Panels",
"Reset Panel Layout": "Reset Panel Layout",
"Resize panel window": "Resize panel window",
- "Resize panels": "Resize panels"
+ "Resize panels": "Resize panels",
+ "Content-Aware": "З урахуванням вмісту"
}
diff --git a/crates/ui-egui/locales/zh-hans.json b/crates/ui-egui/locales/zh-hans.json
index 8a0e58b8e..ef587fe3e 100644
--- a/crates/ui-egui/locales/zh-hans.json
+++ b/crates/ui-egui/locales/zh-hans.json
@@ -1884,5 +1884,6 @@
"Downloading model": "正在下载模型",
"Finding faces": "正在查找人脸",
"Synchronizing folder": "正在同步文件夹",
- "Looking for changes": "正在查找更改"
+ "Looking for changes": "正在查找更改",
+ "Content-Aware": "内容识别"
}
diff --git a/crates/ui-egui/locales/zh-hant.json b/crates/ui-egui/locales/zh-hant.json
index f1cbec3a0..4c9bb8689 100644
--- a/crates/ui-egui/locales/zh-hant.json
+++ b/crates/ui-egui/locales/zh-hant.json
@@ -1884,5 +1884,6 @@
"Downloading model": "正在下載模型",
"Finding faces": "正在尋找臉孔",
"Synchronizing folder": "正在同步資料夾",
- "Looking for changes": "正在尋找變更"
+ "Looking for changes": "正在尋找變更",
+ "Content-Aware": "內容感知"
}
diff --git a/crates/ui-egui/src/panels/detail.rs b/crates/ui-egui/src/panels/detail.rs
index c3678ae20..eb2bcd2f9 100644
--- a/crates/ui-egui/src/panels/detail.rs
+++ b/crates/ui-egui/src/panels/detail.rs
@@ -1875,6 +1875,7 @@ fn remove_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Respo
let mode = match app.ui.tool.as_str() {
"heal" => "heal",
"clone" => "clone",
+ "fill" => "fill",
_ => "remove",
};
let pts: Vec<[f64; 2]> = points.iter().map(|q| [q.x, q.y]).collect();
diff --git a/crates/ui-egui/src/panels/right.rs b/crates/ui-egui/src/panels/right.rs
index 1c5a04ad9..f7c8c145e 100644
--- a/crates/ui-egui/src/panels/right.rs
+++ b/crates/ui-egui/src/panels/right.rs
@@ -343,7 +343,7 @@ fn remove(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {
header(ui, "Remove");
padded(ui, |ui| {
ui.horizontal_wrapped(|ui| {
- for (label, tool) in [("Remove", "remove"), ("Heal", "heal"), ("Clone", "clone")] {
+ for (label, tool) in [("Remove", "remove"), ("Content-Aware", "fill"), ("Heal", "heal"), ("Clone", "clone")] {
if text_button(ui, &format!("removeMode-{tool}"), label, app.ui.tool == tool).clicked() {
app.ui.tool = tool.into();
}
@@ -383,6 +383,7 @@ fn remove(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {
lightcraft_develop::SpotMode::Heal => "Heal",
lightcraft_develop::SpotMode::Clone => "Clone",
lightcraft_develop::SpotMode::Remove => "Remove",
+ lightcraft_develop::SpotMode::Fill => "Content-Aware",
};
super::edit::sub_title(ui, &crate::i18n::tr_format!("{mode} spot {} of {}", i + 1, d.spots.len(), mode = mode));
}
diff --git a/xtask/src/layers.rs b/xtask/src/layers.rs
index 4443cb230..2ad481d8f 100644
--- a/xtask/src/layers.rs
+++ b/xtask/src/layers.rs
@@ -46,6 +46,7 @@ pub const TABLE: &[(&str, Class)] = &[
("codecs", Class::Layer(1)),
("meta", Class::Layer(1)),
("develop", Class::Layer(1)),
+ ("inpaint", Class::Layer(1)),
("faces", Class::Layer(1)),
("scenes", Class::Layer(1)),
("pipeline", Class::Layer(2)),