ceph/src/boost/libs/geometry/test/algorithms/set_operations/difference/difference_multi.cpp

   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.set_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>
  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.set_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.set_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.set_test_validity(false);
 168         TEST_DIFFERENCE_WITH(0, 1, bug_21155501,
 169                              (count_set(1, 4)), expectation_limits(3.75893, 3.75894),
 170                              (count_set(1, 4)), (expectation_limits(1.776357e-15, 7.661281e-15)),
 171                              (count_set(2, 5)));
 172 #endif
 173     }
 174
 175 #if defined(BOOST_GEOMETRY_USE_RESCALING) || defined(BOOST_GEOMETRY_TEST_FAILURES)
 176     {
 177         // With rescaling, it is complete but invalid
 178         // Without rescaling, one ring is missing (for a and s)
 179         ut_settings settings;
 180         settings.set_test_validity(BG_IF_RESCALED(false, true));
 181         TEST_DIFFERENCE_WITH(0, 1, ticket_9081,
 182                              2, 0.0907392476356186,
 183                              4, 0.126018011439877,
 184                              count_set(3, 4));
 185     }
 186 #endif
 187
 188     TEST_DIFFERENCE(ticket_12503, 46, 920.625, 4, 7.625, 50);
 189
 190     {
 191         // Reported issues going wrong with rescaling (except for 630b)
 192         ut_settings settings;
 193         settings.percentage = 0.001;
 194
 195 #if ! defined(BOOST_GEOMETRY_USE_RESCALING) || defined(BOOST_GEOMETRY_TEST_FAILURES)
 196         TEST_DIFFERENCE_WITH(0, 1, issue_630_a, 0, expectation_limits(0.0), 1, (expectation_limits(2.023, 2.2004)), 1);
 197 #endif
 198         TEST_DIFFERENCE_WITH(0, 1, issue_630_b, 1, 0.0056089, 2, 1.498976, 3);
 199 #if ! defined(BOOST_GEOMETRY_USE_RESCALING) || defined(BOOST_GEOMETRY_TEST_FAILURES)
 200
 201 #if defined(BOOST_GEOMETRY_USE_KRAMER) || defined(BOOST_GEOMETRY_TEST_FAILURES)
 202         // Only succeeds with Kramer rule and no rescaling
 203         TEST_DIFFERENCE_WITH(0, 1, issue_630_c, 0, 0, 1, 1.493367, 1);
 204 #endif
 205
 206         TEST_DIFFERENCE_WITH(0, 1, issue_643, 1, expectation_limits(76.5385), optional(), optional_sliver(1.0e-6), 1);
 207 #endif
 208     }
 209
 210     // Areas and #clips correspond with POSTGIS (except sym case)
 211     test_one<Polygon, MultiPolygon, MultiPolygon>("case_101_multi",
 212         case_101_multi[0], case_101_multi[1],
 213             5, 23, 4.75,
 214             5, 40, 12.75,
 215             5, 48, 4.75 + 12.75);
 216
 217     // Areas and #clips correspond with POSTGIS
 218     test_one<Polygon, MultiPolygon, MultiPolygon>("case_102_multi",
 219         case_102_multi[0], case_102_multi[1],
 220             2, 8, 0.75,
 221             6, 25, 3.75,
 222             6, 27, 0.75 + 3.75);
 223
 224     // Areas and #clips correspond with POSTGIS
 225     test_one<Polygon, MultiPolygon, MultiPolygon>("case_107_multi",
 226         case_107_multi[0], case_107_multi[1],
 227             2, 11, 2.25,
 228             3, 14, 3.0,
 229             4, 21, 5.25);
 230
 231     TEST_DIFFERENCE(case_133_multi, 3, 16.0, 2, 8.0, 5);
 232     TEST_DIFFERENCE(case_134_multi, 3, 16.0, 2, 8.0, 5);
 233     TEST_DIFFERENCE(case_135_multi, 2, 2.0, 2, 13.0, 2);
 234     TEST_DIFFERENCE(case_136_multi, 2, 2.0, 3, 13.5, 3);
 235     TEST_DIFFERENCE(case_137_multi, 2, 2.5, 2, 13.0, 2);
 236     TEST_DIFFERENCE(case_138_multi, 5, 16.6, 3, 8.225, 8);
 237     TEST_DIFFERENCE(case_139_multi, 4, 16.328125, 3, 8.078125, 7);
 238     TEST_DIFFERENCE(case_140_multi, 4, 16.328125, 3, 8.078125, 7);
 239     TEST_DIFFERENCE(case_141_multi, 5, 15.5, 5, 10.0, 10);
 240
 241     // Areas correspond with POSTGIS,
 242     // #clips in PostGIS is 11,11,5 but should most probably be be 12,12,6
 243     TEST_DIFFERENCE(case_recursive_boxes_1, 12, 26.0, 12, 24.0, 6);
 244
 245     // Areas and #clips correspond with POSTGIS
 246     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_2",
 247         case_recursive_boxes_2[0], case_recursive_boxes_2[1],
 248             3, 15, 3.0,
 249             7, 33, 7.0,
 250             10, 48, 10.0);
 251
 252     // Areas and #clips by POSTGIS (except sym case)
 253     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_3",
 254         case_recursive_boxes_3[0], case_recursive_boxes_3[1],
 255             24, -1, 21.5,
 256             25, -1, 22.5,
 257             37, -1, 44.0);
 258
 259     // 4, input is not valid
 260
 261     TEST_DIFFERENCE(case_recursive_boxes_5, 16, 22.0, 12, 27.0, 10);
 262     TEST_DIFFERENCE(case_recursive_boxes_6, 7, 3.5, 3, 1.5, 9);
 263
 264     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_7",
 265         case_recursive_boxes_7[0], case_recursive_boxes_7[1],
 266             3, 15, 2.75,
 267             4, 19, 2.75,
 268             3, 22, 5.5);
 269
 270     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_8",
 271         case_recursive_boxes_8[0], case_recursive_boxes_8[1],
 272             2, -1, 2.50,
 273             4, -1, 5.75,
 274             4, -1, 8.25);
 275
 276     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_9",
 277         case_recursive_boxes_9[0], case_recursive_boxes_9[1],
 278             3, -1, 1.5,
 279             4, -1, 2.5,
 280             6, -1, 4.0);
 281
 282     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_10",
 283         case_recursive_boxes_10[0], case_recursive_boxes_10[1],
 284             2, -1, 1.25,
 285             2, -1, 0.75,
 286             4, -1, 2.00);
 287
 288     test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_11",
 289         case_recursive_boxes_11[0], case_recursive_boxes_11[1],
 290             3, -1, 2.5,
 291             3, -1, 4.5,
 292             3, -1, 7.0);
 293
 294     TEST_DIFFERENCE(case_recursive_boxes_12, 4, 2.75, 3, 2.75, 6);
 295     TEST_DIFFERENCE(case_recursive_boxes_13, 4, 4.75, 3, 5.5, 3);
 296     TEST_DIFFERENCE(case_recursive_boxes_14, 3, 2.0, 4, 2.5, 5);
 297     TEST_DIFFERENCE(case_recursive_boxes_15, 3, 3.0, 2, 2.5, 3);
 298     TEST_DIFFERENCE(case_recursive_boxes_16, 8, 6.5, 3, 5.5, 9);
 299     TEST_DIFFERENCE(case_recursive_boxes_17, 10, 7.75, 7, 5.5, 13);
 300     TEST_DIFFERENCE(case_recursive_boxes_18, 2, 1.0, 1, 1.5, 3);
 301     TEST_DIFFERENCE(case_recursive_boxes_19, 2, 1.0, 2, 1.5, 3);
 302     TEST_DIFFERENCE(case_recursive_boxes_20, 2, 1.0, 0, 0.0, 2);
 303
 304     TEST_DIFFERENCE(case_recursive_boxes_21, 2, 1.0, 1, 1.0, 1);
 305     TEST_DIFFERENCE(case_recursive_boxes_22, 2, 1.25, 2, 2.0, 2);
 306     TEST_DIFFERENCE(case_recursive_boxes_23, 2, 0.75, 1, 0.5, 3);
 307     TEST_DIFFERENCE(case_recursive_boxes_24, 3, 2.5, 2, 2.0, 5);
 308     TEST_DIFFERENCE(case_recursive_boxes_25, 2, 2.5, 3, 2.5, 2);
 309     TEST_DIFFERENCE(case_recursive_boxes_26, 2, 1.5, 3, 2.0, 4);
 310     TEST_DIFFERENCE(case_recursive_boxes_27, 1, 1.5, 3, 2.5, 3);
 311     TEST_DIFFERENCE(case_recursive_boxes_28, 3, 2.5, 2, 3.0, 4);
 312     TEST_DIFFERENCE(case_recursive_boxes_29, 5, 7.25, 5, 4.5, 5);
 313     TEST_DIFFERENCE(case_recursive_boxes_30, 6, 4.25, 3, 7.25, 7);
 314
 315     TEST_DIFFERENCE(case_recursive_boxes_31, 2, 2.0, 1, 0.5, 2);
 316     TEST_DIFFERENCE(case_recursive_boxes_32, 2, 2.75, 2, 1.25, 2);
 317     TEST_DIFFERENCE(case_recursive_boxes_33, 4, 3.0, 3, 6.0, 4);
 318     TEST_DIFFERENCE(case_recursive_boxes_34, 7, 7.25, 1, 0.5, 8);
 319     TEST_DIFFERENCE(case_recursive_boxes_35, 5, 1.75, 5, 2.75, 10);
 320     TEST_DIFFERENCE(case_recursive_boxes_36, 2, 1.0, 2, 1.5, 3);
 321     TEST_DIFFERENCE(case_recursive_boxes_37, 3, 2.5, 2, 4.25, 2);
 322     TEST_DIFFERENCE(case_recursive_boxes_38, 5, 7.75, 4, 3.5, 3);
 323     TEST_DIFFERENCE(case_recursive_boxes_39, 3, 6.0, 3, 3.0, 4);
 324     TEST_DIFFERENCE(case_recursive_boxes_40, 11, 14.0, 9, 13.0, 11);
 325
 326     TEST_DIFFERENCE(case_recursive_boxes_41, 1, 0.5, 1, 0.5, 2);
 327     TEST_DIFFERENCE(case_recursive_boxes_42, 1, 1.0, 4, 4.0, 5);
 328     TEST_DIFFERENCE(case_recursive_boxes_43, 1, 0.5, 3, 2.0, 4);
 329     TEST_DIFFERENCE(case_recursive_boxes_44, 3, 5.0, 0, 0.0, 3);
 330     TEST_DIFFERENCE(case_recursive_boxes_45, 6, 20.0, 7, 20.0, 3);
 331     TEST_DIFFERENCE(case_recursive_boxes_46, 4, 14.0, 5, 12.0, 5);
 332     TEST_DIFFERENCE(case_recursive_boxes_47, 4, 10.0, 7, 11.0, 1);
 333     TEST_DIFFERENCE(case_recursive_boxes_48, 0, 0.0, 1, 9.0, 1);
 334     TEST_DIFFERENCE(case_recursive_boxes_49, 10, 22.0, 10, 17.0, 11);
 335     TEST_DIFFERENCE(case_recursive_boxes_50, 14, 21.0, 16, 21.0, 14);
 336     TEST_DIFFERENCE(case_recursive_boxes_51, 14, 25.0, 12, 31.0, 7);
 337     TEST_DIFFERENCE(case_recursive_boxes_52, 13, 30.0, 15, 25.0, 8);
 338     TEST_DIFFERENCE(case_recursive_boxes_53, 6, 3.5, 4, 1.5, 9);
 339     TEST_DIFFERENCE(case_recursive_boxes_54, 6, 6.5, 8, 6.0, 7);
 340     TEST_DIFFERENCE(case_recursive_boxes_55, 4, 5.5, 6, 7.75, 4);
 341     TEST_DIFFERENCE(case_recursive_boxes_56, 4, 4.5, 5, 2.75, 6);
 342     TEST_DIFFERENCE(case_recursive_boxes_57, 5, 3.75, 9, 6.5, 10);
 343     TEST_DIFFERENCE(case_recursive_boxes_58, 4, 2.25, 6, 3.75, 7);
 344     TEST_DIFFERENCE(case_recursive_boxes_59, 8, 6.5, 7, 7.0, 12);
 345     TEST_DIFFERENCE(case_recursive_boxes_60, 6, 5.25, 7, 5.25, 11);
 346     TEST_DIFFERENCE(case_recursive_boxes_61, 2, 1.5, 6, 2.0, 7);
 347 #if defined(BOOST_GEOMETRY_TEST_FAILURES)
 348     // Misses one triangle, should be fixed in traversal.
 349     // It is not related to rescaling.
 350     TEST_DIFFERENCE(case_recursive_boxes_62, 5, 5.0, 11, 5.75, 12);
 351 #endif
 352
 353     TEST_DIFFERENCE(case_recursive_boxes_63, 9, 10.5, 5, 27.75, 4);
 354     TEST_DIFFERENCE(case_recursive_boxes_64, 6, 2.75, 7, 4.5, 11);
 355     TEST_DIFFERENCE(case_recursive_boxes_65, 6, 4.25, 7, 3.0, 13);
 356     TEST_DIFFERENCE(case_recursive_boxes_66, 5, 4.75, 7, 4.0, 9);
 357     TEST_DIFFERENCE(case_recursive_boxes_67, 7, 6.25, 9, 6.0, 10);
 358     TEST_DIFFERENCE(case_recursive_boxes_68, 10, 6.5, 9, 6.5, 7);
 359     TEST_DIFFERENCE(case_recursive_boxes_69, 5, 6.25, 5, 6.75, 8);
 360     TEST_DIFFERENCE(case_recursive_boxes_70, 5, 2.0, 8, 4.5, 11);
 361     TEST_DIFFERENCE(case_recursive_boxes_71, 7, 8.25, 7, 5.75, 8);
 362     TEST_DIFFERENCE(case_recursive_boxes_72, 6, 6.5, 7, 4.0, 10);
 363     TEST_DIFFERENCE(case_recursive_boxes_73, 4, 1.75, 5, 4.0, 8);
 364     TEST_DIFFERENCE(case_recursive_boxes_74, 3, 3.00, 3, 1.5, 5);
 365     TEST_DIFFERENCE(case_recursive_boxes_75, 7, 4.5, 4, 2.0, 11);
 366     TEST_DIFFERENCE(case_recursive_boxes_76, 7, 3.75, 4, 2.5, 9);
 367     TEST_DIFFERENCE(case_recursive_boxes_77, 4, 3.75, 7, 6.25, 8);
 368     TEST_DIFFERENCE(case_recursive_boxes_78, 11, 5.5, 8, 4.5, 14);
 369     TEST_DIFFERENCE(case_recursive_boxes_79, 2, 1.25, 6, 4.5, 8);
 370
 371     // one polygon is divided into two, for same reason as union creates a small
 372     // interior ring there, which is acceptable
 373     TEST_DIFFERENCE(case_recursive_boxes_80, 1, 0.5, 2, 0.75, count_set(2, 3));
 374
 375     TEST_DIFFERENCE(case_recursive_boxes_81, 3, 5.0, 6, 6.75, 6);
 376     TEST_DIFFERENCE(case_recursive_boxes_82, 5, 7.25, 7, 4.5, 8);
 377     TEST_DIFFERENCE(case_recursive_boxes_83, 9, 5.25, 8, 5.25, 12);
 378     TEST_DIFFERENCE(case_recursive_boxes_84, 4, 8.0, 7, 9.0, 4);
 379 #if ! defined(BOOST_GEOMETRY_USE_RESCALING) || defined(BOOST_GEOMETRY_TEST_FAILURES)
 380     TEST_DIFFERENCE(case_recursive_boxes_85, 4, 4.0, 7, 3.75, 9);
 381 #endif
 382
 383     TEST_DIFFERENCE(case_recursive_boxes_86, 1, 1.5, 2, 1.5, 3);
 384     TEST_DIFFERENCE(case_recursive_boxes_87, 4, 2.0, 4, 2.5, 8);
 385     TEST_DIFFERENCE(case_recursive_boxes_88, 3, 4.75, 5, 6.75, 4);
 386
 387     // Output of A can be 0 or 1 polygons (with a very small area)
 388     TEST_DIFFERENCE(case_precision_m1, optional(), expectation_limits(0.0, 5.0e-7), 1, 57.0, count_set(1, 2));
 389     // Output of A can be 1 or 2 polygons (one with a very small area)
 390     TEST_DIFFERENCE(case_precision_m2, count_set(1, 2), 1.0, 1, 57.75, count_set(2, 3));
 391
 392     {
 393         ut_settings sym_settings;
 394     #if ! defined(BOOST_GEOMETRY_USE_RESCALING)
 395         sym_settings.sym_difference = false;
 396     #endif
 397         test_one<Polygon, MultiPolygon, MultiPolygon>("mysql_21965285_b",
 398             mysql_21965285_b[0],
 399             mysql_21965285_b[1],
 400             2, -1, 183.71376870369406,
 401             2, -1, 131.21376870369406,
 402             sym_settings);
 403     }
 404
 405     TEST_DIFFERENCE(mysql_regression_1_65_2017_08_31,
 406                     optional(), optional_sliver(1e-6),
 407                     3, 152.064185, count_set(3, 4));
 408 }
 409
 410
 411 template <typename P>
 412 void test_all()
 413 {
 414     typedef bg::model::ring<P> ring;
 415     typedef bg::model::polygon<P> polygon;
 416     typedef bg::model::multi_polygon<polygon> multi_polygon;
 417     test_areal<ring, polygon, multi_polygon>();
 418 }
 419
 420
 421 // Test cases for integer coordinates / ccw / open
 422 template <typename Polygon, typename MultiPolygon>
 423 void test_specific_areal()
 424 {
 425     {
 426         // Spikes in a-b and b-a, failure in symmetric difference
 427         ut_settings settings;
 428         settings.sym_difference = false;
 429         settings.set_test_validity(false);
 430
 431         TEST_DIFFERENCE_WITH(0, 1, ticket_11674,
 432                              count_set(3, 4),
 433                              expectation_limits(9105473, 9105782),
 434                              5,
 435                              expectation_limits(119059, 119424), ignore_count());
 436     }
 437
 438     {
 439         // Ticket 12751 (Volker)
 440         // Spikes in a-b and b-a, failure in symmetric difference
 441
 442         ut_settings settings;
 443         settings.remove_spikes = true;
 444
 445         TEST_DIFFERENCE_WITH(0, 1, ticket_12751, 1,
 446                              expectation_limits(2781964, 2782115), 1,
 447                              expectation_limits(597.0, 598.0), 2);
 448
 449 #if ! defined(BOOST_GEOMETRY_USE_KRAMER)
 450         // Fails with general line form intersection, symmetric version misses one outcut
 451         // TODO GENERAL FORM
 452         settings.set_test_validity(false);
 453         settings.sym_difference = false;
 454 #endif
 455
 456         TEST_DIFFERENCE_WITH(2, 3, ticket_12751,
 457                              2, expectation_limits(2537992, 2538306),
 458                              2, expectation_limits(294736, 294964),
 459                              3);
 460     }
 461
 462     {
 463         // Ticket 12752 (Volker)
 464         // Spikes in a-b and b-a, failure in symmetric difference
 465         ut_settings settings;
 466         settings.remove_spikes = true;
 467         settings.sym_difference = false;
 468         TEST_DIFFERENCE_WITH(0, 1, ticket_12752,
 469                              count_set(2, 3), expectation_limits(2776656, 2776693),
 470                              3, expectation_limits(7710, 7894),
 471                              2);
 472     }
 473
 474     {
 475 #if defined(BOOST_GEOMETRY_USE_KRAMER) || defined(BOOST_GEOMETRY_TEST_FAILURES)
 476         // Fails completely with general line form intersection
 477         // There is something with scale.
 478         // TODO GENERAL FORM
 479         const std::string a_min_b =
 480             TEST_DIFFERENCE(ticket_10661, 2, 1441632.5, 2, 13167454, 4);
 481
 482         test_one<Polygon, MultiPolygon, MultiPolygon>("ticket_10661_2",
 483             a_min_b, ticket_10661[2],
 484             1, 8, 825192.0,
 485             1, 10, expectation_limits(27226370, 27842812),
 486             1, -1, 825192.0 + 27226370.5);
 487 #endif
 488     }
 489
 490     {
 491         ut_settings settings;
 492         settings.sym_difference = false;
 493
 494 #if defined(BOOST_GEOMETRY_USE_KRAMER) || defined(BOOST_GEOMETRY_TEST_FAILURES)
 495         TEST_DIFFERENCE_WITH(0, 1, ticket_9942, 4, expectation_limits(7427727.5), 4,
 496                              expectation_limits(130083, 131507), 4);
 497 #endif
 498         TEST_DIFFERENCE_WITH(0, 1, ticket_9942a, 2,
 499                              expectation_limits(412676, 413184), 2,
 500                              expectation_limits(76779, 76925), 4);
 501     }
 502 }
 503
 504 template <typename Point, bool ClockWise, bool Closed>
 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
 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 #endif
 523
 524 #if defined(BOOST_GEOMETRY_TEST_FAILURES)
 525     // Not yet fully tested for float.
 526     // The difference algorithm can generate (additional) slivers
 527     BoostGeometryWriteExpectedFailures(22, 13, 19, 7);
 528 #endif
 529
 530     return 0;
 531 }