Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

effects: speed up Match Grain's CPU analysis

Camille Moinea05d97a0e929
diff --git a/crates/effects/src/noise.rs b/crates/effects/src/noise.rs
index d39fd6528..9d21e77a7 100644
--- a/crates/effects/src/noise.rs
+++ b/crates/effects/src/noise.rs
@@ -264,25 +264,30 @@ pub(crate) fn sample_boxes(img: &Image, count: usize, size: usize) -> Vec<(usize
}
let low = Plane::luma(img);
let step = (size / 2).max(1);
- let mut cands: Vec<(f32, usize, usize)> = Vec::new();
- for y in (0..=h - size).step_by(step) {
- for x in (0..=w - size).step_by(step) {
- // Variance of the picture inside the box (the flattest boxes hold the least detail).
- let (mut s, mut sq, mut n, mut opaque) = (0.0f32, 0.0f32, 0.0f32, true);
- for yy in y..y + size {
- for xx in x..x + size {
- let v = low.data[yy * w + xx];
- s += v;
- sq += v * v;
- n += 1.0;
- opaque &= img.data[yy * w + xx][3] > 0.5;
+ // Candidate rows in parallel; the sort below is a total order (variance, y, x), so the
+ // result does not depend on the collection order.
+ let rows: Vec<usize> = (0..=h - size).step_by(step).collect();
+ let mut cands: Vec<(f32, usize, usize)> = rows
+ .par_iter()
+ .flat_map_iter(|&y| {
+ let data = low.data.as_slice();
+ let alpha = img.data.as_slice();
+ (0..=w - size).step_by(step).filter_map(move |x| {
+ // Variance of the picture inside the box (the flattest boxes hold the least detail).
+ let (mut s, mut sq, mut n, mut opaque) = (0.0f32, 0.0f32, 0.0f32, true);
+ for yy in y..y + size {
+ for xx in x..x + size {
+ let v = data[yy * w + xx];
+ s += v;
+ sq += v * v;
+ n += 1.0;
+ opaque &= alpha[yy * w + xx][3] > 0.5;
+ }
}
- }
- if opaque {
- cands.push((sq / n - (s / n).powi(2), x, y));
- }
- }
- }
+ opaque.then(|| (sq / n - (s / n).powi(2), x, y))
+ })
+ })
+ .collect();
cands.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.2.cmp(&b.2)).then(a.1.cmp(&b.1)));
cands.into_iter().take(count).map(|(_, x, y)| (x, y, size)).collect()
}
@@ -479,16 +484,7 @@ pub(crate) fn sampling_boxes(ctx: &EffectCtx, img: &Image, scale: f64) -> Vec<(u
/// The grain level (0.5..2) measured in the sample boxes of `img`.
fn grain_level(img: &Image, boxes: &[(usize, usize, usize)]) -> f32 {
- let mut m = vec![false; img.data.len()];
- let w = img.width as usize;
- for &(x, y, s) in boxes {
- for yy in y..y + s {
- for xx in x..x + s {
- m[yy * w + xx] = true;
- }
- }
- }
- let st = crate::noise2::grain_stats_masked(img, Some(&m));
+ let st = crate::noise2::grain_stats_boxes(img, boxes);
let s = (st.std[0] + st.std[1] + st.std[2]) / 3.0;
if boxes.is_empty() { 1.0 } else { (s / 0.02).clamp(0.5, 2.0) }
}
diff --git a/crates/effects/src/noise2.rs b/crates/effects/src/noise2.rs
index 4c22f6d8f..cfdd4764e 100644
--- a/crates/effects/src/noise2.rs
+++ b/crates/effects/src/noise2.rs
@@ -75,6 +75,101 @@ pub(crate) fn grain_stats_masked(img: &Image, mask: Option<&[bool]>) -> GrainSta
GrainStats { std, size: (1.0 / (1.0 - rho as f32)).clamp(0.5, 20.0) * 0.6 }
}
+/// Grain statistics over sample `boxes` (in image pixels), measured from small crops around each
+/// box instead of the whole image. Empty `boxes` measures every opaque pixel, like
+/// [`grain_stats_masked`] without a mask. Overlapping boxes are deduplicated, so the sums match
+/// the masked version.
+pub(crate) fn grain_stats_boxes(img: &Image, boxes: &[(usize, usize, usize)]) -> GrainStats {
+ if boxes.is_empty() {
+ return grain_stats_masked(img, None);
+ }
+ let (w, h) = (img.width as usize, img.height as usize);
+ if w < 3 || h < 3 {
+ return GrainStats::default();
+ }
+ // The Gaussian's three box passes at sigma 1.5 have radius 1 each, so a 3 px halo is enough
+ // for the high-pass residual of every pixel inside a box.
+ const HALO: usize = 3;
+ let mut mask = vec![false; w * h];
+ for &(x, y, s) in boxes {
+ for yy in y..y.saturating_add(s).min(h) {
+ for xx in x..x.saturating_add(s).min(w) {
+ mask[yy * w + xx] = true;
+ }
+ }
+ }
+ let mut counted = vec![false; w * h];
+ let mut n = [0.0f64; 3];
+ let mut sum = [0.0f64; 3];
+ let mut sq = [0.0f64; 3];
+ let mut rho_num = 0.0f64;
+ let mut rho_den = 0.0f64;
+ let mut crop: Vec<([f32; 3], f32)> = Vec::new();
+ let mut planes: Vec<Plane> = Vec::new();
+ for &(bx, by, bs) in boxes {
+ let x0 = bx.saturating_sub(HALO);
+ let y0 = by.saturating_sub(HALO);
+ let x1 = bx.saturating_add(bs).saturating_add(HALO).min(w);
+ let y1 = by.saturating_add(bs).saturating_add(HALO).min(h);
+ if x1 <= x0 || y1 <= y0 {
+ continue;
+ }
+ let (cw, ch) = (x1 - x0, y1 - y0);
+ crop.clear();
+ crop.extend((y0..y1).flat_map(|y| (x0..x1).map(move |x| unpremul(img.data[y * w + x]))));
+ planes.clear();
+ for k in 0..3 {
+ let pl = Plane { w: cw, h: ch, data: crop.iter().map(|s| s.0[k]).collect() };
+ planes.push(gauss_plane(&pl, 1.5, 1.5));
+ }
+ for ly in 0..bs {
+ let y = by + ly;
+ if y >= h {
+ break;
+ }
+ for lx in 0..bs {
+ let x = bx + lx;
+ if x >= w {
+ break;
+ }
+ let g = y * w + x;
+ if !mask[g] || counted[g] {
+ continue;
+ }
+ counted[g] = true;
+ let l = (y - y0) * cw + (x - x0);
+ let (_, a) = crop[l];
+ if a <= 0.5 {
+ continue;
+ }
+ for k in 0..3 {
+ let hp = crop[l].0[k] - planes[k].data[l];
+ sum[k] += hp as f64;
+ sq[k] += (hp as f64) * (hp as f64);
+ n[k] += 1.0;
+ }
+ if x + 1 < w && mask[g + 1] && crop[l + 1].1 > 0.5 {
+ for k in 0..3 {
+ let hp = crop[l].0[k] - planes[k].data[l];
+ let hn = crop[l + 1].0[k] - planes[k].data[l + 1];
+ rho_num += (hp * hn) as f64;
+ rho_den += (hp * hp) as f64;
+ }
+ }
+ }
+ }
+ }
+ let mut std = [0.0f32; 3];
+ for k in 0..3 {
+ if n[k] > 1.0 {
+ let mean = sum[k] / n[k];
+ std[k] = ((sq[k] / n[k] - mean * mean).max(0.0)).sqrt() as f32;
+ }
+ }
+ let rho = if rho_den > 1e-12 { (rho_num / rho_den).clamp(0.0, 0.95) } else { 0.0 };
+ GrainStats { std, size: (1.0 / (1.0 - rho as f32)).clamp(0.5, 20.0) * 0.6 }
+}
+
/// Match Grain's Viewing Mode options.
const MATCH_GRAIN_VIEWS: [&str; 5] = ["Preview", "Noise Samples", "Compensation Samples", "Blending Matte", "Final Output"];
@@ -86,34 +181,24 @@ fn match_grain(ctx: &EffectCtx, mut b: Buf) -> Buf {
let view = ctx.params.e("viewingMode");
let source = layer_or_self(ctx, &b, "noiseSourceLayer", false, false);
let src_boxes = sampling_boxes(ctx, &source, b.scale);
- let own_boxes = sampling_boxes(ctx, &b.img, b.scale);
let box_col = ctx.params.get("sampling/sampleBoxColor").map(|v| v.as_color()).unwrap_or([1.0, 1.0, 0.0, 1.0]);
if view == 1 || view == 2 {
// Noise Samples (on the source) / Compensation Samples (on this layer).
- let (mut img, boxes) = if view == 1 { (source, src_boxes) } else { (b.img.clone(), own_boxes) };
+ let (mut img, boxes) = if view == 1 { (source, src_boxes) } else { (b.img.clone(), sampling_boxes(ctx, &b.img, b.scale)) };
draw_boxes(&mut img, &boxes, box_col);
b.img = img;
return b;
}
- let mask_of = |img: &Image, boxes: &[(usize, usize, usize)]| -> Option<Vec<bool>> {
- if boxes.is_empty() {
- return None;
- }
- let w = img.width as usize;
- let mut m = vec![false; img.data.len()];
- for &(x, y, s) in boxes {
- for yy in y..y + s {
- for xx in x..x + s {
- m[yy * w + xx] = true;
- }
- }
- }
- Some(m)
- };
- let src_stats = grain_stats_masked(&source, mask_of(&source, &src_boxes).as_deref());
+ let src_stats = grain_stats_boxes(&source, &src_boxes);
let comp = (ctx.params.f("compensateForExistingNoise") / 100.0) as f32;
- let own = if comp > 0.0 { grain_stats_masked(&b.img, mask_of(&b.img, &own_boxes).as_deref()) } else { GrainStats::default() };
- let orig = b.img.clone();
+ // The own-layer boxes only matter for the compensation term; skip them when it is off.
+ let own = if comp > 0.0 {
+ let own_boxes = sampling_boxes(ctx, &b.img, b.scale);
+ grain_stats_boxes(&b.img, &own_boxes)
+ } else {
+ GrainStats::default()
+ };
+ let orig = (view == 0).then(|| b.img.clone());
let look = GrainLook::from_params(ctx);
let amp: [f32; 3] = [0, 1, 2].map(|k| {
let s = src_stats.std[k];
@@ -147,8 +232,8 @@ fn match_grain(ctx: &EffectCtx, mut b: Buf) -> Buf {
}
}
});
- if view == 0 {
- crate::noise::preview_compose(ctx, &mut b, &orig);
+ if let Some(orig) = &orig {
+ crate::noise::preview_compose(ctx, &mut b, orig);
}
b
}
@@ -306,6 +391,63 @@ mod tests {
img
}
+ #[test]
+ fn boxed_grain_stats_match_the_masked_ones() {
+ // Noisy image with alpha holes; the boxes cover overlapping, edge-adjacent and
+ // bottom-right corner cases (clamped crops).
+ let mut img = noisy(64, 48, 0.2, 9);
+ for y in 0..img.height {
+ for x in 0..img.width {
+ if (x / 7 + y / 5) % 6 == 0 {
+ let mut p = img.get(x as i64, y as i64);
+ p[3] = 0.0;
+ img.set(x, y, p);
+ }
+ }
+ }
+ let boxes = [(3usize, 4usize, 9usize), (8, 6, 9), (40, 20, 12), (39, 21, 12), (55, 39, 9)];
+ let w = img.width as usize;
+ let mut mask = vec![false; img.data.len()];
+ for &(x, y, s) in &boxes {
+ for yy in y..y + s {
+ for xx in x..x + s {
+ mask[yy * w + xx] = true;
+ }
+ }
+ }
+ let masked = grain_stats_masked(&img, Some(&mask));
+ let boxed = grain_stats_boxes(&img, &boxes);
+ for k in 0..3 {
+ assert!((masked.std[k] - boxed.std[k]).abs() < 1e-5, "{k}: {masked:?} vs {boxed:?}");
+ }
+ assert!((masked.size - boxed.size).abs() <= 0.05 * masked.size.max(1.0), "size: {masked:?} vs {boxed:?}");
+ // A denser grid where every box overlaps its neighbours (mask dedup across boxes).
+ let img2 = noisy(96, 64, 0.15, 21);
+ let mut boxes2 = Vec::new();
+ for gy in 0..5 {
+ for gx in 0..6 {
+ boxes2.push((gx * 11 + (gy % 3) * 4, gy * 10 + gx % 2, 12));
+ }
+ }
+ let w2 = img2.width as usize;
+ let mut mask2 = vec![false; img2.data.len()];
+ for &(x, y, s) in &boxes2 {
+ for yy in y..y + s {
+ for xx in x..x + s {
+ mask2[yy * w2 + xx] = true;
+ }
+ }
+ }
+ let masked2 = grain_stats_masked(&img2, Some(&mask2));
+ let boxed2 = grain_stats_boxes(&img2, &boxes2);
+ for k in 0..3 {
+ assert!((masked2.std[k] - boxed2.std[k]).abs() < 1e-5, "{k}: {masked2:?} vs {boxed2:?}");
+ }
+ assert!((masked2.size - boxed2.size).abs() <= 0.05 * masked2.size.max(1.0), "size: {masked2:?} vs {boxed2:?}");
+ // No boxes measures the whole image, like no mask.
+ assert_eq!(grain_stats_boxes(&img, &[]), grain_stats(&img));
+ }
+
#[test]
fn match_grain_transfers_grain_strength() {
let flat = Image::filled(48, 48, [0.5, 0.5, 0.5, 1.0]);
diff --git a/crates/effects/src/util.rs b/crates/effects/src/util.rs
index 1527e221f..f22a9885f 100644
--- a/crates/effects/src/util.rs
+++ b/crates/effects/src/util.rs
@@ -6,6 +6,10 @@ use effectcraft_color::{luminance, rgb_to_hsl};
use effectcraft_raster::{Image, Px};
use rayon::prelude::*;
+/// Below this many pixels, `Plane::transpose` and `Plane::map_rows` run on the calling thread:
+/// the rayon dispatch costs more than the work on small crops (the Match Grain sample boxes).
+const PAR_MIN: usize = 4096;
+
/// A single-channel `f32` image (row-major).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Plane {
@@ -62,6 +66,15 @@ impl Plane {
pub fn transpose(&self) -> Plane {
let (w, h) = (self.w, self.h);
let mut out = Plane::new(h, w);
+ if w.saturating_mul(h) < PAR_MIN {
+ // Small planes: the rayon dispatch costs more than the copy itself.
+ for (x, col) in out.data.chunks_mut(h.max(1)).enumerate() {
+ for y in 0..h {
+ col[y] = self.data[y * w + x];
+ }
+ }
+ return out;
+ }
out.data.par_chunks_mut(h.max(1)).enumerate().for_each(|(x, col)| {
for y in 0..h {
col[y] = self.data[y * w + x];
@@ -75,6 +88,11 @@ impl Plane {
if self.w == 0 {
return out;
}
+ if self.w.saturating_mul(self.h) < PAR_MIN {
+ // Small planes: the rayon dispatch costs more than the rows themselves.
+ out.data.chunks_mut(self.w).zip(self.data.chunks(self.w)).for_each(|(o, s)| f(s, o));
+ return out;
+ }
out.data.par_chunks_mut(self.w).zip(self.data.par_chunks(self.w)).for_each(|(o, s)| f(s, o));
out
}