i_overlay 6.0.0

Boolean Operations for 2D Polygons: Supports intersection, union, difference, xor, and self-intersections for all polygon varieties.
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

#[cfg(test)]
mod tests {
    use i_float::float::compatible::FloatPointCompatible;
    use i_overlay::core::fill_rule::FillRule;
    use i_overlay::core::overlay_rule::OverlayRule;
    use i_overlay::float::clip::FloatClip;
    use i_overlay::float::single::SingleFloatOverlay;
    use i_overlay::float::slice::FloatSlice;
    use i_overlay::string::clip::ClipRule;

    #[test]
    fn test_simple_union() {
        // Define the subject "O"
        let subj = [
            // main contour
            vec![
                [1.0, 0.0],
                [4.0, 0.0],
                [4.0, 5.0],
                [1.0, 5.0], // the contour is auto closed!
            ],
            // hole contour
            vec![
                [2.0, 1.0],
                [2.0, 4.0],
                [3.0, 4.0],
                [3.0, 1.0], // the contour is auto closed!
            ],
        ];

        // Define the clip "-"
        let clip = [
            // main contour
            [0.0, 2.0],
            [5.0, 2.0],
            [5.0, 3.0],
            [0.0, 3.0], // the contour is auto closed!
        ];

        let result = subj.overlay(&clip, OverlayRule::Union, FillRule::EvenOdd);

        println!("result: {:?}", result);
    }

    #[test]
    fn test_custom_point() {
        #[derive(Clone, Copy, Debug)]
        struct CustomPoint {
            x: f32,
            y: f32,
        }

        impl FloatPointCompatible for CustomPoint {
            type Scalar = f32;

            fn from_xy(x: f32, y: f32) -> Self {
                Self { x, y }
            }

            fn x(&self) -> f32 {
                self.x
            }

            fn y(&self) -> f32 {
                self.y
            }
        }

        let subj = [
            CustomPoint { x: 0.0, y: 0.0 },
            CustomPoint { x: 0.0, y: 3.0 },
            CustomPoint { x: 3.0, y: 3.0 },
            CustomPoint { x: 3.0, y: 0.0 },
        ];

        let clip = [
            CustomPoint { x: 1.0, y: 1.0 },
            CustomPoint { x: 1.0, y: 2.0 },
            CustomPoint { x: 2.0, y: 2.0 },
            CustomPoint { x: 2.0, y: 1.0 },
        ];

        let result = subj.overlay(&clip, OverlayRule::Difference, FillRule::EvenOdd);

        println!("result: {:?}", result);
    }

    #[test]
    fn test_slice() {
        let polygon = [[1.0, 1.0], [1.0, 4.0], [4.0, 4.0], [4.0, 1.0]];

        let slicing_line = [[3.0, 5.0], [2.0, 2.0], [3.0, 3.0], [2.0, 0.0]];

        let result = polygon.slice_by(&slicing_line, FillRule::NonZero);

        println!("result: {:?}", result);
    }

    #[test]
    fn test_clip() {
        let polygon = [[1.0, 1.0], [1.0, 4.0], [4.0, 4.0], [4.0, 1.0]];

        let string_line = [[3.0, 5.0], [2.0, 2.0], [3.0, 3.0], [2.0, 0.0]];

        let clip_rule = ClipRule {
            invert: false,
            boundary_included: false,
        };
        let result = string_line.clip_by(&polygon, FillRule::NonZero, clip_rule);

        println!("result: {:?}", result);
    }
}