1 /************************************************************************/
2 /* */
3 /* Copyright 2006-2007 by F. Heinrich, B. Seppke, Ullrich Koethe */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35
36 #include <iostream>
37 #include <functional>
38 #include <cmath>
39 #include <set>
40 #include "vigra/unittest.hxx"
41
42 #include "vigra/voxelneighborhood.hxx"
43 #include "vigra/multi_array.hxx"
44
45 using namespace vigra;
46 struct NeighborhoodCirculator3dTest
47 {
48
49 typedef vigra::NeighborhoodCirculator<vigra::StridedMultiIterator<3,int>, vigra::NeighborCode3DSix> SixTraverser;
50 typedef vigra::NeighborhoodCirculator<vigra::StridedMultiIterator<3,int>, vigra::NeighborCode3DTwentySix> TwentySixTraverser;
51
52 typedef vigra::MultiArray<3,int> IntVolume;
53
54 IntVolume vol;
55
56 SixTraverser sixTrav;
57 TwentySixTraverser twentySixTrav;
58
59 enum { w=5,h=5,d=5 };
60
61
NeighborhoodCirculator3dTestNeighborhoodCirculator3dTest62 NeighborhoodCirculator3dTest()
63 : vol(IntVolume::difference_type(w,h,d)),
64 sixTrav(vol.traverser_begin() + vigra::Diff3D(1,1,1)), // set sixTrav to voxel 31=(1,1,1)
65 twentySixTrav(vol.traverser_begin() + vigra::Diff3D(1,1,1)) // set twentySixTrav to voxel 31=(1,1,1)
66 {
67 int i=0;
68 for(vigra::MultiArray<3,int>::iterator iter = vol.begin(); iter!= vol.end(); ++iter, ++i){
69 *iter=i;
70 }
71 }
72
testInitNeighborhoodCirculator3dTest73 void testInit()
74 {
75 should(*sixTrav == 6);
76 should(!sixTrav.isDiagonal());
77 should(*(sixTrav.center()) == 31);
78 should(*twentySixTrav == 0);
79 should(twentySixTrav.isDiagonal());
80 should(*(twentySixTrav.center()) == 31);
81 }
82
testSixTraverserForwardNeighborhoodCirculator3dTest83 void testSixTraverserForward()
84 {
85 sixTrav++;
86 shouldEqual(*sixTrav, 26);
87 sixTrav++;
88 shouldEqual(*sixTrav, 30);
89 sixTrav++;
90 shouldEqual(*sixTrav, 56);
91 sixTrav++;
92 shouldEqual(*sixTrav, 36);
93 sixTrav++;
94 shouldEqual(*sixTrav, 32);
95 }
96
testSixTraverserBackwardNeighborhoodCirculator3dTest97 void testSixTraverserBackward()
98 {
99 sixTrav--;
100 shouldEqual(*sixTrav, 32);
101 sixTrav--;
102 shouldEqual(*sixTrav, 36);
103 sixTrav--;
104 shouldEqual(*sixTrav, 56);
105 sixTrav--;
106 shouldEqual(*sixTrav, 30);
107 sixTrav--;
108 shouldEqual(*sixTrav, 26);
109 }
110
testTwentySixTraverserForwardNeighborhoodCirculator3dTest111 void testTwentySixTraverserForward()
112 {
113 twentySixTrav++;
114 shouldEqual(*twentySixTrav, 1);
115 twentySixTrav++;
116 shouldEqual(*twentySixTrav, 2);
117 twentySixTrav++;
118 shouldEqual(*twentySixTrav, 5);
119 twentySixTrav++;
120 shouldEqual(*twentySixTrav, 6);
121 twentySixTrav++;
122 shouldEqual(*twentySixTrav, 7);
123 twentySixTrav++;
124 shouldEqual(*twentySixTrav, 10);
125 twentySixTrav++;
126 shouldEqual(*twentySixTrav, 11);
127 twentySixTrav++;
128 shouldEqual(*twentySixTrav, 12);
129 twentySixTrav++;
130 shouldEqual(*twentySixTrav, 25);
131 twentySixTrav++;
132 shouldEqual(*twentySixTrav, 26);
133 twentySixTrav++;
134 shouldEqual(*twentySixTrav, 27);
135 twentySixTrav++;
136 shouldEqual(*twentySixTrav, 30);
137 twentySixTrav++;
138 shouldEqual(*twentySixTrav, 32);
139 twentySixTrav++;
140 shouldEqual(*twentySixTrav, 35);
141 twentySixTrav++;
142 shouldEqual(*twentySixTrav, 36);
143 twentySixTrav++;
144 shouldEqual(*twentySixTrav, 37);
145 twentySixTrav++;
146 shouldEqual(*twentySixTrav, 50);
147 twentySixTrav++;
148 shouldEqual(*twentySixTrav, 51);
149 twentySixTrav++;
150 shouldEqual(*twentySixTrav, 52);
151 twentySixTrav++;
152 shouldEqual(*twentySixTrav, 55);
153 twentySixTrav++;
154 shouldEqual(*twentySixTrav, 56);
155 twentySixTrav++;
156 shouldEqual(*twentySixTrav, 57);
157 twentySixTrav++;
158 shouldEqual(*twentySixTrav, 60);
159 twentySixTrav++;
160 shouldEqual(*twentySixTrav, 61);
161 twentySixTrav++;
162 shouldEqual(*twentySixTrav, 62);
163 }
164
testTwentySixTraverserBackwardNeighborhoodCirculator3dTest165 void testTwentySixTraverserBackward()
166 {
167 twentySixTrav--;
168 shouldEqual(*twentySixTrav, 62);
169 twentySixTrav--;
170 shouldEqual(*twentySixTrav, 61);
171 twentySixTrav--;
172 shouldEqual(*twentySixTrav, 60);
173 twentySixTrav--;
174 shouldEqual(*twentySixTrav, 57);
175 twentySixTrav--;
176 shouldEqual(*twentySixTrav, 56);
177 twentySixTrav--;
178 shouldEqual(*twentySixTrav, 55);
179 twentySixTrav--;
180 shouldEqual(*twentySixTrav, 52);
181 twentySixTrav--;
182 shouldEqual(*twentySixTrav, 51);
183 twentySixTrav--;
184 shouldEqual(*twentySixTrav, 50);
185 twentySixTrav--;
186 shouldEqual(*twentySixTrav, 37);
187 twentySixTrav--;
188 shouldEqual(*twentySixTrav, 36);
189 twentySixTrav--;
190 shouldEqual(*twentySixTrav, 35);
191 twentySixTrav--;
192 shouldEqual(*twentySixTrav, 32);
193 twentySixTrav--;
194 shouldEqual(*twentySixTrav, 30);
195 twentySixTrav--;
196 shouldEqual(*twentySixTrav, 27);
197 twentySixTrav--;
198 shouldEqual(*twentySixTrav, 26);
199 twentySixTrav--;
200 shouldEqual(*twentySixTrav, 25);
201 twentySixTrav--;
202 shouldEqual(*twentySixTrav, 12);
203 twentySixTrav--;
204 shouldEqual(*twentySixTrav, 11);
205 twentySixTrav--;
206 shouldEqual(*twentySixTrav, 10);
207 twentySixTrav--;
208 shouldEqual(*twentySixTrav, 7);
209 twentySixTrav--;
210 shouldEqual(*twentySixTrav, 6);
211 twentySixTrav--;
212 shouldEqual(*twentySixTrav, 5);
213 twentySixTrav--;
214 shouldEqual(*twentySixTrav, 2);
215 twentySixTrav--;
216 shouldEqual(*twentySixTrav, 1);
217 }
218
testIsDiagonalNeighborhoodCirculator3dTest219 void testIsDiagonal()
220 {
221 should(*twentySixTrav == 0);
222 should(*sixTrav == 6);
223 for(int i=0; i<27; i++, sixTrav++, twentySixTrav++)
224 {
225 switch(i){
226 case 4 :
227 case 10 :
228 case 12 :
229 case 13 :
230 case 15 :
231 case 21 : should(!twentySixTrav.isDiagonal()); break;
232 default : should(twentySixTrav.isDiagonal());
233 }
234 should(!sixTrav.isDiagonal());
235 }
236 }
237
testEqualityNeighborhoodCirculator3dTest238 void testEquality()
239 {
240 TwentySixTraverser twentySixTrav2 = twentySixTrav;
241 should(twentySixTrav == twentySixTrav2);
242 twentySixTrav2++;
243 should(twentySixTrav != twentySixTrav2);
244 twentySixTrav2++;
245 should(twentySixTrav != twentySixTrav2);
246 twentySixTrav++;
247 should(twentySixTrav != twentySixTrav2);
248 twentySixTrav2--;
249 should(twentySixTrav == twentySixTrav2);
250
251 SixTraverser sixTrav2(vol.traverser_begin() + vigra::Diff3D(1,1,1));
252 should(sixTrav == sixTrav2);
253 sixTrav--;
254 should(sixTrav != sixTrav2);
255
256 twentySixTrav2 = twentySixTrav + 3;
257 twentySixTrav += 3;
258 should(twentySixTrav == twentySixTrav2);
259
260 sixTrav2 = sixTrav + 3;
261 sixTrav += 3;
262 should(sixTrav == sixTrav2);
263
264 twentySixTrav2 = twentySixTrav - 5;
265 twentySixTrav -= 5;
266 should(twentySixTrav == twentySixTrav2);
267
268 sixTrav2 = sixTrav - 5;
269 sixTrav -= 5;
270 should(sixTrav == sixTrav2);
271 }
272
testTurningNeighborhoodCirculator3dTest273 void testTurning()
274 {
275 SixTraverser sixTrav2 = sixTrav;
276 sixTrav2.turnRound();
277 should(sixTrav != sixTrav2);
278 sixTrav2.turnRound();
279 should(sixTrav == sixTrav2);
280
281 TwentySixTraverser twentySixTrav2 = twentySixTrav;
282 twentySixTrav2.turnRound();
283 should(twentySixTrav != twentySixTrav2);
284 twentySixTrav2.turnRound();
285 should(twentySixTrav == twentySixTrav2);
286
287 sixTrav++; // turn to North
288 sixTrav2.turnTo(Neighborhood3DSix::North);
289 should(sixTrav == sixTrav2);
290 sixTrav-=2; // turn to East
291 sixTrav2.turnTo(Neighborhood3DSix::East);
292 should(sixTrav == sixTrav2);
293
294 twentySixTrav++; // turn to InFrontNorth
295 twentySixTrav2.turnTo(Neighborhood3DTwentySix::InFrontNorth);
296 should(twentySixTrav == twentySixTrav2);
297 twentySixTrav+=12; // turn to East
298 twentySixTrav2.turnTo(Neighborhood3DTwentySix::East);
299 should(twentySixTrav == twentySixTrav2);
300 }
301
testMovingNeighborhoodCirculator3dTest302 void testMoving()
303 {
304 sixTrav.turnTo(Neighborhood3DSix::Behind);
305 sixTrav.swapCenterNeighbor();
306 should(*(sixTrav.center()) == 56 );
307 shouldEqual(*sixTrav, 31); // looking Behind from 6 now
308 should(sixTrav.direction() == Neighborhood3DSix::InFront);
309
310 twentySixTrav.turnTo(Neighborhood3DTwentySix::BehindSouthEast);
311 twentySixTrav.swapCenterNeighbor();
312 should(*(twentySixTrav.center()) == 62 );
313 shouldEqual(*twentySixTrav, 31); // looking Behind from 6 now
314 should(twentySixTrav.direction() == Neighborhood3DTwentySix::InFrontNorthWest);
315 }
316
testMiscellaneousNeighborhoodCirculator3dTest317 void testMiscellaneous()
318 {
319 SixTraverser sixTrav2 = sixTrav;
320 TwentySixTraverser twentySixTrav2 = twentySixTrav;
321 // test operator[]
322 for(int i=0; i<6; i++, sixTrav++, twentySixTrav++){
323 should(sixTrav2[i] == *sixTrav);
324 should(twentySixTrav2[i] == *twentySixTrav);
325 }
326
327 twentySixTrav.turnTo(Neighborhood3DTwentySix::InFrontNorthWest);
328
329 // test base()
330 should(twentySixTrav.base() == vol.traverser_begin());
331 twentySixTrav += Neighborhood3DTwentySix::BehindEast - twentySixTrav.direction();
332 twentySixTrav.moveCenterToNeighbor();
333 should(*(twentySixTrav.base()) == 83);
334 twentySixTrav.turnRound();
335 twentySixTrav.swapCenterNeighbor();
336 should(*(twentySixTrav.base()) == 57);
337 }
338 };
339
340 struct RestrictedNeighborhoodCirculator3dTest
341 {
342
343 typedef vigra::RestrictedNeighborhoodCirculator<vigra::StridedMultiIterator<3,int>, vigra::NeighborCode3DSix> SixTraverser;
344 typedef vigra::RestrictedNeighborhoodCirculator<vigra::StridedMultiIterator<3,int>, vigra::NeighborCode3DTwentySix> TwentySixTraverser;
345 typedef vigra::MultiArray<3,int> IntVolume;
346
347 IntVolume vol;
348
349 SixTraverser sixTrav;
350 TwentySixTraverser twentySixTrav;
351
352 enum { w=3,h=3,d=3 };
353
354
RestrictedNeighborhoodCirculator3dTestRestrictedNeighborhoodCirculator3dTest355 RestrictedNeighborhoodCirculator3dTest()
356 : vol(IntVolume::difference_type(w,h,d)),
357 sixTrav(vol.traverser_begin(), TopLeftFrontBorder),
358 twentySixTrav(vol.traverser_begin(), TopLeftFrontBorder)
359 {
360 int i=0;
361 for(vigra::MultiArray<3,int>::iterator iter = vol.begin(); iter!= vol.end(); ++iter, ++i){
362 *iter=i;
363 }
364 }
365
testInitRestrictedNeighborhoodCirculator3dTest366 void testInit()
367 {
368 should(*sixTrav == 9);
369 should(!sixTrav.isDiagonal());
370 should(*(sixTrav.center()) == 0);
371 should(*twentySixTrav == 1);
372 should(!twentySixTrav.isDiagonal());
373 should(*(twentySixTrav.center()) == 0);
374 }
375
testBordersSixRestrictedNeighborhoodCirculator3dTest376 void testBordersSix()
377 {
378 std::set<int> directions;
379 std::set<int>::iterator dir_Iter;
380 int x,y,z,start;
381 AtVolumeBorder atBorder;
382
383 ////////test first plane in volume
384
385 //-------------TopLeftFrontBorder--------------//
386 x=0,y=0,z=0;
387 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
388 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
389 should(*sixTrav == 9);
390 should(atBorder == TopLeftFrontBorder);
391
392 //clear direction list and fill to compare
393 directions.clear();
394 //directions.insert(Neighborhood3DSix::InFront); // insert "0" |
395 //directions.insert(Neighborhood3DSix::North); // insert "1" |- border directions
396 //directions.insert(Neighborhood3DSix::West); // insert "2" |
397 directions.insert(Neighborhood3DSix::Behind); // insert "3"
398 directions.insert(Neighborhood3DSix::South); // insert "4"
399 directions.insert(Neighborhood3DSix::East); // insert "5"
400
401 start = *sixTrav;
402 dir_Iter=directions.begin();
403 do{
404 should(*dir_Iter == sixTrav.direction());
405 sixTrav++;
406 dir_Iter++;
407 }while(*sixTrav!=start);
408
409 //-------------TopFrontBorder--------------//
410 x=1,y=0,z=0;
411 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
412 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
413 should(*sixTrav == 0);
414 should(atBorder == TopFrontBorder);
415
416 //clear direction list and fill to compare
417 directions.clear();
418 directions.insert(2);
419 directions.insert(3);
420 directions.insert(4);
421 directions.insert(5);
422
423 start = *sixTrav;
424 dir_Iter=directions.begin();
425 do{
426 should(*dir_Iter == sixTrav.direction());
427 sixTrav++;
428 dir_Iter++;
429 }while(*sixTrav!=start);
430
431 //-------------TopRightFrontBorder--------------//
432 x=2,y=0,z=0;
433 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
434 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
435 should(*sixTrav == 1);
436 should(atBorder == TopRightFrontBorder);
437
438 //clear direction list and fill to compare
439 directions.clear();
440 directions.insert(2);
441 directions.insert(3);
442 directions.insert(4);
443
444 start = *sixTrav;
445 dir_Iter=directions.begin();
446 do{
447 should(*dir_Iter == sixTrav.direction());
448 sixTrav++;
449 dir_Iter++;
450 }while(*sixTrav!=start);
451
452 //-------------FrontLeftBorder--------------//
453 x=0,y=1,z=0;
454 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
455 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
456 should(*sixTrav == 0);
457 should(atBorder == FrontLeftBorder);
458
459 //clear direction list and fill to compare
460 directions.clear();
461 directions.insert(1);
462 directions.insert(3);
463 directions.insert(4);
464 directions.insert(5);
465
466 start = *sixTrav;
467 dir_Iter=directions.begin();
468 do{
469 should(*dir_Iter == sixTrav.direction());
470 sixTrav++;
471 dir_Iter++;
472 }while(*sixTrav!=start);
473
474 //-------------FrontBorder--------------//
475 x=1,y=1,z=0;
476 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
477 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
478 should(*sixTrav == 1);
479 should(atBorder == FrontBorder);
480
481 //clear direction list and fill to compare
482 directions.clear();
483 directions.insert(1);
484 directions.insert(2);
485 directions.insert(3);
486 directions.insert(4);
487 directions.insert(5);
488
489 start = *sixTrav;
490 dir_Iter=directions.begin();
491 do{
492 should(*dir_Iter == sixTrav.direction());
493 sixTrav++;
494 dir_Iter++;
495 }while(*sixTrav!=start);
496
497 //-------------FrontRightBorder--------------//
498 x=2,y=1,z=0;
499 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
500 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
501 should(*sixTrav == 2);
502 should(atBorder == FrontRightBorder);
503
504 //clear direction list and fill to compare
505 directions.clear();
506 directions.insert(1);
507 directions.insert(2);
508 directions.insert(3);
509 directions.insert(4);
510
511 start = *sixTrav;
512 dir_Iter=directions.begin();
513 do{
514 should(*dir_Iter == sixTrav.direction());
515 sixTrav++;
516 dir_Iter++;
517 }while(*sixTrav!=start);
518
519 //-------------BottomLeftFrontBorder--------------//
520 x=0,y=2,z=0;
521 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
522 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
523 should(*sixTrav == 3);
524 should(atBorder == BottomLeftFrontBorder);
525
526 //clear direction list and fill to compare
527 directions.clear();
528 directions.insert(1);
529 directions.insert(3);
530 directions.insert(5);
531
532 start = *sixTrav;
533 dir_Iter=directions.begin();
534 do{
535 should(*dir_Iter == sixTrav.direction());
536 sixTrav++;
537 dir_Iter++;
538 }while(*sixTrav!=start);
539
540 //-------------BottomFrontBorder--------------//
541 x=1,y=2,z=0;
542 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
543 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
544 should(*sixTrav == 4);
545 should(atBorder == BottomFrontBorder);
546
547 //clear direction list and fill to compare
548 directions.clear();
549 directions.insert(1);
550 directions.insert(2);
551 directions.insert(3);
552 directions.insert(5);
553
554 start = *sixTrav;
555 dir_Iter=directions.begin();
556 do{
557 should(*dir_Iter == sixTrav.direction());
558 sixTrav++;
559 dir_Iter++;
560 }while(*sixTrav!=start);
561
562 //-------------BottomRightFrontBorder--------------//
563 x=2,y=2,z=0;
564 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
565 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
566 should(*sixTrav == 5);
567 should(atBorder == BottomRightFrontBorder);
568
569 //clear direction list and fill to compare
570 directions.clear();
571 directions.insert(1);
572 directions.insert(2);
573 directions.insert(3);
574
575 start = *sixTrav;
576 dir_Iter=directions.begin();
577 do{
578 should(*dir_Iter == sixTrav.direction());
579 sixTrav++;
580 dir_Iter++;
581 }while(*sixTrav!=start);
582
583
584 ////////test second plane in volume
585
586 //-------------TopLeftBorder--------------//
587 x=0,y=0,z=1;
588 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
589 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
590 should(*sixTrav == 0);
591 should(atBorder == TopLeftBorder);
592
593 //clear direction list and fill to compare
594 directions.clear();
595 directions.insert(Neighborhood3DSix::InFront); // insert "1"
596 directions.insert(Neighborhood3DSix::Behind); // insert "3"
597 directions.insert(Neighborhood3DSix::South); // insert "4"
598 directions.insert(Neighborhood3DSix::East); // insert "5"
599
600 start = *sixTrav;
601 dir_Iter=directions.begin();
602 do{
603 should(*dir_Iter == sixTrav.direction());
604 sixTrav++;
605 dir_Iter++;
606 }while(*sixTrav!=start);
607
608 //-------------TopBorder--------------//
609 x=1,y=0,z=1;
610 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
611 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
612 should(*sixTrav == 1);
613 should(atBorder == TopBorder);
614
615 //clear direction list and fill to compare
616 directions.clear();
617 directions.insert(0);
618 directions.insert(2);
619 directions.insert(3);
620 directions.insert(4);
621 directions.insert(5);
622
623 start = *sixTrav;
624 dir_Iter=directions.begin();
625 do{
626 should(*dir_Iter == sixTrav.direction());
627 sixTrav++;
628 dir_Iter++;
629 }while(*sixTrav!=start);
630
631 //-------------TopRightBorder--------------//
632 x=2,y=0,z=1;
633 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
634 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
635 should(*sixTrav == 2);
636 should(atBorder == TopRightBorder);
637
638 //clear direction list and fill to compare
639 directions.clear();
640 directions.insert(0);
641 directions.insert(2);
642 directions.insert(3);
643 directions.insert(4);
644
645 start = *sixTrav;
646 dir_Iter=directions.begin();
647 do{
648 should(*dir_Iter == sixTrav.direction());
649 sixTrav++;
650 dir_Iter++;
651 }while(*sixTrav!=start);
652
653 //-------------LeftBorder--------------//
654 x=0,y=1,z=1;
655 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
656 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
657 should(*sixTrav == 3);
658 should(atBorder == LeftBorder);
659
660 //clear direction list and fill to compare
661 directions.clear();
662 directions.insert(0);
663 directions.insert(1);
664 directions.insert(3);
665 directions.insert(4);
666 directions.insert(5);
667
668 start = *sixTrav;
669 dir_Iter=directions.begin();
670 do{
671 should(*dir_Iter == sixTrav.direction());
672 sixTrav++;
673 dir_Iter++;
674 }while(*sixTrav!=start);
675
676 //-------------NotAtBorder--------------//
677 x=1,y=1,z=1;
678 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
679 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
680 should(*sixTrav == 4);
681 should(atBorder == NotAtBorder);
682
683 //clear direction list and fill to compare
684 directions.clear();
685 directions.insert(0);
686 directions.insert(1);
687 directions.insert(2);
688 directions.insert(3);
689 directions.insert(4);
690 directions.insert(5);
691
692 start = *sixTrav;
693 dir_Iter=directions.begin();
694 do{
695 should(*dir_Iter == sixTrav.direction());
696 sixTrav++;
697 dir_Iter++;
698 }while(*sixTrav!=start);
699
700 //-------------RightBorder--------------//
701 x=2,y=1,z=1;
702 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
703 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
704 should(*sixTrav == 5);
705 should(atBorder == RightBorder);
706
707 //clear direction list and fill to compare
708 directions.clear();
709 directions.insert(0);
710 directions.insert(1);
711 directions.insert(2);
712 directions.insert(3);
713 directions.insert(4);
714
715 start = *sixTrav;
716 dir_Iter=directions.begin();
717 do{
718 should(*dir_Iter == sixTrav.direction());
719 sixTrav++;
720 dir_Iter++;
721 }while(*sixTrav!=start);
722
723 //-------------BottomLeftBorder--------------//
724 x=0,y=2,z=1;
725 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
726 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
727 should(*sixTrav == 6);
728 should(atBorder == BottomLeftBorder);
729
730 //clear direction list and fill to compare
731 directions.clear();
732 directions.insert(0);
733 directions.insert(1);
734 directions.insert(3);
735 directions.insert(5);
736
737 start = *sixTrav;
738 dir_Iter=directions.begin();
739 do{
740 should(*dir_Iter == sixTrav.direction());
741 sixTrav++;
742 dir_Iter++;
743 }while(*sixTrav!=start);
744
745 //-------------BottomBorder--------------//
746 x=1,y=2,z=1;
747 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
748 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
749 should(*sixTrav == 7);
750 should(atBorder == BottomBorder);
751
752 //clear direction list and fill to compare
753 directions.clear();
754 directions.insert(0);
755 directions.insert(1);
756 directions.insert(2);
757 directions.insert(3);
758 directions.insert(5);
759
760 start = *sixTrav;
761 dir_Iter=directions.begin();
762 do{
763 should(*dir_Iter == sixTrav.direction());
764 sixTrav++;
765 dir_Iter++;
766 }while(*sixTrav!=start);
767
768 //-------------BottomRightBorder--------------//
769 x=2,y=2,z=1;
770 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
771 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
772 should(*sixTrav == 8);
773 should(atBorder == BottomRightBorder);
774
775 //clear direction list and fill to compare
776 directions.clear();
777 directions.insert(0);
778 directions.insert(1);
779 directions.insert(2);
780 directions.insert(3);
781
782 start = *sixTrav;
783 dir_Iter=directions.begin();
784 do{
785 should(*dir_Iter == sixTrav.direction());
786 sixTrav++;
787 dir_Iter++;
788 }while(*sixTrav!=start);
789
790
791 ////////test third plane in volume
792
793 //-------------TopLeftRearBorder--------------//
794 x=0,y=0,z=2;
795 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
796 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
797 should(*sixTrav == 9);
798 should(atBorder == TopLeftRearBorder);
799
800 //clear direction list and fill to compare
801 directions.clear();
802 directions.insert(Neighborhood3DSix::InFront);// insert "0"
803 directions.insert(Neighborhood3DSix::South); // insert "4"
804 directions.insert(Neighborhood3DSix::East); // insert "5"
805
806 start = *sixTrav;
807 dir_Iter=directions.begin();
808 do{
809 should(*dir_Iter == sixTrav.direction());
810 sixTrav++;
811 dir_Iter++;
812 }while(*sixTrav!=start);
813
814 //-------------TopRearBorder--------------//
815 x=1,y=0,z=2;
816 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
817 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
818 should(*sixTrav == 10);
819 should(atBorder == TopRearBorder);
820
821 //clear direction list and fill to compare
822 directions.clear();
823 directions.insert(2);
824 directions.insert(0);
825 directions.insert(4);
826 directions.insert(5);
827
828 start = *sixTrav;
829 dir_Iter=directions.begin();
830 do{
831 should(*dir_Iter == sixTrav.direction());
832 sixTrav++;
833 dir_Iter++;
834 }while(*sixTrav!=start);
835
836 //-------------TopRightRearBorder--------------//
837 x=2,y=0,z=2;
838 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
839 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
840 should(*sixTrav == 11);
841 should(atBorder == TopRightRearBorder);
842
843 //clear direction list and fill to compare
844 directions.clear();
845 directions.insert(2);
846 directions.insert(0);
847 directions.insert(4);
848
849 start = *sixTrav;
850 dir_Iter=directions.begin();
851 do{
852 should(*dir_Iter == sixTrav.direction());
853 sixTrav++;
854 dir_Iter++;
855 }while(*sixTrav!=start);
856
857 //-------------RearLeftBorder--------------//
858 x=0,y=1,z=2;
859 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
860 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
861 should(*sixTrav == 12);
862 should(atBorder == RearLeftBorder);
863
864 //clear direction list and fill to compare
865 directions.clear();
866 directions.insert(1);
867 directions.insert(0);
868 directions.insert(4);
869 directions.insert(5);
870
871 start = *sixTrav;
872 dir_Iter=directions.begin();
873 do{
874 should(*dir_Iter == sixTrav.direction());
875 sixTrav++;
876 dir_Iter++;
877 }while(*sixTrav!=start);
878
879 //-------------RearBorder--------------//
880 x=1,y=1,z=2;
881 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
882 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
883 should(*sixTrav == 13);
884 should(atBorder == RearBorder);
885
886 //clear direction list and fill to compare
887 directions.clear();
888 directions.insert(1);
889 directions.insert(2);
890 directions.insert(0);
891 directions.insert(4);
892 directions.insert(5);
893
894 start = *sixTrav;
895 dir_Iter=directions.begin();
896 do{
897 should(*dir_Iter == sixTrav.direction());
898 sixTrav++;
899 dir_Iter++;
900 }while(*sixTrav!=start);
901
902 //-------------RearRightBorder--------------//
903 x=2,y=1,z=2;
904 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
905 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
906 should(*sixTrav == 14);
907 should(atBorder == RearRightBorder);
908
909 //clear direction list and fill to compare
910 directions.clear();
911 directions.insert(1);
912 directions.insert(2);
913 directions.insert(0);
914 directions.insert(4);
915
916 start = *sixTrav;
917 dir_Iter=directions.begin();
918 do{
919 should(*dir_Iter == sixTrav.direction());
920 sixTrav++;
921 dir_Iter++;
922 }while(*sixTrav!=start);
923
924 //-------------BottomLeftRearBorder--------------//
925 x=0,y=2,z=2;
926 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
927 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
928 should(*sixTrav == 15);
929 should(atBorder == BottomLeftRearBorder);
930
931 //clear direction list and fill to compare
932 directions.clear();
933 directions.insert(1);
934 directions.insert(0);
935 directions.insert(5);
936
937 start = *sixTrav;
938 dir_Iter=directions.begin();
939 do{
940 should(*dir_Iter == sixTrav.direction());
941 sixTrav++;
942 dir_Iter++;
943 }while(*sixTrav!=start);
944
945 //-------------BottomRearBorder--------------//
946 x=1,y=2,z=2;
947 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
948 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
949 should(*sixTrav == 16);
950 should(atBorder == BottomRearBorder);
951
952 //clear direction list and fill to compare
953 directions.clear();
954 directions.insert(1);
955 directions.insert(2);
956 directions.insert(0);
957 directions.insert(5);
958
959 start = *sixTrav;
960 dir_Iter=directions.begin();
961 do{
962 should(*dir_Iter == sixTrav.direction());
963 sixTrav++;
964 dir_Iter++;
965 }while(*sixTrav!=start);
966
967 //-------------BottomRightRearBorder--------------//
968 x=2,y=2,z=2;
969 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
970 sixTrav = SixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
971 should(*sixTrav == 17);
972 should(atBorder == BottomRightRearBorder);
973
974 //clear direction list and fill to compare
975 directions.clear();
976 directions.insert(1);
977 directions.insert(2);
978 directions.insert(0);
979
980 start = *sixTrav;
981 dir_Iter=directions.begin();
982 do{
983 should(*dir_Iter == sixTrav.direction());
984 sixTrav++;
985 dir_Iter++;
986 }while(*sixTrav!=start);
987 }
988
989
testBordersTwentySixRestrictedNeighborhoodCirculator3dTest990 void testBordersTwentySix()
991 {
992 std::set<int> directions;
993 std::set<int>::iterator dir_Iter;
994 int x,y,z,start;
995 AtVolumeBorder atBorder;
996
997 ////////test first plane in volume
998
999 //-------------TopLeftFrontBorder--------------//
1000 x=0,y=0,z=0;
1001 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1002 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1003 should(*twentySixTrav == 1);
1004 should(atBorder == TopLeftFrontBorder);
1005
1006 //clear direction list and fill to compare
1007 directions.clear();
1008 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1009 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1010 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1011 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1012 //directions.insert(Neighborhood3DTwentySix::InFront);
1013 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1014 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1015 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1016 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1017
1018 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1019 //directions.insert(Neighborhood3DTwentySix::North);
1020 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1021 //directions.insert(Neighborhood3DTwentySix::West);
1022 directions.insert(Neighborhood3DTwentySix::East);
1023 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1024 directions.insert(Neighborhood3DTwentySix::South);
1025 directions.insert(Neighborhood3DTwentySix::SouthEast);
1026
1027 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1028 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1029 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1030 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1031 directions.insert(Neighborhood3DTwentySix::Behind);
1032 directions.insert(Neighborhood3DTwentySix::BehindEast);
1033 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1034 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1035 directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1036
1037
1038 start = *twentySixTrav;
1039 dir_Iter=directions.begin();
1040 do{
1041 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1042 should(*dir_Iter == twentySixTrav.direction());
1043 twentySixTrav++;
1044 dir_Iter++;
1045 }while(*twentySixTrav!=start);
1046
1047 //-------------TopFrontBorder--------------//
1048 x=1,y=0,z=0;
1049 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1050 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1051 should(*twentySixTrav == 0);
1052 should(atBorder == TopFrontBorder);
1053
1054 //clear direction list and fill to compare
1055 directions.clear();
1056 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1057 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1058 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1059 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1060 //directions.insert(Neighborhood3DTwentySix::InFront);
1061 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1062 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1063 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1064 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1065
1066 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1067 //directions.insert(Neighborhood3DTwentySix::North);
1068 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1069 directions.insert(Neighborhood3DTwentySix::West);
1070 directions.insert(Neighborhood3DTwentySix::East);
1071 directions.insert(Neighborhood3DTwentySix::SouthWest);
1072 directions.insert(Neighborhood3DTwentySix::South);
1073 directions.insert(Neighborhood3DTwentySix::SouthEast);
1074
1075 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1076 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1077 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1078 directions.insert(Neighborhood3DTwentySix::BehindWest);
1079 directions.insert(Neighborhood3DTwentySix::Behind);
1080 directions.insert(Neighborhood3DTwentySix::BehindEast);
1081 directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1082 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1083 directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1084
1085
1086 start = *twentySixTrav;
1087 dir_Iter=directions.begin();
1088 do{
1089 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1090 should(*dir_Iter == twentySixTrav.direction());
1091 twentySixTrav++;
1092 dir_Iter++;
1093 }while(*twentySixTrav!=start);
1094
1095 //-------------TopRightFrontBorder--------------//
1096 x=2,y=0,z=0;
1097 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1098 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1099 should(*twentySixTrav == 1);
1100 should(atBorder == TopRightFrontBorder);
1101
1102 //clear direction list and fill to compare
1103 directions.clear();
1104 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1105 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1106 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1107 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1108 //directions.insert(Neighborhood3DTwentySix::InFront);
1109 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1110 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1111 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1112 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1113
1114 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1115 //directions.insert(Neighborhood3DTwentySix::North);
1116 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1117 directions.insert(Neighborhood3DTwentySix::West);
1118 //directions.insert(Neighborhood3DTwentySix::East);
1119 directions.insert(Neighborhood3DTwentySix::SouthWest);
1120 directions.insert(Neighborhood3DTwentySix::South);
1121 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1122
1123 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1124 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1125 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1126 directions.insert(Neighborhood3DTwentySix::BehindWest);
1127 directions.insert(Neighborhood3DTwentySix::Behind);
1128 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1129 directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1130 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1131 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1132
1133
1134 start = *twentySixTrav;
1135 dir_Iter=directions.begin();
1136 do{
1137 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1138 should(*dir_Iter == twentySixTrav.direction());
1139 twentySixTrav++;
1140 dir_Iter++;
1141 }while(*twentySixTrav!=start);
1142
1143 //-------------FrontLeftBorder--------------//
1144 x=0,y=1,z=0;
1145 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1146 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1147 should(*twentySixTrav == 0);
1148 should(atBorder == FrontLeftBorder);
1149
1150 //clear direction list and fill to compare
1151 directions.clear();
1152 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1153 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1154 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1155 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1156 //directions.insert(Neighborhood3DTwentySix::InFront);
1157 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1158 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1159 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1160 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1161
1162 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1163 directions.insert(Neighborhood3DTwentySix::North);
1164 directions.insert(Neighborhood3DTwentySix::NorthEast);
1165 //directions.insert(Neighborhood3DTwentySix::West);
1166 directions.insert(Neighborhood3DTwentySix::East);
1167 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1168 directions.insert(Neighborhood3DTwentySix::South);
1169 directions.insert(Neighborhood3DTwentySix::SouthEast);
1170
1171 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1172 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1173 directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1174 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1175 directions.insert(Neighborhood3DTwentySix::Behind);
1176 directions.insert(Neighborhood3DTwentySix::BehindEast);
1177 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1178 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1179 directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1180
1181
1182 start = *twentySixTrav;
1183 dir_Iter=directions.begin();
1184 do{
1185 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1186 should(*dir_Iter == twentySixTrav.direction());
1187 twentySixTrav++;
1188 dir_Iter++;
1189 }while(*twentySixTrav!=start);
1190
1191 //-------------FrontBorder--------------//
1192 x=1,y=1,z=0;
1193 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1194 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1195 should(*twentySixTrav == 0);
1196 should(atBorder == FrontBorder);
1197
1198 //clear direction list and fill to compare
1199 directions.clear();
1200 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1201 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1202 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1203 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1204 //directions.insert(Neighborhood3DTwentySix::InFront);
1205 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1206 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1207 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1208 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1209
1210 directions.insert(Neighborhood3DTwentySix::NorthWest);
1211 directions.insert(Neighborhood3DTwentySix::North);
1212 directions.insert(Neighborhood3DTwentySix::NorthEast);
1213 directions.insert(Neighborhood3DTwentySix::West);
1214 directions.insert(Neighborhood3DTwentySix::East);
1215 directions.insert(Neighborhood3DTwentySix::SouthWest);
1216 directions.insert(Neighborhood3DTwentySix::South);
1217 directions.insert(Neighborhood3DTwentySix::SouthEast);
1218
1219 directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1220 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1221 directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1222 directions.insert(Neighborhood3DTwentySix::BehindWest);
1223 directions.insert(Neighborhood3DTwentySix::Behind);
1224 directions.insert(Neighborhood3DTwentySix::BehindEast);
1225 directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1226 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1227 directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1228
1229
1230 start = *twentySixTrav;
1231 dir_Iter=directions.begin();
1232 do{
1233 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1234 should(*dir_Iter == twentySixTrav.direction());
1235 twentySixTrav++;
1236 dir_Iter++;
1237 }while(*twentySixTrav!=start);
1238
1239 //-------------FrontRightBorder--------------//
1240 x=2,y=1,z=0;
1241 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1242 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1243 should(*twentySixTrav == 1);
1244 should(atBorder == FrontRightBorder);
1245
1246 //clear direction list and fill to compare
1247 directions.clear();
1248 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1249 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1250 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1251 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1252 //directions.insert(Neighborhood3DTwentySix::InFront);
1253 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1254 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1255 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1256 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1257
1258 directions.insert(Neighborhood3DTwentySix::NorthWest);
1259 directions.insert(Neighborhood3DTwentySix::North);
1260 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1261 directions.insert(Neighborhood3DTwentySix::West);
1262 //directions.insert(Neighborhood3DTwentySix::East);
1263 directions.insert(Neighborhood3DTwentySix::SouthWest);
1264 directions.insert(Neighborhood3DTwentySix::South);
1265 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1266
1267 directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1268 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1269 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1270 directions.insert(Neighborhood3DTwentySix::BehindWest);
1271 directions.insert(Neighborhood3DTwentySix::Behind);
1272 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1273 directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1274 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1275 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1276
1277
1278 start = *twentySixTrav;
1279 dir_Iter=directions.begin();
1280 do{
1281 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1282 should(*dir_Iter == twentySixTrav.direction());
1283 twentySixTrav++;
1284 dir_Iter++;
1285 }while(*twentySixTrav!=start);
1286
1287 //-------------BottomLeftFrontBorder--------------//
1288 x=0,y=2,z=0;
1289 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1290 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1291 should(*twentySixTrav == 3);
1292 should(atBorder == BottomLeftFrontBorder);
1293
1294 //clear direction list and fill to compare
1295 directions.clear();
1296 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1297 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1298 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1299 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1300 //directions.insert(Neighborhood3DTwentySix::InFront);
1301 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1302 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1303 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1304 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1305
1306 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1307 directions.insert(Neighborhood3DTwentySix::North);
1308 directions.insert(Neighborhood3DTwentySix::NorthEast);
1309 //directions.insert(Neighborhood3DTwentySix::West);
1310 directions.insert(Neighborhood3DTwentySix::East);
1311 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1312 //directions.insert(Neighborhood3DTwentySix::South);
1313 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1314
1315 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1316 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1317 directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1318 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1319 directions.insert(Neighborhood3DTwentySix::Behind);
1320 directions.insert(Neighborhood3DTwentySix::BehindEast);
1321 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1322 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
1323 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1324
1325
1326 start = *twentySixTrav;
1327 dir_Iter=directions.begin();
1328 do{
1329 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1330 should(*dir_Iter == twentySixTrav.direction());
1331 twentySixTrav++;
1332 dir_Iter++;
1333 }while(*twentySixTrav!=start);
1334
1335 //-------------BottomFrontBorder--------------//
1336 x=1,y=2,z=0;
1337 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1338 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1339 should(*twentySixTrav == 3);
1340 should(atBorder == BottomFrontBorder);
1341
1342 //clear direction list and fill to compare
1343 directions.clear();
1344 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1345 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1346 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1347 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1348 //directions.insert(Neighborhood3DTwentySix::InFront);
1349 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1350 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1351 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1352 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1353
1354 directions.insert(Neighborhood3DTwentySix::NorthWest);
1355 directions.insert(Neighborhood3DTwentySix::North);
1356 directions.insert(Neighborhood3DTwentySix::NorthEast);
1357 directions.insert(Neighborhood3DTwentySix::West);
1358 directions.insert(Neighborhood3DTwentySix::East);
1359 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1360 //directions.insert(Neighborhood3DTwentySix::South);
1361 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1362
1363 directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1364 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1365 directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1366 directions.insert(Neighborhood3DTwentySix::BehindWest);
1367 directions.insert(Neighborhood3DTwentySix::Behind);
1368 directions.insert(Neighborhood3DTwentySix::BehindEast);
1369 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1370 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
1371 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1372
1373
1374 start = *twentySixTrav;
1375 dir_Iter=directions.begin();
1376 do{
1377 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1378 should(*dir_Iter == twentySixTrav.direction());
1379 twentySixTrav++;
1380 dir_Iter++;
1381 }while(*twentySixTrav!=start);
1382
1383 //-------------BottomRightFrontBorder--------------//
1384 x=2,y=2,z=0;
1385 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1386 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1387 should(*twentySixTrav == 4);
1388 should(atBorder == BottomRightFrontBorder);
1389
1390 //clear direction list and fill to compare
1391 directions.clear();
1392 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1393 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1394 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1395 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1396 //directions.insert(Neighborhood3DTwentySix::InFront);
1397 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1398 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1399 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1400 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1401
1402 directions.insert(Neighborhood3DTwentySix::NorthWest);
1403 directions.insert(Neighborhood3DTwentySix::North);
1404 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1405 directions.insert(Neighborhood3DTwentySix::West);
1406 //directions.insert(Neighborhood3DTwentySix::East);
1407 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1408 //directions.insert(Neighborhood3DTwentySix::South);
1409 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1410
1411 directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1412 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1413 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1414 directions.insert(Neighborhood3DTwentySix::BehindWest);
1415 directions.insert(Neighborhood3DTwentySix::Behind);
1416 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1417 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1418 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
1419 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1420
1421
1422 start = *twentySixTrav;
1423 dir_Iter=directions.begin();
1424 do{
1425 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1426 should(*dir_Iter == twentySixTrav.direction());
1427 twentySixTrav++;
1428 dir_Iter++;
1429 }while(*twentySixTrav!=start);
1430
1431
1432 ////////test middle plane in volume
1433
1434 //-------------TopLeftBorder--------------//
1435 x=0,y=0,z=1;
1436 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1437 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1438 should(*twentySixTrav == 0);
1439 should(atBorder == TopLeftBorder);
1440
1441 //clear direction list and fill to compare
1442 directions.clear();
1443 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1444 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1445 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1446 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1447 directions.insert(Neighborhood3DTwentySix::InFront);
1448 directions.insert(Neighborhood3DTwentySix::InFrontEast);
1449 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1450 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1451 directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1452
1453 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1454 //directions.insert(Neighborhood3DTwentySix::North);
1455 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1456 //directions.insert(Neighborhood3DTwentySix::West);
1457 directions.insert(Neighborhood3DTwentySix::East);
1458 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1459 directions.insert(Neighborhood3DTwentySix::South);
1460 directions.insert(Neighborhood3DTwentySix::SouthEast);
1461
1462 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1463 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1464 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1465 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1466 directions.insert(Neighborhood3DTwentySix::Behind);
1467 directions.insert(Neighborhood3DTwentySix::BehindEast);
1468 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1469 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1470 directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1471
1472
1473 start = *twentySixTrav;
1474 dir_Iter=directions.begin();
1475 do{
1476 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1477 should(*dir_Iter == twentySixTrav.direction());
1478 twentySixTrav++;
1479 dir_Iter++;
1480 }while(*twentySixTrav!=start);
1481
1482 //-------------TopBorder--------------//
1483 x=1,y=0,z=1;
1484 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1485 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1486 should(*twentySixTrav == 0);
1487 should(atBorder == TopBorder);
1488
1489 //clear direction list and fill to compare
1490 directions.clear();
1491 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1492 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1493 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1494 directions.insert(Neighborhood3DTwentySix::InFrontWest);
1495 directions.insert(Neighborhood3DTwentySix::InFront);
1496 directions.insert(Neighborhood3DTwentySix::InFrontEast);
1497 directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1498 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1499 directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1500
1501 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1502 //directions.insert(Neighborhood3DTwentySix::North);
1503 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1504 directions.insert(Neighborhood3DTwentySix::West);
1505 directions.insert(Neighborhood3DTwentySix::East);
1506 directions.insert(Neighborhood3DTwentySix::SouthWest);
1507 directions.insert(Neighborhood3DTwentySix::South);
1508 directions.insert(Neighborhood3DTwentySix::SouthEast);
1509
1510 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1511 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1512 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1513 directions.insert(Neighborhood3DTwentySix::BehindWest);
1514 directions.insert(Neighborhood3DTwentySix::Behind);
1515 directions.insert(Neighborhood3DTwentySix::BehindEast);
1516 directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1517 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1518 directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1519
1520
1521 start = *twentySixTrav;
1522 dir_Iter=directions.begin();
1523 do{
1524 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1525 should(*dir_Iter == twentySixTrav.direction());
1526 twentySixTrav++;
1527 dir_Iter++;
1528 }while(*twentySixTrav!=start);
1529
1530 //-------------TopRightBorder--------------//
1531 x=2,y=0,z=1;
1532 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1533 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1534 should(*twentySixTrav == 1);
1535 should(atBorder == TopRightBorder);
1536
1537 //clear direction list and fill to compare
1538 directions.clear();
1539 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1540 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1541 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1542 directions.insert(Neighborhood3DTwentySix::InFrontWest);
1543 directions.insert(Neighborhood3DTwentySix::InFront);
1544 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1545 directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1546 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1547 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1548
1549 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1550 //directions.insert(Neighborhood3DTwentySix::North);
1551 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1552 directions.insert(Neighborhood3DTwentySix::West);
1553 //directions.insert(Neighborhood3DTwentySix::East);
1554 directions.insert(Neighborhood3DTwentySix::SouthWest);
1555 directions.insert(Neighborhood3DTwentySix::South);
1556 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1557
1558 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1559 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1560 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1561 directions.insert(Neighborhood3DTwentySix::BehindWest);
1562 directions.insert(Neighborhood3DTwentySix::Behind);
1563 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1564 directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1565 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1566 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1567
1568
1569 start = *twentySixTrav;
1570 dir_Iter=directions.begin();
1571 do{
1572 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1573 should(*dir_Iter == twentySixTrav.direction());
1574 twentySixTrav++;
1575 dir_Iter++;
1576 }while(*twentySixTrav!=start);
1577
1578 //-------------LeftBorder--------------//
1579 x=0,y=1,z=1;
1580 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1581 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1582 should(*twentySixTrav == 0);
1583 should(atBorder == LeftBorder);
1584
1585 //clear direction list and fill to compare
1586 directions.clear();
1587 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1588 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1589 directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1590 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1591 directions.insert(Neighborhood3DTwentySix::InFront);
1592 directions.insert(Neighborhood3DTwentySix::InFrontEast);
1593 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1594 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1595 directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1596
1597 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1598 directions.insert(Neighborhood3DTwentySix::North);
1599 directions.insert(Neighborhood3DTwentySix::NorthEast);
1600 //directions.insert(Neighborhood3DTwentySix::West);
1601 directions.insert(Neighborhood3DTwentySix::East);
1602 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1603 directions.insert(Neighborhood3DTwentySix::South);
1604 directions.insert(Neighborhood3DTwentySix::SouthEast);
1605
1606 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1607 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1608 directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1609 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1610 directions.insert(Neighborhood3DTwentySix::Behind);
1611 directions.insert(Neighborhood3DTwentySix::BehindEast);
1612 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1613 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1614 directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1615
1616
1617 start = *twentySixTrav;
1618 dir_Iter=directions.begin();
1619 do{
1620 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1621 should(*dir_Iter == twentySixTrav.direction());
1622 twentySixTrav++;
1623 dir_Iter++;
1624 }while(*twentySixTrav!=start);
1625
1626 //-------------NotAtBorder--------------//
1627 x=1,y=1,z=1;
1628 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1629 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1630 should(*twentySixTrav == 0);
1631 should(atBorder == NotAtBorder);
1632
1633 //clear direction list and fill to compare
1634 directions.clear();
1635 directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1636 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1637 directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1638 directions.insert(Neighborhood3DTwentySix::InFrontWest);
1639 directions.insert(Neighborhood3DTwentySix::InFront);
1640 directions.insert(Neighborhood3DTwentySix::InFrontEast);
1641 directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1642 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1643 directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1644
1645 directions.insert(Neighborhood3DTwentySix::NorthWest);
1646 directions.insert(Neighborhood3DTwentySix::North);
1647 directions.insert(Neighborhood3DTwentySix::NorthEast);
1648 directions.insert(Neighborhood3DTwentySix::West);
1649 directions.insert(Neighborhood3DTwentySix::East);
1650 directions.insert(Neighborhood3DTwentySix::SouthWest);
1651 directions.insert(Neighborhood3DTwentySix::South);
1652 directions.insert(Neighborhood3DTwentySix::SouthEast);
1653
1654 directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1655 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1656 directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1657 directions.insert(Neighborhood3DTwentySix::BehindWest);
1658 directions.insert(Neighborhood3DTwentySix::Behind);
1659 directions.insert(Neighborhood3DTwentySix::BehindEast);
1660 directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1661 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1662 directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1663
1664
1665 start = *twentySixTrav;
1666 dir_Iter=directions.begin();
1667 do{
1668 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1669 should(*dir_Iter == twentySixTrav.direction());
1670 twentySixTrav++;
1671 dir_Iter++;
1672 }while(*twentySixTrav!=start);
1673
1674 //-------------RightBorder--------------//
1675 x=2,y=1,z=1;
1676 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1677 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1678 should(*twentySixTrav == 1);
1679 should(atBorder == RightBorder);
1680
1681 //clear direction list and fill to compare
1682 directions.clear();
1683 directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1684 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1685 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1686 directions.insert(Neighborhood3DTwentySix::InFrontWest);
1687 directions.insert(Neighborhood3DTwentySix::InFront);
1688 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1689 directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1690 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1691 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1692
1693 directions.insert(Neighborhood3DTwentySix::NorthWest);
1694 directions.insert(Neighborhood3DTwentySix::North);
1695 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1696 directions.insert(Neighborhood3DTwentySix::West);
1697 //directions.insert(Neighborhood3DTwentySix::East);
1698 directions.insert(Neighborhood3DTwentySix::SouthWest);
1699 directions.insert(Neighborhood3DTwentySix::South);
1700 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1701
1702 directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1703 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1704 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1705 directions.insert(Neighborhood3DTwentySix::BehindWest);
1706 directions.insert(Neighborhood3DTwentySix::Behind);
1707 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1708 directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1709 directions.insert(Neighborhood3DTwentySix::BehindSouth);
1710 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1711
1712
1713 start = *twentySixTrav;
1714 dir_Iter=directions.begin();
1715 do{
1716 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1717 should(*dir_Iter == twentySixTrav.direction());
1718 twentySixTrav++;
1719 dir_Iter++;
1720 }while(*twentySixTrav!=start);
1721
1722 //-------------BottomLeftBorder--------------//
1723 x=0,y=2,z=1;
1724 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1725 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1726 should(*twentySixTrav == 3);
1727 should(atBorder == BottomLeftBorder);
1728
1729 //clear direction list and fill to compare
1730 directions.clear();
1731 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1732 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1733 directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1734 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1735 directions.insert(Neighborhood3DTwentySix::InFront);
1736 directions.insert(Neighborhood3DTwentySix::InFrontEast);
1737 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1738 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1739 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1740
1741 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1742 directions.insert(Neighborhood3DTwentySix::North);
1743 directions.insert(Neighborhood3DTwentySix::NorthEast);
1744 //directions.insert(Neighborhood3DTwentySix::West);
1745 directions.insert(Neighborhood3DTwentySix::East);
1746 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1747 //directions.insert(Neighborhood3DTwentySix::South);
1748 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1749
1750 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1751 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1752 directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1753 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1754 directions.insert(Neighborhood3DTwentySix::Behind);
1755 directions.insert(Neighborhood3DTwentySix::BehindEast);
1756 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1757 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
1758 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1759
1760
1761 start = *twentySixTrav;
1762 dir_Iter=directions.begin();
1763 do{
1764 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1765 should(*dir_Iter == twentySixTrav.direction());
1766 twentySixTrav++;
1767 dir_Iter++;
1768 }while(*twentySixTrav!=start);
1769
1770 //-------------BottomBorder--------------//
1771 x=1,y=2,z=1;
1772 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1773 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1774 should(*twentySixTrav == 3);
1775 should(atBorder == BottomBorder);
1776
1777 //clear direction list and fill to compare
1778 directions.clear();
1779 directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1780 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1781 directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1782 directions.insert(Neighborhood3DTwentySix::InFrontWest);
1783 directions.insert(Neighborhood3DTwentySix::InFront);
1784 directions.insert(Neighborhood3DTwentySix::InFrontEast);
1785 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1786 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1787 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1788
1789 directions.insert(Neighborhood3DTwentySix::NorthWest);
1790 directions.insert(Neighborhood3DTwentySix::North);
1791 directions.insert(Neighborhood3DTwentySix::NorthEast);
1792 directions.insert(Neighborhood3DTwentySix::West);
1793 directions.insert(Neighborhood3DTwentySix::East);
1794 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1795 //directions.insert(Neighborhood3DTwentySix::South);
1796 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1797
1798 directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1799 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1800 directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1801 directions.insert(Neighborhood3DTwentySix::BehindWest);
1802 directions.insert(Neighborhood3DTwentySix::Behind);
1803 directions.insert(Neighborhood3DTwentySix::BehindEast);
1804 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1805 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
1806 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1807
1808
1809 start = *twentySixTrav;
1810 dir_Iter=directions.begin();
1811 do{
1812 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1813 should(*dir_Iter == twentySixTrav.direction());
1814 twentySixTrav++;
1815 dir_Iter++;
1816 }while(*twentySixTrav!=start);
1817
1818 //-------------BottomRightBorder--------------//
1819 x=2,y=2,z=1;
1820 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1821 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1822 should(*twentySixTrav == 4);
1823 should(atBorder == BottomRightBorder);
1824
1825 //clear direction list and fill to compare
1826 directions.clear();
1827 directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1828 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1829 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1830 directions.insert(Neighborhood3DTwentySix::InFrontWest);
1831 directions.insert(Neighborhood3DTwentySix::InFront);
1832 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1833 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1834 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1835 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1836
1837 directions.insert(Neighborhood3DTwentySix::NorthWest);
1838 directions.insert(Neighborhood3DTwentySix::North);
1839 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1840 directions.insert(Neighborhood3DTwentySix::West);
1841 //directions.insert(Neighborhood3DTwentySix::East);
1842 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1843 //directions.insert(Neighborhood3DTwentySix::South);
1844 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1845
1846 directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1847 directions.insert(Neighborhood3DTwentySix::BehindNorth);
1848 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1849 directions.insert(Neighborhood3DTwentySix::BehindWest);
1850 directions.insert(Neighborhood3DTwentySix::Behind);
1851 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1852 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1853 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
1854 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1855
1856
1857 start = *twentySixTrav;
1858 dir_Iter=directions.begin();
1859 do{
1860 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1861 should(*dir_Iter == twentySixTrav.direction());
1862 twentySixTrav++;
1863 dir_Iter++;
1864 }while(*twentySixTrav!=start);
1865
1866 ////////test back plane in volume
1867
1868 //-------------TopLeftRearBorder--------------//
1869 x=0,y=0,z=2;
1870 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1871 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1872 should(*twentySixTrav == 9);
1873 should(atBorder == TopLeftRearBorder);
1874
1875 //clear direction list and fill to compare
1876 directions.clear();
1877 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1878 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1879 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1880 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
1881 directions.insert(Neighborhood3DTwentySix::InFront);
1882 directions.insert(Neighborhood3DTwentySix::InFrontEast);
1883 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1884 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1885 directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1886
1887 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1888 //directions.insert(Neighborhood3DTwentySix::North);
1889 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1890 //directions.insert(Neighborhood3DTwentySix::West);
1891 directions.insert(Neighborhood3DTwentySix::East);
1892 //directions.insert(Neighborhood3DTwentySix::SouthWest);
1893 directions.insert(Neighborhood3DTwentySix::South);
1894 directions.insert(Neighborhood3DTwentySix::SouthEast);
1895
1896 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1897 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1898 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1899 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1900 //directions.insert(Neighborhood3DTwentySix::Behind);
1901 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1902 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1903 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
1904 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1905
1906
1907 start = *twentySixTrav;
1908 dir_Iter=directions.begin();
1909 do{
1910 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1911 should(*dir_Iter == twentySixTrav.direction());
1912 twentySixTrav++;
1913 dir_Iter++;
1914 }while(*twentySixTrav!=start);
1915
1916 //-------------TopRearBorder--------------//
1917 x=1,y=0,z=2;
1918 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1919 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1920 should(*twentySixTrav == 9);
1921 should(atBorder == TopRearBorder);
1922
1923 //clear direction list and fill to compare
1924 directions.clear();
1925 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1926 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1927 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1928 directions.insert(Neighborhood3DTwentySix::InFrontWest);
1929 directions.insert(Neighborhood3DTwentySix::InFront);
1930 directions.insert(Neighborhood3DTwentySix::InFrontEast);
1931 directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1932 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1933 directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1934
1935 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1936 //directions.insert(Neighborhood3DTwentySix::North);
1937 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1938 directions.insert(Neighborhood3DTwentySix::West);
1939 directions.insert(Neighborhood3DTwentySix::East);
1940 directions.insert(Neighborhood3DTwentySix::SouthWest);
1941 directions.insert(Neighborhood3DTwentySix::South);
1942 directions.insert(Neighborhood3DTwentySix::SouthEast);
1943
1944 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1945 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1946 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1947 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1948 //directions.insert(Neighborhood3DTwentySix::Behind);
1949 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1950 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1951 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
1952 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
1953
1954
1955 start = *twentySixTrav;
1956 dir_Iter=directions.begin();
1957 do{
1958 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
1959 should(*dir_Iter == twentySixTrav.direction());
1960 twentySixTrav++;
1961 dir_Iter++;
1962 }while(*twentySixTrav!=start);
1963
1964 //-------------TopRightRearBorder--------------//
1965 x=2,y=0,z=2;
1966 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
1967 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
1968 should(*twentySixTrav == 10);
1969 should(atBorder == TopRightRearBorder);
1970
1971 //clear direction list and fill to compare
1972 directions.clear();
1973 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
1974 //directions.insert(Neighborhood3DTwentySix::InFrontNorth);
1975 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
1976 directions.insert(Neighborhood3DTwentySix::InFrontWest);
1977 directions.insert(Neighborhood3DTwentySix::InFront);
1978 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
1979 directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
1980 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
1981 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
1982
1983 //directions.insert(Neighborhood3DTwentySix::NorthWest);
1984 //directions.insert(Neighborhood3DTwentySix::North);
1985 //directions.insert(Neighborhood3DTwentySix::NorthEast);
1986 directions.insert(Neighborhood3DTwentySix::West);
1987 //directions.insert(Neighborhood3DTwentySix::East);
1988 directions.insert(Neighborhood3DTwentySix::SouthWest);
1989 directions.insert(Neighborhood3DTwentySix::South);
1990 //directions.insert(Neighborhood3DTwentySix::SouthEast);
1991
1992 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
1993 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
1994 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
1995 //directions.insert(Neighborhood3DTwentySix::BehindWest);
1996 //directions.insert(Neighborhood3DTwentySix::Behind);
1997 //directions.insert(Neighborhood3DTwentySix::BehindEast);
1998 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
1999 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
2000 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
2001
2002
2003 start = *twentySixTrav;
2004 dir_Iter=directions.begin();
2005 do{
2006 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
2007 should(*dir_Iter == twentySixTrav.direction());
2008 twentySixTrav++;
2009 dir_Iter++;
2010 }while(*twentySixTrav!=start);
2011
2012 //-------------RearLeftBorder--------------//
2013 x=0,y=1,z=2;
2014 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
2015 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
2016 should(*twentySixTrav == 9);
2017 should(atBorder == RearLeftBorder);
2018
2019 //clear direction list and fill to compare
2020 directions.clear();
2021 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
2022 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
2023 directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
2024 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
2025 directions.insert(Neighborhood3DTwentySix::InFront);
2026 directions.insert(Neighborhood3DTwentySix::InFrontEast);
2027 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
2028 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
2029 directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
2030
2031 //directions.insert(Neighborhood3DTwentySix::NorthWest);
2032 directions.insert(Neighborhood3DTwentySix::North);
2033 directions.insert(Neighborhood3DTwentySix::NorthEast);
2034 //directions.insert(Neighborhood3DTwentySix::West);
2035 directions.insert(Neighborhood3DTwentySix::East);
2036 //directions.insert(Neighborhood3DTwentySix::SouthWest);
2037 directions.insert(Neighborhood3DTwentySix::South);
2038 directions.insert(Neighborhood3DTwentySix::SouthEast);
2039
2040 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
2041 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
2042 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
2043 //directions.insert(Neighborhood3DTwentySix::BehindWest);
2044 //directions.insert(Neighborhood3DTwentySix::Behind);
2045 //directions.insert(Neighborhood3DTwentySix::BehindEast);
2046 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
2047 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
2048 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
2049
2050
2051 start = *twentySixTrav;
2052 dir_Iter=directions.begin();
2053 do{
2054 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
2055 should(*dir_Iter == twentySixTrav.direction());
2056 twentySixTrav++;
2057 dir_Iter++;
2058 }while(*twentySixTrav!=start);
2059
2060 //-------------RearBorder--------------//
2061 x=1,y=1,z=2;
2062 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
2063 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
2064 should(*twentySixTrav == 9);
2065 should(atBorder == RearBorder);
2066
2067 //clear direction list and fill to compare
2068 directions.clear();
2069 directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
2070 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
2071 directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
2072 directions.insert(Neighborhood3DTwentySix::InFrontWest);
2073 directions.insert(Neighborhood3DTwentySix::InFront);
2074 directions.insert(Neighborhood3DTwentySix::InFrontEast);
2075 directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
2076 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
2077 directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
2078
2079 directions.insert(Neighborhood3DTwentySix::NorthWest);
2080 directions.insert(Neighborhood3DTwentySix::North);
2081 directions.insert(Neighborhood3DTwentySix::NorthEast);
2082 directions.insert(Neighborhood3DTwentySix::West);
2083 directions.insert(Neighborhood3DTwentySix::East);
2084 directions.insert(Neighborhood3DTwentySix::SouthWest);
2085 directions.insert(Neighborhood3DTwentySix::South);
2086 directions.insert(Neighborhood3DTwentySix::SouthEast);
2087
2088 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
2089 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
2090 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
2091 //directions.insert(Neighborhood3DTwentySix::BehindWest);
2092 //directions.insert(Neighborhood3DTwentySix::Behind);
2093 //directions.insert(Neighborhood3DTwentySix::BehindEast);
2094 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
2095 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
2096 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
2097
2098
2099 start = *twentySixTrav;
2100 dir_Iter=directions.begin();
2101 do{
2102 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
2103 should(*dir_Iter == twentySixTrav.direction());
2104 twentySixTrav++;
2105 dir_Iter++;
2106 }while(*twentySixTrav!=start);
2107
2108 //-------------RearRightBorder--------------//
2109 x=2,y=1,z=2;
2110 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
2111 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
2112 should(*twentySixTrav == 10);
2113 should(atBorder == RearRightBorder);
2114
2115 //clear direction list and fill to compare
2116 directions.clear();
2117 directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
2118 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
2119 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
2120 directions.insert(Neighborhood3DTwentySix::InFrontWest);
2121 directions.insert(Neighborhood3DTwentySix::InFront);
2122 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
2123 directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
2124 directions.insert(Neighborhood3DTwentySix::InFrontSouth);
2125 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
2126
2127 directions.insert(Neighborhood3DTwentySix::NorthWest);
2128 directions.insert(Neighborhood3DTwentySix::North);
2129 //directions.insert(Neighborhood3DTwentySix::NorthEast);
2130 directions.insert(Neighborhood3DTwentySix::West);
2131 //directions.insert(Neighborhood3DTwentySix::East);
2132 directions.insert(Neighborhood3DTwentySix::SouthWest);
2133 directions.insert(Neighborhood3DTwentySix::South);
2134 //directions.insert(Neighborhood3DTwentySix::SouthEast);
2135
2136 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
2137 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
2138 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
2139 //directions.insert(Neighborhood3DTwentySix::BehindWest);
2140 //directions.insert(Neighborhood3DTwentySix::Behind);
2141 //directions.insert(Neighborhood3DTwentySix::BehindEast);
2142 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
2143 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
2144 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
2145
2146
2147 start = *twentySixTrav;
2148 dir_Iter=directions.begin();
2149 do{
2150 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
2151 should(*dir_Iter == twentySixTrav.direction());
2152 twentySixTrav++;
2153 dir_Iter++;
2154 }while(*twentySixTrav!=start);
2155
2156 //-------------BottomLeftRearBorder--------------//
2157 x=0,y=2,z=2;
2158 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
2159 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
2160 should(*twentySixTrav == 12);
2161 should(atBorder == BottomLeftRearBorder);
2162
2163 //clear direction list and fill to compare
2164 directions.clear();
2165 //directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
2166 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
2167 directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
2168 //directions.insert(Neighborhood3DTwentySix::InFrontWest);
2169 directions.insert(Neighborhood3DTwentySix::InFront);
2170 directions.insert(Neighborhood3DTwentySix::InFrontEast);
2171 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
2172 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
2173 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
2174
2175 //directions.insert(Neighborhood3DTwentySix::NorthWest);
2176 directions.insert(Neighborhood3DTwentySix::North);
2177 directions.insert(Neighborhood3DTwentySix::NorthEast);
2178 //directions.insert(Neighborhood3DTwentySix::West);
2179 directions.insert(Neighborhood3DTwentySix::East);
2180 //directions.insert(Neighborhood3DTwentySix::SouthWest);
2181 //directions.insert(Neighborhood3DTwentySix::South);
2182 //directions.insert(Neighborhood3DTwentySix::SouthEast);
2183
2184 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
2185 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
2186 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
2187 //directions.insert(Neighborhood3DTwentySix::BehindWest);
2188 //directions.insert(Neighborhood3DTwentySix::Behind);
2189 //directions.insert(Neighborhood3DTwentySix::BehindEast);
2190 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
2191 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
2192 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
2193
2194
2195 start = *twentySixTrav;
2196 dir_Iter=directions.begin();
2197 do{
2198 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
2199 should(*dir_Iter == twentySixTrav.direction());
2200 twentySixTrav++;
2201 dir_Iter++;
2202 }while(*twentySixTrav!=start);
2203
2204 //-------------BottomRearBorder--------------//
2205 x=1,y=2,z=2;
2206 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
2207 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
2208 should(*twentySixTrav == 12);
2209 should(atBorder == BottomRearBorder);
2210
2211 //clear direction list and fill to compare
2212 directions.clear();
2213 directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
2214 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
2215 directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
2216 directions.insert(Neighborhood3DTwentySix::InFrontWest);
2217 directions.insert(Neighborhood3DTwentySix::InFront);
2218 directions.insert(Neighborhood3DTwentySix::InFrontEast);
2219 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
2220 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
2221 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
2222
2223 directions.insert(Neighborhood3DTwentySix::NorthWest);
2224 directions.insert(Neighborhood3DTwentySix::North);
2225 directions.insert(Neighborhood3DTwentySix::NorthEast);
2226 directions.insert(Neighborhood3DTwentySix::West);
2227 directions.insert(Neighborhood3DTwentySix::East);
2228 //directions.insert(Neighborhood3DTwentySix::SouthWest);
2229 //directions.insert(Neighborhood3DTwentySix::South);
2230 //directions.insert(Neighborhood3DTwentySix::SouthEast);
2231
2232 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
2233 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
2234 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
2235 //directions.insert(Neighborhood3DTwentySix::BehindWest);
2236 //directions.insert(Neighborhood3DTwentySix::Behind);
2237 //directions.insert(Neighborhood3DTwentySix::BehindEast);
2238 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
2239 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
2240 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
2241
2242
2243 start = *twentySixTrav;
2244 dir_Iter=directions.begin();
2245 do{
2246 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
2247 should(*dir_Iter == twentySixTrav.direction());
2248 twentySixTrav++;
2249 dir_Iter++;
2250 }while(*twentySixTrav!=start);
2251
2252 //-------------BottomRightRearBorder--------------//
2253 x=2,y=2,z=2;
2254 atBorder = isAtVolumeBorder(x,y,z,w,h,d);
2255 twentySixTrav = TwentySixTraverser(vol.traverser_begin() + vigra::Diff3D(x,y,z), atBorder);
2256 should(*twentySixTrav == 13);
2257 should(atBorder == BottomRightRearBorder);
2258
2259 //clear direction list and fill to compare
2260 directions.clear();
2261 directions.insert(Neighborhood3DTwentySix::InFrontNorthWest);
2262 directions.insert(Neighborhood3DTwentySix::InFrontNorth);
2263 //directions.insert(Neighborhood3DTwentySix::InFrontNorthEast);
2264 directions.insert(Neighborhood3DTwentySix::InFrontWest);
2265 directions.insert(Neighborhood3DTwentySix::InFront);
2266 //directions.insert(Neighborhood3DTwentySix::InFrontEast);
2267 //directions.insert(Neighborhood3DTwentySix::InFrontSouthWest);
2268 //directions.insert(Neighborhood3DTwentySix::InFrontSouth);
2269 //directions.insert(Neighborhood3DTwentySix::InFrontSouthEast);
2270
2271 directions.insert(Neighborhood3DTwentySix::NorthWest);
2272 directions.insert(Neighborhood3DTwentySix::North);
2273 //directions.insert(Neighborhood3DTwentySix::NorthEast);
2274 directions.insert(Neighborhood3DTwentySix::West);
2275 //directions.insert(Neighborhood3DTwentySix::East);
2276 //directions.insert(Neighborhood3DTwentySix::SouthWest);
2277 //directions.insert(Neighborhood3DTwentySix::South);
2278 //directions.insert(Neighborhood3DTwentySix::SouthEast);
2279
2280 //directions.insert(Neighborhood3DTwentySix::BehindNorthWest);
2281 //directions.insert(Neighborhood3DTwentySix::BehindNorth);
2282 //directions.insert(Neighborhood3DTwentySix::BehindNorthEast);
2283 //directions.insert(Neighborhood3DTwentySix::BehindWest);
2284 //directions.insert(Neighborhood3DTwentySix::Behind);
2285 //directions.insert(Neighborhood3DTwentySix::BehindEast);
2286 //directions.insert(Neighborhood3DTwentySix::BehindSouthWest);
2287 //directions.insert(Neighborhood3DTwentySix::BehindSouth);
2288 //directions.insert(Neighborhood3DTwentySix::BehindSouthEast);
2289
2290
2291 start = *twentySixTrav;
2292 dir_Iter=directions.begin();
2293 do{
2294 //std::cerr << *dir_Iter << " =?= " << twentySixTrav.direction() << std::endl;
2295 should(*dir_Iter == twentySixTrav.direction());
2296 twentySixTrav++;
2297 dir_Iter++;
2298 }while(*twentySixTrav!=start);
2299
2300 }
2301 };
2302
2303 struct NeighborhoodCirculator3dTestSuite
2304 : public vigra::test_suite
2305 {
NeighborhoodCirculator3dTestSuiteNeighborhoodCirculator3dTestSuite2306 NeighborhoodCirculator3dTestSuite()
2307 : vigra::test_suite("NeighborhoodCirculator3dTestSuite")
2308 {
2309 add( testCase( &NeighborhoodCirculator3dTest::testInit));
2310 add( testCase( &NeighborhoodCirculator3dTest::testSixTraverserForward));
2311 add( testCase( &NeighborhoodCirculator3dTest::testSixTraverserBackward));
2312 add( testCase( &NeighborhoodCirculator3dTest::testTwentySixTraverserForward));
2313 add( testCase( &NeighborhoodCirculator3dTest::testTwentySixTraverserBackward));
2314 add( testCase( &NeighborhoodCirculator3dTest::testIsDiagonal));
2315 add( testCase( &NeighborhoodCirculator3dTest::testEquality));
2316 add( testCase( &NeighborhoodCirculator3dTest::testTurning));
2317 add( testCase( &NeighborhoodCirculator3dTest::testMoving));
2318 add( testCase( &NeighborhoodCirculator3dTest::testMiscellaneous));
2319
2320 add( testCase( &RestrictedNeighborhoodCirculator3dTest::testInit));
2321 add( testCase( &RestrictedNeighborhoodCirculator3dTest::testBordersSix));
2322 add( testCase( &RestrictedNeighborhoodCirculator3dTest::testBordersTwentySix));
2323 }
2324 };
2325
main(int argc,char ** argv)2326 int main(int argc, char ** argv)
2327 {
2328 NeighborhoodCirculator3dTestSuite test;
2329
2330 int failed = test.run(vigra::testsToBeExecuted(argc, argv));
2331
2332 std::cout << test.report() << std::endl;
2333 return (failed != 0);
2334 }
2335
2336