Merge PR #8257: test(algo): cover deinterlace choices and NTSC signal limits

This commit is contained in:
aiongg committed 2026-10-22 02:22:58 +00:00
commit ed69a40204
1 file changed
+159
+159
View File
@@ -88,3 +88,162 @@ pub(crate) fn ntsc(src: &Image, out: Rect, ctx: &Ctx) -> Vec<f32> {
}
res
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{FilterParams, apply};
use photocraft_color::{PixelFormat, SampleType};
use photocraft_raster::Surface;
const DEPTHS: [SampleType; 3] = [SampleType::U8, SampleType::U16, SampleType::F32];
fn tolerance(depth: SampleType) -> f32 {
match depth {
SampleType::U8 => 1.0 / 255.0,
SampleType::U16 => 1.0 / 65535.0,
SampleType::F32 => 1e-6,
}
}
fn rows(depth: SampleType, bounds: Rect, pixels: &[[f32; 4]]) -> Surface {
let mut src = Surface::new(PixelFormat::new(ColorMode::Rgb, depth, true));
for (row, px) in pixels.iter().enumerate() {
let y = bounds.y0 + row as i32;
src.fill_rect(Rect::new(bounds.x0, y, bounds.x1, y + 1), px);
}
src
}
#[test]
fn deinterlace_all_field_and_interpolation_choices_use_bounds_relative_rows() {
// Odd document origin: parity is relative to the bounds, not absolute y.
let b = Rect::new(-2, 11, 0, 16);
let pixels = [0.0, 0.2, 0.6, 0.8, 1.0].map(|v| [v, 1.0 - v, v / 2.0, 1.0]);
for depth in DEPTHS {
let src = rows(depth, b, &pixels);
let before = src.read_region(b);
for (eliminate_even, interpolate, neighbours) in [
(false, false, [(1, 1), (1, 1), (1, 1), (3, 3), (3, 3)]),
(false, true, [(1, 1), (1, 1), (1, 3), (3, 3), (3, 3)]),
(true, false, [(0, 0), (0, 0), (2, 2), (2, 2), (4, 4)]),
(true, true, [(0, 0), (0, 2), (2, 2), (2, 4), (4, 4)]),
] {
let out = apply(&src, &FilterParams::DeInterlace { eliminate_even, interpolate }, b, b, None);
for (row, (a, c)) in neighbours.into_iter().enumerate() {
for x in b.x0..b.x1 {
let (pa, pc) = (src.pixel(x, b.y0 + a), src.pixel(x, b.y0 + c));
let actual = out.pixel(x, b.y0 + row as i32);
for channel in 0..4 {
let expected = (pa[channel] + pc[channel]) / 2.0;
assert!(
(actual[channel] - expected).abs() <= tolerance(depth),
"{depth:?}, even={eliminate_even}, interp={interpolate}, row={row}: {actual:?}"
);
}
}
}
}
assert_eq!(src.read_region(b), before);
}
}
#[test]
fn deinterlace_interpolation_weights_colour_by_alpha() {
let b = Rect::new(0, 0, 1, 3);
for depth in DEPTHS {
for [a, c] in [[0.25, 0.75], [1.0, 0.0], [0.0, 0.0]] {
let src = rows(depth, b, &[[1.0, 0.0, 0.0, a], [0.0, 1.0, 0.0, 1.0], [0.0, 0.0, 1.0, c]]);
let out = apply(&src, &FilterParams::DeInterlace { eliminate_even: true, interpolate: true }, b, b, None);
let (a, c) = (src.pixel(0, 0)[3], src.pixel(0, 2)[3]);
let total = a + c;
let expected = if total > 0.0 { [a / total, 0.0, c / total, total / 2.0] } else { [0.0; 4] };
let actual = out.pixel(0, 1);
for (v, want) in actual.iter().zip(expected) {
assert!((v - want).abs() <= tolerance(depth), "{depth:?}: {actual:?} != {expected:?}");
}
assert_eq!(out.pixel(0, 0), src.pixel(0, 0));
assert_eq!(out.pixel(0, 2), src.pixel(0, 2));
}
}
}
#[test]
fn deinterlace_one_and_two_row_images_without_alpha_handle_missing_neighbours() {
for depth in DEPTHS {
for height in [1, 2] {
let b = Rect::new(0, -3, 1, -3 + height);
let mut src = Surface::new(PixelFormat::new(ColorMode::Grayscale, depth, false));
src.fill_rect(b, &[0.2]);
if height == 2 {
src.fill_rect(Rect::new(0, -2, 1, -1), &[0.8]);
}
for eliminate_even in [false, true] {
for interpolate in [false, true] {
let out = apply(&src, &FilterParams::DeInterlace { eliminate_even, interpolate }, b, b, None);
let kept_y = if height == 2 && !eliminate_even { -2 } else { -3 };
for y in b.y0..b.y1 {
assert_eq!(out.pixel(0, y), src.pixel(0, kept_y), "{depth:?}, height={height}, even={eliminate_even}, interp={interpolate}");
}
}
}
}
}
}
#[test]
fn deinterlace_leaves_pixels_outside_reference_bounds_unchanged() {
let area = Rect::new(0, 0, 1, 5);
let b = Rect::new(0, 1, 1, 4);
let src = rows(SampleType::F32, area, &[[0.1; 4], [0.2; 4], [0.4; 4], [0.8; 4], [1.0; 4]]);
for eliminate_even in [false, true] {
for interpolate in [false, true] {
let out = apply(&src, &FilterParams::DeInterlace { eliminate_even, interpolate }, area, b, None);
assert_eq!(out.pixel(0, 0), src.pixel(0, 0));
assert_eq!(out.pixel(0, 4), src.pixel(0, 4));
}
}
}
#[test]
fn ntsc_safe_colours_and_alpha_are_bit_exact_at_all_depths() {
let b = Rect::new(0, 0, 1, 5);
for depth in DEPTHS {
let src = rows(depth, b, &[[0.0, 0.0, 0.0, 0.0], [0.5, 0.5, 0.5, 0.25], [1.0, 1.0, 1.0, 0.75], [0.2, 0.3, 0.4, 1.0], [1.0, 0.0, 1.0, 1.0]]);
let out = apply(&src, &FilterParams::NtscColors, b, b, None);
assert_eq!(out.read_region(b), src.read_region(b), "{depth:?}");
}
}
fn luma_chroma(p: &[f32]) -> (f32, f32) {
let y = 0.299 * p[0] + 0.587 * p[1] + 0.114 * p[2];
let i = 0.595716 * p[0] - 0.274453 * p[1] - 0.321263 * p[2];
let q = 0.211456 * p[0] - 0.522591 * p[1] + 0.311135 * p[2];
(y, i.hypot(q))
}
#[test]
fn ntsc_saturated_colours_keep_luma_alpha_and_meet_composite_limits() {
// Independent signal checks: -20..120 IRE relative to the 7.5..100 IRE luma range.
let (lo, hi) = ((-20.0 - 7.5) / 92.5, (120.0 - 7.5) / 92.5);
let colours = [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.25], [1.0, 1.0, 0.0, 0.5], [0.0, 1.0, 1.0, 0.75]];
let b = Rect::new(0, 0, 1, colours.len() as i32);
for depth in DEPTHS {
let src = rows(depth, b, &colours);
let out = apply(&src, &FilterParams::NtscColors, b, b, None);
// The rounded YIQ inverse contributes < 0.0003; integer writes add one sample step.
let eps = 0.0003 + 2.0 * tolerance(depth);
for y in b.y0..b.y1 {
let (before, after) = (src.pixel(0, y), out.pixel(0, y));
let (y0, c0) = luma_chroma(&before);
let (y1, c1) = luma_chroma(&after);
assert!(y0 - c0 < lo || y0 + c0 > hi, "fixture must require correction");
assert!(c1 < c0, "chroma not reduced: {depth:?} {after:?}");
assert!((y1 - y0).abs() <= eps, "luma changed: {depth:?} {before:?} -> {after:?}");
assert!(y1 - c1 >= lo - eps && y1 + c1 <= hi + eps, "signal out of gamut: {depth:?} {after:?}");
assert!(after[..3].iter().all(|v| v.is_finite() && *v >= 0.0 && *v <= 1.0));
assert_eq!(after[3], before[3], "alpha changed: {depth:?}");
}
}
}
}