automesh 0.3.9

Automatic mesh generation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::{NSD, Remove, Scale, Translate};

use super::{Nel, Voxels, filter_voxel_data};

const NUM_ELEMENTS: usize = 39;

const BLOCKS_GOLD: [u8; NUM_ELEMENTS] = [1; NUM_ELEMENTS];
const VOXELS_GOLD: [[usize; NSD]; NUM_ELEMENTS] = [
    [0, 0, 0],
    [1, 0, 0],
    [2, 0, 0],
    [3, 0, 0],
    [0, 1, 0],
    [1, 1, 0],
    [2, 1, 0],
    [3, 1, 0],
    [0, 2, 0],
    [1, 2, 0],
    [2, 2, 0],
    [3, 2, 0],
    [0, 3, 0],
    [1, 3, 0],
    [2, 3, 0],
    [3, 3, 0],
    [0, 4, 0],
    [1, 4, 0],
    [2, 4, 0],
    [3, 4, 0],
    [0, 0, 1],
    [0, 1, 1],
    [0, 2, 1],
    [1, 2, 1],
    [2, 2, 1],
    [3, 2, 1],
    [0, 3, 1],
    [0, 4, 1],
    [1, 4, 1],
    [2, 4, 1],
    [3, 4, 1],
    [0, 0, 2],
    [0, 1, 2],
    [0, 2, 2],
    [0, 3, 2],
    [0, 4, 2],
    [1, 4, 2],
    [2, 4, 2],
    [3, 4, 2],
];

#[test]
fn filter() {
    let spn = Voxels::from_npy(
        "tests/input/letter_f_3d.npy",
        Remove::default(),
        Scale::default(),
        Translate::default(),
    )
    .unwrap();
    let (filtered_voxel_data, element_blocks) =
        filter_voxel_data(spn.get_data().to_owned(), Remove::from(vec![0]));
    assert_eq!(element_blocks.len(), NUM_ELEMENTS);
    BLOCKS_GOLD
        .iter()
        .zip(element_blocks.iter())
        .for_each(|(gold_n, block_n)| assert_eq!(gold_n, block_n));
    assert_eq!(filtered_voxel_data.len(), NUM_ELEMENTS);
    VOXELS_GOLD
        .iter()
        .flatten()
        .zip(filtered_voxel_data.iter().flatten())
        .for_each(|(entry, gold)| assert_eq!(entry, gold));
}

mod nel {
    use super::*;
    mod from_input {
        use super::*;
        #[test]
        #[should_panic(expected = "Argument nelx was required but was not provided")]
        fn missing_x() {
            let _ = Nel::from_input([None, None, None]).unwrap();
        }
        #[test]
        #[should_panic(expected = "Argument nely was required but was not provided")]
        fn missing_y() {
            let _ = Nel::from_input([Some(1), None, None]).unwrap();
        }
        #[test]
        #[should_panic(expected = "Argument nelz was required but was not provided")]
        fn missing_z() {
            let _ = Nel::from_input([Some(1), Some(1), None]).unwrap();
        }
        #[test]
        fn success() {
            let _ = Nel::from_input([Some(1), Some(1), Some(1)]).unwrap();
        }
    }
    mod from_slice {
        use super::*;
        #[test]
        #[should_panic(expected = "Need to specify nel > 0")]
        fn nonzero() {
            let _ = Nel::from(&[0, 1, 2][..]);
        }
        #[test]
        fn success() {
            let _ = Nel::from(&[1, 2, 3][..]);
        }
    }
    mod from_iter {
        use super::*;
        #[test]
        #[should_panic(expected = "Need to specify nel > 0")]
        fn nonzero() {
            let _ = [0, 2, 3].into_iter().collect::<Nel>();
        }
        #[test]
        fn success() {
            let _ = [1, 2, 3].into_iter().collect::<Nel>();
        }
    }
}