1 // Boost.Geometry (aka GGL, Generic Geometry Library)
2 // Unit Test
3 
4 // Copyright (c) 2010-2015 Barend Gehrels, Amsterdam, the Netherlands.
5 
6 // Use, modification and distribution is subject to the Boost Software License,
7 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt)
9 
10 #include <iostream>
11 #include <string>
12 
13 #include "test_difference.hpp"
14 #include <algorithms/test_overlay.hpp>
15 #include <algorithms/overlay/multi_overlay_cases.hpp>
16 
17 #include <boost/geometry/algorithms/correct.hpp>
18 #include <boost/geometry/algorithms/intersection.hpp>
19 
20 #include <boost/geometry/geometries/point_xy.hpp>
21 #include <boost/geometry/geometries/multi_point.hpp>
22 #include <boost/geometry/geometries/multi_polygon.hpp>
23 
24 #include <boost/geometry/io/wkt/read.hpp>
25 
26 // Convenience macros (points are not checked)
27 #define TEST_DIFFERENCE(caseid, clips1, area1, clips2, area2, clips3) \
28     (test_one<Polygon, MultiPolygon, MultiPolygon>) \
29     ( #caseid, caseid[0], caseid[1], clips1, -1, area1, clips2, -1, area2, \
30                 clips3, -1, area1 + area2)
31 
32 #define TEST_DIFFERENCE_IGNORE(caseid, clips1, area1, clips2, area2, clips3) \
33     { ut_settings ignore_validity; ignore_validity.test_validity = false; \
34     (test_one<Polygon, MultiPolygon, MultiPolygon>) \
35     ( #caseid, caseid[0], caseid[1], clips1, -1, area1, clips2, -1, area2, \
36                 clips3, -1, area1 + area2, ignore_validity); }
37 
38 #define TEST_DIFFERENCE_WITH(index1, index2, caseid, clips1, area1, \
39                 clips2, area2, clips3) \
40     (test_one<Polygon, MultiPolygon, MultiPolygon>) \
41     ( #caseid "_" #index1 "_" #index2, caseid[index1], caseid[index2], \
42             clips1, -1, area1, \
43             clips2, -1, area2, \
44             clips3, -1, area1 + area2, settings)
45 
46 
47 template <typename Ring, typename Polygon, typename MultiPolygon>
test_areal()48 void test_areal()
49 {
50     test_one<Polygon, MultiPolygon, MultiPolygon>("simplex_multi",
51             case_multi_simplex[0], case_multi_simplex[1],
52             5, 21, 5.58, 4, 17, 2.58);
53 
54     test_one<Polygon, MultiPolygon, MultiPolygon>("case_multi_no_ip",
55             case_multi_no_ip[0], case_multi_no_ip[1],
56             2, 12, 24.0, 2, 12, 34.0);
57     test_one<Polygon, MultiPolygon, MultiPolygon>("case_multi_2",
58             case_multi_2[0], case_multi_2[1],
59             2, 15, 19.6, 2, 13, 33.6);
60 
61     test_one<Polygon, MultiPolygon, Polygon>("simplex_multi_mp_p",
62             case_multi_simplex[0], case_single_simplex,
63             5, 21, 5.58, 4, 17, 2.58);
64     test_one<Polygon, Ring, MultiPolygon>("simplex_multi_r_mp",
65             case_single_simplex, case_multi_simplex[0],
66             4, 17, 2.58, 5, 21, 5.58);
67     test_one<Polygon, MultiPolygon, Ring>("simplex_multi_mp_r",
68             case_multi_simplex[0], case_single_simplex,
69             5, 21, 5.58, 4, 17, 2.58);
70 
71     // Constructed cases for multi/touch/equal/etc
72     test_one<Polygon, MultiPolygon, MultiPolygon>("case_61_multi",
73             case_61_multi[0], case_61_multi[1],
74             2, 10, 2, 2, 10, 2, 1, 10, 4);
75     test_one<Polygon, MultiPolygon, MultiPolygon>("case_62_multi",
76             case_62_multi[0], case_62_multi[1],
77             0, 0, 0, 1, 5, 1);
78     test_one<Polygon, MultiPolygon, MultiPolygon>("case_63_multi",
79             case_63_multi[0], case_63_multi[1],
80             0, 0, 0, 1, 5, 1);
81     test_one<Polygon, MultiPolygon, MultiPolygon>("case_64_multi",
82         case_64_multi[0], case_64_multi[1],
83         1, 5, 1, 1, 5, 1, 1, 7, 2);
84     test_one<Polygon, MultiPolygon, MultiPolygon>("case_65_multi",
85         case_65_multi[0], case_65_multi[1],
86             0, 0, 0, 2, 10, 3);
87 
88     test_one<Polygon, MultiPolygon, MultiPolygon>("case_72_multi",
89         case_72_multi[0], case_72_multi[1],
90             3, 13, 1.65, 3, 17, 6.15);
91 
92     test_one<Polygon, MultiPolygon, MultiPolygon>("case_77_multi",
93         case_77_multi[0], case_77_multi[1],
94             6, 31, 7.0,
95             5, 33, 13.0,
96             5, 38, 7.0 + 13.0);
97 
98     test_one<Polygon, MultiPolygon, MultiPolygon>("case_78_multi",
99         case_78_multi[0], case_78_multi[1],
100             1, 5, 1.0, 1, 5, 1.0);
101 
102     TEST_DIFFERENCE(case_123_multi, 1, 0.25, 2, 0.625, 3);
103     TEST_DIFFERENCE(case_124_multi, 1, 0.25, 2, 0.4375, 3);
104     TEST_DIFFERENCE(case_125_multi, 1, 0.25, 2, 0.400, 3);
105 
106     // A should have 3 clips, B should have 5 clips
107     TEST_DIFFERENCE(case_126_multi, 4, 16.0, 5, 27.0, 9);
108 
109     {
110         ut_settings settings;
111 
112         settings.sym_difference = BG_IF_RESCALED(false, true);
113 
114         test_one<Polygon, MultiPolygon, MultiPolygon>("case_108_multi",
115             case_108_multi[0], case_108_multi[1],
116                 7, 32, 5.5,
117                 4, 24, 9.75,
118                 7, 45, 15.25,
119                 settings);
120     }
121 
122     // Ticket on GGL list 2011/10/25
123     // to mix polygon/multipolygon in call to difference
124     test_one<Polygon, Polygon, Polygon>("ggl_list_20111025_vd_pp",
125         ggl_list_20111025_vd[0], ggl_list_20111025_vd[1],
126             1, 4, 8.0, 1, 4, 12.5);
127     test_one<Polygon, Polygon, MultiPolygon>("ggl_list_20111025_vd_pm",
128         ggl_list_20111025_vd[0], ggl_list_20111025_vd[3],
129             1, 4, 8.0, 1, 4, 12.5);
130     test_one<Polygon, MultiPolygon, Polygon>("ggl_list_20111025_vd_mp",
131         ggl_list_20111025_vd[2], ggl_list_20111025_vd[1],
132             1, 4, 8.0, 1, 4, 12.5);
133     test_one<Polygon, MultiPolygon, MultiPolygon>("ggl_list_20111025_vd_mm",
134         ggl_list_20111025_vd[2], ggl_list_20111025_vd[3],
135             1, 4, 8.0, 1, 4, 12.5);
136 
137     test_one<Polygon, Polygon, MultiPolygon>("ggl_list_20111025_vd_2",
138         ggl_list_20111025_vd_2[0], ggl_list_20111025_vd_2[1],
139             1, 7, 10.0, 2, 10, 6.0);
140 
141     test_one<Polygon, MultiPolygon, MultiPolygon>("ggl_list_20120915_h2_a",
142         ggl_list_20120915_h2[0], ggl_list_20120915_h2[1],
143             2, 13, 17.0, 0, 0, 0.0);
144     test_one<Polygon, MultiPolygon, MultiPolygon>("ggl_list_20120915_h2_b",
145         ggl_list_20120915_h2[0], ggl_list_20120915_h2[2],
146             2, 13, 17.0, 0, 0, 0.0);
147 
148     {
149         ut_settings settings;
150         settings.percentage = 0.001;
151         settings.test_validity = BG_IF_RESCALED(true, false);
152         TEST_DIFFERENCE_WITH(0, 1, ggl_list_20120221_volker, 2, 7962.66, 2, 2775258.93, 4);
153     }
154 
155     {
156         // With rescaling, A is invalid (this is a robustness problem) and the other
157         // output is discarded because of zero area
158         // POSTGIS areas: 3.75893745345145, 2.5810000723917e-15
159         ut_settings settings;
160         settings.sym_difference = BG_IF_RESCALED(false, true);
161         settings.test_validity = BG_IF_RESCALED(false, true);
162 #if defined(BOOST_GEOMETRY_USE_RESCALING) || ! defined(BOOST_GEOMETRY_USE_KRAMER_RULE)
163         // No output for B
164         TEST_DIFFERENCE_WITH(0, 1, bug_21155501, 1, 3.758937, 0, 0.0, 1);
165 #else
166         // Very small sliver for B, and sym difference is not considered valid
167         settings.test_validity = false;
168         TEST_DIFFERENCE_WITH(0, 1, bug_21155501, 1, 3.758937, 1, 1.7763568394002505e-15, 2);
169 #endif
170     }
171 
172 #if defined(BOOST_GEOMETRY_USE_RESCALING) || defined(BOOST_GEOMETRY_TEST_FAILURES)
173     {
174         // With rescaling, it is complete but invalid
175         ut_settings settings;
176         settings.percentage = 0.001;
177         settings.test_validity = BG_IF_RESCALED(false, true);
178         TEST_DIFFERENCE_WITH(0, 1, ticket_9081,
179                              2, 0.0907392476356186,
180                              4, 0.126018011439877,
181                              BG_IF_RESCALED(4, 3));
182     }
183 #endif
184 
185     TEST_DIFFERENCE(ticket_12503, 46, 920.625, 4, 7.625, 50);
186 
187     {
188         // Reported issues going wrong with rescaling (except for 630b)
189         ut_settings settings;
190         settings.percentage = 0.001;
191 
192 #if ! defined(BOOST_GEOMETRY_USE_RESCALING) || defined(BOOST_GEOMETRY_TEST_FAILURES)
193         TEST_DIFFERENCE_WITH(0, 1, issue_630_a, 0, 0.0, 1, BG_IF_KRAMER(2.023326, 2.200326), 1);
194 #endif
195         TEST_DIFFERENCE_WITH(0, 1, issue_630_b, 1, 0.0056089, 2, 1.498976, 3);
196 #if ! defined(BOOST_GEOMETRY_USE_RESCALING) || defined(BOOST_GEOMETRY_TEST_FAILURES)
197 
198 #if defined(BOOST_GEOMETRY_USE_KRAMER) || defined(BOOST_GEOMETRY_TEST_FAILURES)
199         // Only succeeds with Kramer rule and no rescaling
200         TEST_DIFFERENCE_WITH(0, 1, issue_630_c, 0, 0, 1, 1.493367, 1);
201 #endif
202 
203         TEST_DIFFERENCE_WITH(0, 1, issue_643, 1, 76.5385, BG_IF_KRAMER(1, 0), BG_IF_KRAMER(2.8634e-09, 0.0), 1);
204 #endif
205     }
206 
207     // Areas and #clips correspond with POSTGIS (except sym case)
208     test_one<Polygon, MultiPolygon, MultiPolygon>("case_101_multi",
209         case_101_multi[0], case_101_multi[1],
210             5, 23, 4.75,
211             5, 40, 12.75,
212             5, 48, 4.75 + 12.75);
213 
214     // Areas and #clips correspond with POSTGIS
215     test_one<Polygon, MultiPolygon, MultiPolygon>("case_102_multi",
216         case_102_multi[0], case_102_multi[1],
217             2, 8, 0.75,
218             6, 25, 3.75,
219             6, 27, 0.75 + 3.75);
220 
221     // Areas and #clips correspond with POSTGIS
222     test_one<Polygon, MultiPolygon, MultiPolygon>("case_107_multi",
223         case_107_multi[0], case_107_multi[1],
224             2, 11, 2.25,
225             3, 14, 3.0,
226             4, 21, 5.25);
227 
228     TEST_DIFFERENCE(case_133_multi, 3, 16.0, 2, 8.0, 5);
229     TEST_DIFFERENCE(case_134_multi, 3, 16.0, 2, 8.0, 5);
230     TEST_DIFFERENCE(case_135_multi, 2, 2.0, 2, 13.0, 2);
231     TEST_DIFFERENCE(case_136_multi, 2, 2.0, 3, 13.5, 3);
232     TEST_DIFFERENCE(case_137_multi, 2, 2.5, 2, 13.0, 2);
233     TEST_DIFFERENCE(case_138_multi, 5, 16.6, 3, 8.225, 8);
234     TEST_DIFFERENCE(case_139_multi, 4, 16.328125, 3, 8.078125, 7);
235     TEST_DIFFERENCE(case_140_multi, 4, 16.328125, 3, 8.078125, 7);
236     TEST_DIFFERENCE(case_141_multi, 5, 15.5, 5, 10.0, 10);
237 
238     // Areas correspond with POSTGIS,
239     // #clips in PostGIS is 11,11,5 but should most probably be be 12,12,6
240     TEST_DIFFERENCE(case_recursive_boxes_1, 12, 26.0, 12, 24.0, 6);
241 
242     // Areas and #clips correspond with POSTGIS
243     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_2",
244         case_recursive_boxes_2[0], case_recursive_boxes_2[1],
245             3, 15, 3.0,
246             7, 33, 7.0,
247             10, 48, 10.0);
248 
249     // Areas and #clips by POSTGIS (except sym case)
250     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_3",
251         case_recursive_boxes_3[0], case_recursive_boxes_3[1],
252             24, -1, 21.5,
253             25, -1, 22.5,
254             37, -1, 44.0);
255 
256     // 4, input is not valid
257 
258     TEST_DIFFERENCE(case_recursive_boxes_5, 16, 22.0, 12, 27.0, 10);
259     TEST_DIFFERENCE(case_recursive_boxes_6, 7, 3.5, 3, 1.5, 9);
260 
261     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_7",
262         case_recursive_boxes_7[0], case_recursive_boxes_7[1],
263             3, 15, 2.75,
264             4, 19, 2.75,
265             3, 22, 5.5);
266 
267     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_8",
268         case_recursive_boxes_8[0], case_recursive_boxes_8[1],
269             2, -1, 2.50,
270             4, -1, 5.75,
271             4, -1, 8.25);
272 
273     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_9",
274         case_recursive_boxes_9[0], case_recursive_boxes_9[1],
275             3, -1, 1.5,
276             4, -1, 2.5,
277             6, -1, 4.0);
278 
279     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_10",
280         case_recursive_boxes_10[0], case_recursive_boxes_10[1],
281             2, -1, 1.25,
282             2, -1, 0.75,
283             4, -1, 2.00);
284 
285     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_11",
286         case_recursive_boxes_11[0], case_recursive_boxes_11[1],
287             3, -1, 2.5,
288             3, -1, 4.5,
289             3, -1, 7.0);
290 
291     TEST_DIFFERENCE(case_recursive_boxes_12, 4, 2.75, 3, 2.75, 6);
292     TEST_DIFFERENCE(case_recursive_boxes_13, 4, 4.75, 3, 5.5, 3);
293     TEST_DIFFERENCE(case_recursive_boxes_14, 3, 2.0, 4, 2.5, 5);
294     TEST_DIFFERENCE(case_recursive_boxes_15, 3, 3.0, 2, 2.5, 3);
295     TEST_DIFFERENCE(case_recursive_boxes_16, 8, 6.5, 3, 5.5, 9);
296     TEST_DIFFERENCE(case_recursive_boxes_17, 10, 7.75, 7, 5.5, 13);
297     TEST_DIFFERENCE(case_recursive_boxes_18, 2, 1.0, 1, 1.5, 3);
298     TEST_DIFFERENCE(case_recursive_boxes_19, 2, 1.0, 2, 1.5, 3);
299     TEST_DIFFERENCE(case_recursive_boxes_20, 2, 1.0, 0, 0.0, 2);
300 
301     TEST_DIFFERENCE(case_recursive_boxes_21, 2, 1.0, 1, 1.0, 1);
302     TEST_DIFFERENCE(case_recursive_boxes_22, 2, 1.25, 2, 2.0, 2);
303     TEST_DIFFERENCE(case_recursive_boxes_23, 2, 0.75, 1, 0.5, 3);
304     TEST_DIFFERENCE(case_recursive_boxes_24, 3, 2.5, 2, 2.0, 5);
305     TEST_DIFFERENCE(case_recursive_boxes_25, 2, 2.5, 3, 2.5, 2);
306     TEST_DIFFERENCE(case_recursive_boxes_26, 2, 1.5, 3, 2.0, 4);
307     TEST_DIFFERENCE(case_recursive_boxes_27, 1, 1.5, 3, 2.5, 3);
308     TEST_DIFFERENCE(case_recursive_boxes_28, 3, 2.5, 2, 3.0, 4);
309     TEST_DIFFERENCE(case_recursive_boxes_29, 5, 7.25, 5, 4.5, 5);
310     TEST_DIFFERENCE(case_recursive_boxes_30, 6, 4.25, 3, 7.25, 7);
311 
312     TEST_DIFFERENCE(case_recursive_boxes_31, 2, 2.0, 1, 0.5, 2);
313     TEST_DIFFERENCE(case_recursive_boxes_32, 2, 2.75, 2, 1.25, 2);
314     TEST_DIFFERENCE(case_recursive_boxes_33, 4, 3.0, 3, 6.0, 4);
315     TEST_DIFFERENCE(case_recursive_boxes_34, 7, 7.25, 1, 0.5, 8);
316     TEST_DIFFERENCE(case_recursive_boxes_35, 5, 1.75, 5, 2.75, 10);
317     TEST_DIFFERENCE(case_recursive_boxes_36, 2, 1.0, 2, 1.5, 3);
318     TEST_DIFFERENCE(case_recursive_boxes_37, 3, 2.5, 2, 4.25, 2);
319     TEST_DIFFERENCE(case_recursive_boxes_38, 5, 7.75, 4, 3.5, 3);
320     TEST_DIFFERENCE(case_recursive_boxes_39, 3, 6.0, 3, 3.0, 4);
321     TEST_DIFFERENCE(case_recursive_boxes_40, 11, 14.0, 9, 13.0, 11);
322 
323     TEST_DIFFERENCE(case_recursive_boxes_41, 1, 0.5, 1, 0.5, 2);
324     TEST_DIFFERENCE(case_recursive_boxes_42, 1, 1.0, 4, 4.0, 5);
325     TEST_DIFFERENCE(case_recursive_boxes_43, 1, 0.5, 3, 2.0, 4);
326     TEST_DIFFERENCE(case_recursive_boxes_44, 3, 5.0, 0, 0.0, 3);
327     TEST_DIFFERENCE(case_recursive_boxes_45, 6, 20.0, 7, 20.0, 3);
328     TEST_DIFFERENCE(case_recursive_boxes_46, 4, 14.0, 5, 12.0, 5);
329     TEST_DIFFERENCE(case_recursive_boxes_47, 4, 10.0, 7, 11.0, 1);
330     TEST_DIFFERENCE(case_recursive_boxes_48, 0, 0.0, 1, 9.0, 1);
331     TEST_DIFFERENCE(case_recursive_boxes_49, 10, 22.0, 10, 17.0, 11);
332     TEST_DIFFERENCE(case_recursive_boxes_50, 14, 21.0, 16, 21.0, 14);
333     TEST_DIFFERENCE(case_recursive_boxes_51, 14, 25.0, 12, 31.0, 7);
334     TEST_DIFFERENCE(case_recursive_boxes_52, 13, 30.0, 15, 25.0, 8);
335     TEST_DIFFERENCE(case_recursive_boxes_53, 6, 3.5, 4, 1.5, 9);
336     TEST_DIFFERENCE(case_recursive_boxes_54, 6, 6.5, 8, 6.0, 7);
337     TEST_DIFFERENCE(case_recursive_boxes_55, 4, 5.5, 6, 7.75, 4);
338     TEST_DIFFERENCE(case_recursive_boxes_56, 4, 4.5, 5, 2.75, 6);
339     TEST_DIFFERENCE(case_recursive_boxes_57, 5, 3.75, 9, 6.5, 10);
340     TEST_DIFFERENCE(case_recursive_boxes_58, 4, 2.25, 6, 3.75, 7);
341     TEST_DIFFERENCE(case_recursive_boxes_59, 8, 6.5, 7, 7.0, 12);
342     TEST_DIFFERENCE(case_recursive_boxes_60, 6, 5.25, 7, 5.25, 11);
343     TEST_DIFFERENCE(case_recursive_boxes_61, 2, 1.5, 6, 2.0, 7);
344 #if defined(BOOST_GEOMETRY_TEST_FAILURES)
345     // Misses one triangle, should be fixed in traversal.
346     // It is not related to rescaling.
347     TEST_DIFFERENCE(case_recursive_boxes_62, 5, 5.0, 11, 5.75, 12);
348 #endif
349 
350     TEST_DIFFERENCE(case_recursive_boxes_63, 9, 10.5, 5, 27.75, 4);
351     TEST_DIFFERENCE(case_recursive_boxes_64, 6, 2.75, 7, 4.5, 11);
352     TEST_DIFFERENCE(case_recursive_boxes_65, 6, 4.25, 7, 3.0, 13);
353     TEST_DIFFERENCE(case_recursive_boxes_66, 5, 4.75, 7, 4.0, 9);
354     TEST_DIFFERENCE(case_recursive_boxes_67, 7, 6.25, 9, 6.0, 10);
355     TEST_DIFFERENCE(case_recursive_boxes_68, 10, 6.5, 9, 6.5, 7);
356     TEST_DIFFERENCE(case_recursive_boxes_69, 5, 6.25, 5, 6.75, 8);
357     TEST_DIFFERENCE(case_recursive_boxes_70, 5, 2.0, 8, 4.5, 11);
358     TEST_DIFFERENCE(case_recursive_boxes_71, 7, 8.25, 7, 5.75, 8);
359     TEST_DIFFERENCE(case_recursive_boxes_72, 6, 6.5, 7, 4.0, 10);
360     TEST_DIFFERENCE(case_recursive_boxes_73, 4, 1.75, 5, 4.0, 8);
361     TEST_DIFFERENCE(case_recursive_boxes_74, 3, 3.00, 3, 1.5, 5);
362     TEST_DIFFERENCE(case_recursive_boxes_75, 7, 4.5, 4, 2.0, 11);
363     TEST_DIFFERENCE(case_recursive_boxes_76, 7, 3.75, 4, 2.5, 9);
364     TEST_DIFFERENCE(case_recursive_boxes_77, 4, 3.75, 7, 6.25, 8);
365     TEST_DIFFERENCE(case_recursive_boxes_78, 11, 5.5, 8, 4.5, 14);
366     TEST_DIFFERENCE(case_recursive_boxes_79, 2, 1.25, 6, 4.5, 8);
367 
368     // one polygon is divided into two, for same reason as union creates a small
369     // interior ring there
370     TEST_DIFFERENCE(case_recursive_boxes_80, 1, 0.5, 2, 0.75, BG_IF_RESCALED(3, 2));
371 
372     TEST_DIFFERENCE(case_recursive_boxes_81, 3, 5.0, 6, 6.75, 6);
373     TEST_DIFFERENCE(case_recursive_boxes_82, 5, 7.25, 7, 4.5, 8);
374     TEST_DIFFERENCE(case_recursive_boxes_83, 9, 5.25, 8, 5.25, 12);
375     TEST_DIFFERENCE(case_recursive_boxes_84, 4, 8.0, 7, 9.0, 4);
376 #if ! defined(BOOST_GEOMETRY_USE_RESCALING) || defined(BOOST_GEOMETRY_TEST_FAILURES)
377     TEST_DIFFERENCE(case_recursive_boxes_85, 4, 4.0, 7, 3.75, 9);
378 #endif
379 
380     TEST_DIFFERENCE(case_recursive_boxes_86, 1, 1.5, 2, 1.5, 3);
381     TEST_DIFFERENCE(case_recursive_boxes_87, 4, 2.0, 4, 2.5, 8);
382     TEST_DIFFERENCE(case_recursive_boxes_88, 3, 4.75, 5, 6.75, 4);
383 
384     // Output of A can be 0 or 1 polygons (with a very small area)
385     TEST_DIFFERENCE(case_precision_m1, -1, 0.0, 1, 57.0, -1);
386     // Output of A can be 1 or 2 polygons (one with a very small area)
387     TEST_DIFFERENCE(case_precision_m2, -1, 1.0, 1, 57.75, -1);
388 
389     {
390         ut_settings sym_settings;
391     #if ! defined(BOOST_GEOMETRY_USE_RESCALING)
392         sym_settings.sym_difference = false;
393     #endif
394         test_one<Polygon, MultiPolygon, MultiPolygon>("mysql_21965285_b",
395             mysql_21965285_b[0],
396             mysql_21965285_b[1],
397             2, -1, 183.71376870369406,
398             2, -1, 131.21376870369406,
399             sym_settings);
400     }
401 
402     TEST_DIFFERENCE(mysql_regression_1_65_2017_08_31,
403                     BG_IF_RESCALED(1, 0), BG_IF_RESCALED(4.30697514e-7, 0),
404                     3, 152.0642, BG_IF_RESCALED(4, 3));
405 }
406 
407 
408 template <typename P>
test_all()409 void test_all()
410 {
411     typedef bg::model::ring<P> ring;
412     typedef bg::model::polygon<P> polygon;
413     typedef bg::model::multi_polygon<polygon> multi_polygon;
414     test_areal<ring, polygon, multi_polygon>();
415 }
416 
417 
418 // Test cases for integer coordinates / ccw / open
419 template <typename Polygon, typename MultiPolygon>
test_specific_areal()420 void test_specific_areal()
421 {
422     {
423         // Spikes in a-b and b-a, failure in symmetric difference
424         ut_settings settings;
425         settings.sym_difference = false;
426         settings.test_validity = false;
427 
428         TEST_DIFFERENCE_WITH(0, 1, ticket_11674,
429                              BG_IF_KRAMER(3, 4),
430                              BG_IF_KRAMER(9105781.5, 9105473.5),
431                              5,
432                              BG_IF_KRAMER(119059.5, 119423), -1);
433     }
434 
435     {
436         // Ticket 12751 (Volker)
437         // Spikes in a-b and b-a, failure in symmetric difference
438 
439         ut_settings settings;
440         settings.remove_spikes = true;
441 
442         TEST_DIFFERENCE_WITH(0, 1, ticket_12751, 1,
443                              BG_IF_KRAMER(2781965.0, 2782114), 1,
444                              BG_IF_KRAMER(597.0, 598.0), 2);
445 
446 #if ! defined(BOOST_GEOMETRY_USE_KRAMER)
447         // Fails with general line form intersection, symmetric version misses one outcut
448         // TODO GENERAL FORM
449         settings.test_validity = false;
450         settings.sym_difference = false;
451 #endif
452 
453         TEST_DIFFERENCE_WITH(2, 3, ticket_12751,
454                              2, BG_IF_KRAMER(2537992.5, 2538305),
455                              2, BG_IF_KRAMER(294963.5, 294737),
456                              3);
457     }
458 
459     {
460         // Ticket 12752 (Volker)
461         // Spikes in a-b and b-a, failure in symmetric difference
462         ut_settings settings;
463         settings.remove_spikes = true;
464         settings.sym_difference = false;
465         TEST_DIFFERENCE_WITH(0, 1, ticket_12752,
466                              BG_IF_KRAMER(3, 2), BG_IF_KRAMER(2776692.0, 2776657),
467                              3, BG_IF_KRAMER(7893.0, 7710.5),
468                              2);
469     }
470 
471     {
472 #if defined(BOOST_GEOMETRY_USE_KRAMER) || defined(BOOST_GEOMETRY_TEST_FAILURES)
473         // Fails completely with general line form intersection
474         // There is something with scale.
475         // TODO GENERAL FORM
476         const std::string a_min_b =
477             TEST_DIFFERENCE(ticket_10661, 2, 1441632.5, 2, 13167454, 4);
478 
479         test_one<Polygon, MultiPolygon, MultiPolygon>("ticket_10661_2",
480             a_min_b, ticket_10661[2],
481             1, 8, 825192.0,
482             1, 10, BG_IF_KRAMER(27226370.5, 27842811),
483             1, -1, 825192.0 + 27226370.5);
484 #endif
485     }
486 
487     {
488         ut_settings settings;
489         settings.sym_difference = false;
490 
491 #if defined(BOOST_GEOMETRY_USE_KRAMER) || defined(BOOST_GEOMETRY_TEST_FAILURES)
492         // Fails with general line form intersection
493         // Misses one clip
494         // TODO GENERAL FORM
495         TEST_DIFFERENCE_WITH(0, 1, ticket_9942, 4, 7427727.5, 4,
496                              BG_IF_KRAMER(131506, 130083.5), 4);
497 #endif
498         TEST_DIFFERENCE_WITH(0, 1, ticket_9942a, 2,
499                              BG_IF_KRAMER(412676.5, 413183.5), 2,
500                              BG_IF_KRAMER(76779.5, 76924), 4);
501     }
502 }
503 
504 template <typename Point, bool ClockWise, bool Closed>
test_specific()505 void test_specific()
506 {
507     typedef bg::model::polygon<Point, ClockWise, Closed> polygon;
508     typedef bg::model::multi_polygon<polygon> multi_polygon;
509     test_specific_areal<polygon, multi_polygon>();
510 }
511 
512 
test_main(int,char * [])513 int test_main(int, char* [])
514 {
515     BoostGeometryWriteTestConfiguration();
516     test_all<bg::model::d2::point_xy<default_test_type> >();
517 
518     test_specific<bg::model::d2::point_xy<int>, false, false>();
519 
520 #if ! defined(BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE)
521     test_all<bg::model::d2::point_xy<float> >();
522 
523 #if defined(HAVE_TTMATH)
524     std::cout << "Testing TTMATH" << std::endl;
525     test_all<bg::model::d2::point_xy<ttmath_big> >();
526 #endif
527 
528 #endif
529 
530     return 0;
531 }
532