]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Geometry (aka GGL, Generic Geometry Library) |
2 | ||
3 | // Copyright (c) 2014-2015, Oracle and/or its affiliates. | |
4 | ||
5 | // Licensed under the Boost Software License version 1.0. | |
6 | // http://www.boost.org/users/license.html | |
7 | ||
8 | // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle | |
9 | // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle | |
10 | ||
11 | #ifndef BOOST_TEST_MODULE | |
12 | #define BOOST_TEST_MODULE test_disjoint_coverage | |
13 | #endif | |
14 | ||
15 | // unit test to test disjoint for all geometry combinations | |
16 | ||
17 | #include <iostream> | |
18 | ||
19 | #include <boost/test/included/unit_test.hpp> | |
20 | ||
21 | #include <boost/geometry/core/tag.hpp> | |
22 | #include <boost/geometry/core/tags.hpp> | |
23 | ||
24 | #include <boost/geometry/strategies/strategies.hpp> | |
25 | ||
26 | #include <boost/geometry/io/wkt/wkt.hpp> | |
27 | #include <boost/geometry/io/dsv/write.hpp> | |
28 | ||
29 | #include <boost/geometry/geometries/geometries.hpp> | |
30 | ||
31 | #include <boost/geometry/algorithms/disjoint.hpp> | |
32 | ||
33 | #include <from_wkt.hpp> | |
34 | ||
35 | ||
36 | #ifdef HAVE_TTMATH | |
37 | #include <boost/geometry/extensions/contrib/ttmath_stub.hpp> | |
38 | #endif | |
39 | ||
40 | namespace bg = ::boost::geometry; | |
41 | ||
42 | //============================================================================ | |
43 | ||
44 | struct test_disjoint | |
45 | { | |
46 | template <typename Geometry1, typename Geometry2> | |
47 | static inline void apply(std::string const& case_id, | |
48 | Geometry1 const& geometry1, | |
49 | Geometry2 const& geometry2, | |
50 | bool expected_result) | |
51 | { | |
52 | bool result = bg::disjoint(geometry1, geometry2); | |
53 | BOOST_CHECK_MESSAGE(result == expected_result, | |
54 | "case ID: " << case_id << ", G1: " << bg::wkt(geometry1) | |
55 | << ", G2: " << bg::wkt(geometry2) << " -> Expected: " | |
56 | << expected_result << ", detected: " << result); | |
57 | ||
58 | result = bg::disjoint(geometry2, geometry1); | |
59 | BOOST_CHECK_MESSAGE(result == expected_result, | |
60 | "case ID: " << case_id << ", G1: " << bg::wkt(geometry2) | |
61 | << ", G2: " << bg::wkt(geometry1) << " -> Expected: " | |
62 | << expected_result << ", detected: " << result); | |
63 | ||
64 | #ifdef BOOST_GEOMETRY_TEST_DEBUG | |
65 | std::cout << "case ID: " << case_id << "; G1 - G2: "; | |
66 | std::cout << bg::wkt(geometry1) << " - "; | |
67 | std::cout << bg::wkt(geometry2) << std::endl; | |
68 | std::cout << std::boolalpha; | |
69 | std::cout << "expected/computed result: " | |
70 | << expected_result << " / " << result << std::endl; | |
71 | std::cout << std::endl; | |
72 | std::cout << std::noboolalpha; | |
73 | #endif | |
74 | } | |
75 | }; | |
76 | ||
77 | //============================================================================ | |
78 | ||
79 | // linear-areal geometries | |
80 | template <typename P> | |
81 | inline void test_segment_box() | |
82 | { | |
83 | typedef bg::model::segment<P> S; | |
84 | typedef bg::model::box<P> B; | |
85 | ||
86 | typedef test_disjoint tester; | |
87 | ||
88 | tester::apply("s-b-01", | |
89 | from_wkt<S>("SEGMENT(0 0,2 0)"), | |
90 | from_wkt<B>("BOX(0 0,2 2)"), | |
91 | false); | |
92 | ||
93 | tester::apply("s-b-02", | |
94 | from_wkt<S>("SEGMENT(1 1,3 3)"), | |
95 | from_wkt<B>("BOX(0 0,2 2)"), | |
96 | false); | |
97 | ||
98 | tester::apply("s-b-03", | |
99 | from_wkt<S>("SEGMENT(2 2,3 3)"), | |
100 | from_wkt<B>("BOX(0 0,2 2)"), | |
101 | false); | |
102 | ||
103 | tester::apply("s-b-04", | |
104 | from_wkt<S>("SEGMENT(4 4,3 3)"), | |
105 | from_wkt<B>("BOX(0 0,2 2)"), | |
106 | true); | |
107 | ||
108 | tester::apply("s-b-05", | |
109 | from_wkt<S>("SEGMENT(0 4,4 4)"), | |
110 | from_wkt<B>("BOX(0 0,2 2)"), | |
111 | true); | |
112 | ||
113 | tester::apply("s-b-06", | |
114 | from_wkt<S>("SEGMENT(4 0,4 4)"), | |
115 | from_wkt<B>("BOX(0 0,2 2)"), | |
116 | true); | |
117 | ||
118 | tester::apply("s-b-07", | |
119 | from_wkt<S>("SEGMENT(0 -2,0 -1)"), | |
120 | from_wkt<B>("BOX(0 0,1 1)"), | |
121 | true); | |
122 | ||
123 | tester::apply("s-b-08", | |
124 | from_wkt<S>("SEGMENT(-2 -2,-2 -1)"), | |
125 | from_wkt<B>("BOX(0 0,1 1)"), | |
126 | true); | |
127 | ||
128 | tester::apply("s-b-09", | |
129 | from_wkt<S>("SEGMENT(-2 -2,-2 -2)"), | |
130 | from_wkt<B>("BOX(0 0,1 1)"), | |
131 | true); | |
132 | ||
133 | tester::apply("s-b-10", | |
134 | from_wkt<S>("SEGMENT(-2 0,-2 0)"), | |
135 | from_wkt<B>("BOX(0 0,1 1)"), | |
136 | true); | |
137 | ||
138 | tester::apply("s-b-11", | |
139 | from_wkt<S>("SEGMENT(0 -2,0 -2)"), | |
140 | from_wkt<B>("BOX(0 0,1 1)"), | |
141 | true); | |
142 | ||
143 | tester::apply("s-b-12", | |
144 | from_wkt<S>("SEGMENT(-2 0,-1 0)"), | |
145 | from_wkt<B>("BOX(0 0,1 1)"), | |
146 | true); | |
147 | ||
148 | // segment degenerates to a point | |
149 | tester::apply("s-b-13", | |
150 | from_wkt<S>("SEGMENT(0 0,0 0)"), | |
151 | from_wkt<B>("BOX(0 0,1 1)"), | |
152 | false); | |
153 | ||
154 | tester::apply("s-b-14", | |
155 | from_wkt<S>("SEGMENT(1 1,1 1)"), | |
156 | from_wkt<B>("BOX(0 0,2 2)"), | |
157 | false); | |
158 | ||
159 | tester::apply("s-b-15", | |
160 | from_wkt<S>("SEGMENT(2 2,2 2)"), | |
161 | from_wkt<B>("BOX(0 0,2 2)"), | |
162 | false); | |
163 | ||
164 | tester::apply("s-b-16", | |
165 | from_wkt<S>("SEGMENT(2 0,2 0)"), | |
166 | from_wkt<B>("BOX(0 0,2 2)"), | |
167 | false); | |
168 | ||
169 | tester::apply("s-b-17", | |
170 | from_wkt<S>("SEGMENT(0 2,0 2)"), | |
171 | from_wkt<B>("BOX(0 0,2 2)"), | |
172 | false); | |
173 | ||
174 | tester::apply("s-b-18", | |
175 | from_wkt<S>("SEGMENT(2 2,2 2)"), | |
176 | from_wkt<B>("BOX(0 0,1 1)"), | |
177 | true); | |
178 | } | |
179 | ||
180 | template <typename P> | |
181 | inline void test_segment_ring() | |
182 | { | |
183 | typedef bg::model::segment<P> S; | |
184 | typedef bg::model::ring<P, false, false> R; // ccw, open | |
185 | ||
186 | typedef test_disjoint tester; | |
187 | ||
188 | tester::apply("s-r-01", | |
189 | from_wkt<S>("SEGMENT(0 0,2 0)"), | |
190 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
191 | false); | |
192 | ||
193 | tester::apply("s-r-02", | |
194 | from_wkt<S>("SEGMENT(1 0,3 3)"), | |
195 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
196 | false); | |
197 | ||
198 | tester::apply("s-r-03", | |
199 | from_wkt<S>("SEGMENT(1 1,3 3)"), | |
200 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
201 | false); | |
202 | ||
203 | tester::apply("s-r-04", | |
204 | from_wkt<S>("SEGMENT(2 2,3 3)"), | |
205 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
206 | true); | |
207 | } | |
208 | ||
209 | template <typename P> | |
210 | inline void test_segment_polygon() | |
211 | { | |
212 | typedef bg::model::segment<P> S; | |
213 | typedef bg::model::polygon<P, false, false> PL; // ccw, open | |
214 | ||
215 | typedef test_disjoint tester; | |
216 | ||
217 | tester::apply("s-pg-01", | |
218 | from_wkt<S>("SEGMENT(0 0,2 0)"), | |
219 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
220 | false); | |
221 | ||
222 | tester::apply("s-pg-02", | |
223 | from_wkt<S>("SEGMENT(1 0,3 3)"), | |
224 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
225 | false); | |
226 | ||
227 | tester::apply("s-pg-03", | |
228 | from_wkt<S>("SEGMENT(1 1,3 3)"), | |
229 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
230 | false); | |
231 | ||
232 | tester::apply("s-pg-04", | |
233 | from_wkt<S>("SEGMENT(2 2,3 3)"), | |
234 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
235 | true); | |
236 | } | |
237 | ||
238 | template <typename P> | |
239 | inline void test_segment_multipolygon() | |
240 | { | |
241 | typedef bg::model::segment<P> S; | |
242 | typedef bg::model::polygon<P, false, false> PL; // ccw, open | |
243 | typedef bg::model::multi_polygon<PL> MPL; | |
244 | ||
245 | typedef test_disjoint tester; | |
246 | ||
247 | tester::apply("s-mpg-01", | |
248 | from_wkt<S>("SEGMENT(0 0,2 0)"), | |
249 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
250 | false); | |
251 | ||
252 | tester::apply("s-mpg-02", | |
253 | from_wkt<S>("SEGMENT(1 0,3 3)"), | |
254 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
255 | false); | |
256 | ||
257 | tester::apply("s-mpg-03", | |
258 | from_wkt<S>("SEGMENT(1 1,3 3)"), | |
259 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
260 | false); | |
261 | ||
262 | tester::apply("s-mpg-04", | |
263 | from_wkt<S>("SEGMENT(2 2,3 3)"), | |
264 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
265 | true); | |
266 | } | |
267 | ||
268 | template <typename P> | |
269 | inline void test_linestring_box() | |
270 | { | |
271 | typedef bg::model::linestring<P> L; | |
272 | typedef bg::model::box<P> B; | |
273 | ||
274 | typedef test_disjoint tester; | |
275 | ||
276 | tester::apply("l-b-01", | |
277 | from_wkt<L>("LINESTRING(0 0,2 0)"), | |
278 | from_wkt<B>("BOX(0 0,2 2)"), | |
279 | false); | |
280 | ||
281 | tester::apply("l-b-02", | |
282 | from_wkt<L>("LINESTRING(1 1,3 3)"), | |
283 | from_wkt<B>("BOX(0 0,2 2)"), | |
284 | false); | |
285 | ||
286 | tester::apply("l-b-03", | |
287 | from_wkt<L>("LINESTRING(2 2,3 3)"), | |
288 | from_wkt<B>("BOX(0 0,2 2)"), | |
289 | false); | |
290 | ||
291 | tester::apply("l-b-04", | |
292 | from_wkt<L>("LINESTRING(4 4,3 3)"), | |
293 | from_wkt<B>("BOX(0 0,2 2)"), | |
294 | true); | |
295 | } | |
296 | ||
297 | template <typename P> | |
298 | inline void test_linestring_ring() | |
299 | { | |
300 | typedef bg::model::linestring<P> L; | |
301 | typedef bg::model::ring<P, false, false> R; // ccw, open | |
302 | ||
303 | typedef test_disjoint tester; | |
304 | ||
305 | tester::apply("l-r-01", | |
306 | from_wkt<L>("LINESTRING(0 0,2 0)"), | |
307 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
308 | false); | |
309 | ||
310 | tester::apply("l-r-02", | |
311 | from_wkt<L>("LINESTRING(1 0,3 3)"), | |
312 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
313 | false); | |
314 | ||
315 | tester::apply("l-r-03", | |
316 | from_wkt<L>("LINESTRING(1 1,3 3)"), | |
317 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
318 | false); | |
319 | ||
320 | tester::apply("l-r-04", | |
321 | from_wkt<L>("LINESTRING(2 2,3 3)"), | |
322 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
323 | true); | |
324 | } | |
325 | ||
326 | template <typename P> | |
327 | inline void test_linestring_polygon() | |
328 | { | |
329 | typedef bg::model::linestring<P> L; | |
330 | typedef bg::model::polygon<P, false, false> PL; // ccw, open | |
331 | ||
332 | typedef test_disjoint tester; | |
333 | ||
334 | tester::apply("l-pg-01", | |
335 | from_wkt<L>("LINESTRING(0 0,2 0)"), | |
336 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
337 | false); | |
338 | ||
339 | tester::apply("l-pg-02", | |
340 | from_wkt<L>("LINESTRING(1 0,3 3)"), | |
341 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
342 | false); | |
343 | ||
344 | tester::apply("l-pg-03", | |
345 | from_wkt<L>("LINESTRING(1 1,3 3)"), | |
346 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
347 | false); | |
348 | ||
349 | tester::apply("l-pg-04", | |
350 | from_wkt<L>("LINESTRING(2 2,3 3)"), | |
351 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
352 | true); | |
353 | } | |
354 | ||
355 | template <typename P> | |
356 | inline void test_linestring_multipolygon() | |
357 | { | |
358 | typedef bg::model::linestring<P> L; | |
359 | typedef bg::model::polygon<P, false, false> PL; // ccw, open | |
360 | typedef bg::model::multi_polygon<PL> MPL; | |
361 | ||
362 | typedef test_disjoint tester; | |
363 | ||
364 | tester::apply("l-mpg-01", | |
365 | from_wkt<L>("LINESTRING(0 0,2 0)"), | |
366 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
367 | false); | |
368 | ||
369 | tester::apply("l-mpg-02", | |
370 | from_wkt<L>("LINESTRING(1 0,3 3)"), | |
371 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
372 | false); | |
373 | ||
374 | tester::apply("l-mpg-03", | |
375 | from_wkt<L>("LINESTRING(1 1,3 3)"), | |
376 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
377 | false); | |
378 | ||
379 | tester::apply("l-mpg-04", | |
380 | from_wkt<L>("LINESTRING(2 2,3 3)"), | |
381 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
382 | true); | |
383 | } | |
384 | ||
385 | template <typename P> | |
386 | inline void test_multilinestring_box() | |
387 | { | |
388 | typedef bg::model::linestring<P> L; | |
389 | typedef bg::model::multi_linestring<L> ML; | |
390 | typedef bg::model::box<P> B; | |
391 | ||
392 | typedef test_disjoint tester; | |
393 | ||
394 | tester::apply("ml-b-01", | |
395 | from_wkt<ML>("MULTILINESTRING((0 0,2 0))"), | |
396 | from_wkt<B>("BOX(0 0,2 2)"), | |
397 | false); | |
398 | ||
399 | tester::apply("ml-b-02", | |
400 | from_wkt<ML>("MULTILINESTRING((1 1,3 3))"), | |
401 | from_wkt<B>("BOX(0 0,2 2)"), | |
402 | false); | |
403 | ||
404 | tester::apply("ml-b-03", | |
405 | from_wkt<ML>("MULTILINESTRING((2 2,3 3))"), | |
406 | from_wkt<B>("BOX(0 0,2 2)"), | |
407 | false); | |
408 | ||
409 | tester::apply("ml-b-04", | |
410 | from_wkt<ML>("MULTILINESTRING((4 4,3 3))"), | |
411 | from_wkt<B>("BOX(0 0,2 2)"), | |
412 | true); | |
413 | } | |
414 | ||
415 | template <typename P> | |
416 | inline void test_multilinestring_ring() | |
417 | { | |
418 | typedef bg::model::linestring<P> L; | |
419 | typedef bg::model::multi_linestring<L> ML; | |
420 | typedef bg::model::ring<P, false, false> R; // ccw, open | |
421 | ||
422 | typedef test_disjoint tester; | |
423 | ||
424 | tester::apply("ml-r-01", | |
425 | from_wkt<ML>("MULTILINESTRING((0 0,2 0))"), | |
426 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
427 | false); | |
428 | ||
429 | tester::apply("ml-r-02", | |
430 | from_wkt<ML>("MULTILINESTRING((1 0,3 3))"), | |
431 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
432 | false); | |
433 | ||
434 | tester::apply("ml-r-03", | |
435 | from_wkt<ML>("MULTILINESTRING((1 1,3 3))"), | |
436 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
437 | false); | |
438 | ||
439 | tester::apply("ml-r-04", | |
440 | from_wkt<ML>("MULTILINESTRING((2 2,3 3))"), | |
441 | from_wkt<R>("POLYGON((0 0,2 0,0 2))"), | |
442 | true); | |
443 | } | |
444 | ||
445 | template <typename P> | |
446 | inline void test_multilinestring_polygon() | |
447 | { | |
448 | typedef bg::model::linestring<P> L; | |
449 | typedef bg::model::multi_linestring<L> ML; | |
450 | typedef bg::model::polygon<P, false, false> PL; // ccw, open | |
451 | ||
452 | typedef test_disjoint tester; | |
453 | ||
454 | tester::apply("ml-pg-01", | |
455 | from_wkt<ML>("MULTILINESTRING((0 0,2 0))"), | |
456 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
457 | false); | |
458 | ||
459 | tester::apply("ml-pg-02", | |
460 | from_wkt<ML>("MULTILINESTRING((1 0,3 3))"), | |
461 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
462 | false); | |
463 | ||
464 | tester::apply("ml-pg-03", | |
465 | from_wkt<ML>("MULTILINESTRING((1 1,3 3))"), | |
466 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
467 | false); | |
468 | ||
469 | tester::apply("ml-pg-04", | |
470 | from_wkt<ML>("MULTILINESTRING((2 2,3 3))"), | |
471 | from_wkt<PL>("POLYGON((0 0,2 0,0 2))"), | |
472 | true); | |
473 | } | |
474 | ||
475 | template <typename P> | |
476 | inline void test_multilinestring_multipolygon() | |
477 | { | |
478 | typedef bg::model::linestring<P> L; | |
479 | typedef bg::model::multi_linestring<L> ML; | |
480 | typedef bg::model::polygon<P, false, false> PL; // ccw, open | |
481 | typedef bg::model::multi_polygon<PL> MPL; | |
482 | ||
483 | typedef test_disjoint tester; | |
484 | ||
485 | tester::apply("ml-mpg-01", | |
486 | from_wkt<ML>("MULTILINESTRING((0 0,2 0))"), | |
487 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
488 | false); | |
489 | ||
490 | tester::apply("ml-mpg-02", | |
491 | from_wkt<ML>("MULTILINESTRING((1 0,3 3))"), | |
492 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
493 | false); | |
494 | ||
495 | tester::apply("ml-mpg-03", | |
496 | from_wkt<ML>("MULTILINESTRING((1 1,3 3))"), | |
497 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
498 | false); | |
499 | ||
500 | tester::apply("ml-mpg-04", | |
501 | from_wkt<ML>("MULTILINESTRING((2 2,3 3))"), | |
502 | from_wkt<MPL>("MULTIPOLYGON(((0 0,2 0,0 2)))"), | |
503 | true); | |
504 | } | |
505 | ||
506 | //============================================================================ | |
507 | ||
508 | template <typename CoordinateType> | |
509 | inline void test_linear_areal() | |
510 | { | |
511 | typedef bg::model::point<CoordinateType, 2, bg::cs::cartesian> point_type; | |
512 | ||
513 | test_segment_polygon<point_type>(); | |
514 | test_segment_multipolygon<point_type>(); | |
515 | test_segment_ring<point_type>(); | |
516 | test_segment_box<point_type>(); | |
517 | ||
518 | test_linestring_polygon<point_type>(); | |
519 | test_linestring_multipolygon<point_type>(); | |
520 | test_linestring_ring<point_type>(); | |
521 | test_linestring_box<point_type>(); | |
522 | ||
523 | test_multilinestring_polygon<point_type>(); | |
524 | test_multilinestring_multipolygon<point_type>(); | |
525 | test_multilinestring_ring<point_type>(); | |
526 | test_multilinestring_box<point_type>(); | |
527 | } | |
528 | ||
529 | //============================================================================ | |
530 | ||
531 | BOOST_AUTO_TEST_CASE( test_linear_areal_all ) | |
532 | { | |
533 | test_linear_areal<double>(); | |
534 | test_linear_areal<int>(); | |
535 | #ifdef HAVE_TTMATH | |
536 | test_linear_areal<ttmath_big>(); | |
537 | #endif | |
538 | } |