figcraft/crates/render/src/band_tests.rs

//! Rendering in parallel bands matches rendering in one piece: effects that look past a band's
//! rows (inner shadows, background blurs) must not draw the band's edges into the picture.
#![cfg(not(target_arch = "wasm32"))]

use std::sync::Arc;

use super::*;
use figcraft_color::{ImageScaleMode, Paint};
use figcraft_doc::{Effect, EffectKind, ImageData, Shadow};

fn inner_shadow(offset: (f64, f64), radius: f64, spread: f64) -> Effect {
    Effect {
        kind: EffectKind::InnerShadow(Shadow { color: Color::from_hex("000000B3").unwrap(), offset, radius, spread, ..Default::default() }),
        visible: true,
    }
}

fn png() -> Vec<u8> {
    let img = image::RgbaImage::from_fn(64, 64, |x, y| image::Rgba([(x * 4) as u8, (y * 4) as u8, 160, 255]));
    let mut out = Vec::new();
    img.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
    out
}

/// An image-filled ellipse and a rotated solid rectangle, with inner shadows (`shadows`), and a
/// glass panel (background blur) over both (`glass`).
fn scene(shadows: bool, glass: bool) -> (Document, NodeId) {
    let mut d = Document::new("bands");
    let p = d.first_page().unwrap();
    // Image ids are content hashes in real documents and key the shared decode cache, so test
    // fixtures running in parallel need ids of their own.
    d.images.insert("band-tests-gradient".into(), ImageData { bytes: Arc::new(png()), width: 64, height: 64 });
    let e = d.create(p, NodeKind::Ellipse { start: 0.0, sweep: std::f64::consts::TAU, inner: 0.0 }, "E", 0.0, 0.0, 200.0, 200.0).unwrap();
    let n = d.get_mut(e).unwrap();
    n.fills = vec![Paint::image("band-tests-gradient", ImageScaleMode::Fill)];
    if shadows {
        n.effects = vec![inner_shadow((0.0, 4.0), 8.0, 0.0)];
    }
    let r = d.create(p, NodeKind::Rectangle, "R", 0.0, 0.0, 150.0, 180.0).unwrap();
    let n = d.get_mut(r).unwrap();
    n.fills = vec![Paint::solid(Color::from_hex("3C8CE6").unwrap())];
    n.transform = Affine::translate((260.0, 10.0)) * Affine::rotate(0.35);
    if shadows {
        n.effects = vec![inner_shadow((4.0, 4.0), 12.0, 2.0)];
    }
    if glass {
        let g = d.create(p, NodeKind::Rectangle, "Glass", 40.0, 60.0, 320.0, 120.0).unwrap();
        let n = d.get_mut(g).unwrap();
        n.fills = vec![Paint::solid(Color::from_hex("FFFFFF33").unwrap())];
        n.effects = vec![Effect { kind: EffectKind::BackgroundBlur(figcraft_doc::Blur::uniform(12.0)), visible: true }];
    }
    (d, p)
}

fn view(scale: f64) -> View {
    View { origin: (-10.0, -10.0), scale, width: (440.0 * scale) as u32, height: (240.0 * scale) as u32 }
}

/// Per row: the mean channel difference and how many pixels differ by more than 2. A band artifact
/// differs along a whole row; edge antialiasing may differ in a few pixels per edge (a curve
/// clipped at a band's edge rasterises a hair differently, most where it runs nearly level).
fn row_diffs(a: &Pixmap, b: &Pixmap) -> Vec<(f64, usize)> {
    let row = a.width() as usize * 4;
    a.data()
        .chunks(row)
        .zip(b.data().chunks(row))
        .map(|(x, y)| {
            let sum: f64 = x.iter().zip(y).map(|(p, q)| f64::from(p.abs_diff(*q))).sum();
            let off = x.chunks(4).zip(y.chunks(4)).filter(|(p, q)| p.iter().zip(*q).any(|(c, d)| c.abs_diff(*d) > 2)).count();
            (sum / row as f64, off)
        })
        .collect()
}

#[test]
fn bands_match_one_piece_rendering() {
    let (d, p) = scene(true, true);
    for scale in [1.0, 2.0] {
        let v = view(scale);
        let one = render_view_single(&d, p, &v, &Options::default()).unwrap();
        for bands in [2, 3, 7] {
            let banded = render_bands(&d, p, &v, &Options::default(), bands).unwrap();
            assert_eq!((banded.width(), banded.height()), (one.width(), one.height()));
            for (y, (mean, off)) in row_diffs(&one, &banded).into_iter().enumerate() {
                assert!(
                    mean < 0.25 && off * 20 <= v.width as usize,
                    "scale {scale}, {bands} bands: row {y} differs ({off} pixels, {mean:.2} on average)"
                );
            }
        }
    }
}

#[test]
fn inner_shadow_leaves_the_interior_alone() {
    // Far from the ellipse's edge, the image fill shows exactly as without the shadow, on every row
    // (the shadow used to draw a band at each render band's edge).
    let (with, p) = scene(true, false);
    let (without, _) = scene(false, false);
    let v = view(2.0);
    let a = render_bands(&with, p, &v, &Options::default(), 6).unwrap();
    let b = render_bands(&without, p, &v, &Options::default(), 6).unwrap();
    // Ellipse centre (100, 100) page units; the shadow reaches 3 sigma + offset = 16 units in.
    let (cx, cy, r) = (110.0 * 2.0, 110.0 * 2.0, (100.0 - 20.0) * 2.0);
    let mut checked = 0;
    for y in 0..v.height {
        for x in 0..v.width {
            let (dx, dy) = (f64::from(x) - cx, f64::from(y) - cy);
            if dx * dx + dy * dy > r * r {
                continue;
            }
            let i = ((y * v.width + x) * 4) as usize;
            assert_eq!(a.data()[i..i + 4], b.data()[i..i + 4], "pixel {x},{y}");
            checked += 1;
        }
    }
    assert!(checked > 10_000, "{checked}");
}

#[test]
fn huge_backdrop_blur_renders_in_one_piece() {
    let (mut d, p) = scene(true, true);
    let g = d.find_by_name("Glass", None)[0];
    d.get_mut(g).unwrap().effects = vec![Effect { kind: EffectKind::BackgroundBlur(figcraft_doc::Blur::uniform(1e6)), visible: true }];
    assert!(render_bands(&d, p, &view(1.0), &Options::default(), 4).is_none());
    assert!(render_view(&d, p, &view(1.0), &Options::default()).is_some());
}