1 // Boost.Geometry (aka GGL, Generic Geometry Library)
2 // Unit Test
3 
4 // Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
5 // Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
6 
7 // This file was modified by Oracle on 2017.
8 // Modifications copyright (c) 2017 Oracle and/or its affiliates.
9 
10 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
11 
12 // Use, modification and distribution is subject to the Boost Software License,
13 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
14 // http://www.boost.org/LICENSE_1_0.txt)
15 
16 
17 #ifndef BOOST_GEOMETRY_TEST_COVERED_BY_HPP
18 #define BOOST_GEOMETRY_TEST_COVERED_BY_HPP
19 
20 
21 #include <geometry_test_common.hpp>
22 
23 #include <boost/variant/variant.hpp>
24 
25 #include <boost/geometry/algorithms/covered_by.hpp>
26 #include <boost/geometry/core/ring_type.hpp>
27 #include <boost/geometry/geometries/ring.hpp>
28 #include <boost/geometry/geometries/polygon.hpp>
29 #include <boost/geometry/geometries/multi_linestring.hpp>
30 #include <boost/geometry/io/wkt/read.hpp>
31 #include <boost/geometry/strategies/strategies.hpp>
32 
33 struct no_strategy {};
34 
35 template <typename Geometry1, typename Geometry2, typename Strategy>
call_covered_by(Geometry1 const & geometry1,Geometry2 const & geometry2,Strategy const & strategy)36 bool call_covered_by(Geometry1 const& geometry1,
37                      Geometry2 const& geometry2,
38                      Strategy const& strategy)
39 {
40     return bg::covered_by(geometry1, geometry2, strategy);
41 }
42 
43 template <typename Geometry1, typename Geometry2>
call_covered_by(Geometry1 const & geometry1,Geometry2 const & geometry2,no_strategy)44 bool call_covered_by(Geometry1 const& geometry1,
45                      Geometry2 const& geometry2,
46                      no_strategy)
47 {
48     return bg::covered_by(geometry1, geometry2);
49 }
50 
51 template <typename Geometry1, typename Geometry2, typename Strategy>
check_geometry(Geometry1 const & geometry1,Geometry2 const & geometry2,std::string const & wkt1,std::string const & wkt2,bool expected,Strategy const & strategy)52 void check_geometry(Geometry1 const& geometry1,
53                     Geometry2 const& geometry2,
54                     std::string const& wkt1,
55                     std::string const& wkt2,
56                     bool expected,
57                     Strategy const& strategy)
58 {
59     bool detected = call_covered_by(geometry1, geometry2, strategy);
60 
61     BOOST_CHECK_MESSAGE(detected == expected,
62         "covered_by: " << wkt1
63         << " in " << wkt2
64         << " -> Expected: " << expected
65         << " detected: " << detected);
66 }
67 
68 template <typename Geometry1, typename Geometry2>
test_geometry(std::string const & wkt1,std::string const & wkt2,bool expected)69 void test_geometry(std::string const& wkt1,
70         std::string const& wkt2, bool expected)
71 {
72     Geometry1 geometry1;
73     Geometry2 geometry2;
74     bg::read_wkt(wkt1, geometry1);
75     bg::read_wkt(wkt2, geometry2);
76     boost::variant<Geometry1> v1(geometry1);
77     boost::variant<Geometry2> v2(geometry2);
78 
79     typedef typename bg::strategy::covered_by::services::default_strategy
80         <
81             Geometry1, Geometry2
82         >::type strategy_type;
83 
84     check_geometry(geometry1, geometry2, wkt1, wkt2, expected, no_strategy());
85     check_geometry(geometry1, geometry2, wkt1, wkt2, expected, strategy_type());
86     check_geometry(v1, geometry2, wkt1, wkt2, expected, no_strategy());
87     check_geometry(geometry1, v2, wkt1, wkt2, expected, no_strategy());
88     check_geometry(v1, v2, wkt1, wkt2, expected, no_strategy());
89 }
90 
91 template <typename Geometry1, typename Geometry2, typename Strategy>
test_geometry(std::string const & wkt1,std::string const & wkt2,bool expected,Strategy const & strategy)92 void test_geometry(std::string const& wkt1,
93                    std::string const& wkt2,
94                    bool expected,
95                    Strategy const& strategy)
96 {
97     Geometry1 geometry1;
98     Geometry2 geometry2;
99     bg::read_wkt(wkt1, geometry1);
100     bg::read_wkt(wkt2, geometry2);
101 
102     check_geometry(geometry1, geometry2, wkt1, wkt2, expected, strategy);
103 }
104 
105 /*
106 
107 template <typename Point, bool Clockwise, bool Closed>
108 void test_ordered_ring(std::string const& wkt_point,
109         std::string const& wkt_geometry, bool expected)
110 {
111     typedef bg::model::ring<Point, Clockwise, Closed> ring_type;
112     ring_type ring;
113     Point point;
114 
115     bg::read_wkt(wkt_geometry, ring);
116     if (! Clockwise)
117     {
118         std::reverse(boost::begin(ring), boost::end(ring));
119     }
120     if (! Closed)
121     {
122         ring.resize(ring.size() - 1);
123     }
124 
125     bg::read_wkt(wkt_point, point);
126 
127     bool detected = bg::covered_by(point, ring);
128 
129     BOOST_CHECK_MESSAGE(detected == expected,
130         "covered_by: " << wkt_point
131         << " in " << wkt_geometry
132         << " -> Expected: " << expected
133         << " detected: " << detected
134         << " clockwise: " << int(Clockwise)
135         << " closed: " << int(Closed)
136         );
137 
138     // other strategy (note that this one cannot detect OnBorder
139     // (without modifications)
140 
141     bg::strategy::covered_by::franklin<Point> franklin;
142     detected = bg::covered_by(point, ring, franklin);
143     if (! on_border)
144     {
145         BOOST_CHECK_MESSAGE(detected == expected,
146             "covered_by: " << wkt_point
147             << " in " << wkt_geometry
148             << " -> Expected: " << expected
149             << " detected: " << detected
150             << " clockwise: " << int(Clockwise)
151             << " closed: " << int(Closed)
152             );
153     }
154 
155 
156     bg::strategy::covered_by::crossings_multiply<Point> cm;
157     detected = bg::covered_by(point, ring, cm);
158     if (! on_border)
159     {
160         BOOST_CHECK_MESSAGE(detected == expected,
161             "covered_by: " << wkt_point
162             << " in " << wkt_geometry
163             << " -> Expected: " << expected
164             << " detected: " << detected
165             << " clockwise: " << int(Clockwise)
166             << " closed: " << int(Closed)
167             );
168     }
169 }
170 
171 template <typename Point>
172 void test_ring(std::string const& wkt_point,
173         std::string const& wkt_geometry,
174         bool expected)
175 {
176     test_ordered_ring<Point, true, true>(wkt_point, wkt_geometry, expected);
177     test_ordered_ring<Point, false, true>(wkt_point, wkt_geometry, expected);
178     test_ordered_ring<Point, true, false>(wkt_point, wkt_geometry, expected);
179     test_ordered_ring<Point, false, false>(wkt_point, wkt_geometry, expected);
180     test_geometry<Point, bg::model::polygon<Point> >(wkt_point, wkt_geometry, expected);
181 }
182 */
183 
184 #endif
185