]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Geometry (aka GGL, Generic Geometry Library) |
2 | // Unit Test | |
3 | ||
4 | // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. | |
5 | ||
6 | // Use, modification and distribution is subject to the Boost Software License, | |
7 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
8 | // http://www.boost.org/LICENSE_1_0.txt) | |
9 | ||
10 | #include <geometry_test_common.hpp> | |
11 | ||
12 | #include <algorithm> | |
13 | ||
14 | #include <boost/geometry/algorithms/make.hpp> | |
15 | #include <boost/geometry/io/dsv/write.hpp> | |
16 | ||
17 | #include <boost/geometry/policies/compare.hpp> | |
18 | ||
19 | #include <boost/geometry/strategies/strategies.hpp> | |
20 | ||
21 | #include <boost/geometry/geometries/point.hpp> | |
22 | #include <boost/geometry/geometries/adapted/c_array.hpp> | |
23 | #include <boost/geometry/geometries/adapted/boost_tuple.hpp> | |
24 | ||
25 | #include <test_common/test_point.hpp> | |
26 | ||
27 | BOOST_GEOMETRY_REGISTER_C_ARRAY_CS(cs::cartesian) | |
28 | BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(cs::cartesian) | |
29 | ||
30 | ||
31 | template <typename Container> | |
32 | inline std::string coordinates(Container const& points) | |
33 | { | |
34 | std::ostringstream out; | |
35 | for (typename boost::range_const_iterator<Container>::type it = boost::begin(points); | |
36 | it != boost::end(points); | |
37 | ++it) | |
38 | { | |
39 | out << bg::dsv(*it); | |
40 | } | |
41 | return out.str(); | |
42 | } | |
43 | ||
44 | template <typename P> | |
45 | void test_2d_compare() | |
46 | { | |
47 | P p1 = bg::make<P>(3, 1); | |
48 | P p2 = bg::make<P>(3, 1); | |
49 | P p3 = bg::make<P>(1, 3); | |
50 | P p4 = bg::make<P>(5, 2); | |
51 | P p5 = bg::make<P>(3, 2); | |
52 | ||
53 | // Test in all dimensions | |
54 | { | |
55 | bg::equal_to<P> et; | |
56 | bg::less<P> lt; | |
57 | bg::greater<P> gt; | |
58 | ||
59 | BOOST_CHECK_EQUAL(et(p1, p2), true); | |
60 | BOOST_CHECK_EQUAL(et(p1, p3), false); | |
61 | BOOST_CHECK_EQUAL(et(p1, p4), false); | |
62 | BOOST_CHECK_EQUAL(et(p1, p5), false); | |
63 | BOOST_CHECK_EQUAL(et(p3, p4), false); | |
64 | ||
65 | BOOST_CHECK_EQUAL(lt(p1, p2), false); | |
66 | BOOST_CHECK_EQUAL(lt(p1, p3), false); | |
67 | BOOST_CHECK_EQUAL(lt(p1, p4), true); | |
68 | BOOST_CHECK_EQUAL(lt(p1, p5), true); | |
69 | BOOST_CHECK_EQUAL(lt(p3, p4), true); | |
70 | ||
71 | BOOST_CHECK_EQUAL(gt(p1, p2), false); | |
72 | BOOST_CHECK_EQUAL(gt(p1, p3), true); | |
73 | BOOST_CHECK_EQUAL(gt(p1, p4), false); | |
74 | BOOST_CHECK_EQUAL(gt(p1, p5), false); | |
75 | BOOST_CHECK_EQUAL(gt(p3, p4), false); | |
76 | } | |
77 | ||
78 | ||
79 | // Test in dimension 0, X | |
80 | { | |
81 | bg::equal_to<P, 0> et; | |
82 | bg::less<P, 0> lt; | |
83 | bg::greater<P, 0> gt; | |
84 | ||
85 | BOOST_CHECK_EQUAL(et(p1, p2), true); | |
86 | BOOST_CHECK_EQUAL(et(p1, p3), false); | |
87 | BOOST_CHECK_EQUAL(et(p1, p4), false); | |
88 | BOOST_CHECK_EQUAL(et(p1, p5), true); | |
89 | BOOST_CHECK_EQUAL(et(p3, p4), false); | |
90 | ||
91 | BOOST_CHECK_EQUAL(lt(p1, p2), false); | |
92 | BOOST_CHECK_EQUAL(lt(p1, p3), false); | |
93 | BOOST_CHECK_EQUAL(lt(p1, p4), true); | |
94 | BOOST_CHECK_EQUAL(lt(p1, p5), false); | |
95 | BOOST_CHECK_EQUAL(lt(p3, p4), true); | |
96 | ||
97 | BOOST_CHECK_EQUAL(gt(p1, p2), false); | |
98 | BOOST_CHECK_EQUAL(gt(p1, p3), true); | |
99 | BOOST_CHECK_EQUAL(gt(p1, p4), false); | |
100 | BOOST_CHECK_EQUAL(gt(p1, p5), false); | |
101 | BOOST_CHECK_EQUAL(gt(p3, p4), false); | |
102 | } | |
103 | ||
104 | // Test in dimension 1, Y | |
105 | { | |
106 | bg::equal_to<P, 1> et; | |
107 | bg::less<P, 1> lt; | |
108 | bg::greater<P, 1> gt; | |
109 | ||
110 | BOOST_CHECK_EQUAL(et(p1, p2), true); | |
111 | BOOST_CHECK_EQUAL(et(p1, p3), false); | |
112 | BOOST_CHECK_EQUAL(et(p1, p4), false); | |
113 | BOOST_CHECK_EQUAL(et(p1, p5), false); | |
114 | BOOST_CHECK_EQUAL(et(p3, p4), false); | |
115 | ||
116 | BOOST_CHECK_EQUAL(lt(p1, p2), false); | |
117 | BOOST_CHECK_EQUAL(lt(p1, p3), true); | |
118 | BOOST_CHECK_EQUAL(lt(p1, p4), true); | |
119 | BOOST_CHECK_EQUAL(lt(p1, p5), true); | |
120 | BOOST_CHECK_EQUAL(lt(p3, p4), false); | |
121 | ||
122 | BOOST_CHECK_EQUAL(gt(p1, p2), false); | |
123 | BOOST_CHECK_EQUAL(gt(p1, p3), false); | |
124 | BOOST_CHECK_EQUAL(gt(p1, p4), false); | |
125 | BOOST_CHECK_EQUAL(gt(p1, p5), false); | |
126 | BOOST_CHECK_EQUAL(gt(p3, p4), true); | |
127 | } | |
128 | } | |
129 | ||
130 | ||
131 | template <typename P> | |
132 | void test_2d_sort() | |
133 | { | |
134 | std::vector<P> v; | |
135 | v.push_back(bg::make<P>(3, 1)); | |
136 | v.push_back(bg::make<P>(2, 3)); | |
137 | v.push_back(bg::make<P>(2, 2)); | |
138 | v.push_back(bg::make<P>(1, 3)); | |
139 | ||
140 | // Sort on coordinates in order x,y,z | |
141 | std::sort(v.begin(), v.end(), bg::less<P>()); | |
142 | std::string s = coordinates(v); | |
143 | BOOST_CHECK_EQUAL(s, "(1, 3)(2, 2)(2, 3)(3, 1)"); | |
144 | ||
145 | // Reverse sort | |
146 | std::sort(v.begin(), v.end(), bg::greater<P>()); | |
147 | s = coordinates(v); | |
148 | BOOST_CHECK_EQUAL(s, "(3, 1)(2, 3)(2, 2)(1, 3)"); | |
149 | ||
150 | // Sort backwards on coordinates in order x,y,z | |
151 | //std::sort(v.begin(), v.end(), bg::greater<P>()); | |
152 | //std::string s = coordinates(v); | |
153 | //BOOST_CHECK_EQUAL(s, "(1, 3)(2, 2)(2, 3)(3, 1)"); | |
154 | ||
155 | // Refill to remove duplicate coordinates | |
156 | v.clear(); | |
157 | v.push_back(bg::make<P>(4, 1)); | |
158 | v.push_back(bg::make<P>(3, 2)); | |
159 | v.push_back(bg::make<P>(2, 3)); | |
160 | v.push_back(bg::make<P>(1, 4)); | |
161 | ||
162 | // Sort ascending on only x-coordinate | |
163 | std::sort(v.begin(), v.end(), bg::less<P, 0>()); | |
164 | s = coordinates(v); | |
165 | BOOST_CHECK_EQUAL(s, "(1, 4)(2, 3)(3, 2)(4, 1)"); | |
166 | ||
167 | // Sort ascending on only y-coordinate | |
168 | std::sort(v.begin(), v.end(), bg::less<P, 1>()); | |
169 | s = coordinates(v); | |
170 | BOOST_CHECK_EQUAL(s, "(4, 1)(3, 2)(2, 3)(1, 4)"); | |
171 | ||
172 | // Sort descending on only x-coordinate | |
173 | std::sort(v.begin(), v.end(), bg::greater<P, 0>()); | |
174 | s = coordinates(v); | |
175 | //BOOST_CHECK_EQUAL(s, "(4, 1)(3, 2)(2, 3)(1, 4)"); | |
176 | ||
177 | // Sort descending on only y-coordinate | |
178 | std::sort(v.begin(), v.end(), bg::greater<P, 1>()); | |
179 | s = coordinates(v); | |
180 | BOOST_CHECK_EQUAL(s, "(1, 4)(2, 3)(3, 2)(4, 1)"); | |
181 | ||
182 | // Make non-unique vector | |
183 | v.push_back(bg::make<P>(4, 1)); | |
184 | v.push_back(bg::make<P>(3, 2)); | |
185 | v.push_back(bg::make<P>(2, 3)); | |
186 | v.push_back(bg::make<P>(1, 4)); | |
187 | v.push_back(bg::make<P>(1, 5)); | |
188 | std::sort(v.begin(), v.end(), bg::less<P>()); | |
189 | s = coordinates(v); | |
190 | BOOST_CHECK_EQUAL(s, "(1, 4)(1, 4)(1, 5)(2, 3)(2, 3)(3, 2)(3, 2)(4, 1)(4, 1)"); | |
191 | ||
192 | ||
193 | std::vector<P> v2; | |
194 | std::unique_copy(v.begin(), v.end(), std::back_inserter(v2), bg::equal_to<P>()); | |
195 | s = coordinates(v2); | |
196 | BOOST_CHECK_EQUAL(s, "(1, 4)(1, 5)(2, 3)(3, 2)(4, 1)"); | |
197 | } | |
198 | ||
199 | ||
200 | template <typename P> | |
201 | void test_spherical() | |
202 | { | |
203 | typedef typename bg::coordinate_type<P>::type ct; | |
204 | ||
205 | std::vector<P> v; | |
206 | v.push_back(bg::make<P>( 179.73, 71.56)); // east | |
207 | v.push_back(bg::make<P>( 177.47, 71.23)); // less east | |
208 | v.push_back(bg::make<P>(-178.78, 70.78)); // further east, = west, this is the most right point | |
209 | ||
210 | // Sort on coordinates in order x,y,z | |
211 | std::sort(v.begin(), v.end(), bg::less<P>()); | |
212 | std::string s = coordinates(v); | |
213 | BOOST_CHECK_EQUAL(s, "(177.47, 71.23)(179.73, 71.56)(-178.78, 70.78)"); | |
214 | ||
215 | // Sort ascending on only x-coordinate | |
216 | std::sort(v.begin(), v.end(), bg::less<P, 0>()); | |
217 | s = coordinates(v); | |
218 | BOOST_CHECK_EQUAL(s, "(177.47, 71.23)(179.73, 71.56)(-178.78, 70.78)"); | |
219 | ||
220 | // Sort ascending on only x-coordinate, but override with std-comparison, | |
221 | // (so this is the normal sorting behaviour that would have been used | |
222 | // if it would not have been spherical) | |
223 | std::sort(v.begin(), v.end(), bg::less<P, 0, std::less<ct> >()); | |
224 | s = coordinates(v); | |
225 | BOOST_CHECK_EQUAL(s, "(-178.78, 70.78)(177.47, 71.23)(179.73, 71.56)"); | |
226 | } | |
227 | ||
228 | ||
229 | int test_main(int, char* []) | |
230 | { | |
231 | test_2d_compare<bg::model::point<int, 2, bg::cs::cartesian> >(); | |
232 | test_2d_compare<bg::model::point<double, 2, bg::cs::cartesian> >(); | |
233 | ||
234 | test_2d_sort<bg::model::point<int, 2, bg::cs::cartesian> >(); | |
235 | test_2d_sort<bg::model::point<float, 2, bg::cs::cartesian> >(); | |
236 | test_2d_sort<boost::tuple<double, double> >(); | |
237 | test_2d_sort<bg::model::point<double, 2, bg::cs::cartesian> >(); | |
238 | ||
239 | test_spherical<bg::model::point<double, 2, bg::cs::spherical<bg::degree> > >(); | |
240 | ||
241 | return 0; | |
242 | } |