boostvoronoi 0.12.1

Boost voronoi ported to 100% rust
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203

use boostvoronoi::prelude as BV;
use boostvoronoi::prelude::*;

mod common;
use common::to_segments;

type I = i32;

fn retrieve_point<T: InputType>(
    point_data_: &[Point<T>],
    segment_data_: &[Line<T>],
    source: (BV::SourceIndex, SourceCategory),
) -> Point<T> {
    let source_index = source.0.usize();
    match source.1 {
        SourceCategory::SinglePoint => point_data_[source_index],
        SourceCategory::SegmentStart => segment_data_[source_index - point_data_.len()].start,
        SourceCategory::Segment | SourceCategory::SegmentEnd => {
            segment_data_[source_index - point_data_.len()].end
        }
    }
}

#[test]
fn segment_4_1() -> Result<(), BvError> {
    let _output = {
        let segments = to_segments(&[
            [200, 200, 200, 400],
            [200, 400, 400, 400],
            [400, 400, 400, 200],
            [400, 200, 200, 200],
            [529, 242, 367, 107],
            [94, 628, 512, 632],
            [680, 608, 669, 291],
            [572, 96, 363, 51],
            [147, 103, 96, 170],
        ]);

        Builder::<I>::default()
            .with_segments(segments.iter())?
            .build()?
    };
    for v in _output.vertices().iter() {
        assert!(!v.x().is_nan());
        assert!(!v.y().is_nan());
    }
    Ok(())
}

#[test]
fn vertical_segment_1() -> Result<(), BvError> {
    let v = Vec::<Point<I>>::default();
    let s = to_segments::<I>(&[
        [200, 200, 200, 400],
        [94, 628, 512, 632],
        [147, 103, 96, 170],
    ]);

    let output = Builder::<I>::default()
        .with_vertices(v.iter())?
        .with_segments(s.iter())?
        .build()?;

    for v in output.vertices().iter() {
        assert!(!v.x().is_nan());
        assert!(!v.y().is_nan());
    }

    assert_eq!(output.cells().len(), 9);
    let cell = output.cells()[0];
    assert_eq!(cell.id(), 0);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 94, y: 628 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[1];
    assert_eq!(cell.id(), 1);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 512, y: 632 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[2];
    assert_eq!(cell.id(), 2);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 96, y: 170 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[3];
    assert_eq!(cell.id(), 3);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 96, y: 170 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[4];
    assert_eq!(cell.id(), 4);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 147, y: 103 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[5];
    assert_eq!(cell.id(), 5);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 200, y: 200 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[6];
    assert_eq!(cell.id(), 6);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 200, y: 400 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[7];
    assert_eq!(cell.id(), 7);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 200, y: 400 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[8];
    assert_eq!(cell.id(), 8);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&v, &s, (source_index, cat));
    assert_eq!(p, Point { x: 512, y: 632 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    assert_eq!(output.vertices().len(), 10);
    assert_eq!(output.edges().len(), 36);
    /*let v = output.vertices()[0].get();
    assert!(almost_equal(v.x(), 143.7970909, v.y(), 200.0000000));
    assert_eq!(v.get_incident_edge().unwrap(),13);
    let v = output.vertices()[1].get();
    assert!(almost_equal(v.x(), 142.0840045, v.y(), 205.0788691));
    assert_eq!(v.get_incident_edge().unwrap(),15);
    let v = output.vertices()[2].get();
    assert!(almost_equal(v.x(), -102.2273417, v.y(), 398.1387452));
    assert_eq!(v.get_incident_edge().unwrap(),17);
    let v = output.vertices()[3].get();
    assert!(almost_equal(v.x(), -98.2075472, v.y(), 400.0000000));
    assert_eq!(v.get_incident_edge().unwrap(),21);
    let v = output.vertices()[4].get();
    assert!(almost_equal(v.x(), 95.3208257, v.y(), 489.9737172));
    assert_eq!(v.get_incident_edge().unwrap(),23);
    let v = output.vertices()[5].get();
    assert!(almost_equal(v.x(), 195.1646270, v.y(), 139.6626265));
    assert_eq!(v.get_incident_edge().unwrap(),25);
    let v = output.vertices()[6].get();
    assert!(almost_equal(v.x(), 431.2163645, v.y(), 400.0000000));
    assert_eq!(v.get_incident_edge().unwrap(),29);
    let v = output.vertices()[7].get();
    assert!(almost_equal(v.x(), 515.0143534, v.y(), 317.0000690));
    assert_eq!(v.get_incident_edge().unwrap(),31);
    let v = output.vertices()[8].get();
    assert!(almost_equal(v.x(), 655.0769231, v.y(), 200.0000000));
    assert_eq!(v.get_incident_edge().unwrap(),33);
    let v = output.vertices()[9].get();
    assert!(almost_equal(v.x(), 2427.4071661, v.y(), -1080.0162866));
    assert_eq!(v.get_incident_edge().unwrap(),35);*/
    Ok(())
}

#[test]
/// This used to give NaN coordinates in some vertexes
fn segment_4_2() -> Result<(), BvError> {
    let _output = {
        let segments: [[I; 4]; 7] = [
            [-19546, 47259, -45936, 36666],
            [-45936, 36666, -59968, -21417],
            [-59968, -21417, -125257, -19781],
            [-125257, -19781, -148480, -47150],
            [-148480, -47150, 148480, -57522],
            [148480, -57522, 105345, 58720],
            [105345, 58720, -19546, 47259],
        ];

        Builder::<I>::default()
            .with_segments(segments.iter())?
            .build()?
    };
    for v in _output.vertices().iter() {
        assert!(!v.x().is_nan());
        assert!(!v.y().is_nan());
    }
    Ok(())
}