mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-19 16:37:03 +00:00
Reduce Noise: reuse guide statistics with bit-identical output (#9639)
* perf(algo): reuse Reduce Noise guide statistics * fix(algo): use fixed-size chunks for guide statistics * Reduce Noise: test that the caller routes the cleaned luma guide and both chroma planes Review follow-up: compares reduce_noise's output (Lab, so planes pass through) with the independent guided filters run in order. * test(algo): assert bit-identical output in Reduce Noise routing test
This commit is contained in:
1 parent
991ef9907b
commit
6b2ad6b620
1 file changed
+153
-26
+153
-26
@@ -28,28 +28,57 @@ pub(crate) fn reach() -> f32 {
|
||||
(2 * MAX_LUMA_R + 2 * MAX_CHROMA_R + 6) as f32
|
||||
}
|
||||
|
||||
/// Guided filter of `p` with guide `g` (both `w × h`), box radius `r`.
|
||||
fn guided(g: &[f32], p: &[f32], w: usize, h: usize, r: usize, eps: f32) -> Vec<f32> {
|
||||
let len = w * h;
|
||||
// Interleave the four box-filtered moments to run one pass.
|
||||
let mut m = vec![0.0f32; len * 4];
|
||||
for i in 0..len {
|
||||
m[i * 4] = g[i];
|
||||
m[i * 4 + 1] = p[i];
|
||||
m[i * 4 + 2] = g[i] * g[i];
|
||||
m[i * 4 + 3] = g[i] * p[i];
|
||||
/// Shared first and second moments of a guide (two filtered channels).
|
||||
fn guide_moments(g: &[f32], w: usize, h: usize, r: usize) -> Vec<f32> {
|
||||
let mut moments = Vec::with_capacity(g.len() * 2);
|
||||
for &v in g {
|
||||
moments.extend_from_slice(&[v, v * v]);
|
||||
}
|
||||
box_blur_n(&mut m, w, h, 4, r);
|
||||
let mut ab = vec![0.0f32; len * 2];
|
||||
for i in 0..len {
|
||||
let (mg, mp, mgg, mgp) = (m[i * 4], m[i * 4 + 1], m[i * 4 + 2], m[i * 4 + 3]);
|
||||
let var = (mgg - mg * mg).max(0.0);
|
||||
let a = (mgp - mg * mp) / (var + eps);
|
||||
ab[i * 2] = a;
|
||||
ab[i * 2 + 1] = mp - a * mg;
|
||||
box_blur_n(&mut moments, w, h, 2, r);
|
||||
moments
|
||||
}
|
||||
|
||||
/// Self-guided luminance: mean(p) = mean(g), mean(g*p) = mean(g*g).
|
||||
fn guided_luma(g: &[f32], w: usize, h: usize, r: usize, eps: f32) -> Vec<f32> {
|
||||
let mut ab = guide_moments(g, w, h, r);
|
||||
for pair in ab.as_chunks_mut::<2>().0.iter_mut() {
|
||||
let mean = pair[0];
|
||||
let covariance = pair[1] - mean * mean;
|
||||
// Keep the original unclamped numerator, including roundoff below zero.
|
||||
let a = covariance / (covariance.max(0.0) + eps);
|
||||
pair[0] = a;
|
||||
pair[1] = mean - a * mean;
|
||||
}
|
||||
box_blur_n(&mut ab, w, h, 2, r);
|
||||
(0..len).map(|i| ab[i * 2] * g[i] + ab[i * 2 + 1]).collect()
|
||||
g.iter().zip(ab.as_chunks::<2>().0.iter()).map(|(&v, pair)| pair[0] * v + pair[1]).collect()
|
||||
}
|
||||
|
||||
/// Chroma planes share the cleaned guide's mean and regularised variance.
|
||||
/// Two guide channels plus two moments and two coefficients per chroma plane:
|
||||
/// ten filtered channels, versus twelve for two independent guided filters.
|
||||
fn guided_chroma(g: &[f32], planes: [&mut [f32]; 2], w: usize, h: usize, r: usize, eps: f32, amount: f32) {
|
||||
let mut stats = guide_moments(g, w, h, r);
|
||||
for pair in stats.as_chunks_mut::<2>().0.iter_mut() {
|
||||
pair[1] = (pair[1] - pair[0] * pair[0]).max(0.0) + eps;
|
||||
}
|
||||
for plane in planes {
|
||||
let mut ab = Vec::with_capacity(g.len() * 2);
|
||||
for (&guide, &p) in g.iter().zip(plane.iter()) {
|
||||
ab.extend_from_slice(&[p, guide * p]);
|
||||
}
|
||||
box_blur_n(&mut ab, w, h, 2, r);
|
||||
for (pair, guide) in ab.as_chunks_mut::<2>().0.iter_mut().zip(stats.as_chunks::<2>().0.iter()) {
|
||||
let mean = pair[0];
|
||||
let a = (pair[1] - guide[0] * mean) / guide[1];
|
||||
pair[0] = a;
|
||||
pair[1] = mean - a * guide[0];
|
||||
}
|
||||
box_blur_n(&mut ab, w, h, 2, r);
|
||||
for ((v, &guide), pair) in plane.iter_mut().zip(g).zip(ab.as_chunks::<2>().0.iter()) {
|
||||
let filtered = pair[0] * guide + pair[1];
|
||||
*v += (filtered - *v) * amount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn reduce_noise(src: &Image, out: Rect, ctx: &Ctx, spec: &DenoiseSpec) -> Vec<f32> {
|
||||
@@ -125,7 +154,7 @@ pub(crate) fn reduce_noise(src: &Image, out: Rect, ctx: &Ctx, spec: &DenoiseSpec
|
||||
let r = (1.0 + spec.strength.clamp(0.0, 10.0) * 0.4).round() as usize;
|
||||
let keep = spec.preserve.clamp(0.0, 100.0) / 100.0;
|
||||
let eps = (0.004 + 0.05 * s).powi(2) * (1.05 - keep);
|
||||
let d = guided(&yv, &yv, ww, wh, r.min(MAX_LUMA_R), eps);
|
||||
let d = guided_luma(&yv, ww, wh, r.min(MAX_LUMA_R), eps);
|
||||
let k = s.sqrt();
|
||||
for (v, dv) in yv.iter_mut().zip(d) {
|
||||
*v += (dv - *v) * k;
|
||||
@@ -135,12 +164,7 @@ pub(crate) fn reduce_noise(src: &Image, out: Rect, ctx: &Ctx, spec: &DenoiseSpec
|
||||
if col > 0.0 && model != Model::Gray {
|
||||
let r = (1.0 + col * 8.0).round() as usize;
|
||||
let eps = (0.01 + 0.05 * col).powi(2);
|
||||
for plane in [&mut c1, &mut c2] {
|
||||
let d = guided(&yv, plane, ww, wh, r.min(MAX_CHROMA_R), eps);
|
||||
for (v, dv) in plane.iter_mut().zip(d) {
|
||||
*v += (dv - *v) * col;
|
||||
}
|
||||
}
|
||||
guided_chroma(&yv, [&mut c1, &mut c2], ww, wh, r.min(MAX_CHROMA_R), eps, col);
|
||||
}
|
||||
// Sharpen Details: unsharp mask on luma.
|
||||
if sh > 0.0 {
|
||||
@@ -178,3 +202,106 @@ pub(crate) fn reduce_noise(src: &Image, out: Rect, ctx: &Ctx, spec: &DenoiseSpec
|
||||
}
|
||||
res
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Guided filter of `p` with guide `g` (both `w × h`), box radius `r`.
|
||||
fn reference_guided(g: &[f32], p: &[f32], w: usize, h: usize, r: usize, eps: f32) -> Vec<f32> {
|
||||
let len = w * h;
|
||||
// Interleave the four box-filtered moments to run one pass.
|
||||
let mut m = vec![0.0f32; len * 4];
|
||||
for i in 0..len {
|
||||
m[i * 4] = g[i];
|
||||
m[i * 4 + 1] = p[i];
|
||||
m[i * 4 + 2] = g[i] * g[i];
|
||||
m[i * 4 + 3] = g[i] * p[i];
|
||||
}
|
||||
box_blur_n(&mut m, w, h, 4, r);
|
||||
let mut ab = vec![0.0f32; len * 2];
|
||||
for i in 0..len {
|
||||
let (mg, mp, mgg, mgp) = (m[i * 4], m[i * 4 + 1], m[i * 4 + 2], m[i * 4 + 3]);
|
||||
let var = (mgg - mg * mg).max(0.0);
|
||||
let a = (mgp - mg * mp) / (var + eps);
|
||||
ab[i * 2] = a;
|
||||
ab[i * 2 + 1] = mp - a * mg;
|
||||
}
|
||||
box_blur_n(&mut ab, w, h, 2, r);
|
||||
(0..len).map(|i| ab[i * 2] * g[i] + ab[i * 2 + 1]).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_statistics_match_independent_filters_bit_for_bit() {
|
||||
for (w, h) in [(1, 1), (1, 19), (23, 1), (7, 5), (33, 17)] {
|
||||
let len = w * h;
|
||||
for flat in [false, true] {
|
||||
let g: Vec<f32> = (0..len).map(|i| if flat { 0.1 } else { ((i * 37 % 101) as f32 - 20.0) / 63.0 }).collect();
|
||||
let p: Vec<f32> = (0..len).map(|i| (i * 13 % 71) as f32 / 70.0 - 0.5).collect();
|
||||
let q: Vec<f32> = (0..len).map(|i| (i * 29 % 83) as f32 / 41.0 - 1.0).collect();
|
||||
for r in [0, 1, MAX_LUMA_R, MAX_CHROMA_R, 25] {
|
||||
for eps in [0.000001, 0.0036] {
|
||||
let expected = reference_guided(&g, &g, w, h, r, eps);
|
||||
let actual = guided_luma(&g, w, h, r, eps);
|
||||
assert_bits(&actual, &expected);
|
||||
for amount in [0.01, 0.45, 1.0] {
|
||||
let mut actual_p = p.clone();
|
||||
let mut actual_q = q.clone();
|
||||
guided_chroma(&g, [&mut actual_p, &mut actual_q], w, h, r, eps, amount);
|
||||
for (original, actual) in [(&p, &actual_p), (&q, &actual_q)] {
|
||||
let filtered = reference_guided(&g, original, w, h, r, eps);
|
||||
let expected: Vec<f32> = original.iter().zip(filtered).map(|(&v, d)| v + (d - v) * amount).collect();
|
||||
assert_bits(actual, &expected);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reduce_noise_guides_both_chroma_planes_by_the_cleaned_luma() {
|
||||
// Caller wiring: Lab keeps its planes as they are, so each output plane is compared with
|
||||
// the independent filters run on the planes in order (luma by itself, chroma by the
|
||||
// cleaned luma).
|
||||
let (w, h) = (19, 13);
|
||||
let rect = Rect::new(0, 0, w as i32, h as i32);
|
||||
let mut src = Image::new(rect, 3);
|
||||
for (i, px) in src.data.as_chunks_mut::<3>().0.iter_mut().enumerate() {
|
||||
px[0] = (i * 37 % 101) as f32 / 100.0;
|
||||
px[1] = (i * 13 % 71) as f32 / 70.0 - 0.5;
|
||||
px[2] = (i * 29 % 83) as f32 / 41.0 - 1.0;
|
||||
}
|
||||
let ctx = Ctx { bounds: rect, mode: ColorMode::Lab, alpha: false };
|
||||
let spec = DenoiseSpec { strength: 6.0, preserve: 30.0, color: 50.0, sharpen: 0.0, jpeg: false };
|
||||
let out = reduce_noise(&src, rect, &ctx, &spec);
|
||||
|
||||
let plane = |c: usize| -> Vec<f32> { src.data.as_chunks::<3>().0.iter().map(|px| px[c]).collect() };
|
||||
let (luma, chroma) = (plane(0), [plane(1), plane(2)]);
|
||||
let s = spec.strength / 10.0;
|
||||
let eps = (0.004 + 0.05 * s).powi(2) * (1.05 - spec.preserve / 100.0);
|
||||
let smooth = reference_guided(&luma, &luma, w, h, (1.0 + spec.strength * 0.4).round() as usize, eps);
|
||||
let cleaned: Vec<f32> = luma.iter().zip(&smooth).map(|(&v, &d)| v + (d - v) * s.sqrt()).collect();
|
||||
let col = spec.color / 100.0;
|
||||
let chroma_r = (1.0 + col * 8.0).round() as usize;
|
||||
let chroma_eps = (0.01 + 0.05 * col).powi(2);
|
||||
let mut expected = vec![cleaned];
|
||||
for p in &chroma {
|
||||
let filtered = reference_guided(&expected[0], p, w, h, chroma_r, chroma_eps);
|
||||
expected.push(p.iter().zip(filtered).map(|(&v, f)| v + (f - v) * col).collect());
|
||||
}
|
||||
for (c, expected) in expected.iter().enumerate() {
|
||||
let actual: Vec<f32> = out.as_chunks::<3>().0.iter().map(|px| px[c]).collect();
|
||||
assert_bits(&actual, expected);
|
||||
assert!(actual.iter().zip(&plane(c)).any(|(a, o)| (a - o).abs() > 1e-3), "plane {c} was filtered");
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_bits(actual: &[f32], expected: &[f32]) {
|
||||
assert_eq!(actual.len(), expected.len());
|
||||
for (i, (actual, expected)) in actual.iter().zip(expected).enumerate() {
|
||||
assert_eq!(actual.to_bits(), expected.to_bits(), "pixel {i}: {actual} != {expected}");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user