libs/geometry/test/algorithms/set_operations/intersection/test_intersection.hpp

   1 // Boost.Geometry (aka GGL, Generic Geometry Library)
   2 // Unit Test
   3
   4 // Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
   5
   6 // This file was modified by Oracle on 2016, 2017.
   7 // Modifications copyright (c) 2016-2017, Oracle and/or its affiliates.
   8 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
   9
  10 // Use, modification and distribution is subject to the Boost Software License,
  11 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  12 // http://www.boost.org/LICENSE_1_0.txt)
  13
  14 #ifndef BOOST_GEOMETRY_TEST_INTERSECTION_HPP
  15 #define BOOST_GEOMETRY_TEST_INTERSECTION_HPP
  16
  17 #include <fstream>
  18 #include <iomanip>
  19
  20 #include <boost/foreach.hpp>
  21 #include <boost/variant/variant.hpp>
  22
  23 #include <boost/geometry/algorithms/intersection.hpp>
  24 #include <boost/geometry/algorithms/area.hpp>
  25 #include <boost/geometry/algorithms/correct.hpp>
  26 #include <boost/geometry/algorithms/is_valid.hpp>
  27 #include <boost/geometry/algorithms/length.hpp>
  28 #include <boost/geometry/algorithms/num_points.hpp>
  29 #include <boost/geometry/algorithms/num_interior_rings.hpp>
  30
  31 #include <boost/geometry/geometries/geometries.hpp>
  32
  33 #include <boost/geometry/strategies/strategies.hpp>
  34
  35 #include <boost/geometry/io/wkt/wkt.hpp>
  36
  37
  38 #if defined(TEST_WITH_SVG)
  39 #  include <boost/geometry/io/svg/svg_mapper.hpp>
  40 #endif
  41
  42 #include <geometry_test_common.hpp>
  43 #include "../setop_output_type.hpp"
  44
  45 struct ut_settings
  46 {
  47     double percentage;
  48     bool test_validity;
  49     bool debug;
  50
  51     explicit ut_settings(double p = 0.0001, bool tv = true)
  52         : percentage(p)
  53         , test_validity(tv)
  54         , debug(false)
  55     {}
  56
  57 };
  58
  59 template <typename G1, typename G2, typename IntersectionOutput>
  60 typename bg::default_area_result<G1>::type
  61 check_result(
  62     IntersectionOutput const& intersection_output,
  63     std::string const& caseid,
  64     std::size_t expected_count, std::size_t expected_holes_count,
  65     int expected_point_count, double expected_length_or_area,
  66     ut_settings const& settings)
  67 {
  68     typedef typename boost::range_value<IntersectionOutput>::type OutputType;
  69     bool const is_line = bg::geometry_id<OutputType>::type::value == 2;
  70
  71     typename bg::default_area_result<G1>::type length_or_area = 0;
  72     int n = 0;
  73     std::size_t nholes = 0;
  74     for (typename IntersectionOutput::const_iterator it = intersection_output.begin();
  75             it != intersection_output.end();
  76             ++it)
  77     {
  78         if (expected_point_count > 0)
  79         {
  80             // here n should rather be of type std::size_t, but expected_point_count
  81             // is set to -1 in some test cases so type int was left for now
  82             n += static_cast<int>(bg::num_points(*it, true));
  83         }
  84
  85         if (expected_holes_count > 0)
  86         {
  87             nholes += bg::num_interior_rings(*it);
  88         }
  89
  90         // instead of specialization we check it run-time here
  91         length_or_area += is_line
  92             ? bg::length(*it)
  93             : bg::area(*it);
  94
  95         if (settings.debug)
  96         {
  97             std::cout << std::setprecision(20) << bg::wkt(*it) << std::endl;
  98         }
  99
 100         if (settings.test_validity)
 101         {
 102             std::string message;
 103             bool const valid = bg::is_valid(*it, message);
 104             BOOST_CHECK_MESSAGE(valid,
 105                 "intersection: " << caseid << " not valid " << message);
 106         }
 107     }
 108
 109 #if ! defined(BOOST_GEOMETRY_NO_BOOST_TEST)
 110 #if ! defined(BOOST_GEOMETRY_NO_ROBUSTNESS)
 111     if (expected_point_count > 0)
 112     {
 113         BOOST_CHECK_MESSAGE(bg::math::abs(n - expected_point_count) < 3,
 114                 "intersection: " << caseid
 115                 << " #points expected: " << expected_point_count
 116                 << " detected: " << n
 117                 << " type: " << (type_for_assert_message<G1, G2>())
 118                 );
 119     }
 120 #endif
 121
 122     if (expected_count > 0)
 123     {
 124         BOOST_CHECK_MESSAGE(intersection_output.size() == expected_count,
 125                 "intersection: " << caseid
 126                 << " #outputs expected: " << expected_count
 127                 << " detected: " << intersection_output.size()
 128                 << " type: " << (type_for_assert_message<G1, G2>())
 129                 );
 130     }
 131
 132     if (expected_holes_count > 0)
 133     {
 134
 135         BOOST_CHECK_MESSAGE(nholes == expected_holes_count,
 136             "intersection: " << caseid
 137             << " #holes expected: " << expected_holes_count
 138             << " detected: " << nholes
 139             << " type: " << (type_for_assert_message<G1, G2>())
 140         );
 141     }
 142
 143     double const detected_length_or_area = boost::numeric_cast<double>(length_or_area);
 144     if (settings.percentage > 0.0)
 145     {
 146         BOOST_CHECK_CLOSE(detected_length_or_area, expected_length_or_area, settings.percentage);
 147     }
 148     else
 149     {
 150         // In some cases (geos_2) the intersection is either 0, or a tiny rectangle,
 151         // depending on compiler/settings. That cannot be tested by CLOSE
 152         BOOST_CHECK_LE(detected_length_or_area, expected_length_or_area);
 153     }
 154 #endif
 155
 156     return length_or_area;
 157 }
 158
 159
 160 template <typename OutputType, typename CalculationType, typename G1, typename G2>
 161 typename bg::default_area_result<G1>::type test_intersection(std::string const& caseid,
 162         G1 const& g1, G2 const& g2,
 163         std::size_t expected_count = 0, std::size_t expected_holes_count = 0,
 164         int expected_point_count = 0, double expected_length_or_area = 0,
 165         ut_settings const& settings = ut_settings())
 166 {
 167     if (settings.debug)
 168     {
 169         std::cout << std::endl << "case " << caseid << std::endl;
 170     }
 171
 172     typedef typename bg::point_type<G1>::type point_type;
 173     typedef typename setop_output_type<OutputType>::type result_type;
 174
 175     if (! settings.debug)
 176     {
 177         // Check _inserter behaviour with stratey
 178         typedef typename bg::strategy::intersection::services::default_strategy
 179             <
 180                 typename bg::cs_tag<point_type>::type
 181             >::type strategy_type;
 182         result_type clip;
 183         bg::detail::intersection::intersection_insert<OutputType>(g1, g2, std::back_inserter(clip), strategy_type());
 184     }
 185
 186     typename bg::default_area_result<G1>::type length_or_area = 0;
 187
 188     // Check normal behaviour
 189     result_type intersection_output;
 190     bg::intersection(g1, g2, intersection_output);
 191
 192     check_result<G1, G2>(intersection_output, caseid, expected_count,
 193         expected_holes_count, expected_point_count, expected_length_or_area,
 194         settings);
 195
 196     // Check strategy passed explicitly
 197     typedef typename bg::strategy::relate::services::default_strategy
 198             <
 199                 G1, G2
 200             >::type strategy_type;
 201     intersection_output.clear();
 202     bg::intersection(g1, g2, intersection_output, strategy_type());
 203
 204     check_result<G1, G2>(intersection_output, caseid, expected_count,
 205         expected_holes_count, expected_point_count, expected_length_or_area,
 206         settings);
 207
 208     // Check variant behaviour
 209     intersection_output.clear();
 210     bg::intersection(boost::variant<G1>(g1), g2, intersection_output);
 211
 212     check_result<G1, G2>(intersection_output, caseid, expected_count,
 213         expected_holes_count, expected_point_count, expected_length_or_area,
 214         settings);
 215
 216     intersection_output.clear();
 217     bg::intersection(g1, boost::variant<G2>(g2), intersection_output);
 218
 219     check_result<G1, G2>(intersection_output, caseid, expected_count,
 220         expected_holes_count, expected_point_count, expected_length_or_area,
 221         settings);
 222
 223     intersection_output.clear();
 224     bg::intersection(boost::variant<G1>(g1), boost::variant<G2>(g2), intersection_output);
 225
 226     check_result<G1, G2>(intersection_output, caseid, expected_count,
 227         expected_holes_count, expected_point_count, expected_length_or_area,
 228         settings);
 229
 230 #if defined(TEST_WITH_SVG)
 231     {
 232         bool const is_line = bg::geometry_id<OutputType>::type::value == 2;
 233         typedef typename bg::coordinate_type<G1>::type coordinate_type;
 234
 235         bool const ccw =
 236             bg::point_order<G1>::value == bg::counterclockwise
 237             || bg::point_order<G2>::value == bg::counterclockwise;
 238         bool const open =
 239             bg::closure<G1>::value == bg::open
 240             || bg::closure<G2>::value == bg::open;
 241
 242         std::ostringstream filename;
 243         filename << "intersection_"
 244             << caseid << "_"
 245             << string_from_type<coordinate_type>::name()
 246             << string_from_type<CalculationType>::name()
 247             << (ccw ? "_ccw" : "")
 248             << (open ? "_open" : "")
 249 #if defined(BOOST_GEOMETRY_NO_ROBUSTNESS)
 250             << "_no_rob"
 251 #endif
 252             << ".svg";
 253
 254         std::ofstream svg(filename.str().c_str());
 255
 256         bg::svg_mapper<point_type> mapper(svg, 500, 500);
 257
 258         mapper.add(g1);
 259         mapper.add(g2);
 260
 261         mapper.map(g1, is_line
 262             ? "opacity:0.6;stroke:rgb(0,255,0);stroke-width:5"
 263             : "fill-opacity:0.5;fill:rgb(153,204,0);"
 264                     "stroke:rgb(153,204,0);stroke-width:3");
 265         mapper.map(g2, "fill-opacity:0.3;fill:rgb(51,51,153);"
 266                     "stroke:rgb(51,51,153);stroke-width:3");
 267
 268         for (typename result_type::const_iterator it = intersection_output.begin();
 269                 it != intersection_output.end(); ++it)
 270         {
 271             mapper.map(*it, "fill-opacity:0.2;stroke-opacity:0.4;fill:rgb(255,0,0);"
 272                         "stroke:rgb(255,0,255);stroke-width:8");
 273         }
 274     }
 275 #endif
 276
 277
 278     if (settings.debug)
 279     {
 280         std::cout << "end case " << caseid << std::endl;
 281     }
 282
 283     return length_or_area;
 284 }
 285
 286 template <typename OutputType, typename CalculationType, typename G1, typename G2>
 287 typename bg::default_area_result<G1>::type test_intersection(std::string const& caseid,
 288         G1 const& g1, G2 const& g2,
 289         std::size_t expected_count = 0, int expected_point_count = 0,
 290         double expected_length_or_area = 0,
 291         ut_settings const& settings = ut_settings())
 292 {
 293     return test_intersection<OutputType, CalculationType>(
 294         caseid, g1, g2, expected_count, 0, expected_point_count,
 295         expected_length_or_area, settings
 296     );
 297 }
 298
 299 template <typename OutputType, typename G1, typename G2>
 300 typename bg::default_area_result<G1>::type test_one(std::string const& caseid,
 301         std::string const& wkt1, std::string const& wkt2,
 302         std::size_t expected_count = 0, std::size_t expected_holes_count = 0,
 303         int expected_point_count = 0, double expected_length_or_area = 0,
 304         ut_settings const& settings = ut_settings())
 305 {
 306     G1 g1;
 307     bg::read_wkt(wkt1, g1);
 308
 309     G2 g2;
 310     bg::read_wkt(wkt2, g2);
 311
 312     // Reverse if necessary
 313     bg::correct(g1);
 314     bg::correct(g2);
 315
 316     return test_intersection<OutputType, void>(caseid, g1, g2,
 317         expected_count, expected_holes_count, expected_point_count,
 318         expected_length_or_area, settings);
 319 }
 320
 321 template <typename OutputType, typename G1, typename G2>
 322 typename bg::default_area_result<G1>::type test_one(std::string const& caseid,
 323     std::string const& wkt1, std::string const& wkt2,
 324     std::size_t expected_count = 0, int expected_point_count = 0,
 325     double expected_length_or_area = 0,
 326     ut_settings const& settings = ut_settings())
 327 {
 328     return test_one<OutputType, G1, G2>(caseid, wkt1, wkt2,
 329         expected_count, 0, expected_point_count,
 330         expected_length_or_area,
 331         settings);
 332 }
 333
 334 template <typename OutputType, typename Areal, typename Linear>
 335 void test_one_lp(std::string const& caseid,
 336         std::string const& wkt_areal, std::string const& wkt_linear,
 337         std::size_t expected_count = 0, int expected_point_count = 0,
 338         double expected_length = 0,
 339         ut_settings const& settings = ut_settings())
 340 {
 341 #ifdef BOOST_GEOMETRY_TEST_DEBUG
 342     std::cout << caseid << " -- start" << std::endl;
 343 #endif
 344     Areal areal;
 345     bg::read_wkt(wkt_areal, areal);
 346     bg::correct(areal);
 347
 348     Linear linear;
 349     bg::read_wkt(wkt_linear, linear);
 350
 351     test_intersection<OutputType, void>(caseid, areal, linear,
 352         expected_count, expected_point_count,
 353         expected_length, settings);
 354
 355     // A linestring reversed should deliver exactly the same.
 356     bg::reverse(linear);
 357
 358     test_intersection<OutputType, void>(caseid + "_rev", areal, linear,
 359         expected_count, expected_point_count,
 360         expected_length, settings);
 361 #ifdef BOOST_GEOMETRY_TEST_DEBUG
 362     std::cout << caseid << " -- end" << std::endl;
 363 #endif
 364 }
 365
 366 template <typename Geometry1, typename Geometry2>
 367 void test_point_output(std::string const& wkt1, std::string const& wkt2, unsigned int expected_count)
 368 {
 369     Geometry1 g1;
 370     bg::read_wkt(wkt1, g1);
 371     bg::correct(g1);
 372
 373     Geometry2 g2;
 374     bg::read_wkt(wkt2, g2);
 375     bg::correct(g2);
 376
 377     bg::model::multi_point<typename bg::point_type<Geometry1>::type> points;
 378     bg::intersection(g1, g2, points);
 379     BOOST_CHECK_EQUAL(points.size(), expected_count);
 380 }
 381
 382
 383 #endif