Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

4.0 KB
Raw Blame
use super::*;

/// A plane with 1 inside `inside` and 0 elsewhere.
fn square(rect: IRect, inside: IRect) -> Plane {
    let mut p = Plane::filled(rect, 0.0);
    let mut i = 0;
    for y in rect.y..rect.bottom() {
        for x in rect.x..rect.right() {
            if inside.contains(x, y) {
                p.v[i] = 1.0;
            }
            i += 1;
        }
    }
    p
}

#[test]
fn crop_and_get_read_zero_outside() {
    let p = square(IRect::new(0, 0, 4, 4), IRect::new(1, 1, 2, 2));
    assert_eq!(p.get(1, 1), 1.0);
    assert_eq!(p.get(10, 1), 0.0);
    let c = p.crop(IRect::new(-2, -2, 4, 4));
    assert_eq!(c.v.iter().filter(|&&v| v == 1.0).count(), 1);
    assert_eq!(c.get(1, 1), 1.0);
}

#[test]
fn blur_keeps_flat_areas_and_spreads_edges_symmetrically() {
    let rect = IRect::new(0, 0, 80, 80);
    let mut p = square(rect, IRect::new(20, 20, 40, 40));
    blur(&mut p, 3.0);
    // Deep inside stays 1, far outside 0.
    assert!((p.get(40, 40) - 1.0).abs() < 1e-4);
    assert!(p.get(2, 2) < 1e-4);
    // The edge is half covered, and the falloff mirrors around it.
    let edge = (p.get(19, 40) + p.get(20, 40)) / 2.0;
    assert!((edge - 0.5).abs() < 0.02, "{edge}");
    for d in 1..8 {
        let out = p.get(19 - d, 40);
        let inside = p.get(20 + d, 40);
        assert!((out + inside - 1.0).abs() < 0.02, "{d}: {out} {inside}");
    }
    // Small sigmas do nothing.
    let mut q = square(rect, IRect::new(20, 20, 40, 40));
    let before = q.clone();
    blur(&mut q, 0.2);
    assert_eq!(q, before);
    // Huge ones are clamped, not a hang or a panic.
    let mut tiny = Plane::filled(IRect::new(0, 0, 3, 3), 1.0);
    blur(&mut tiny, 1e9);
    assert!(tiny.v.iter().all(|v| v.is_finite()));
}

#[test]
fn distance_matches_brute_force() {
    let rect = IRect::new(5, -3, 23, 17);
    let set: Vec<(i32, i32)> = vec![(2, 3), (17, 1), (9, 14), (20, 15)];
    let d = distance(rect, |i| {
        let (x, y) = ((i as i32) % rect.w, (i as i32) / rect.w);
        set.contains(&(x, y))
    });
    for y in 0..rect.h {
        for x in 0..rect.w {
            let expected = set
                .iter()
                .map(|&(sx, sy)| (((sx - x).pow(2) + (sy - y).pow(2)) as f32).sqrt())
                .fold(f32::MAX, f32::min);
            let got = d[(y * rect.w + x) as usize];
            assert!(
                (got - expected).abs() < 1e-4,
                "({x}, {y}): {got} vs {expected}"
            );
        }
    }
    // Nothing set: everything is infinitely far.
    let none = distance(IRect::new(0, 0, 3, 3), |_| false);
    assert!(none.iter().all(|&v| v == f32::MAX));
}

#[test]
fn dilation_and_erosion_move_edges_by_their_radius() {
    let rect = IRect::new(0, 0, 60, 60);
    let p = square(rect, IRect::new(20, 20, 20, 20));
    let grown = dilate(&p, 3.0);
    // Three more columns on each side, the next one untouched.
    for x in 17..43 {
        assert_eq!(grown.get(x, 30), 1.0, "{x}");
    }
    assert_eq!(grown.get(16, 30), 0.0);
    assert_eq!(grown.get(43, 30), 0.0);
    // Corners round off: the diagonal pixel at distance ~3.6 is partial.
    assert!(grown.get(16, 16) < 0.5);
    let half = dilate(&p, 0.5);
    assert!((half.get(19, 30) - 0.5).abs() < 1e-6);
    let shrunk = erode(&p, 4.0);
    assert_eq!(shrunk.get(23, 30), 0.0);
    assert_eq!(shrunk.get(24, 30), 1.0);
    assert_eq!(shrunk.get(35, 30), 1.0);
    assert_eq!(shrunk.get(36, 30), 0.0);
    assert_eq!(erode(&p, 0.0), p);
    // Eroding away everything leaves nothing.
    assert!(erode(&p, 15.0).v.iter().all(|&v| v == 0.0));
}

#[test]
fn shifting_moves_by_whole_and_fractional_pixels() {
    let rect = IRect::new(0, 0, 10, 10);
    let p = square(rect, IRect::new(4, 4, 1, 1));
    let s = p.shifted(2.0, -1.0, rect, 0.0);
    assert_eq!(s.get(6, 3), 1.0);
    assert_eq!(s.v.iter().sum::<f32>(), 1.0);
    let h = p.shifted(0.5, 0.0, rect, 0.0);
    assert!((h.get(4, 4) - 0.5).abs() < 1e-6 && (h.get(5, 4) - 0.5).abs() < 1e-6);
    // Outside the source, the given value.
    let o = p.shifted(3.0, 0.0, rect, 1.0);
    assert_eq!(o.get(0, 0), 1.0);
}