hcie-rust-v3.05/hcie-selection/tests/mask_ops.rs

#[test]
fn test_create_rect_mask_full() {
    let mask = hcie_selection::create_rect_mask(4, 4, 0, 0, 3, 3);
    assert!(mask.iter().all(|&v| v == 255), "full rect mask should be all 255");
}

#[test]
fn test_create_rect_mask_partial() {
    let mask = hcie_selection::create_rect_mask(4, 4, 1, 1, 2, 2);
    assert_eq!(mask[0], 0, "top-left should be 0");
    assert_eq!(mask[(1 * 4 + 1) as usize], 255, "center should be 255");
}

#[test]
fn test_create_ellipse_mask() {
    let mask = hcie_selection::create_ellipse_mask(5, 5, 2, 2, 2, 2);
    assert_eq!(mask[(2 * 5 + 2) as usize], 255, "center should be selected");
    assert!(mask[(0 * 5 + 0) as usize] == 0, "corner should be 0");
}

#[test]
fn test_invert_mask() {
    let mut mask = vec![0u8; 16];
    mask[0] = 255;
    hcie_selection::invert_mask(&mut mask);
    assert_eq!(mask[0], 0, "originally 255 should become 0");
    assert_eq!(mask[1], 255, "originally 0 should become 255");
}

#[test]
fn test_invert_twice_is_identity() {
    let original = vec![
        0, 255, 0, 255,
        255, 0, 255, 0,
        0, 255, 0, 255,
        255, 0, 255, 0,
    ];
    let mut mask = original.clone();
    hcie_selection::invert_mask(&mut mask);
    hcie_selection::invert_mask(&mut mask);
    assert_eq!(mask, original, "double invert should be identity");
}

#[test]
fn test_grow_mask() {
    let mut mask = vec![0u8; 25];
    mask[12] = 255;
    hcie_selection::grow_mask(&mut mask, 5, 5, 1);
    let new_count = mask.iter().filter(|&&v| v > 0).count();
    assert!(new_count > 1, "grow should add more selected pixels");
}

#[test]
fn test_grow_zero_is_noop() {
    let mut mask = vec![
        0, 255, 0,
        255, 0, 255,
        0, 255, 0,
    ];
    let original = mask.clone();
    hcie_selection::grow_mask(&mut mask, 3, 3, 0);
    assert_eq!(mask, original, "px=0 should not change mask");
}

#[test]
fn test_shrink_mask() {
    let mut mask = vec![255u8; 25];
    hcie_selection::shrink_mask(&mut mask, 5, 5, 1);
    let new_count = mask.iter().filter(|&&v| v > 0).count();
    assert!(new_count < 25, "shrink should remove border pixels");
}

#[test]
fn test_shrink_zero_is_noop() {
    let mut mask = vec![255u8; 25];
    let original = mask.clone();
    hcie_selection::shrink_mask(&mut mask, 5, 5, 0);
    assert_eq!(mask, original, "px=0 should not change mask");
}

#[test]
fn test_grow_shrink_roundtrip() {
    let original = vec![
        0, 0, 0, 0, 0,
        0, 255, 255, 255, 0,
        0, 255, 255, 255, 0,
        0, 255, 255, 255, 0,
        0, 0, 0, 0, 0,
    ];
    let mut mask = original.clone();
    hcie_selection::grow_mask(&mut mask, 5, 5, 1);
    hcie_selection::shrink_mask(&mut mask, 5, 5, 1);
    assert_eq!(mask, original, "grow then shrink should restore original");
}

#[test]
fn test_feather_mask() {
    let mut mask = vec![0u8; 25];
    for y in 1..4 {
        for x in 1..4 {
            mask[(y * 5 + x) as usize] = 255;
        }
    }
    hcie_selection::feather_mask(&mut mask, 5, 5, 1.0);
    assert_eq!(mask[12], 255, "center should stay 255");
    assert!(mask[0] < 255, "corner should have some feathering");
}

#[test]
fn test_feather_zero_is_noop() {
    let mut mask = vec![0u8; 16];
    mask[5] = 255;
    let original = mask.clone();
    hcie_selection::feather_mask(&mut mask, 4, 4, 0.0);
    assert_eq!(mask, original, "radius=0 should not change mask");
}

#[test]
fn test_mask_at() {
    let mask = vec![
        0, 255, 0,
        255, 0, 255,
        0, 255, 0,
    ];
    assert_eq!(hcie_selection::mask_at(Some(&mask), 3, 1, 1), 0);
    assert_eq!(hcie_selection::mask_at(Some(&mask), 3, 0, 1), 255);
    assert_eq!(hcie_selection::mask_at(None, 3, 5, 5), 255);
}

#[test]
fn test_magic_wand() {
    let pixels = vec![
        255, 0, 0, 255,  255, 0, 0, 255,
        255, 0, 0, 255,  0, 255, 0, 255,
    ];
    let mask = hcie_selection::magic_wand_mask(&pixels, 2, 2, 0, 0, 10);
    assert_eq!(mask[0], 255, "seed itself");
    assert_eq!(mask[1], 255, "adjacent same color");
    assert_eq!(mask[3], 0, "different pixel at (1,1)");
}

#[test]
fn test_lasso_fill_mask() {
    let mut mask = vec![0u8; 25];
    let points = [(0u32, 0u32), (4, 0), (4, 4), (0, 4)];
    hcie_selection::lasso_fill_mask(&mut mask, 5, 5, &points);
    assert_eq!(mask[12], 255, "center should be filled");
}