1 // Boost.Geometry (aka GGL, Generic Geometry Library)
2 // Unit Test
3
4 // Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
5 // Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
6 // Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
7
8 // This file was modified by Oracle on 2014.
9 // Modifications copyright (c) 2014, Oracle and/or its affiliates.
10
11 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
12
13 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
14 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
15
16 // Use, modification and distribution is subject to the Boost Software License,
17 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
18 // http://www.boost.org/LICENSE_1_0.txt)
19
20 #ifndef BOOST_TEST_MODULE
21 #define BOOST_TEST_MODULE test_pythagoras_point_box
22 #endif
23
24 #include <boost/test/included/unit_test.hpp>
25
26 #if defined(_MSC_VER)
27 # pragma warning( disable : 4101 )
28 #endif
29
30 #include <boost/core/ignore_unused.hpp>
31 #include <boost/timer.hpp>
32
33 #include <boost/concept/requires.hpp>
34 #include <boost/concept_check.hpp>
35
36 #include <boost/geometry/algorithms/assign.hpp>
37 #include <boost/geometry/algorithms/expand.hpp>
38 #include <boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp>
39 #include <boost/geometry/strategies/concepts/distance_concept.hpp>
40
41
42 #include <boost/geometry/geometries/point.hpp>
43 #include <boost/geometry/geometries/box.hpp>
44 #include <boost/geometry/geometries/adapted/c_array.hpp>
45 #include <boost/geometry/geometries/adapted/boost_tuple.hpp>
46
47 #include <test_common/test_point.hpp>
48
49 #ifdef HAVE_TTMATH
50 # include <boost/geometry/extensions/contrib/ttmath_stub.hpp>
51 #endif
52
53
54 namespace bg = boost::geometry;
55
56
57 BOOST_GEOMETRY_REGISTER_C_ARRAY_CS(cs::cartesian)
BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(cs::cartesian)58 BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(cs::cartesian)
59
60
61 template <typename Box, typename Coordinate>
62 inline void assign_values(Box& box,
63 Coordinate const& x1,
64 Coordinate const& y1,
65 Coordinate const& z1,
66 Coordinate const& x2,
67 Coordinate const& y2,
68 Coordinate const& z2)
69 {
70 typename bg::point_type<Box>::type p1, p2;
71 bg::assign_values(p1, x1, y1, z1);
72 bg::assign_values(p2, x2, y2, z2);
73 bg::assign(box, p1);
74 bg::expand(box, p2);
75 }
76
77 template <typename Point, typename Box>
test_null_distance_3d()78 inline void test_null_distance_3d()
79 {
80 Point p;
81 bg::assign_values(p, 1, 2, 4);
82 Box b;
83 assign_values(b, 1, 2, 3, 4, 5, 6);
84
85 typedef bg::strategy::distance::pythagoras_point_box<> pythagoras_pb_type;
86 typedef typename bg::strategy::distance::services::return_type
87 <
88 pythagoras_pb_type, Point, Box
89 >::type return_type;
90
91 pythagoras_pb_type pythagoras_pb;
92 return_type result = pythagoras_pb.apply(p, b);
93
94 BOOST_CHECK_EQUAL(result, return_type(0));
95
96 bg::assign_values(p, 1, 3, 4);
97 result = pythagoras_pb.apply(p, b);
98 BOOST_CHECK_EQUAL(result, return_type(0));
99
100 bg::assign_values(p, 2, 3, 4);
101 result = pythagoras_pb.apply(p, b);
102 BOOST_CHECK_EQUAL(result, return_type(0));
103 }
104
105 template <typename Point, typename Box>
test_axis_3d()106 inline void test_axis_3d()
107 {
108 Box b;
109 assign_values(b, 0, 0, 0, 1, 1, 1);
110 Point p;
111 bg::assign_values(p, 2, 0, 0);
112
113 typedef bg::strategy::distance::pythagoras_point_box<> pythagoras_pb_type;
114 typedef typename bg::strategy::distance::services::return_type
115 <
116 pythagoras_pb_type, Point, Box
117 >::type return_type;
118
119 pythagoras_pb_type pythagoras_pb;
120
121 return_type result = pythagoras_pb.apply(p, b);
122 BOOST_CHECK_EQUAL(result, return_type(1));
123
124 bg::assign_values(p, 0, 2, 0);
125 result = pythagoras_pb.apply(p, b);
126 BOOST_CHECK_EQUAL(result, return_type(1));
127
128 bg::assign_values(p, 0, 0, 2);
129 result = pythagoras_pb.apply(p, b);
130 BOOST_CHECK_CLOSE(result, return_type(1), 0.001);
131 }
132
133 template <typename Point, typename Box>
test_arbitrary_3d()134 inline void test_arbitrary_3d()
135 {
136 Box b;
137 assign_values(b, 0, 0, 0, 1, 2, 3);
138 Point p;
139 bg::assign_values(p, 9, 8, 7);
140
141 {
142 typedef bg::strategy::distance::pythagoras_point_box<> strategy_type;
143 typedef typename bg::strategy::distance::services::return_type
144 <
145 strategy_type, Point, Box
146 >::type return_type;
147
148 strategy_type strategy;
149 return_type result = strategy.apply(p, b);
150 BOOST_CHECK_CLOSE(result, return_type(10.77032961427), 0.001);
151 }
152
153 {
154 // Check comparable distance
155 typedef bg::strategy::distance::comparable::pythagoras_point_box<>
156 strategy_type;
157
158 typedef typename bg::strategy::distance::services::return_type
159 <
160 strategy_type, Point, Box
161 >::type return_type;
162
163 strategy_type strategy;
164 return_type result = strategy.apply(p, b);
165 BOOST_CHECK_EQUAL(result, return_type(116));
166 }
167 }
168
169 template <typename Point, typename Box, typename CalculationType>
test_services()170 inline void test_services()
171 {
172 namespace bgsd = bg::strategy::distance;
173 namespace services = bg::strategy::distance::services;
174
175 {
176 // Compile-check if there is a strategy for this type
177 typedef typename services::default_strategy
178 <
179 bg::point_tag, bg::box_tag, Point, Box
180 >::type pythagoras_pb_strategy_type;
181
182 // reverse geometry tags
183 typedef typename services::default_strategy
184 <
185 bg::box_tag, bg::point_tag, Box, Point
186 >::type reversed_pythagoras_pb_strategy_type;
187
188 boost::ignore_unused
189 <
190 pythagoras_pb_strategy_type,
191 reversed_pythagoras_pb_strategy_type
192 >();
193 }
194
195 Point p;
196 bg::assign_values(p, 1, 2, 3);
197
198 Box b;
199 assign_values(b, 4, 5, 6, 14, 15, 16);
200
201 double const sqr_expected = 3*3 + 3*3 + 3*3; // 27
202 double const expected = sqrt(sqr_expected); // sqrt(27)=5.1961524227
203
204 // 1: normal, calculate distance:
205
206 typedef bgsd::pythagoras_point_box<CalculationType> strategy_type;
207
208 BOOST_CONCEPT_ASSERT
209 ( (bg::concepts::PointDistanceStrategy<strategy_type, Point, Box>) );
210
211 typedef typename bgsd::services::return_type
212 <
213 strategy_type, Point, Box
214 >::type return_type;
215
216 strategy_type strategy;
217 return_type result = strategy.apply(p, b);
218 BOOST_CHECK_CLOSE(result, return_type(expected), 0.001);
219
220 // 2: the strategy should return the same result if we reverse parameters
221 // result = strategy.apply(p2, p1);
222 // BOOST_CHECK_CLOSE(result, return_type(expected), 0.001);
223
224
225 // 3: "comparable" to construct a "comparable strategy" for Point/Box
226 // a "comparable strategy" is a strategy which does not calculate the exact distance, but
227 // which returns results which can be mutually compared (e.g. avoid sqrt)
228
229 // 3a: "comparable_type"
230 typedef typename services::comparable_type
231 <
232 strategy_type
233 >::type comparable_type;
234
235 // 3b: "get_comparable"
236 comparable_type comparable = bgsd::services::get_comparable
237 <
238 strategy_type
239 >::apply(strategy);
240
241 typedef typename bgsd::services::return_type
242 <
243 comparable_type, Point, Box
244 >::type comparable_return_type;
245
246 comparable_return_type c_result = comparable.apply(p, b);
247 BOOST_CHECK_CLOSE(c_result, return_type(sqr_expected), 0.001);
248
249 // 4: the comparable_type should have a distance_strategy_constructor as well,
250 // knowing how to compare something with a fixed distance
251 comparable_return_type c_dist5 = services::result_from_distance
252 <
253 comparable_type, Point, Box
254 >::apply(comparable, 5.0);
255
256 comparable_return_type c_dist6 = services::result_from_distance
257 <
258 comparable_type, Point, Box
259 >::apply(comparable, 6.0);
260
261 // If this is the case:
262 BOOST_CHECK(c_dist5 < c_result && c_result < c_dist6);
263
264 // This should also be the case
265 return_type dist5 = services::result_from_distance
266 <
267 strategy_type, Point, Box
268 >::apply(strategy, 5.0);
269 return_type dist6 = services::result_from_distance
270 <
271 strategy_type, Point, Box
272 >::apply(strategy, 6.0);
273 BOOST_CHECK(dist5 < result && result < dist6);
274 }
275
276 template
277 <
278 typename CoordinateType,
279 typename CalculationType,
280 typename AssignType
281 >
test_big_2d_with(AssignType const & x1,AssignType const & y1,AssignType const & x2,AssignType const & y2,AssignType const & zero)282 inline void test_big_2d_with(AssignType const& x1, AssignType const& y1,
283 AssignType const& x2, AssignType const& y2,
284 AssignType const& zero)
285 {
286 typedef bg::model::point<CoordinateType, 2, bg::cs::cartesian> point_type;
287 typedef bg::model::box<point_type> box_type;
288 typedef bg::strategy::distance::pythagoras_point_box
289 <
290 CalculationType
291 > pythagoras_pb_type;
292
293 pythagoras_pb_type pythagoras_pb;
294 typedef typename bg::strategy::distance::services::return_type
295 <
296 pythagoras_pb_type, point_type, box_type
297 >::type return_type;
298
299
300 point_type p;
301 box_type b;
302 bg::assign_values(b, zero, zero, x1, y1);
303 bg::assign_values(p, x2, y2);
304 return_type d = pythagoras_pb.apply(p, b);
305
306 BOOST_CHECK_CLOSE(d, return_type(1076554.5485833955678294387789057), 0.001);
307 }
308
309 template <typename CoordinateType, typename CalculationType>
test_big_2d()310 inline void test_big_2d()
311 {
312 test_big_2d_with<CoordinateType, CalculationType>
313 (123456.78900001, 234567.89100001,
314 987654.32100001, 876543.21900001,
315 0.0);
316 }
317
318 template <typename CoordinateType, typename CalculationType>
test_big_2d_string()319 inline void test_big_2d_string()
320 {
321 test_big_2d_with<CoordinateType, CalculationType>
322 ("123456.78900001", "234567.89100001",
323 "987654.32100001", "876543.21900001",
324 "0.0000000000000");
325 }
326
327 template <typename CoordinateType>
test_integer(bool check_types)328 inline void test_integer(bool check_types)
329 {
330 typedef bg::model::point<CoordinateType, 2, bg::cs::cartesian> point_type;
331 typedef bg::model::box<point_type> box_type;
332
333 point_type p;
334 box_type b;
335 bg::assign_values(b, 0, 0, 12345678, 23456789);
336 bg::assign_values(p, 98765432, 87654321);
337
338 typedef bg::strategy::distance::pythagoras_point_box<> pythagoras_type;
339 typedef typename bg::strategy::distance::services::comparable_type
340 <
341 pythagoras_type
342 >::type comparable_type;
343
344 typedef typename bg::strategy::distance::services::return_type
345 <
346 pythagoras_type, point_type, box_type
347 >::type distance_type;
348 typedef typename bg::strategy::distance::services::return_type
349 <
350 comparable_type, point_type, box_type
351 >::type cdistance_type;
352
353 pythagoras_type pythagoras;
354 distance_type distance = pythagoras.apply(p, b);
355 BOOST_CHECK_CLOSE(distance, 107655455.02347542, 0.001);
356
357 comparable_type comparable;
358 cdistance_type cdistance = comparable.apply(p, b);
359 BOOST_CHECK_EQUAL(cdistance, 11589696996311540.0);
360
361 distance_type distance2 = sqrt(distance_type(cdistance));
362 BOOST_CHECK_CLOSE(distance, distance2, 0.001);
363
364 if (check_types)
365 {
366 BOOST_CHECK((boost::is_same<distance_type, double>::type::value));
367 BOOST_CHECK((boost::is_same<cdistance_type, boost::long_long_type>::type::value));
368 }
369 }
370
371 template <typename P1, typename P2>
test_all_3d()372 void test_all_3d()
373 {
374 test_null_distance_3d<P1, bg::model::box<P2> >();
375 test_axis_3d<P1, bg::model::box<P2> >();
376 test_arbitrary_3d<P1, bg::model::box<P2> >();
377
378 test_null_distance_3d<P2, bg::model::box<P1> >();
379 test_axis_3d<P2, bg::model::box<P1> >();
380 test_arbitrary_3d<P2, bg::model::box<P1> >();
381 }
382
383 template <typename P>
test_all_3d()384 void test_all_3d()
385 {
386 test_all_3d<P, int[3]>();
387 test_all_3d<P, float[3]>();
388 test_all_3d<P, double[3]>();
389 test_all_3d<P, test::test_point>();
390 test_all_3d<P, bg::model::point<int, 3, bg::cs::cartesian> >();
391 test_all_3d<P, bg::model::point<float, 3, bg::cs::cartesian> >();
392 test_all_3d<P, bg::model::point<double, 3, bg::cs::cartesian> >();
393 }
394
395 template <typename P, typename Strategy>
time_compare_s(int const n)396 void time_compare_s(int const n)
397 {
398 typedef bg::model::box<P> box_type;
399
400 boost::timer t;
401 P p;
402 box_type b;
403 bg::assign_values(b, 0, 0, 1, 1);
404 bg::assign_values(p, 2, 2);
405 Strategy strategy;
406 typename bg::strategy::distance::services::return_type
407 <
408 Strategy, P, box_type
409 >::type s = 0;
410 for (int i = 0; i < n; i++)
411 {
412 for (int j = 0; j < n; j++)
413 {
414 bg::set<0>(p, bg::get<0>(p) + 0.001);
415 s += strategy.apply(p, b);
416 }
417 }
418 std::cout << "s: " << s << " t: " << t.elapsed() << std::endl;
419 }
420
421 template <typename P>
time_compare(int const n)422 inline void time_compare(int const n)
423 {
424 time_compare_s<P, bg::strategy::distance::pythagoras_point_box<> >(n);
425 time_compare_s
426 <
427 P, bg::strategy::distance::comparable::pythagoras_point_box<>
428 >(n);
429 }
430
431
432
433
BOOST_AUTO_TEST_CASE(test_integer_all)434 BOOST_AUTO_TEST_CASE( test_integer_all )
435 {
436 test_integer<int>(true);
437 test_integer<boost::long_long_type>(true);
438 test_integer<double>(false);
439 }
440
441
BOOST_AUTO_TEST_CASE(test_3d_all)442 BOOST_AUTO_TEST_CASE( test_3d_all )
443 {
444 test_all_3d<int[3]>();
445 test_all_3d<float[3]>();
446 test_all_3d<double[3]>();
447
448 test_all_3d<test::test_point>();
449
450 test_all_3d<bg::model::point<int, 3, bg::cs::cartesian> >();
451 test_all_3d<bg::model::point<float, 3, bg::cs::cartesian> >();
452 test_all_3d<bg::model::point<double, 3, bg::cs::cartesian> >();
453 }
454
455
BOOST_AUTO_TEST_CASE(test_big_2d_all)456 BOOST_AUTO_TEST_CASE( test_big_2d_all )
457 {
458 test_big_2d<float, float>();
459 test_big_2d<double, double>();
460 test_big_2d<long double, long double>();
461 test_big_2d<float, long double>();
462 }
463
464
BOOST_AUTO_TEST_CASE(test_services_all)465 BOOST_AUTO_TEST_CASE( test_services_all )
466 {
467 test_services
468 <
469 bg::model::point<float, 3, bg::cs::cartesian>,
470 bg::model::box<double[3]>,
471 long double
472 >();
473 test_services<double[3], bg::model::box<test::test_point>, float>();
474
475 // reverse the point and box types
476 test_services
477 <
478 double[3],
479 bg::model::box<bg::model::point<float, 3, bg::cs::cartesian> >,
480 long double
481 >();
482 test_services<test::test_point, bg::model::box<double[3]>, float>();
483 }
484
485
BOOST_AUTO_TEST_CASE(test_time_compare)486 BOOST_AUTO_TEST_CASE( test_time_compare )
487 {
488 // TODO move this to another non-unit test
489 // time_compare<bg::model::point<double, 2, bg::cs::cartesian> >(10000);
490 }
491
492
493 #if defined(HAVE_TTMATH)
BOOST_AUTO_TEST_CASE(test_ttmath_all)494 BOOST_AUTO_TEST_CASE( test_ttmath_all )
495 {
496 typedef ttmath::Big<1,4> tt;
497 typedef bg::model::point<tt, 3, bg::cs::cartesian> tt_point;
498
499 //test_all_3d<tt[3]>();
500 test_all_3d<tt_point>();
501 test_all_3d<tt_point, tt_point>();
502 test_big_2d<tt, tt>();
503 test_big_2d_string<tt, tt>();
504 }
505 #endif
506