1 // Boost.Polygon library polygon_interval_test.cpp file
2
3 // Copyright Andrii Sydorchuk 2012.
4 // Distributed under the Boost Software License, Version 1.0.
5 // (See accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt)
7
8 // See http://www.boost.org for updates, documentation, and revision history.
9
10 #define BOOST_TEST_MODULE POLYGON_INTERVAL_TEST
11 #include <boost/mpl/list.hpp>
12 #include <boost/test/test_case_template.hpp>
13
14 #include "boost/polygon/interval_concept.hpp"
15 #include "boost/polygon/interval_data.hpp"
16 #include "boost/polygon/interval_traits.hpp"
17 using namespace boost::polygon;
18
19 typedef boost::mpl::list<int> test_types;
20
BOOST_AUTO_TEST_CASE_TEMPLATE(interval_data_test,T,test_types)21 BOOST_AUTO_TEST_CASE_TEMPLATE(interval_data_test, T, test_types) {
22 typedef interval_data<T> interval_type;
23 interval_type interval1(1, 2);
24 interval_type interval2;
25 interval2 = interval1;
26
27 BOOST_CHECK_EQUAL(interval1.low(), 1);
28 BOOST_CHECK_EQUAL(interval1.high(), 2);
29 BOOST_CHECK_EQUAL(interval1.get(LOW), 1);
30 BOOST_CHECK_EQUAL(interval1.get(HIGH), 2);
31 BOOST_CHECK(interval1 == interval2);
32 BOOST_CHECK(!(interval1 != interval2));
33 BOOST_CHECK(!(interval1 < interval2));
34 BOOST_CHECK(!(interval1 > interval2));
35 BOOST_CHECK(interval1 <= interval2);
36 BOOST_CHECK(interval1 >= interval2);
37
38 interval1.low(2);
39 interval1.high(1);
40 BOOST_CHECK_EQUAL(interval1.low(), 2);
41 BOOST_CHECK_EQUAL(interval1.high(), 1);
42 BOOST_CHECK(!(interval1 == interval2));
43 BOOST_CHECK(interval1 != interval2);
44
45 interval2.set(LOW, 2);
46 interval2.set(HIGH, 1);
47 BOOST_CHECK(interval1 == interval2);
48 }
49
BOOST_AUTO_TEST_CASE_TEMPLATE(interval_traits_test,T,test_types)50 BOOST_AUTO_TEST_CASE_TEMPLATE(interval_traits_test, T, test_types) {
51 typedef interval_data<T> interval_type;
52
53 interval_type interval = interval_mutable_traits<interval_type>::construct(1, 2);
54 BOOST_CHECK_EQUAL(interval_traits<interval_type>::get(interval, LOW), 1);
55 BOOST_CHECK_EQUAL(interval_traits<interval_type>::get(interval, HIGH), 2);
56
57 interval_mutable_traits<interval_type>::set(interval, LOW, 3);
58 interval_mutable_traits<interval_type>::set(interval, HIGH, 4);
59 BOOST_CHECK_EQUAL(interval_traits<interval_type>::get(interval, LOW), 3);
60 BOOST_CHECK_EQUAL(interval_traits<interval_type>::get(interval, HIGH), 4);
61 }
62
63 template <typename T>
64 struct Interval {
65 T left;
66 T right;
67 };
68
69 namespace boost {
70 namespace polygon {
71 template <typename T>
72 struct geometry_concept< Interval<T> > {
73 typedef interval_concept type;
74 };
75
76 template <typename T>
77 struct interval_traits< Interval<T> > {
78 typedef T coordinate_type;
79
getboost::polygon::interval_traits80 static coordinate_type get(const Interval<T>& interval, direction_1d dir) {
81 return (dir == LOW) ? interval.left : interval.right;
82 }
83 };
84
85 template <typename T>
86 struct interval_mutable_traits< Interval<T> > {
87 typedef T coordinate_type;
88
setboost::polygon::interval_mutable_traits89 static void set(Interval<T>& interval, direction_1d dir, T value) {
90 (dir == LOW) ? interval.left = value : interval.right = value;
91 }
92
constructboost::polygon::interval_mutable_traits93 static Interval<T> construct(coordinate_type left, coordinate_type right) {
94 Interval<T> interval;
95 interval.left = left;
96 interval.right = right;
97 return interval;
98 }
99 };
100 } // polygon
101 } // boost
102
BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test1,T,test_types)103 BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test1, T, test_types) {
104 typedef Interval<T> interval_type;
105
106 interval_type interval1 = construct<interval_type>(2, 1);
107 BOOST_CHECK_EQUAL(interval1.left, 1);
108 BOOST_CHECK_EQUAL(interval1.right, 2);
109
110 set(interval1, LOW, 3);
111 set(interval1, HIGH, 4);
112 BOOST_CHECK_EQUAL(get(interval1, LOW), 3);
113 BOOST_CHECK_EQUAL(get(interval1, HIGH), 4);
114
115 interval_type interval2 = copy_construct<interval_type>(interval1);
116 BOOST_CHECK(equivalence(interval1, interval2));
117
118 low(interval2, 1);
119 high(interval2, 2);
120 BOOST_CHECK_EQUAL(low(interval2), 1);
121 BOOST_CHECK_EQUAL(high(interval2), 2);
122
123 assign(interval1, interval2);
124 BOOST_CHECK(equivalence(interval1, interval2));
125 }
126
BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test2,T,test_types)127 BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test2, T, test_types) {
128 typedef Interval<T> interval_type;
129
130 interval_type interval1 = construct<interval_type>(1, 3);
131 BOOST_CHECK_EQUAL(center(interval1), 2);
132 BOOST_CHECK_EQUAL(delta(interval1), 2);
133
134 flip(interval1, -1);
135 BOOST_CHECK_EQUAL(low(interval1), -5);
136 BOOST_CHECK_EQUAL(high(interval1), -3);
137
138 scale_up(interval1, 2);
139 BOOST_CHECK_EQUAL(low(interval1), -10);
140 BOOST_CHECK_EQUAL(high(interval1), -6);
141
142 scale_down(interval1, 2);
143 BOOST_CHECK_EQUAL(low(interval1), -5);
144 BOOST_CHECK_EQUAL(high(interval1), -3);
145
146 move(interval1, 5);
147 BOOST_CHECK_EQUAL(low(interval1), 0);
148 BOOST_CHECK_EQUAL(high(interval1), 2);
149
150 convolve(interval1, 1);
151 BOOST_CHECK_EQUAL(low(interval1), 1);
152 BOOST_CHECK_EQUAL(high(interval1), 3);
153
154 deconvolve(interval1, 2);
155 BOOST_CHECK_EQUAL(low(interval1), -1);
156 BOOST_CHECK_EQUAL(high(interval1), 1);
157
158 interval_type interval2 = construct<interval_type>(-1, 2);
159 convolve(interval1, interval2);
160 BOOST_CHECK_EQUAL(low(interval1), -2);
161 BOOST_CHECK_EQUAL(high(interval1), 3);
162
163 deconvolve(interval1, interval2);
164 BOOST_CHECK_EQUAL(low(interval1), -1);
165 BOOST_CHECK_EQUAL(high(interval1), 1);
166
167 reflected_convolve(interval1, interval2);
168 BOOST_CHECK_EQUAL(low(interval1), -3);
169 BOOST_CHECK_EQUAL(high(interval1), 2);
170
171 reflected_deconvolve(interval1, interval2);
172 BOOST_CHECK_EQUAL(low(interval1), -1);
173 BOOST_CHECK_EQUAL(high(interval1), 1);
174 }
175
BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test3,T,test_types)176 BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test3, T, test_types) {
177 typedef Interval<T> interval_type;
178
179 interval_type interval1 = construct<interval_type>(1, 3);
180 BOOST_CHECK_EQUAL(euclidean_distance(interval1, -2), 3);
181 BOOST_CHECK_EQUAL(euclidean_distance(interval1, 2), 0);
182 BOOST_CHECK_EQUAL(euclidean_distance(interval1, 4), 1);
183
184 interval_type interval2 = construct<interval_type>(-1, 0);
185 BOOST_CHECK_EQUAL(euclidean_distance(interval1, interval2), 1);
186 BOOST_CHECK(!intersects(interval1, interval2));
187 BOOST_CHECK(!boundaries_intersect(interval1, interval2));
188 BOOST_CHECK(!intersect(interval2, interval1));
189 BOOST_CHECK_EQUAL(low(interval2), -1);
190 BOOST_CHECK_EQUAL(high(interval2), 0);
191
192 interval_type interval3 = construct<interval_type>(-1, 6);
193 BOOST_CHECK_EQUAL(euclidean_distance(interval1, interval3), 0);
194 BOOST_CHECK(intersects(interval1, interval3));
195 BOOST_CHECK(!boundaries_intersect(interval1, interval3));
196 BOOST_CHECK(intersect(interval3, interval1));
197 BOOST_CHECK_EQUAL(low(interval3), 1);
198 BOOST_CHECK_EQUAL(high(interval3), 3);
199
200 interval_type interval4 = construct<interval_type>(5, 6);
201 BOOST_CHECK_EQUAL(euclidean_distance(interval1, interval4), 2);
202 BOOST_CHECK(!intersects(interval1, interval4));
203 BOOST_CHECK(!boundaries_intersect(interval1, interval4));
204 BOOST_CHECK(!intersect(interval4, interval1));
205 BOOST_CHECK_EQUAL(low(interval4), 5);
206 BOOST_CHECK_EQUAL(high(interval4), 6);
207
208 interval_type interval5 = construct<interval_type>(3, 5);
209 BOOST_CHECK_EQUAL(euclidean_distance(interval1, interval5), 0);
210 BOOST_CHECK(!intersects(interval1, interval5, false));
211 BOOST_CHECK(boundaries_intersect(interval1, interval5));
212 BOOST_CHECK(intersect(interval5, interval1));
213 BOOST_CHECK_EQUAL(low(interval5), 3);
214 BOOST_CHECK_EQUAL(high(interval5), 3);
215 }
216
BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test4,T,test_types)217 BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test4, T, test_types) {
218 typedef Interval<T> interval_type;
219
220 interval_type interval1 = construct<interval_type>(1, 3);
221 interval_type interval2 = construct<interval_type>(3, 5);
222 BOOST_CHECK(!abuts(interval1, interval2, LOW));
223 BOOST_CHECK(abuts(interval1, interval2, HIGH));
224 BOOST_CHECK(abuts(interval1, interval2));
225
226 bloat(interval1, 1);
227 BOOST_CHECK_EQUAL(low(interval1), 0);
228 BOOST_CHECK_EQUAL(high(interval1), 4);
229 BOOST_CHECK(!abuts(interval1, interval2));
230
231 bloat(interval1, LOW, 1);
232 BOOST_CHECK_EQUAL(low(interval1), -1);
233 BOOST_CHECK_EQUAL(high(interval1), 4);
234
235 shrink(interval1, LOW, 1);
236 BOOST_CHECK_EQUAL(low(interval1), 0);
237 BOOST_CHECK_EQUAL(high(interval1), 4);
238
239 shrink(interval1, 1);
240 BOOST_CHECK_EQUAL(low(interval1), 1);
241 BOOST_CHECK_EQUAL(high(interval1), 3);
242
243 BOOST_CHECK(encompass(interval1, 4));
244 BOOST_CHECK_EQUAL(low(interval1), 1);
245 BOOST_CHECK_EQUAL(high(interval1), 4);
246
247 BOOST_CHECK(encompass(interval1, interval2));
248 BOOST_CHECK_EQUAL(low(interval1), 1);
249 BOOST_CHECK_EQUAL(high(interval1), 5);
250
251 interval1 = get_half(interval1, LOW);
252 BOOST_CHECK_EQUAL(low(interval1), 1);
253 BOOST_CHECK_EQUAL(high(interval1), 3);
254
255 BOOST_CHECK(join_with(interval1, interval2));
256 BOOST_CHECK_EQUAL(low(interval1), 1);
257 BOOST_CHECK_EQUAL(high(interval1), 5);
258 }
259