use crate::RenderError;
use rayon::prelude::*;
fn gaussian_kernel_1d_11(sigma: f32) -> [f64; 11] {
const K: usize = 11;
const HALF: i32 = 5;
let sigma_sq = (sigma * sigma) as f64;
let mut kernel = [0.0f64; K];
let mut sum = 0.0f64;
for (k, slot) in kernel.iter_mut().enumerate() {
let d = (k as i32 - HALF) as f64;
let val = (-(d * d) / (2.0 * sigma_sq)).exp();
*slot = val;
sum += val;
}
for v in &mut kernel {
*v /= sum;
}
kernel
}
fn valid_weight_sums(n: usize, kernel1d: &[f64]) -> Vec<f64> {
let half = (kernel1d.len() / 2) as i32;
(0..n)
.map(|c| {
kernel1d
.iter()
.enumerate()
.filter_map(|(k, &w)| {
let p = c as i32 + k as i32 - half;
if p >= 0 && p < n as i32 {
Some(w)
} else {
None
}
})
.sum()
})
.collect()
}
fn downsample_2x(image: &[f32], width: usize, height: usize) -> (Vec<f32>, usize, usize) {
let new_w = width / 2;
let new_h = height / 2;
let mut out = vec![0.0f32; new_w * new_h * 4];
for ny in 0..new_h {
for nx in 0..new_w {
let x = nx * 2;
let y = ny * 2;
for c in 0..4 {
let fetch = |iy: usize, ix: usize| -> f32 {
let iy_c = iy.min(height - 1);
let ix_c = ix.min(width - 1);
image[(iy_c * width + ix_c) * 4 + c]
};
let val =
(fetch(y, x) + fetch(y, x + 1) + fetch(y + 1, x) + fetch(y + 1, x + 1)) * 0.25;
out[(ny * new_w + nx) * 4 + c] = val;
}
}
}
(out, new_w, new_h)
}
pub fn compute_psnr(
predicted: &[f32],
reference: &[f32],
max_val: f32,
) -> Result<f32, RenderError> {
if predicted.is_empty() || reference.is_empty() {
return Err(RenderError::MismatchedBufferSizes {
expected: 0,
actual: 0,
});
}
if predicted.len() != reference.len() {
return Err(RenderError::MismatchedBufferSizes {
expected: reference.len(),
actual: predicted.len(),
});
}
let mut sum_sq = 0.0f64;
let mut count = 0usize;
for (i, (&p, &r)) in predicted.iter().zip(reference.iter()).enumerate() {
if i % 4 == 3 {
continue;
}
let diff = (p as f64) - (r as f64);
sum_sq += diff * diff;
count += 1;
}
if count == 0 {
return Err(RenderError::MismatchedBufferSizes {
expected: 1,
actual: 0,
});
}
let mse = sum_sq / (count as f64);
if mse == 0.0 {
return Ok(f32::INFINITY);
}
let max_sq = (max_val as f64) * (max_val as f64);
Ok((10.0 * (max_sq / mse).log10()) as f32)
}
pub fn compute_ssim(
predicted: &[f32],
reference: &[f32],
width: usize,
height: usize,
) -> Result<f32, RenderError> {
if predicted.len() != reference.len() {
return Err(RenderError::MismatchedBufferSizes {
expected: reference.len(),
actual: predicted.len(),
});
}
if predicted.len() != width * height * 4 {
return Err(RenderError::MismatchedBufferSizes {
expected: width * height * 4,
actual: predicted.len(),
});
}
let kernel = gaussian_kernel_1d_11(1.5);
let ssim_total = ssim_over_channels(predicted, reference, width, height, &kernel);
Ok(ssim_total as f32)
}
fn ssim_over_channels(
pred: &[f32],
refer: &[f32],
width: usize,
height: usize,
kernel1d: &[f64],
) -> f64 {
const L: f64 = 1.0;
const C1: f64 = (0.01 * L) * (0.01 * L); const C2: f64 = (0.03 * L) * (0.03 * L); const HALF: i32 = 5;
if width == 0 || height == 0 {
return 1.0;
}
let wx = valid_weight_sums(width, kernel1d);
let wy = valid_weight_sums(height, kernel1d);
let mut channel_ssims = [0.0f64; 3];
for (ch, channel_ssim) in channel_ssims.iter_mut().enumerate() {
let mut horiz: Vec<[f64; 5]> = vec![[0.0; 5]; width * height];
horiz
.par_chunks_mut(width)
.enumerate()
.for_each(|(py, row_out)| {
for (cx, slot) in row_out.iter_mut().enumerate() {
let mut acc = [0.0f64; 5];
for (kx, &w) in kernel1d.iter().enumerate() {
let px = cx as i32 + kx as i32 - HALF;
if px < 0 || px >= width as i32 {
continue;
}
let px = px as usize;
let x_val = pred[(py * width + px) * 4 + ch] as f64;
let y_val = refer[(py * width + px) * 4 + ch] as f64;
acc[0] += w * x_val;
acc[1] += w * y_val;
acc[2] += w * x_val * x_val;
acc[3] += w * y_val * y_val;
acc[4] += w * x_val * y_val;
}
*slot = acc;
}
});
let row_sums: Vec<f64> = (0..height)
.into_par_iter()
.map(|cy| {
let mut row_sum = 0.0f64;
for cx in 0..width {
let mut acc = [0.0f64; 5];
for (ky, &w) in kernel1d.iter().enumerate() {
let py = cy as i32 + ky as i32 - HALF;
if py < 0 || py >= height as i32 {
continue;
}
let h = horiz[py as usize * width + cx];
acc[0] += w * h[0];
acc[1] += w * h[1];
acc[2] += w * h[2];
acc[3] += w * h[3];
acc[4] += w * h[4];
}
let w_sum = wx[cx] * wy[cy];
let mu_x = acc[0] / w_sum;
let mu_y = acc[1] / w_sum;
let mut sigma_x2 = acc[2] / w_sum - mu_x * mu_x;
let mut sigma_y2 = acc[3] / w_sum - mu_y * mu_y;
let sigma_xy = acc[4] / w_sum - mu_x * mu_y;
if sigma_x2 < 0.0 {
sigma_x2 = 0.0;
}
if sigma_y2 < 0.0 {
sigma_y2 = 0.0;
}
let numerator = (2.0 * mu_x * mu_y + C1) * (2.0 * sigma_xy + C2);
let denominator = (mu_x * mu_x + mu_y * mu_y + C1) * (sigma_x2 + sigma_y2 + C2);
row_sum += numerator / denominator;
}
row_sum
})
.collect();
*channel_ssim = row_sums.iter().sum::<f64>() / (width * height) as f64;
}
(channel_ssims[0] + channel_ssims[1] + channel_ssims[2]) / 3.0
}
pub fn compute_ms_ssim(
predicted: &[f32],
reference: &[f32],
width: usize,
height: usize,
) -> Result<f32, RenderError> {
if predicted.len() != reference.len() {
return Err(RenderError::MismatchedBufferSizes {
expected: reference.len(),
actual: predicted.len(),
});
}
if predicted.len() != width * height * 4 {
return Err(RenderError::MismatchedBufferSizes {
expected: width * height * 4,
actual: predicted.len(),
});
}
const WEIGHTS: [f64; 3] = [0.0448, 0.2856, 0.3001];
const MIN_DIM: usize = 11;
let kernel = gaussian_kernel_1d_11(1.5);
let mut pred_cur: Vec<f32> = predicted.to_vec();
let mut ref_cur: Vec<f32> = reference.to_vec();
let mut w_cur = width;
let mut h_cur = height;
let mut weighted_ssim_sum = 0.0f64;
let mut weight_sum = 0.0f64;
for &weight in WEIGHTS.iter() {
if w_cur < MIN_DIM || h_cur < MIN_DIM {
break;
}
let ssim_val = ssim_over_channels(&pred_cur, &ref_cur, w_cur, h_cur, &kernel);
weighted_ssim_sum += weight * ssim_val;
weight_sum += weight;
let (new_pred, nw, nh) = downsample_2x(&pred_cur, w_cur, h_cur);
let (new_ref, _, _) = downsample_2x(&ref_cur, w_cur, h_cur);
pred_cur = new_pred;
ref_cur = new_ref;
w_cur = nw;
h_cur = nh;
}
if weight_sum == 0.0 {
return compute_ssim(predicted, reference, width, height);
}
Ok((weighted_ssim_sum / weight_sum) as f32)
}
#[derive(Debug, Clone)]
pub struct RenderQualityMetrics {
pub psnr: f32,
pub ssim: f32,
pub ms_ssim: f32,
pub mean_abs_error: f32,
pub max_abs_error: f32,
}
impl RenderQualityMetrics {
pub fn compute(
predicted: &[f32],
reference: &[f32],
width: usize,
height: usize,
) -> Result<Self, RenderError> {
if predicted.len() != width * height * 4 {
return Err(RenderError::MismatchedBufferSizes {
expected: width * height * 4,
actual: predicted.len(),
});
}
if predicted.len() != reference.len() {
return Err(RenderError::MismatchedBufferSizes {
expected: predicted.len(),
actual: reference.len(),
});
}
let psnr = compute_psnr(predicted, reference, 1.0)?;
let ssim = compute_ssim(predicted, reference, width, height)?;
let ms_ssim = compute_ms_ssim(predicted, reference, width, height)?;
let mut sum_abs = 0.0f64;
let mut max_abs = 0.0f32;
let mut rgb_count = 0usize;
for (i, (&p, &r)) in predicted.iter().zip(reference.iter()).enumerate() {
if i % 4 == 3 {
continue;
}
let diff = (p - r).abs();
sum_abs += diff as f64;
if diff > max_abs {
max_abs = diff;
}
rgb_count += 1;
}
let mean_abs_error = if rgb_count == 0 {
0.0
} else {
(sum_abs / rgb_count as f64) as f32
};
Ok(Self {
psnr,
ssim,
ms_ssim,
mean_abs_error,
max_abs_error: max_abs,
})
}
pub fn is_high_quality(&self) -> bool {
self.psnr > 30.0 && self.ssim > 0.9
}
pub fn format_report(&self) -> String {
format!(
"┌─────────────────────────────────┐\n\
│ Render Quality Metrics │\n\
├─────────────────┬───────────────┤\n\
│ PSNR │ {:>10.4} dB │\n\
│ SSIM │ {:>13.6} │\n\
│ MS-SSIM │ {:>13.6} │\n\
│ Mean Abs Error │ {:>13.6} │\n\
│ Max Abs Error │ {:>13.6} │\n\
└─────────────────┴───────────────┘",
self.psnr, self.ssim, self.ms_ssim, self.mean_abs_error, self.max_abs_error
)
}
}
#[derive(Debug, Clone)]
pub struct MetricThresholds {
pub min_psnr: f32,
pub min_ssim: f32,
pub min_ms_ssim: f32,
pub max_mae: f32,
}
impl Default for MetricThresholds {
fn default() -> Self {
Self {
min_psnr: 25.0,
min_ssim: 0.85,
min_ms_ssim: 0.90,
max_mae: 0.05,
}
}
}
impl MetricThresholds {
pub fn strict() -> Self {
Self {
min_psnr: 35.0,
min_ssim: 0.95,
min_ms_ssim: 0.97,
max_mae: 0.01,
}
}
pub fn permissive() -> Self {
Self {
min_psnr: 20.0,
min_ssim: 0.70,
min_ms_ssim: 0.80,
max_mae: 0.10,
}
}
pub fn check(&self, metrics: &RenderQualityMetrics) -> Vec<String> {
let mut failures = Vec::new();
if metrics.psnr < self.min_psnr && metrics.psnr.is_finite() {
failures.push(format!(
"PSNR {:.4} dB is below minimum {:.4} dB",
metrics.psnr, self.min_psnr
));
}
if metrics.ssim < self.min_ssim {
failures.push(format!(
"SSIM {:.6} is below minimum {:.6}",
metrics.ssim, self.min_ssim
));
}
if metrics.ms_ssim < self.min_ms_ssim {
failures.push(format!(
"MS-SSIM {:.6} is below minimum {:.6}",
metrics.ms_ssim, self.min_ms_ssim
));
}
if metrics.mean_abs_error > self.max_mae {
failures.push(format!(
"MAE {:.6} exceeds maximum {:.6}",
metrics.mean_abs_error, self.max_mae
));
}
failures
}
}
pub fn compare_renders(
renders: &[Vec<f32>],
reference: &[Vec<f32>],
width: usize,
height: usize,
) -> Result<Vec<RenderQualityMetrics>, RenderError> {
if renders.len() != reference.len() {
return Err(RenderError::MismatchedBufferSizes {
expected: reference.len(),
actual: renders.len(),
});
}
renders
.iter()
.zip(reference.iter())
.map(|(pred, refer)| RenderQualityMetrics::compute(pred, refer, width, height))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn solid_rgba(r: f32, g: f32, b: f32, a: f32, width: usize, height: usize) -> Vec<f32> {
let n = width * height * 4;
let mut buf = Vec::with_capacity(n);
for _ in 0..(width * height) {
buf.push(r);
buf.push(g);
buf.push(b);
buf.push(a);
}
buf
}
fn add_noise(image: &[f32], delta: f32) -> Vec<f32> {
image
.iter()
.enumerate()
.map(|(i, &v)| {
if i % 4 == 3 {
v
} else {
(v + delta).clamp(0.0, 1.0)
}
})
.collect()
}
#[test]
fn test_psnr_identical_images() {
let img = solid_rgba(0.5, 0.5, 0.5, 1.0, 32, 32);
let psnr = compute_psnr(&img, &img, 1.0).expect("psnr failed");
assert!(
psnr.is_infinite(),
"identical images must yield infinite PSNR"
);
}
#[test]
fn test_psnr_all_zeros_vs_all_ones() {
let zeros = solid_rgba(0.0, 0.0, 0.0, 0.0, 8, 8);
let ones = solid_rgba(1.0, 1.0, 1.0, 1.0, 8, 8);
let psnr = compute_psnr(&zeros, &ones, 1.0).expect("psnr failed");
assert!((psnr - 0.0).abs() < 1e-4, "expected 0 dB, got {psnr}");
}
#[test]
fn test_psnr_small_error() {
let base = solid_rgba(0.5, 0.5, 0.5, 1.0, 16, 16);
let noisy = add_noise(&base, 0.01);
let psnr = compute_psnr(&noisy, &base, 1.0).expect("psnr failed");
assert!(psnr > 35.0 && psnr < 50.0, "expected ~40 dB, got {psnr}");
}
#[test]
fn test_psnr_length_mismatch_error() {
let a = vec![0.0f32; 16];
let b = vec![0.0f32; 32];
assert!(
compute_psnr(&a, &b, 1.0).is_err(),
"must error on length mismatch"
);
}
#[test]
fn test_ssim_identical_images() {
let img = solid_rgba(0.5, 0.3, 0.8, 1.0, 32, 32);
let ssim = compute_ssim(&img, &img, 32, 32).expect("ssim failed");
assert!(
(ssim - 1.0).abs() < 1e-4,
"identical images must yield SSIM ≈ 1.0, got {ssim}"
);
}
#[test]
fn test_ssim_completely_different() {
let black = solid_rgba(0.0, 0.0, 0.0, 1.0, 32, 32);
let white = solid_rgba(1.0, 1.0, 1.0, 1.0, 32, 32);
let ssim = compute_ssim(&black, &white, 32, 32).expect("ssim failed");
assert!(
ssim < 0.5,
"completely different images must yield SSIM < 0.5, got {ssim}"
);
}
#[test]
fn test_ssim_small_perturbation() {
let base = solid_rgba(0.5, 0.5, 0.5, 1.0, 32, 32);
let noisy = add_noise(&base, 0.02);
let ssim = compute_ssim(&noisy, &base, 32, 32).expect("ssim failed");
assert!(
ssim > 0.9,
"small perturbation must yield SSIM > 0.9, got {ssim}"
);
}
#[test]
fn test_ssim_image_size_mismatch_error() {
let a = solid_rgba(0.5, 0.5, 0.5, 1.0, 8, 8); let b = solid_rgba(0.5, 0.5, 0.5, 1.0, 16, 16); assert!(
compute_ssim(&a, &b, 8, 8).is_err(),
"length mismatch must error"
);
}
#[test]
fn test_ssim_border_pixels_use_renormalized_weighted_moments() {
const A: f32 = 0.7;
const B: f32 = 0.5;
let predicted = solid_rgba(A, A, A, 1.0, 32, 32);
let reference = solid_rgba(B, B, B, 1.0, 32, 32);
let ssim = compute_ssim(&predicted, &reference, 32, 32).expect("ssim failed");
let c1 = (0.01_f64 * 1.0) * (0.01_f64 * 1.0);
let (a, b) = (A as f64, B as f64);
let expected = (2.0 * a * b + c1) / (a * a + b * b + c1);
assert!(
(ssim as f64 - expected).abs() < 1e-3,
"expected SSIM \u{2248} {expected} (closed form for two constant images), got {ssim}"
);
}
#[test]
fn test_ms_ssim_identical() {
let img = solid_rgba(0.4, 0.6, 0.2, 1.0, 64, 64);
let ms = compute_ms_ssim(&img, &img, 64, 64).expect("ms-ssim failed");
assert!(
(ms - 1.0).abs() < 1e-4,
"identical images must yield MS-SSIM ≈ 1.0, got {ms}"
);
}
#[test]
fn test_ms_ssim_different() {
let black = solid_rgba(0.0, 0.0, 0.0, 1.0, 64, 64);
let white = solid_rgba(1.0, 1.0, 1.0, 1.0, 64, 64);
let ms = compute_ms_ssim(&black, &white, 64, 64).expect("ms-ssim failed");
assert!(
ms < 0.5,
"different images must yield MS-SSIM < 0.5, got {ms}"
);
}
#[test]
fn test_gaussian_kernel_1d_sums_to_one() {
let kernel = gaussian_kernel_1d_11(1.5);
assert_eq!(kernel.len(), 11, "1-D kernel must have 11 entries");
let sum: f64 = kernel.iter().sum();
assert!(
(sum - 1.0).abs() < 1e-10,
"1-D kernel must sum to 1.0, got {sum}"
);
}
fn gaussian_kernel_11x11_reference(sigma: f32) -> Vec<f64> {
const K: usize = 11;
const HALF: i32 = 5;
let sigma_sq = (sigma * sigma) as f64;
let mut kernel = Vec::with_capacity(K * K);
let mut sum = 0.0f64;
for ky in 0..K {
for kx in 0..K {
let dy = (ky as i32 - HALF) as f64;
let dx = (kx as i32 - HALF) as f64;
let val = (-(dx * dx + dy * dy) / (2.0 * sigma_sq)).exp();
kernel.push(val);
sum += val;
}
}
for v in &mut kernel {
*v /= sum;
}
kernel
}
fn ssim_over_channels_naive_reference(
pred: &[f32],
refer: &[f32],
width: usize,
height: usize,
kernel2d: &[f64],
) -> f64 {
const K: usize = 11;
const HALF: i32 = 5;
const C1: f64 = 0.0001;
const C2: f64 = 0.0009;
let mut channel_ssims = [0.0f64; 3];
for ch in 0..3usize {
let mut ssim_sum = 0.0f64;
let mut pixel_count = 0u64;
for cy in 0..height {
for cx in 0..width {
let mut mu_x = 0.0f64;
let mut mu_y = 0.0f64;
let mut sigma_x2 = 0.0f64;
let mut sigma_y2 = 0.0f64;
let mut sigma_xy = 0.0f64;
let mut w_sum = 0.0f64;
for ky in 0..K {
let py = cy as i32 + (ky as i32 - HALF);
if py < 0 || py >= height as i32 {
continue;
}
let py = py as usize;
for kx in 0..K {
let px = cx as i32 + (kx as i32 - HALF);
if px < 0 || px >= width as i32 {
continue;
}
let px = px as usize;
let w = kernel2d[ky * K + kx];
let x_val = pred[(py * width + px) * 4 + ch] as f64;
let y_val = refer[(py * width + px) * 4 + ch] as f64;
mu_x += w * x_val;
mu_y += w * y_val;
sigma_x2 += w * x_val * x_val;
sigma_y2 += w * y_val * y_val;
sigma_xy += w * x_val * y_val;
w_sum += w;
}
}
mu_x /= w_sum;
mu_y /= w_sum;
sigma_x2 /= w_sum;
sigma_y2 /= w_sum;
sigma_xy /= w_sum;
sigma_x2 -= mu_x * mu_x;
sigma_y2 -= mu_y * mu_y;
sigma_xy -= mu_x * mu_y;
if sigma_x2 < 0.0 {
sigma_x2 = 0.0;
}
if sigma_y2 < 0.0 {
sigma_y2 = 0.0;
}
let numerator = (2.0 * mu_x * mu_y + C1) * (2.0 * sigma_xy + C2);
let denominator = (mu_x * mu_x + mu_y * mu_y + C1) * (sigma_x2 + sigma_y2 + C2);
ssim_sum += numerator / denominator;
pixel_count += 1;
}
}
channel_ssims[ch] = if pixel_count == 0 {
1.0
} else {
ssim_sum / (pixel_count as f64)
};
}
(channel_ssims[0] + channel_ssims[1] + channel_ssims[2]) / 3.0
}
#[test]
fn test_ssim_separable_matches_naive_reference_asymmetric_image() {
let width = 13usize;
let height = 9usize;
let mut predicted = vec![0.0f32; width * height * 4];
let mut reference = vec![0.0f32; width * height * 4];
for y in 0..height {
for x in 0..width {
let idx = (y * width + x) * 4;
let gx = x as f32 / (width - 1) as f32;
let gy = y as f32 / (height - 1) as f32;
let patch = if (8..=10).contains(&x) && (1..=2).contains(&y) {
0.4
} else {
0.0
};
predicted[idx] = (0.2 + 0.5 * gx + patch).clamp(0.0, 1.0);
predicted[idx + 1] = (0.3 + 0.4 * gy).clamp(0.0, 1.0);
predicted[idx + 2] = (0.1 + 0.3 * gx * gy).clamp(0.0, 1.0);
predicted[idx + 3] = 1.0;
reference[idx] = (0.25 + 0.45 * gx).clamp(0.0, 1.0);
reference[idx + 1] = (0.35 + 0.35 * gy + patch * 0.5).clamp(0.0, 1.0);
reference[idx + 2] = (0.15 + 0.25 * gx * gy).clamp(0.0, 1.0);
reference[idx + 3] = 1.0;
}
}
let kernel1d = gaussian_kernel_1d_11(1.5);
let kernel2d_ref = gaussian_kernel_11x11_reference(1.5);
let separable = ssim_over_channels(&predicted, &reference, width, height, &kernel1d);
let naive = ssim_over_channels_naive_reference(
&predicted,
&reference,
width,
height,
&kernel2d_ref,
);
assert!(
(separable - naive).abs() < 1e-9,
"separable SSIM {separable} must match naive 2-D reference {naive} (diff {})",
(separable - naive).abs()
);
}
#[test]
fn test_downsample_2x_shape() {
let img = solid_rgba(0.5, 0.5, 0.5, 1.0, 32, 16);
let (out, nw, nh) = downsample_2x(&img, 32, 16);
assert_eq!(nw, 16);
assert_eq!(nh, 8);
assert_eq!(out.len(), 16 * 8 * 4);
}
#[test]
fn test_downsample_2x_uniform_image() {
let img = solid_rgba(0.3, 0.7, 0.1, 0.5, 8, 8);
let (out, nw, nh) = downsample_2x(&img, 8, 8);
assert_eq!(nw, 4);
assert_eq!(nh, 4);
for chunk in out.chunks(4) {
assert!((chunk[0] - 0.3).abs() < 1e-5, "R channel mismatch");
assert!((chunk[1] - 0.7).abs() < 1e-5, "G channel mismatch");
assert!((chunk[2] - 0.1).abs() < 1e-5, "B channel mismatch");
assert!((chunk[3] - 0.5).abs() < 1e-5, "A channel mismatch");
}
}
#[test]
fn test_render_quality_metrics_compute() {
let img = solid_rgba(0.5, 0.5, 0.5, 1.0, 16, 16);
let noisy = add_noise(&img, 0.01);
let metrics =
RenderQualityMetrics::compute(&noisy, &img, 16, 16).expect("metrics compute failed");
assert!(
metrics.psnr > 30.0,
"expected PSNR > 30, got {}",
metrics.psnr
);
assert!(
metrics.ssim > 0.9,
"expected SSIM > 0.9, got {}",
metrics.ssim
);
assert!(
metrics.ms_ssim > 0.9,
"expected MS-SSIM > 0.9, got {}",
metrics.ms_ssim
);
assert!(
metrics.mean_abs_error < 0.02,
"expected MAE < 0.02, got {}",
metrics.mean_abs_error
);
}
#[test]
fn test_render_quality_metrics_is_high_quality() {
let img = solid_rgba(0.5, 0.5, 0.5, 1.0, 16, 16);
let m = RenderQualityMetrics::compute(&img, &img, 16, 16).expect("compute failed");
assert!(m.is_high_quality(), "identical images must be high quality");
let bad = solid_rgba(1.0, 0.0, 0.0, 0.0, 16, 16);
let m2 = RenderQualityMetrics::compute(&bad, &img, 16, 16).expect("compute failed");
assert!(
!m2.is_high_quality(),
"completely different must not be high quality"
);
}
#[test]
fn test_metric_thresholds_default() {
let t = MetricThresholds::default();
assert_eq!(t.min_psnr, 25.0);
assert_eq!(t.min_ssim, 0.85);
assert_eq!(t.min_ms_ssim, 0.90);
assert_eq!(t.max_mae, 0.05);
}
#[test]
fn test_metric_thresholds_check_passing() {
let img = solid_rgba(0.5, 0.5, 0.5, 1.0, 32, 32);
let noisy = add_noise(&img, 0.005); let metrics = RenderQualityMetrics::compute(&noisy, &img, 32, 32).expect("compute failed");
let failures = MetricThresholds::default().check(&metrics);
assert!(
failures.is_empty(),
"expected all pass but got failures: {failures:?}"
);
}
#[test]
fn test_metric_thresholds_check_failing() {
let black = solid_rgba(0.0, 0.0, 0.0, 1.0, 32, 32);
let white = solid_rgba(1.0, 1.0, 1.0, 1.0, 32, 32);
let metrics = RenderQualityMetrics::compute(&black, &white, 32, 32).expect("compute");
let failures = MetricThresholds::default().check(&metrics);
assert!(!failures.is_empty(), "expected failures for black vs white");
}
#[test]
fn test_compare_renders_multiple() {
let w = 16;
let h = 16;
let renders: Vec<Vec<f32>> = vec![
solid_rgba(0.5, 0.5, 0.5, 1.0, w, h),
solid_rgba(0.2, 0.8, 0.4, 1.0, w, h),
];
let references: Vec<Vec<f32>> =
vec![add_noise(&renders[0], 0.01), add_noise(&renders[1], 0.01)];
let results = compare_renders(&renders, &references, w, h).expect("compare_renders failed");
assert_eq!(results.len(), 2);
for m in &results {
assert!(m.psnr > 30.0, "expected PSNR > 30, got {}", m.psnr);
}
let one_render = vec![renders[0].clone()];
assert!(compare_renders(&one_render, &references, w, h).is_err());
}
}