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 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
13
14 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
15 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
16
17 // Use, modification and distribution is subject to the Boost Software License,
18 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
19 // http://www.boost.org/LICENSE_1_0.txt)
20
21 #ifndef BOOST_GEOMETRY_TEST_STRATEGIES_TEST_PROJECTED_POINT_HPP
22 #define BOOST_GEOMETRY_TEST_STRATEGIES_TEST_PROJECTED_POINT_HPP
23
24 #include <geometry_test_common.hpp>
25
26 #include <boost/core/ignore_unused.hpp>
27
28 #include <boost/geometry/strategies/cartesian/distance_projected_point.hpp>
29 #include <boost/geometry/strategies/cartesian/distance_projected_point_ax.hpp>
30 #include <boost/geometry/strategies/concepts/distance_concept.hpp>
31
32 #include <boost/geometry/io/wkt/read.hpp>
33
34 #include <boost/geometry/geometries/point.hpp>
35 #include <boost/geometry/geometries/adapted/c_array.hpp>
36 #include <boost/geometry/geometries/adapted/boost_tuple.hpp>
37 #include <test_common/test_point.hpp>
38
39 #ifdef HAVE_TTMATH
40 # include <boost/geometry/extensions/contrib/ttmath_stub.hpp>
41 #endif
42
43 BOOST_GEOMETRY_REGISTER_C_ARRAY_CS(cs::cartesian)
BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(cs::cartesian)44 BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(cs::cartesian)
45
46
47 template <typename P, typename PS, typename CalculationType>
48 void test_services()
49 {
50 PS p1, p2;
51 bg::assign_values(p1, 0, 0);
52 bg::assign_values(p2, 0, 4);
53
54 P p;
55 bg::assign_values(p, 2, 0);
56
57 CalculationType const sqr_expected = 4;
58 CalculationType const expected = 2;
59
60
61 namespace bgsd = bg::strategy::distance;
62 namespace services = bg::strategy::distance::services;
63
64 {
65 // compile-check if there is a strategy for this type
66 typedef typename services::default_strategy
67 <
68 bg::point_tag, bg::segment_tag, P, PS
69 >::type projected_point_strategy_type;
70
71 typedef typename services::default_strategy
72 <
73 bg::segment_tag, bg::point_tag, PS, P
74 >::type reversed_tags_projected_point_strategy_type;
75
76 boost::ignore_unused<projected_point_strategy_type,
77 reversed_tags_projected_point_strategy_type>();
78 }
79
80 // 1: normal, calculate distance:
81
82 typedef bgsd::projected_point<CalculationType> strategy_type;
83
84 BOOST_CONCEPT_ASSERT( (bg::concepts::PointSegmentDistanceStrategy<strategy_type, P, PS>) );
85
86 typedef typename services::return_type<strategy_type, P, PS>::type return_type;
87
88 strategy_type strategy;
89 return_type result = strategy.apply(p, p1, p2);
90 BOOST_CHECK_CLOSE(result, return_type(expected), 0.001);
91
92 // 2: the strategy should return the same result if we reverse parameters
93 result = strategy.apply(p, p2, p1);
94 BOOST_CHECK_CLOSE(result, return_type(expected), 0.001);
95
96
97 // 3: "comparable" to construct a "comparable strategy" for P1/P2
98 // a "comparable strategy" is a strategy which does not calculate the exact distance, but
99 // which returns results which can be mutually compared (e.g. avoid sqrt)
100
101 // 3a: "comparable_type"
102 typedef typename services::comparable_type<strategy_type>::type comparable_type;
103
104 // 3b: "get_comparable"
105 comparable_type comparable = bgsd::services::get_comparable<strategy_type>::apply(strategy);
106
107 return_type c_result = comparable.apply(p, p1, p2);
108 BOOST_CHECK_CLOSE(c_result, return_type(sqr_expected), 0.001);
109 }
110
111 template <typename T1, typename T2>
test_check_close(T1 const & v1,T2 const & v2,double f)112 void test_check_close(T1 const& v1, T2 const& v2, double f)
113 {
114 BOOST_CHECK_CLOSE(v1, v2, f);
115 }
116
117 template <typename T1, typename T2>
test_check_close(bg::strategy::distance::detail::projected_point_ax_result<T1> const & v1,bg::strategy::distance::detail::projected_point_ax_result<T2> const & v2,double f)118 void test_check_close(bg::strategy::distance::detail::projected_point_ax_result<T1> const& v1,
119 bg::strategy::distance::detail::projected_point_ax_result<T2> const& v2,
120 double f)
121 {
122 BOOST_CHECK_CLOSE(v1.atd, v2.atd, f);
123 BOOST_CHECK_CLOSE(v1.xtd, v2.xtd, f);
124 }
125
126 template <typename P1, typename P2, typename T, typename Strategy, typename ComparableStrategy>
test_2d(std::string const & wkt_p,std::string const & wkt_sp1,std::string const & wkt_sp2,T expected_distance,T expected_comparable_distance,Strategy strategy,ComparableStrategy comparable_strategy)127 void test_2d(std::string const& wkt_p,
128 std::string const& wkt_sp1,
129 std::string const& wkt_sp2,
130 T expected_distance,
131 T expected_comparable_distance,
132 Strategy strategy,
133 ComparableStrategy comparable_strategy)
134 {
135 P1 p;
136 P2 sp1, sp2;
137 bg::read_wkt(wkt_p, p);
138 bg::read_wkt(wkt_sp1, sp1);
139 bg::read_wkt(wkt_sp2, sp2);
140
141 BOOST_CONCEPT_ASSERT
142 (
143 (bg::concepts::PointSegmentDistanceStrategy<Strategy, P1, P2>)
144 );
145 BOOST_CONCEPT_ASSERT
146 (
147 (bg::concepts::PointSegmentDistanceStrategy<ComparableStrategy, P1, P2>)
148 );
149
150 {
151 typedef typename bg::strategy::distance::services::return_type<Strategy, P1, P2>::type return_type;
152 return_type d = strategy.apply(p, sp1, sp2);
153 test_check_close(d, expected_distance, 0.001);
154 }
155
156 // Test combination with the comparable strategy
157 {
158 typedef typename bg::strategy::distance::services::return_type<ComparableStrategy, P1, P2>::type return_type;
159 return_type d = comparable_strategy.apply(p, sp1, sp2);
160 test_check_close(d, expected_comparable_distance, 0.01);
161 }
162
163 }
164
165 template <typename P1, typename P2, typename T>
test_2d(std::string const & wkt_p,std::string const & wkt_sp1,std::string const & wkt_sp2,T expected_distance)166 void test_2d(std::string const& wkt_p,
167 std::string const& wkt_sp1,
168 std::string const& wkt_sp2,
169 T expected_distance)
170 {
171 typedef bg::strategy::distance::projected_point<> strategy_type;
172 typedef bg::strategy::distance::projected_point
173 <
174 void,
175 bg::strategy::distance::comparable::pythagoras<>
176 > comparable_strategy_type;
177
178 strategy_type strategy;
179 comparable_strategy_type comparable_strategy;
180
181 T expected_squared_distance = expected_distance * expected_distance;
182 test_2d<P1, P2>(wkt_p, wkt_sp1, wkt_sp2, expected_distance, expected_squared_distance, strategy, comparable_strategy);
183 }
184
185 #endif // BOOST_GEOMETRY_TEST_STRATEGIES_TEST_PROJECTED_POINT_HPP
186