1 | /* |
2 | * Box_unit_tests.hpp |
3 | * |
4 | * Created on: May 8, 2015 |
5 | * Author: i-bird |
6 | */ |
7 | |
8 | #ifndef BOX_UNIT_TESTS_HPP_ |
9 | #define BOX_UNIT_TESTS_HPP_ |
10 | |
11 | BOOST_AUTO_TEST_SUITE( box_test ) |
12 | |
13 | BOOST_AUTO_TEST_CASE( box_use) |
14 | { |
15 | std::cout << "Box unit test start" << "\n" ; |
16 | |
17 | //! [expand the box with some spacing] |
18 | |
19 | float spacing[2] = {0.1,0.1}; |
20 | |
21 | Box<2,float> sp({1.0,1.0},{2.0,3.0}); |
22 | sp.expand(spacing); |
23 | |
24 | BOOST_REQUIRE_CLOSE(sp.getLow(0),1.0,0.0001); |
25 | BOOST_REQUIRE_CLOSE(sp.getLow(1),1.0,0.0001); |
26 | |
27 | BOOST_REQUIRE_CLOSE(sp.getHigh(0),2.1,0.0001); |
28 | BOOST_REQUIRE_CLOSE(sp.getHigh(1),3.1,0.0001); |
29 | |
30 | //! [expand the box with some spacing] |
31 | |
32 | { |
33 | //! [create an enclosing box] |
34 | |
35 | Box<3,float> box1({0.1,0.2,0.3},{1.0,1.1,1.3}); |
36 | Box<3,float> box2({0.5,0.6,0.7},{2.0,2.1,2.2}); |
37 | |
38 | box1.enclose(box2); |
39 | |
40 | BOOST_REQUIRE_EQUAL(box1.getLow(0),0.1f); |
41 | BOOST_REQUIRE_EQUAL(box1.getLow(1),0.2f); |
42 | BOOST_REQUIRE_EQUAL(box1.getLow(2),0.3f); |
43 | |
44 | BOOST_REQUIRE_EQUAL(box1.getHigh(0),2.0f); |
45 | BOOST_REQUIRE_EQUAL(box1.getHigh(1),2.1f); |
46 | BOOST_REQUIRE_EQUAL(box1.getHigh(2),2.2f); |
47 | |
48 | //! [create an enclosing box] |
49 | } |
50 | |
51 | // Create the smallest boxes between several boxes or |
52 | // Create a box that is contained into more boxes centering them on p1 |
53 | |
54 | { |
55 | |
56 | //! [Create the smallest boxes between several boxes] |
57 | Box<3,float> box1({0.0,0.0,0.0},{1.0,1.1,1.3}); |
58 | Box<3,float> box2({0.5,2.0,0.5},{2.0,2.1,2.2}); |
59 | Box<3,float> box3({1.5,1.5,4.2},{5.0,5.1,5.2}); |
60 | |
61 | box1.contained(box2); |
62 | box1.contained(box3); |
63 | |
64 | BOOST_REQUIRE_CLOSE(box1.getHigh(0),1.0f,0.0001); |
65 | BOOST_REQUIRE_CLOSE(box1.getHigh(1),0.1f,0.0001); |
66 | BOOST_REQUIRE_CLOSE(box1.getHigh(2),1.0f,0.0001); |
67 | |
68 | //! [Create the smallest boxes between several boxes] |
69 | } |
70 | |
71 | { |
72 | //! [Enlarge the box] |
73 | |
74 | Box<3,float> box1({0.1,0.2,0.3},{1.0,1.1,1.3}); |
75 | Box<3,float> box2({-0.5,-0.6,-0.7},{0.5,0.6,0.7}); |
76 | |
77 | box1.enlarge(box2); |
78 | |
79 | BOOST_REQUIRE_CLOSE(box1.getLow(0),-0.4,0.0001); |
80 | BOOST_REQUIRE_CLOSE(box1.getLow(1),-0.4,0.0001); |
81 | BOOST_REQUIRE_CLOSE(box1.getLow(2),-0.4,0.0001); |
82 | |
83 | BOOST_REQUIRE_CLOSE(box1.getHigh(0),1.5,0.0001); |
84 | BOOST_REQUIRE_CLOSE(box1.getHigh(1),1.7,0.0001); |
85 | BOOST_REQUIRE_CLOSE(box1.getHigh(2),2.0,0.0001); |
86 | |
87 | //! [Enlarge the box] |
88 | } |
89 | |
90 | { |
91 | //! [Enlarge the box with fixed P1] |
92 | |
93 | Box<3,float> box1({0.1,0.2,0.3},{1.0,1.1,1.3}); |
94 | Box<3,float> box2({-0.5,-0.6,-0.7},{0.5,0.6,0.7}); |
95 | |
96 | box1.enlarge_fix_P1(box2); |
97 | |
98 | BOOST_REQUIRE_CLOSE(box1.getLow(0),0.1,0.0001); |
99 | BOOST_REQUIRE_CLOSE(box1.getLow(1),0.2,0.0001); |
100 | BOOST_REQUIRE_CLOSE(box1.getLow(2),0.3,0.0001); |
101 | |
102 | BOOST_REQUIRE_CLOSE(box1.getHigh(0),2.0,0.0001); |
103 | BOOST_REQUIRE_CLOSE(box1.getHigh(1),2.3,0.0001); |
104 | BOOST_REQUIRE_CLOSE(box1.getHigh(2),2.7,0.0001); |
105 | |
106 | //! [Enlarge the box with fixed P1] |
107 | } |
108 | |
109 | { |
110 | //! [Magnify the box] |
111 | |
112 | Box<3,float> box1({0.1,0.2,0.3},{1.0,1.1,1.3}); |
113 | |
114 | box1.magnify(1.001); |
115 | |
116 | BOOST_REQUIRE_CLOSE(box1.getLow(0),0.1001,0.001); |
117 | BOOST_REQUIRE_CLOSE(box1.getLow(1),0.2002,0.001); |
118 | BOOST_REQUIRE_CLOSE(box1.getLow(2),0.3003,0.001); |
119 | |
120 | BOOST_REQUIRE_CLOSE(box1.getHigh(0),1.001,0.00001); |
121 | BOOST_REQUIRE_CLOSE(box1.getHigh(1),1.1011,0.00001); |
122 | BOOST_REQUIRE_CLOSE(box1.getHigh(2),1.3013,0.00001); |
123 | |
124 | // Check that the dimensions of the box are magnified of 0.1% |
125 | BOOST_REQUIRE_CLOSE(box1.getHigh(0) - box1.getLow(0), 1.001 * 0.9 ,0.001); |
126 | BOOST_REQUIRE_CLOSE(box1.getHigh(1) - box1.getLow(1), 1.001 * 0.9, 0.001); |
127 | BOOST_REQUIRE_CLOSE(box1.getHigh(2) - box1.getLow(2), 1.001 * 1.0, 0.001); |
128 | |
129 | //! [Magnify the box] |
130 | } |
131 | |
132 | { |
133 | //! [Magnify the box with fixed P1] |
134 | |
135 | Box<3,float> box1({0.1,0.2,0.3},{1.0,1.1,1.3}); |
136 | |
137 | box1.magnify_fix_P1(1.001); |
138 | |
139 | BOOST_REQUIRE_CLOSE(box1.getLow(0),0.1,0.0001); |
140 | BOOST_REQUIRE_CLOSE(box1.getLow(1),0.2,0.0001); |
141 | BOOST_REQUIRE_CLOSE(box1.getLow(2),0.3,0.0001); |
142 | |
143 | BOOST_REQUIRE_CLOSE(box1.getHigh(0),1.0009,0.00001); |
144 | BOOST_REQUIRE_CLOSE(box1.getHigh(1),1.1009,0.00001); |
145 | BOOST_REQUIRE_CLOSE(box1.getHigh(2),1.301,0.00001); |
146 | |
147 | // Check that the dimensions of the box are magnified of 0.1% |
148 | BOOST_REQUIRE_CLOSE(box1.getHigh(0) - box1.getLow(0), 1.001 * 0.9 ,0.00001); |
149 | BOOST_REQUIRE_CLOSE(box1.getHigh(1) - box1.getLow(1), 1.001 * 0.9, 0.00001); |
150 | BOOST_REQUIRE_CLOSE(box1.getHigh(2) - box1.getLow(2), 1.001 * 1.0, 0.00001); |
151 | |
152 | //! [Magnify the box with fixed P1] |
153 | } |
154 | |
155 | { |
156 | //! [Translate a box] |
157 | |
158 | Box<3,float> box1({0.1,0.5,0.6},{1.0,1.2,1.4}); |
159 | Point<3,float> pnt({0.1,0.2,0.3}); |
160 | |
161 | box1 -= pnt; |
162 | |
163 | BOOST_REQUIRE_CLOSE(box1.getLow(0),0.0,0.0001); |
164 | BOOST_REQUIRE_CLOSE(box1.getLow(1),0.3,0.0001); |
165 | BOOST_REQUIRE_CLOSE(box1.getLow(2),0.3,0.0001); |
166 | |
167 | BOOST_REQUIRE_CLOSE(box1.getHigh(0),0.9,0.0001); |
168 | BOOST_REQUIRE_CLOSE(box1.getHigh(1),1.0,0.0001); |
169 | BOOST_REQUIRE_CLOSE(box1.getHigh(2),1.1,0.0001); |
170 | |
171 | //! [Translate a box] |
172 | |
173 | box1 -= box1.getP2(); |
174 | |
175 | BOOST_REQUIRE_CLOSE(box1.getLow(0),-0.9,0.0001); |
176 | BOOST_REQUIRE_CLOSE(box1.getLow(1),-0.7,0.0001); |
177 | BOOST_REQUIRE_CLOSE(box1.getLow(2),-0.8,0.0001); |
178 | |
179 | BOOST_REQUIRE_CLOSE(box1.getHigh(0),0.0,0.0001); |
180 | BOOST_REQUIRE_CLOSE(box1.getHigh(1),0.0,0.0001); |
181 | BOOST_REQUIRE_CLOSE(box1.getHigh(2),0.0,0.0001); |
182 | |
183 | box1 -= box1.getP1(); |
184 | |
185 | BOOST_REQUIRE_CLOSE(box1.getLow(0),0.0,0.0001); |
186 | BOOST_REQUIRE_CLOSE(box1.getLow(1),0.0,0.0001); |
187 | BOOST_REQUIRE_CLOSE(box1.getLow(2),0.0,0.0001); |
188 | |
189 | BOOST_REQUIRE_CLOSE(box1.getHigh(0),0.9,0.0001); |
190 | BOOST_REQUIRE_CLOSE(box1.getHigh(1),0.7,0.0001); |
191 | BOOST_REQUIRE_CLOSE(box1.getHigh(2),0.8,0.0001); |
192 | } |
193 | |
194 | { |
195 | Box<2,size_t> invalid1({5,7},{3,9}); |
196 | Box<2,size_t> invalid2({5,11},{9,9}); |
197 | Box<2,size_t> invalid3({12,11},{9,9}); |
198 | |
199 | Box<2,size_t> valid1({1,5},{6,9}); |
200 | Box<2,size_t> valid2({1,1},{1,1}); |
201 | |
202 | bool val = invalid1.isValid(); |
203 | BOOST_REQUIRE_EQUAL(val,false); |
204 | val = invalid2.isValid(); |
205 | BOOST_REQUIRE_EQUAL(invalid2.isValid(),false); |
206 | val = invalid3.isValid(); |
207 | BOOST_REQUIRE_EQUAL(invalid3.isValid(),false); |
208 | val = valid1.isValid(); |
209 | BOOST_REQUIRE_EQUAL(valid1.isValid(),true); |
210 | val = valid2.isValid(); |
211 | BOOST_REQUIRE_EQUAL(valid2.isValid(),true); |
212 | |
213 | } |
214 | |
215 | { |
216 | //! [Box operators] |
217 | |
218 | Box<2,float> box({0.5,0.6},{1.4,1.3}); |
219 | Point<2,float> p({3.0,4.0}); |
220 | Box<2,float> result; |
221 | |
222 | result = box * p; |
223 | |
224 | BOOST_REQUIRE_CLOSE(result.getHigh(0),4.2,0.0001); |
225 | BOOST_REQUIRE_CLOSE(result.getHigh(1),5.2,0.0001); |
226 | |
227 | BOOST_REQUIRE_CLOSE(result.getLow(0),1.5,0.0001); |
228 | BOOST_REQUIRE_CLOSE(result.getLow(1),2.4,0.0001); |
229 | |
230 | //! [Box operators] |
231 | } |
232 | |
233 | { |
234 | //! [Box is insideNP] |
235 | |
236 | Box<2,float> box({0.0,0.0},{1.0,1.0}); |
237 | Point<2,float> p1({0.0,0.0}); |
238 | Point<2,float> p2({0.5,0.5}); |
239 | Point<2,float> p3({1.0,0.5}); |
240 | |
241 | BOOST_REQUIRE_EQUAL(box.isInsideNP(p1),true); |
242 | BOOST_REQUIRE_EQUAL(box.isInsideNP(p2),true); |
243 | BOOST_REQUIRE_EQUAL(box.isInsideNP(p3),false); |
244 | |
245 | //! [Box is insideNP] |
246 | } |
247 | |
248 | { |
249 | //! [Box is inside] |
250 | |
251 | Box<2,float> box({0.0,0.0},{1.0,1.0}); |
252 | Point<2,float> p1({0.0,0.0}); |
253 | Point<2,float> p2({0.5,0.5}); |
254 | Point<2,float> p3({1.0,0.5}); |
255 | |
256 | BOOST_REQUIRE_EQUAL(box.isInside(p1),true); |
257 | BOOST_REQUIRE_EQUAL(box.isInside(p2),true); |
258 | BOOST_REQUIRE_EQUAL(box.isInside(p3),true); |
259 | |
260 | //! [Box is inside] |
261 | } |
262 | |
263 | { |
264 | //! [Box is insideNB] |
265 | |
266 | Box<2,float> box({0.0,0.0},{1.0,1.0}); |
267 | Point<2,float> p1({0.0,0.0}); |
268 | Point<2,float> p2({0.5,0.5}); |
269 | Point<2,float> p3({1.0,0.5}); |
270 | |
271 | BOOST_REQUIRE_EQUAL(box.isInsideNB(p1),false); |
272 | BOOST_REQUIRE_EQUAL(box.isInsideNB(p2),true); |
273 | BOOST_REQUIRE_EQUAL(box.isInsideNB(p3),false); |
274 | |
275 | //! [Box is insideNB] |
276 | } |
277 | |
278 | Box<3,float> b1({1.0,2.4,5.3},{6.0,7.9,9.9}); |
279 | Box<3,float> b2 = b1; |
280 | |
281 | bool ret = (b1 == b2); |
282 | |
283 | BOOST_REQUIRE_EQUAL(ret,true); |
284 | |
285 | b1.invalidate(); |
286 | |
287 | BOOST_REQUIRE_EQUAL(b1.isValid(),false); |
288 | |
289 | std::cout << "Box unit test stop" << "\n" ; |
290 | } |
291 | |
292 | BOOST_AUTO_TEST_CASE( box_min_distance_test ) |
293 | { |
294 | // 2D |
295 | |
296 | Box<2,float> b1({0.0,0.0},{1.0,1.0}); |
297 | |
298 | // Tounching boxes |
299 | Box<2,float> b2({-1.0,-1.0},{0.0,0.0}); |
300 | Box<2,float> b3({-1.0, 0.0},{0.0,1.0}); |
301 | Box<2,float> b4({-1.0, 1.0},{0.0,2.0}); |
302 | Box<2,float> b5({ 0.0,-1.0},{1.0,0.0}); |
303 | Box<2,float> b6({ 0.0, 0.0},{1.0,1.0}); |
304 | Box<2,float> b7({ 0.0, 1.0},{1.0,2.0}); |
305 | Box<2,float> b8({ 1.0,-1.0},{2.0,0.0}); |
306 | Box<2,float> b9({ 1.0, 0.0},{2.0,1.0}); |
307 | Box<2,float> b10({1.0, 1.0},{2.0,2.0}); |
308 | |
309 | BOOST_REQUIRE_EQUAL(b1.min_distance(b2),0.0); |
310 | BOOST_REQUIRE_EQUAL(b1.min_distance(b3),0.0); |
311 | BOOST_REQUIRE_EQUAL(b1.min_distance(b4),0.0); |
312 | BOOST_REQUIRE_EQUAL(b1.min_distance(b5),0.0); |
313 | BOOST_REQUIRE_EQUAL(b1.min_distance(b6),0.0); |
314 | BOOST_REQUIRE_EQUAL(b1.min_distance(b7),0.0); |
315 | BOOST_REQUIRE_EQUAL(b1.min_distance(b8),0.0); |
316 | BOOST_REQUIRE_EQUAL(b1.min_distance(b9),0.0); |
317 | BOOST_REQUIRE_EQUAL(b1.min_distance(b10),0.0); |
318 | |
319 | // shift 0.1 on X |
320 | |
321 | Point<2,float> p({-0.1,0.0}); |
322 | |
323 | b2 += p; |
324 | b3 += p; |
325 | b4 += p; |
326 | b5 += p; |
327 | b6 += p; |
328 | b7 += p; |
329 | b8 += p; |
330 | b9 += p; |
331 | b10 += p; |
332 | |
333 | BOOST_REQUIRE_CLOSE(b1.min_distance(b2),0.1,0.01); |
334 | BOOST_REQUIRE_CLOSE(b1.min_distance(b3),0.1,0.01); |
335 | BOOST_REQUIRE_CLOSE(b1.min_distance(b4),0.1,0.01); |
336 | BOOST_REQUIRE_CLOSE(b1.min_distance(b5),0.1,0.01); |
337 | BOOST_REQUIRE_CLOSE(b1.min_distance(b6),0.1,0.01); |
338 | BOOST_REQUIRE_CLOSE(b1.min_distance(b7),0.1,0.01); |
339 | BOOST_REQUIRE_CLOSE(b1.min_distance(b8),0.1,0.01); |
340 | BOOST_REQUIRE_CLOSE(b1.min_distance(b9),0.1,0.01); |
341 | BOOST_REQUIRE_CLOSE(b1.min_distance(b10),0.1,0.01); |
342 | |
343 | // shift out -0.1 on Y |
344 | |
345 | Point<2,float> p2({0.0,-0.1}); |
346 | |
347 | // Tounching boxes |
348 | b2 += p2; |
349 | b3 += p2; |
350 | b4 += p2; |
351 | b5 += p2; |
352 | b6 += p2; |
353 | b7 += p2; |
354 | b8 += p2; |
355 | b9 += p2; |
356 | b10 += p2; |
357 | |
358 | BOOST_REQUIRE_CLOSE(b1.min_distance(b2),sqrt(0.01 + 0.01),0.01); |
359 | BOOST_REQUIRE_CLOSE(b1.min_distance(b3),sqrt(0.01 + 0.01),0.01); |
360 | BOOST_REQUIRE_CLOSE(b1.min_distance(b4),sqrt(0.01 + 0.01),0.01); |
361 | BOOST_REQUIRE_CLOSE(b1.min_distance(b5),sqrt(0.01 + 0.01),0.01); |
362 | BOOST_REQUIRE_CLOSE(b1.min_distance(b6),sqrt(0.01 + 0.01),0.01); |
363 | BOOST_REQUIRE_CLOSE(b1.min_distance(b7),sqrt(0.01 + 0.01),0.01); |
364 | BOOST_REQUIRE_CLOSE(b1.min_distance(b8),sqrt(0.01 + 0.01),0.01); |
365 | BOOST_REQUIRE_CLOSE(b1.min_distance(b9),sqrt(0.01 + 0.01),0.01); |
366 | BOOST_REQUIRE_CLOSE(b1.min_distance(b10),sqrt(0.01 + 0.01),0.01); |
367 | } |
368 | |
369 | BOOST_AUTO_TEST_CASE( box_is_inside_with_border ) |
370 | { |
371 | // 2D |
372 | |
373 | size_t bc_nn[] = {NON_PERIODIC,NON_PERIODIC}; |
374 | size_t bc_pn[] = {PERIODIC,NON_PERIODIC}; |
375 | size_t bc_np[] = {NON_PERIODIC,PERIODIC}; |
376 | size_t bc_pp[] = {PERIODIC,PERIODIC}; |
377 | |
378 | Box<2,float> border({0.0,0.0},{1.0,1.0}); |
379 | |
380 | // non-tounching box |
381 | Box<2,float> b2({0.1,0.1},{0.2,0.2}); |
382 | Box<2,float> b3({0.1,0.1},{1.0,1.0}); |
383 | |
384 | Point<2,float> p1({0.15,0.15}); |
385 | Point<2,float> p2({0.25,0.25}); |
386 | Point<2,float> p3({0.15,0.2}); |
387 | |
388 | Point<2,float> p4({0.1,0.25}); |
389 | Point<2,float> p5({0.15,1.0}); |
390 | Point<2,float> p6({0.1,1.0}); |
391 | |
392 | ////// NON PERIODIC TEST |
393 | |
394 | bool result = b2.isInsideNP_with_border(p1,border,bc_nn); |
395 | BOOST_REQUIRE_EQUAL(result,true); |
396 | |
397 | result = b2.isInsideNP_with_border(p2,border,bc_nn); |
398 | BOOST_REQUIRE_EQUAL(result,false); |
399 | |
400 | result = b2.isInsideNP_with_border(p3,border,bc_nn); |
401 | BOOST_REQUIRE_EQUAL(result,false); |
402 | |
403 | result = b3.isInsideNP_with_border(p1,border,bc_nn); |
404 | |
405 | BOOST_REQUIRE_EQUAL(result,true); |
406 | |
407 | result = b3.isInsideNP_with_border(p4,border,bc_nn); |
408 | BOOST_REQUIRE_EQUAL(result,true); |
409 | |
410 | result = b3.isInsideNP_with_border(p5,border,bc_nn); |
411 | BOOST_REQUIRE_EQUAL(result,true); |
412 | |
413 | result = b3.isInsideNP_with_border(p6,border,bc_nn); |
414 | BOOST_REQUIRE_EQUAL(result,true); |
415 | |
416 | ////////////// |
417 | |
418 | result = b2.isInsideNP_with_border(p1,border,bc_pn); |
419 | BOOST_REQUIRE_EQUAL(result,true); |
420 | |
421 | result = b2.isInsideNP_with_border(p2,border,bc_pn); |
422 | BOOST_REQUIRE_EQUAL(result,false); |
423 | |
424 | result = b2.isInsideNP_with_border(p3,border,bc_pn); |
425 | BOOST_REQUIRE_EQUAL(result,false); |
426 | |
427 | result = b3.isInsideNP_with_border(p1,border,bc_pn); |
428 | |
429 | BOOST_REQUIRE_EQUAL(result,true); |
430 | |
431 | result = b3.isInsideNP_with_border(p4,border,bc_pn); |
432 | BOOST_REQUIRE_EQUAL(result,true); |
433 | |
434 | result = b3.isInsideNP_with_border(p5,border,bc_pn); |
435 | BOOST_REQUIRE_EQUAL(result,true); |
436 | |
437 | result = b3.isInsideNP_with_border(p6,border,bc_pn); |
438 | BOOST_REQUIRE_EQUAL(result,true); |
439 | |
440 | //////////// |
441 | |
442 | result = b2.isInsideNP_with_border(p1,border,bc_np); |
443 | BOOST_REQUIRE_EQUAL(result,true); |
444 | |
445 | result = b2.isInsideNP_with_border(p2,border,bc_np); |
446 | BOOST_REQUIRE_EQUAL(result,false); |
447 | |
448 | result = b2.isInsideNP_with_border(p3,border,bc_np); |
449 | BOOST_REQUIRE_EQUAL(result,false); |
450 | |
451 | result = b3.isInsideNP_with_border(p1,border,bc_np); |
452 | |
453 | BOOST_REQUIRE_EQUAL(result,true); |
454 | |
455 | result = b3.isInsideNP_with_border(p4,border,bc_np); |
456 | BOOST_REQUIRE_EQUAL(result,true); |
457 | |
458 | result = b3.isInsideNP_with_border(p5,border,bc_np); |
459 | BOOST_REQUIRE_EQUAL(result,false); |
460 | |
461 | result = b3.isInsideNP_with_border(p6,border,bc_np); |
462 | BOOST_REQUIRE_EQUAL(result,false); |
463 | |
464 | //////////// |
465 | |
466 | result = b2.isInsideNP_with_border(p1,border,bc_pp); |
467 | BOOST_REQUIRE_EQUAL(result,true); |
468 | |
469 | result = b2.isInsideNP_with_border(p2,border,bc_pp); |
470 | BOOST_REQUIRE_EQUAL(result,false); |
471 | |
472 | result = b2.isInsideNP_with_border(p3,border,bc_pp); |
473 | BOOST_REQUIRE_EQUAL(result,false); |
474 | |
475 | result = b3.isInsideNP_with_border(p1,border,bc_pp); |
476 | |
477 | BOOST_REQUIRE_EQUAL(result,true); |
478 | |
479 | result = b3.isInsideNP_with_border(p4,border,bc_pp); |
480 | BOOST_REQUIRE_EQUAL(result,true); |
481 | |
482 | result = b3.isInsideNP_with_border(p5,border,bc_pp); |
483 | BOOST_REQUIRE_EQUAL(result,false); |
484 | |
485 | result = b3.isInsideNP_with_border(p6,border,bc_pp); |
486 | BOOST_REQUIRE_EQUAL(result,false); |
487 | } |
488 | |
489 | BOOST_AUTO_TEST_SUITE_END() |
490 | |
491 | |
492 | |
493 | #endif /* BOX_UNIT_TESTS_HPP_ */ |
494 | |