1 // Boost.Geometry (aka GGL, Generic Geometry Library)
4 // Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
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
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)
14 #ifndef BOOST_GEOMETRY_TEST_INTERSECTION_HPP
15 #define BOOST_GEOMETRY_TEST_INTERSECTION_HPP
20 #include <boost/foreach.hpp>
21 #include <boost/variant/variant.hpp>
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>
31 #include <boost/geometry/geometries/geometries.hpp>
33 #include <boost/geometry/strategies/strategies.hpp>
35 #include <boost/geometry/io/wkt/wkt.hpp>
38 #if defined(TEST_WITH_SVG)
39 # include <boost/geometry/io/svg/svg_mapper.hpp>
42 #include <geometry_test_common.hpp>
43 #include <algorithms/check_validity.hpp>
44 #include "../setop_output_type.hpp"
52 explicit ut_settings(double p = 0.0001, bool tv = true)
60 template<typename IntersectionOutput, typename G1, typename G2>
61 void check_result(IntersectionOutput const& intersection_output,
62 std::string const& caseid,
63 G1 const& g1, G2 const& g2,
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)
68 typedef typename boost::range_value<IntersectionOutput>::type OutputType;
69 bool const is_line = bg::geometry_id<OutputType>::type::value == 2;
71 typename bg::default_area_result<G1>::type length_or_area = 0;
73 std::size_t nholes = 0;
74 for (typename IntersectionOutput::const_iterator it = intersection_output.begin();
75 it != intersection_output.end();
78 if (expected_point_count > 0)
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));
85 if (expected_holes_count > 0)
87 nholes += bg::num_interior_rings(*it);
90 // instead of specialization we check it run-time here
91 length_or_area += is_line
97 std::cout << std::setprecision(20) << bg::wkt(*it) << std::endl;
101 #if ! defined(BOOST_GEOMETRY_TEST_ALWAYS_CHECK_VALIDITY)
102 if (settings.test_validity)
106 bool const valid = check_validity<IntersectionOutput>
107 ::apply(intersection_output, caseid, g1, g2, message);
109 BOOST_CHECK_MESSAGE(valid,
110 "intersection: " << caseid << " not valid: " << message
111 << " type: " << (type_for_assert_message<G1, G2>()));
114 #if ! defined(BOOST_GEOMETRY_NO_BOOST_TEST)
115 #if defined(BOOST_GEOMETRY_USE_RESCALING)
116 // Without rescaling, point count might easily differ (which is no problem)
117 if (expected_point_count > 0)
119 BOOST_CHECK_MESSAGE(bg::math::abs(n - expected_point_count) < 3,
120 "intersection: " << caseid
121 << " #points expected: " << expected_point_count
122 << " detected: " << n
123 << " type: " << (type_for_assert_message<G1, G2>())
128 if (expected_count > 0)
130 BOOST_CHECK_MESSAGE(intersection_output.size() == expected_count,
131 "intersection: " << caseid
132 << " #outputs expected: " << expected_count
133 << " detected: " << intersection_output.size()
134 << " type: " << (type_for_assert_message<G1, G2>())
138 if (expected_holes_count > 0)
141 BOOST_CHECK_MESSAGE(nholes == expected_holes_count,
142 "intersection: " << caseid
143 << " #holes expected: " << expected_holes_count
144 << " detected: " << nholes
145 << " type: " << (type_for_assert_message<G1, G2>())
149 double const detected_length_or_area = boost::numeric_cast<double>(length_or_area);
150 if (settings.percentage > 0.0)
152 if (expected_length_or_area > 0)
154 BOOST_CHECK_CLOSE(detected_length_or_area, expected_length_or_area, settings.percentage);
158 // Compare 0 with 0 or a very small detected area
159 BOOST_CHECK_LE(detected_length_or_area, settings.percentage);
164 // In some cases (geos_2) the intersection is either 0, or a tiny rectangle,
165 // depending on compiler/settings. That cannot be tested by CLOSE
166 BOOST_CHECK_LE(detected_length_or_area, expected_length_or_area);
173 template <typename OutputType, typename CalculationType, typename G1, typename G2>
174 typename bg::default_area_result<G1>::type test_intersection(std::string const& caseid,
175 G1 const& g1, G2 const& g2,
176 std::size_t expected_count = 0, std::size_t expected_holes_count = 0,
177 int expected_point_count = 0, double expected_length_or_area = 0,
178 ut_settings const& settings = ut_settings())
182 std::cout << std::endl << "case " << caseid << std::endl;
185 typedef typename setop_output_type<OutputType>::type result_type;
187 typedef typename bg::point_type<G1>::type point_type;
188 boost::ignore_unused<point_type>();
190 #if ! defined(BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE)
191 if (! settings.debug)
193 // Check _inserter behaviour with stratey
194 typedef typename bg::strategy::intersection::services::default_strategy
196 typename bg::cs_tag<point_type>::type
197 >::type strategy_type;
199 bg::detail::intersection::intersection_insert<OutputType>(g1, g2, std::back_inserter(clip), strategy_type());
203 typename bg::default_area_result<G1>::type length_or_area = 0;
205 // Check normal behaviour
206 result_type intersection_output;
207 bg::intersection(g1, g2, intersection_output);
209 check_result(intersection_output, caseid, g1, g2, expected_count,
210 expected_holes_count, expected_point_count, expected_length_or_area,
213 #if ! defined(BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE)
214 // Check variant behaviour
215 intersection_output.clear();
216 bg::intersection(boost::variant<G1>(g1), g2, intersection_output);
218 check_result(intersection_output, caseid, g1, g2, expected_count,
219 expected_holes_count, expected_point_count, expected_length_or_area,
222 intersection_output.clear();
223 bg::intersection(g1, boost::variant<G2>(g2), intersection_output);
225 check_result(intersection_output, caseid, g1, g2, expected_count,
226 expected_holes_count, expected_point_count, expected_length_or_area,
229 intersection_output.clear();
230 bg::intersection(boost::variant<G1>(g1), boost::variant<G2>(g2), intersection_output);
232 check_result(intersection_output, caseid, g1, g2, expected_count,
233 expected_holes_count, expected_point_count, expected_length_or_area,
237 #if defined(TEST_WITH_SVG)
239 bool const is_line = bg::geometry_id<OutputType>::type::value == 2;
240 typedef typename bg::coordinate_type<G1>::type coordinate_type;
243 bg::point_order<G1>::value == bg::counterclockwise
244 || bg::point_order<G2>::value == bg::counterclockwise;
246 bg::closure<G1>::value == bg::open
247 || bg::closure<G2>::value == bg::open;
249 std::ostringstream filename;
250 filename << "intersection_"
252 << string_from_type<coordinate_type>::name()
253 << string_from_type<CalculationType>::name()
254 << (ccw ? "_ccw" : "")
255 << (open ? "_open" : "")
256 #if defined(BOOST_GEOMETRY_USE_RESCALING)
261 std::ofstream svg(filename.str().c_str());
263 bg::svg_mapper<point_type> mapper(svg, 500, 500);
268 mapper.map(g1, is_line
269 ? "opacity:0.6;stroke:rgb(0,255,0);stroke-width:5"
270 : "fill-opacity:0.5;fill:rgb(153,204,0);"
271 "stroke:rgb(153,204,0);stroke-width:3");
272 mapper.map(g2, "fill-opacity:0.3;fill:rgb(51,51,153);"
273 "stroke:rgb(51,51,153);stroke-width:3");
275 for (typename result_type::const_iterator it = intersection_output.begin();
276 it != intersection_output.end(); ++it)
278 mapper.map(*it, "fill-opacity:0.2;stroke-opacity:0.4;fill:rgb(255,0,0);"
279 "stroke:rgb(255,0,255);stroke-width:8");
287 std::cout << "end case " << caseid << std::endl;
290 return length_or_area;
293 template <typename OutputType, typename CalculationType, typename G1, typename G2>
294 typename bg::default_area_result<G1>::type test_intersection(std::string const& caseid,
295 G1 const& g1, G2 const& g2,
296 std::size_t expected_count = 0, int expected_point_count = 0,
297 double expected_length_or_area = 0,
298 ut_settings const& settings = ut_settings())
300 return test_intersection<OutputType, CalculationType>(
301 caseid, g1, g2, expected_count, 0, expected_point_count,
302 expected_length_or_area, settings
306 template <typename OutputType, typename G1, typename G2>
307 typename bg::default_area_result<G1>::type test_one(std::string const& caseid,
308 std::string const& wkt1, std::string const& wkt2,
309 std::size_t expected_count = 0, std::size_t expected_holes_count = 0,
310 int expected_point_count = 0, double expected_length_or_area = 0,
311 ut_settings const& settings = ut_settings())
314 bg::read_wkt(wkt1, g1);
317 bg::read_wkt(wkt2, g2);
319 // Reverse if necessary
323 return test_intersection<OutputType, void>(caseid, g1, g2,
324 expected_count, expected_holes_count, expected_point_count,
325 expected_length_or_area, settings);
328 template <typename OutputType, typename G1, typename G2>
329 typename bg::default_area_result<G1>::type test_one(std::string const& caseid,
330 std::string const& wkt1, std::string const& wkt2,
331 std::size_t expected_count = 0, int expected_point_count = 0,
332 double expected_length_or_area = 0,
333 ut_settings const& settings = ut_settings())
335 return test_one<OutputType, G1, G2>(caseid, wkt1, wkt2,
336 expected_count, 0, expected_point_count,
337 expected_length_or_area,
341 template <typename OutputType, typename Areal, typename Linear>
342 void test_one_lp(std::string const& caseid,
343 std::string const& wkt_areal, std::string const& wkt_linear,
344 std::size_t expected_count = 0, int expected_point_count = 0,
345 double expected_length = 0,
346 ut_settings const& settings = ut_settings())
348 #ifdef BOOST_GEOMETRY_TEST_DEBUG
349 std::cout << caseid << " -- start" << std::endl;
352 bg::read_wkt(wkt_areal, areal);
356 bg::read_wkt(wkt_linear, linear);
358 test_intersection<OutputType, void>(caseid, areal, linear,
359 expected_count, expected_point_count,
360 expected_length, settings);
362 // A linestring reversed should deliver exactly the same.
365 test_intersection<OutputType, void>(caseid + "_rev", areal, linear,
366 expected_count, expected_point_count,
367 expected_length, settings);
368 #ifdef BOOST_GEOMETRY_TEST_DEBUG
369 std::cout << caseid << " -- end" << std::endl;
373 template <typename Geometry1, typename Geometry2>
374 void test_point_output(std::string const& wkt1, std::string const& wkt2, unsigned int expected_count)
377 bg::read_wkt(wkt1, g1);
381 bg::read_wkt(wkt2, g2);
384 bg::model::multi_point<typename bg::point_type<Geometry1>::type> points;
385 bg::intersection(g1, g2, points);
386 BOOST_CHECK_EQUAL(points.size(), expected_count);