Function compute_ssim_luminance

tools/bloom-diff/src/main.rs:140–188

SSIM over the luminance channel with a single-scale 8×8 window. Not as good as MS-SSIM but fast and plenty accurate for our "did this PR move the image closer to truth" check.

(
    reference: &[[f32; 3]],
    candidate: &[[f32; 3]],
    width: u32,
    height: u32,
)

/// Not as good as MS-SSIM but fast and plenty accurate for our
/// "did this PR move the image closer to truth" check.
fn compute_ssim_luminance(
    reference: &[[f32; 3]],
    candidate: &[[f32; 3]],
    width: u32,
    height: u32,
) -> f32 {
    const WINDOW: usize = 8;
    // SSIM's stability constants (from the original Wang et al. paper,
    // scaled to the 0..1 luminance range we use).
    const K1: f32 = 0.01;
    const K2: f32 = 0.03;
    const L: f32 = 1.0; // dynamic range for normalized images
    let c1 = (K1 * L) * (K1 * L);
    let c2 = (K2 * L) * (K2 * L);

    let w = width as usize;
    let h = height as usize;
    if w < WINDOW || h < WINDOW {
        return 1.0; // too small to analyze meaningfully; treat as identical
    }

    let mut sum = 0f64;
    let mut count = 0u64;

    // Non-overlapping 8×8 windows. Sliding windows would be more
    // accurate but 8× slower; for regression testing the blocky
    // version is plenty — we care about directional signal, not a
    // perfect Wang-et-al reproduction.
    let mut y = 0usize;
    while y + WINDOW <= h {
        let mut x = 0usize;
        while x + WINDOW <= w {
            let (mean_r, mean_c, var_r, var_c, cov) =
                window_luminance_stats(reference, candidate, w, x, y, WINDOW);
            let num = (2.0 * mean_r * mean_c + c1) * (2.0 * cov + c2);
            let den = (mean_r * mean_r + mean_c * mean_c + c1) * (var_r + var_c + c2);
            sum += (num / den) as f64;
            count += 1;
            x += WINDOW;
        }
        y += WINDOW;
    }

    if count == 0 {
        1.0
    } else {
        (sum / count as f64) as f32
    }
}

/// Mean and variance of luminance in an N×N window plus the
/// covariance between reference and candidate. Returned as f32s.