i_shape 3.0.0

iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

#[macro_export]
macro_rules! int_path {
    ( $( [$x:expr, $y:expr] ),* $(,)? ) => {
        {
            let mut path: $crate::base::data::Path<_> = ::core::default::Default::default();
            $(
                path.push($crate::int::IntPoint::new($x, $y));
            )*
            path
        }
    };
}

#[macro_export]
macro_rules! int_shape {
    ( $( [ $( [$x:expr, $y:expr] ),* $(,)? ] ),* $(,)? ) => {
        {
            let mut shape: $crate::base::data::Shape<_> = ::core::default::Default::default();
            $(
                let mut contour: $crate::base::data::Contour<_> = ::core::default::Default::default();
                $(
                    contour.push($crate::int::IntPoint::new($x, $y));
                )*
                shape.push(contour);
            )*
            shape
        }
    };
}

#[macro_export]
macro_rules! int_shapes {
    ( $( [ $( [ $( [$x:expr, $y:expr] ),* $(,)? ] ),* $(,)? ] ),* $(,)? ) => {
        {
            let mut shapes: $crate::base::data::Shapes<_> = ::core::default::Default::default();
            $(
                let mut shape: $crate::base::data::Shape<_> = ::core::default::Default::default();
                $(
                    let mut contour: $crate::base::data::Contour<_> = ::core::default::Default::default();
                    $(
                        contour.push($crate::int::IntPoint::new($x, $y));
                    )*
                    shape.push(contour);
                )*
                shapes.push(shape);
            )*
            shapes
        }
    };
}

#[macro_export]
macro_rules! path {
    ( $( $point:expr ),* $(,)? ) => {
        {
            let mut path: $crate::base::data::Path<_> = ::core::default::Default::default();
            $(
                path.push($point);
            )*
            path
        }
    };
}

#[macro_export]
macro_rules! paths {
    ( $( [ $( $point:expr ),* $(,)? ] ),* $(,)? ) => {
        {
            let mut paths: $crate::base::data::Paths<_> = ::core::default::Default::default();
            $(
                let mut path: $crate::base::data::Path<_> = ::core::default::Default::default();
                $(
                    path.push($point);
                )*
                paths.push(path);
            )*
            paths
        }
    };
}

#[cfg(test)]
mod tests {
    use alloc::vec;
    use i_float::int::point::IntPoint;

    #[test]
    fn int_path_macro_builds_vectors() {
        let path = int_path![[0, 1], [2, 3], [4, 5]];
        assert_eq!(
            path,
            vec![IntPoint::new(0, 1), IntPoint::new(2, 3), IntPoint::new(4, 5),]
        );
    }

    #[test]
    fn int_shape_macro_builds_nested_vectors() {
        let shape = int_shape![[[0, 0], [1, 0], [1, 1]], [[2, 2], [3, 2], [3, 3], [2, 3]],];

        assert_eq!(
            shape,
            vec![
                vec![IntPoint::new(0, 0), IntPoint::new(1, 0), IntPoint::new(1, 1),],
                vec![
                    IntPoint::new(2, 2),
                    IntPoint::new(3, 2),
                    IntPoint::new(3, 3),
                    IntPoint::new(2, 3),
                ],
            ]
        );
    }

    #[test]
    fn int_shapes_macro_builds_multiple_shapes() {
        let shapes = int_shapes![
            [[[0, 0], [1, 0], [1, 1]], [[2, 0], [3, 0], [3, 1]],],
            [[[10, 10], [11, 10], [11, 11], [10, 11]],],
        ];

        assert_eq!(
            shapes,
            vec![
                vec![
                    vec![IntPoint::new(0, 0), IntPoint::new(1, 0), IntPoint::new(1, 1),],
                    vec![IntPoint::new(2, 0), IntPoint::new(3, 0), IntPoint::new(3, 1),],
                ],
                vec![vec![
                    IntPoint::new(10, 10),
                    IntPoint::new(11, 10),
                    IntPoint::new(11, 11),
                    IntPoint::new(10, 11),
                ],],
            ]
        );
    }
}