]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Geometry (aka GGL, Generic Geometry Library) |
2 | // Unit Test | |
3 | ||
92f5a8d4 | 4 | // Copyright (c) 2014-2018, Oracle and/or its affiliates. |
7c673cae | 5 | |
92f5a8d4 | 6 | // Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle |
7c673cae FG |
7 | // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle |
8 | // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle | |
9 | ||
10 | // Licensed under the Boost Software License version 1.0. | |
11 | // http://www.boost.org/users/license.html | |
12 | ||
13 | #include <iostream> | |
14 | ||
15 | #ifndef BOOST_TEST_MODULE | |
92f5a8d4 | 16 | #define BOOST_TEST_MODULE test_distance_spherical_equatorial_pointlike_linear |
7c673cae FG |
17 | #endif |
18 | ||
19 | #include <boost/test/included/unit_test.hpp> | |
20 | ||
21 | #include "test_distance_se_common.hpp" | |
92f5a8d4 | 22 | #include "test_empty_geometry.hpp" |
7c673cae FG |
23 | |
24 | typedef bg::cs::spherical_equatorial<bg::degree> cs_type; | |
25 | typedef bg::model::point<double, 2, cs_type> point_type; | |
26 | typedef bg::model::segment<point_type> segment_type; | |
27 | typedef bg::model::multi_point<point_type> multi_point_type; | |
28 | typedef bg::model::segment<point_type> segment_type; | |
29 | typedef bg::model::linestring<point_type> linestring_type; | |
30 | typedef bg::model::multi_linestring<linestring_type> multi_linestring_type; | |
31 | ||
32 | namespace services = bg::strategy::distance::services; | |
33 | typedef bg::default_distance_result<point_type>::type return_type; | |
34 | ||
35 | typedef bg::strategy::distance::haversine<double> point_point_strategy; | |
36 | typedef bg::strategy::distance::cross_track<> point_segment_strategy; | |
37 | ||
38 | ||
39 | //=========================================================================== | |
40 | ||
41 | template <typename Strategy> | |
42 | inline bg::default_distance_result<point_type>::type | |
43 | pp_distance(std::string const& wkt1, | |
44 | std::string const& wkt2, | |
45 | Strategy const& strategy) | |
46 | { | |
47 | point_type p1, p2; | |
48 | bg::read_wkt(wkt1, p1); | |
49 | bg::read_wkt(wkt2, p2); | |
50 | return bg::distance(p1, p2) * strategy.radius(); | |
51 | } | |
52 | ||
53 | template <typename Strategy> | |
54 | inline bg::default_comparable_distance_result<point_type>::type | |
55 | pp_comparable_distance(std::string const& wkt1, | |
56 | std::string const& wkt2, | |
57 | Strategy const&) | |
58 | { | |
59 | point_type p1, p2; | |
60 | bg::read_wkt(wkt1, p1); | |
61 | bg::read_wkt(wkt2, p2); | |
62 | return bg::comparable_distance(p1, p2); | |
63 | } | |
64 | ||
65 | template <typename Strategy> | |
66 | inline bg::default_distance_result<point_type>::type | |
67 | ps_distance(std::string const& wkt1, | |
68 | std::string const& wkt2, | |
69 | Strategy const& strategy) | |
70 | { | |
71 | point_type p; | |
72 | segment_type s; | |
73 | bg::read_wkt(wkt1, p); | |
74 | bg::read_wkt(wkt2, s); | |
75 | return bg::distance(p, s, strategy); | |
76 | } | |
77 | ||
78 | template <typename Strategy> | |
79 | inline bg::default_comparable_distance_result<point_type>::type | |
80 | ps_comparable_distance(std::string const& wkt1, | |
81 | std::string const& wkt2, | |
82 | Strategy const& strategy) | |
83 | { | |
84 | point_type p; | |
85 | segment_type s; | |
86 | bg::read_wkt(wkt1, p); | |
87 | bg::read_wkt(wkt2, s); | |
88 | return bg::comparable_distance(p, s, strategy); | |
89 | } | |
90 | ||
91 | template <typename Strategy, typename T> | |
92 | T to_comparable(Strategy const& strategy, T const& distance) | |
93 | { | |
94 | namespace services = bg::strategy::distance::services; | |
95 | ||
96 | typedef typename services::comparable_type | |
97 | < | |
98 | Strategy | |
99 | >::type comparable_strategy; | |
100 | ||
101 | typedef typename services::result_from_distance | |
102 | < | |
103 | comparable_strategy, | |
104 | point_type, | |
105 | bg::point_type<segment_type>::type | |
106 | > get_comparable_distance; | |
107 | ||
108 | comparable_strategy cstrategy = services::get_comparable | |
109 | < | |
110 | Strategy | |
111 | >::apply(strategy); | |
112 | ||
113 | return get_comparable_distance::apply(cstrategy, distance); | |
114 | } | |
115 | ||
116 | //=========================================================================== | |
117 | ||
118 | template <typename Strategy> | |
119 | void test_distance_point_segment(Strategy const& strategy) | |
120 | { | |
121 | #ifdef BOOST_GEOMETRY_TEST_DEBUG | |
122 | std::cout << std::endl; | |
123 | std::cout << "point/segment distance tests" << std::endl; | |
124 | #endif | |
125 | typedef test_distance_of_geometries<point_type, segment_type> tester; | |
126 | ||
127 | double const d2r = bg::math::d2r<double>(); | |
128 | ||
129 | tester::apply("p-s-01", | |
130 | "POINT(0 0)", | |
131 | "SEGMENT(2 0,3 0)", | |
132 | 2.0 * d2r * strategy.radius(), | |
133 | to_comparable(strategy, 2.0 * d2r * strategy.radius()), | |
134 | strategy); | |
135 | tester::apply("p-s-02", | |
136 | "POINT(2.5 3)", | |
137 | "SEGMENT(2 0,3 0)", | |
138 | 3.0 * d2r * strategy.radius(), | |
139 | to_comparable(strategy, 3.0 * d2r * strategy.radius()), | |
140 | strategy); | |
141 | tester::apply("p-s-03", | |
142 | "POINT(2 0)", | |
143 | "SEGMENT(2 0,3 0)", | |
144 | 0, | |
145 | strategy); | |
146 | tester::apply("p-s-04", | |
147 | "POINT(3 0)", | |
148 | "SEGMENT(2 0,3 0)", | |
149 | 0, | |
150 | strategy); | |
151 | tester::apply("p-s-05", | |
152 | "POINT(2.5 0)", | |
153 | "SEGMENT(2 0,3 0)", | |
154 | 0, | |
155 | strategy); | |
156 | tester::apply("p-s-06", | |
157 | "POINT(3.5 3)", | |
158 | "SEGMENT(2 0,3 0)", | |
159 | pp_distance("POINT(3 0)", "POINT(3.5 3)", strategy), | |
160 | pp_comparable_distance("POINT(3 0)", | |
161 | "POINT(3.5 3)", | |
162 | strategy), | |
163 | strategy); | |
b32b8144 FG |
164 | tester::apply("p-s-07", |
165 | "POINT(0 0)", | |
166 | "SEGMENT(0 10,10 10)", | |
167 | ps_distance("POINT(0 0)", "SEGMENT(10 10,0 10)", strategy), | |
168 | pp_comparable_distance("POINT(0 0)", | |
169 | "POINT(0 10)", | |
170 | strategy), | |
171 | strategy); | |
7c673cae FG |
172 | // very small distances to segment |
173 | tester::apply("p-s-07", | |
174 | "POINT(90 1e-3)", | |
175 | "SEGMENT(0.5 0,175.5 0)", | |
176 | 1e-3 * d2r * strategy.radius(), | |
177 | to_comparable(strategy, 1e-3 * d2r * strategy.radius()), | |
178 | strategy); | |
179 | tester::apply("p-s-08", | |
180 | "POINT(90 1e-4)", | |
181 | "SEGMENT(0.5 0,175.5 0)", | |
182 | 1e-4 * d2r * strategy.radius(), | |
183 | to_comparable(strategy, 1e-4 * d2r * strategy.radius()), | |
184 | strategy); | |
185 | tester::apply("p-s-09", | |
186 | "POINT(90 1e-5)", | |
187 | "SEGMENT(0.5 0,175.5 0)", | |
188 | 1e-5 * d2r * strategy.radius(), | |
189 | to_comparable(strategy, 1e-5 * d2r * strategy.radius()), | |
190 | strategy); | |
191 | tester::apply("p-s-10", | |
192 | "POINT(90 1e-6)", | |
193 | "SEGMENT(0.5 0,175.5 0)", | |
194 | 1e-6 * d2r * strategy.radius(), | |
195 | to_comparable(strategy, 1e-6 * d2r * strategy.radius()), | |
196 | strategy); | |
197 | tester::apply("p-s-11", | |
198 | "POINT(90 1e-7)", | |
199 | "SEGMENT(0.5 0,175.5 0)", | |
200 | 1e-7 * d2r * strategy.radius(), | |
201 | to_comparable(strategy, 1e-7 * d2r * strategy.radius()), | |
202 | strategy); | |
203 | tester::apply("p-s-12", | |
204 | "POINT(90 1e-8)", | |
205 | "SEGMENT(0.5 0,175.5 0)", | |
206 | 1e-8 * d2r * strategy.radius(), | |
207 | to_comparable(strategy, 1e-8 * d2r * strategy.radius()), | |
208 | strategy); | |
209 | } | |
210 | ||
211 | //=========================================================================== | |
212 | ||
213 | template <typename Strategy> | |
214 | void test_distance_point_linestring(Strategy const& strategy) | |
215 | { | |
216 | #ifdef BOOST_GEOMETRY_TEST_DEBUG | |
217 | std::cout << std::endl; | |
218 | std::cout << "point/linestring distance tests" << std::endl; | |
219 | #endif | |
220 | typedef test_distance_of_geometries<point_type, linestring_type> tester; | |
221 | ||
222 | double const r = strategy.radius(); | |
223 | double const d2r = bg::math::d2r<double>(); | |
224 | ||
225 | tester::apply("p-l-01", | |
226 | "POINT(0 0)", | |
227 | "LINESTRING(2 0,2 0)", | |
228 | 2.0 * d2r * r, | |
229 | to_comparable(strategy, 2.0 * d2r * r), | |
230 | strategy); | |
231 | tester::apply("p-l-02", | |
232 | "POINT(0 0)", | |
233 | "LINESTRING(2 0,3 0)", | |
234 | 2.0 * d2r * r, | |
235 | to_comparable(strategy, 2.0 * d2r * r), | |
236 | strategy); | |
237 | tester::apply("p-l-03", | |
238 | "POINT(2.5 3)", | |
239 | "LINESTRING(2 0,3 0)", | |
240 | 3.0 * d2r * r, | |
241 | to_comparable(strategy, 3.0 * d2r * r), | |
242 | strategy); | |
243 | tester::apply("p-l-04", | |
244 | "POINT(2 0)", | |
245 | "LINESTRING(2 0,3 0)", | |
246 | 0, | |
247 | strategy); | |
248 | tester::apply("p-l-05", | |
249 | "POINT(3 0)", | |
250 | "LINESTRING(2 0,3 0)", | |
251 | 0, | |
252 | strategy); | |
253 | tester::apply("p-l-06", | |
254 | "POINT(2.5 0)", | |
255 | "LINESTRING(2 0,3 0)", | |
256 | 0, | |
257 | strategy); | |
258 | tester::apply("p-l-07", | |
259 | "POINT(7.5 10)", | |
260 | "LINESTRING(1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 0)", | |
261 | 10.0 * d2r * r, | |
262 | to_comparable(strategy, 10.0 * d2r * r), | |
263 | strategy); | |
264 | tester::apply("p-l-08", | |
265 | "POINT(7.5 10)", | |
266 | "LINESTRING(1 1,2 1,3 1,4 1,5 1,6 1,7 1,20 2,21 2)", | |
267 | ps_distance("POINT(7.5 10)", "SEGMENT(7 1,20 2)", strategy), | |
268 | ps_comparable_distance("POINT(7.5 10)", | |
269 | "SEGMENT(7 1,20 2)", | |
270 | strategy), | |
271 | strategy); | |
272 | ||
273 | // https://svn.boost.org/trac/boost/ticket/11982 | |
274 | tester::apply("p-l-09", | |
275 | "POINT(10.4 63.43)", | |
276 | "LINESTRING(10.733557 59.911923, 10.521812 59.887214)", | |
277 | 0.06146397739758279 * r, | |
278 | 0.000944156107132969, | |
279 | strategy); | |
92f5a8d4 TL |
280 | |
281 | //https://github.com/boostorg/geometry/issues/557 | |
282 | tester::apply("p-l-issue557", | |
283 | "POINT(51.99999790563572 43.71656981636763)", | |
284 | "LINESTRING(52.0000243071011 43.716569742012496,\ | |
285 | 52.0000121532845 43.71656942616241,\ | |
286 | 52.0 43.7165690998572,\ | |
287 | 51.999987847203 43.7165687638793)", | |
288 | 1.35062e-08 * r, | |
289 | 4.5604e-17, | |
290 | strategy); | |
291 | ||
7c673cae FG |
292 | } |
293 | ||
294 | //=========================================================================== | |
295 | ||
296 | template <typename Strategy> | |
297 | void test_distance_point_multilinestring(Strategy const& strategy) | |
298 | { | |
299 | #ifdef BOOST_GEOMETRY_TEST_DEBUG | |
300 | std::cout << std::endl; | |
301 | std::cout << "point/multilinestring distance tests" << std::endl; | |
302 | #endif | |
303 | typedef test_distance_of_geometries | |
304 | < | |
305 | point_type, multi_linestring_type | |
306 | > tester; | |
307 | ||
308 | double const d2r = bg::math::d2r<double>(); | |
309 | ||
310 | tester::apply("p-ml-01", | |
311 | "POINT(0 0)", | |
312 | "MULTILINESTRING((-5 0,-3 0),(2 0,3 0))", | |
313 | 2.0 * d2r * strategy.radius(), | |
314 | to_comparable(strategy, 2.0 * d2r * strategy.radius()), | |
315 | strategy); | |
316 | tester::apply("p-ml-02", | |
317 | "POINT(2.5 3)", | |
318 | "MULTILINESTRING((-5 0,-3 0),(2 0,3 0))", | |
319 | 3.0 * d2r * strategy.radius(), | |
320 | to_comparable(strategy, 3.0 * d2r * strategy.radius()), | |
321 | strategy); | |
322 | tester::apply("p-ml-03", | |
323 | "POINT(2 0)", | |
324 | "MULTILINESTRING((-5 0,-3 0),(2 0,3 0))", | |
325 | 0, | |
326 | strategy); | |
327 | tester::apply("p-ml-04", | |
328 | "POINT(3 0)", | |
329 | "MULTILINESTRING((-5 0,-3 0),(2 0,3 0))", | |
330 | 0, | |
331 | strategy); | |
332 | tester::apply("p-ml-05", | |
333 | "POINT(2.5 0)", | |
334 | "MULTILINESTRING((-5 0,-3 0),(2 0,3 0))", | |
335 | 0, | |
336 | strategy); | |
337 | tester::apply("p-ml-06", | |
338 | "POINT(7.5 10)", | |
339 | "MULTILINESTRING((-5 0,-3 0),(2 0,3 0,4 0,5 0,6 0,20 1,21 1))", | |
340 | ps_distance("POINT(7.5 10)", "SEGMENT(6 0,20 1)", strategy), | |
341 | ps_comparable_distance("POINT(7.5 10)", | |
342 | "SEGMENT(6 0,20 1)", | |
343 | strategy), | |
344 | strategy); | |
345 | tester::apply("p-ml-07", | |
346 | "POINT(-8 10)", | |
347 | "MULTILINESTRING((-20 10,-19 11,-18 10,-6 0,-5 0,-3 0),(2 0,6 0,20 1,21 1))", | |
348 | ps_distance("POINT(-8 10)", "SEGMENT(-6 0,-18 10)", strategy), | |
349 | ps_comparable_distance("POINT(-8 10)", | |
350 | "SEGMENT(-6 0,-18 10)", | |
351 | strategy), | |
352 | strategy); | |
353 | } | |
354 | ||
355 | //=========================================================================== | |
356 | ||
357 | template <typename Strategy> | |
358 | void test_distance_linestring_multipoint(Strategy const& strategy) | |
359 | { | |
360 | #ifdef BOOST_GEOMETRY_TEST_DEBUG | |
361 | std::cout << std::endl; | |
362 | std::cout << "linestring/multipoint distance tests" << std::endl; | |
363 | #endif | |
364 | typedef test_distance_of_geometries | |
365 | < | |
366 | linestring_type, multi_point_type | |
367 | > tester; | |
368 | ||
369 | tester::apply("l-mp-01", | |
370 | "LINESTRING(2 0,0 2,100 80)", | |
371 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
372 | ps_distance("POINT(1 1)", "SEGMENT(2 0,0 2)", strategy), | |
373 | ps_comparable_distance("POINT(1 1)", | |
374 | "SEGMENT(2 0,0 2)", | |
375 | strategy), | |
376 | strategy); | |
377 | tester::apply("l-mp-02", | |
378 | "LINESTRING(4 0,0 4,100 80)", | |
379 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
380 | ps_distance("POINT(1 1)", "SEGMENT(0 4,4 0)", strategy), | |
381 | ps_comparable_distance("POINT(1 1)", | |
382 | "SEGMENT(0 4,4 0)", | |
383 | strategy), | |
384 | strategy); | |
385 | tester::apply("l-mp-03", | |
386 | "LINESTRING(1 1,2 2,100 80)", | |
387 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
388 | 0, | |
389 | strategy); | |
390 | tester::apply("l-mp-04", | |
391 | "LINESTRING(3 3,4 4,100 80)", | |
392 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
393 | pp_distance("POINT(1 1)", "POINT(3 3)", strategy), | |
394 | pp_comparable_distance("POINT(1 1)", "POINT(3 3)", strategy), | |
395 | strategy); | |
396 | tester::apply("l-mp-05", | |
397 | "LINESTRING(0 0,10 0,10 10,0 10,0 0)", | |
398 | "MULTIPOINT(1 -1,80 80,5 0,150 90)", | |
399 | 0, | |
400 | strategy); | |
401 | } | |
402 | ||
403 | //=========================================================================== | |
404 | ||
405 | template <typename Strategy> | |
406 | void test_distance_multipoint_multilinestring(Strategy const& strategy) | |
407 | { | |
408 | #ifdef BOOST_GEOMETRY_TEST_DEBUG | |
409 | std::cout << std::endl; | |
410 | std::cout << "multipoint/multilinestring distance tests" << std::endl; | |
411 | #endif | |
412 | typedef test_distance_of_geometries | |
413 | < | |
414 | multi_point_type, multi_linestring_type | |
415 | > tester; | |
416 | ||
417 | tester::apply("mp-ml-01", | |
418 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
419 | "MULTILINESTRING((2 0,0 2),(2 2,3 3))", | |
420 | ps_distance("POINT(1 1)", "SEGMENT(2 0,0 2)", strategy), | |
421 | ps_comparable_distance("POINT(1 1)", | |
422 | "SEGMENT(2 0,0 2)", | |
423 | strategy), | |
424 | strategy); | |
425 | tester::apply("mp-ml-02", | |
426 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
427 | "MULTILINESTRING((3 0,0 3),(4 4,5 5))", | |
428 | ps_distance("POINT(1 1)", "SEGMENT(3 0,0 3)", strategy), | |
429 | ps_comparable_distance("POINT(1 1)", | |
430 | "SEGMENT(3 0,0 3)", | |
431 | strategy), | |
432 | strategy); | |
433 | tester::apply("mp-ml-03", | |
434 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
435 | "MULTILINESTRING((4 4,5 5),(1 1,2 2))", | |
436 | 0, | |
437 | strategy); | |
438 | tester::apply("mp-ml-04", | |
439 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
440 | "MULTILINESTRING((4 4,3 3),(4 4,5 5))", | |
441 | pp_distance("POINT(1 1)", "POINT(3 3)", strategy), | |
442 | pp_comparable_distance("POINT(1 1)", "POINT(3 3)", strategy), | |
443 | strategy); | |
444 | } | |
445 | ||
446 | //=========================================================================== | |
447 | ||
448 | template <typename Strategy> | |
449 | void test_distance_multipoint_segment(Strategy const& strategy) | |
450 | { | |
451 | #ifdef BOOST_GEOMETRY_TEST_DEBUG | |
452 | std::cout << std::endl; | |
453 | std::cout << "multipoint/segment distance tests" << std::endl; | |
454 | #endif | |
455 | typedef test_distance_of_geometries<multi_point_type, segment_type> tester; | |
456 | ||
457 | double d2r = bg::math::d2r<double>(); | |
458 | ||
459 | tester::apply("mp-s-01", | |
460 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
461 | "SEGMENT(2 0,0 2)", | |
462 | ps_distance("POINT(1 1)", "SEGMENT(2 0,0 2)", strategy), | |
463 | ps_comparable_distance("POINT(1 1)", | |
464 | "SEGMENT(2 0,0 2)", | |
465 | strategy), | |
466 | strategy); | |
467 | tester::apply("mp-s-02", | |
468 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
469 | "SEGMENT(0 -3,1 -10)", | |
470 | 3.0 * d2r * strategy.radius(), | |
471 | to_comparable(strategy, 3.0 * d2r * strategy.radius()), | |
472 | strategy); | |
473 | tester::apply("mp-s-03", | |
474 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
475 | "SEGMENT(1 1,2 2)", | |
476 | 0, | |
477 | strategy); | |
478 | tester::apply("mp-s-04", | |
479 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
480 | "SEGMENT(3 3,4 4)", | |
481 | pp_distance("POINT(1 1)", "POINT(3 3)", strategy), | |
482 | pp_comparable_distance("POINT(1 1)", "POINT(3 3)", strategy), | |
483 | strategy); | |
484 | tester::apply("mp-s-05", | |
485 | "MULTIPOINT(0 0,1 0,0 1,1 1)", | |
486 | "SEGMENT(0.5 -3,1 -10)", | |
487 | pp_distance("POINT(1 0)", "POINT(0.5 -3)", strategy), | |
488 | pp_comparable_distance("POINT(1 0)", | |
489 | "POINT(0.5 -3)", | |
490 | strategy), | |
491 | strategy); | |
492 | } | |
493 | ||
7c673cae FG |
494 | //=========================================================================== |
495 | //=========================================================================== | |
496 | //=========================================================================== | |
497 | ||
92f5a8d4 | 498 | BOOST_AUTO_TEST_CASE( test_all_pointlike_linear ) |
7c673cae FG |
499 | { |
500 | test_distance_point_segment(point_segment_strategy()); | |
501 | test_distance_point_segment(point_segment_strategy(earth_radius_km)); | |
502 | test_distance_point_segment(point_segment_strategy(earth_radius_miles)); | |
503 | } | |
504 | ||
505 | BOOST_AUTO_TEST_CASE( test_all_point_linestring ) | |
506 | { | |
507 | test_distance_point_linestring(point_segment_strategy()); | |
508 | test_distance_point_linestring(point_segment_strategy(earth_radius_km)); | |
509 | test_distance_point_linestring(point_segment_strategy(earth_radius_miles)); | |
510 | } | |
511 | ||
512 | BOOST_AUTO_TEST_CASE( test_all_point_multilinestring ) | |
513 | { | |
514 | test_distance_point_multilinestring(point_segment_strategy()); | |
515 | test_distance_point_multilinestring(point_segment_strategy(earth_radius_km)); | |
516 | test_distance_point_multilinestring(point_segment_strategy(earth_radius_miles)); | |
517 | } | |
518 | ||
519 | BOOST_AUTO_TEST_CASE( test_all_linestring_multipoint ) | |
520 | { | |
521 | test_distance_linestring_multipoint(point_segment_strategy()); | |
522 | test_distance_linestring_multipoint(point_segment_strategy(earth_radius_km)); | |
523 | test_distance_linestring_multipoint(point_segment_strategy(earth_radius_miles)); | |
524 | } | |
525 | ||
526 | BOOST_AUTO_TEST_CASE( test_all_multipoint_multilinestring ) | |
527 | { | |
528 | test_distance_multipoint_multilinestring(point_segment_strategy()); | |
529 | test_distance_multipoint_multilinestring(point_segment_strategy(earth_radius_km)); | |
530 | test_distance_multipoint_multilinestring(point_segment_strategy(earth_radius_miles)); | |
531 | } | |
532 | ||
533 | BOOST_AUTO_TEST_CASE( test_all_multipoint_segment ) | |
534 | { | |
535 | test_distance_multipoint_segment(point_segment_strategy()); | |
536 | test_distance_multipoint_segment(point_segment_strategy(earth_radius_km)); | |
537 | test_distance_multipoint_segment(point_segment_strategy(earth_radius_miles)); | |
538 | } | |
539 | ||
540 | BOOST_AUTO_TEST_CASE( test_all_empty_input_pointlike_linear ) | |
541 | { | |
542 | test_more_empty_input_pointlike_linear | |
543 | < | |
544 | point_type | |
545 | >(point_segment_strategy()); | |
546 | ||
547 | test_more_empty_input_pointlike_linear | |
548 | < | |
549 | point_type | |
550 | >(point_segment_strategy(earth_radius_km)); | |
551 | ||
552 | test_more_empty_input_pointlike_linear | |
553 | < | |
554 | point_type | |
555 | >(point_segment_strategy(earth_radius_miles)); | |
556 | } |