Debian Codegraph @

src/ImathTest/testBox.cpp

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 #ifdef NDEBUG
7 # undef NDEBUG
8 #endif
9
10 #include <ImathBoxAlgo.h>
11 #include <ImathRandom.h>
12
13 #include <algorithm>
14 #include <assert.h>
15 #include <iostream>
16 #include <typeinfo>
17 #include <vector>
18 #include "testBoxAlgo.h"
19
20 // Include ImathForward *after* other headers to validate forward declarations
21 #include <ImathForward.h>
22
23 using namespace std;
24 using namespace IMATH_INTERNAL_NAMESPACE;
25
26 namespace
27 {
28
29 //
30 // Test case generation utility - create a vector of IMATH_INTERNAL_NAMESPACE::Vec{2,3,4}
31 // with all permutations of integers 1..T::dimensions().
32 //
33 // Algorithm from www.bearcave.com/random_hacks/permute.html
34 //
35 template <class T>
36 static void
37 addItem (const std::vector<int>& value, std::vector<T>& perms)
38 {
39 T p;
40 for (unsigned int i = 0; i < value.size(); i++)
41 {
42 p[i] = static_cast<typename T::BaseType>(value[i]);
43 }
44 perms.push_back (p);
45 }
46
47 template <class T>
48 static void
49 visit (int& level, int n, int k, std::vector<int>& value, std::vector<T>& perms)
50 {
51 level = level + 1;
52 value[k] = level;
53
54 if (level == n)
55 addItem (value, perms);
56 else
57 for (int i = 0; i < n; i++)
58 if (value[i] == 0)
59 visit (level, n, i, value, perms);
60
61 level = level - 1;
62 value[k] = 0;
63 }
64
65 template <class T>
66 static void
67 permutations (std::vector<T>& perms)
68 {
69 std::vector<int> value (T::dimensions());
70 int level = -1;
71 int n = T::dimensions();
72
73 visit (level, n, 0, value, perms);
74 }
75
76 template <class T>
77 static void
78 testConstructors (const char* type)
79 {
80 cout << " constructors for type " << type << endl;
81
82 //
83 // Empty
84 //
85 {
86 IMATH_INTERNAL_NAMESPACE::Box<T> b;
87 assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest()));
88 }
89
90 //
91 // Single point
92 //
93 {
94 T p;
95 for (unsigned int i = 0; i < T::dimensions (); i++)
96 p[i] = static_cast<typename T::BaseType>(i);
97
98 IMATH_INTERNAL_NAMESPACE::Box<T> b (p);
99 assert (b.min == p && b.max == p);
100 }
101
102 //
103 // Min and max
104 //
105 {
106 T p0;
107 T p1;
108 for (unsigned int i = 0; i < T::dimensions(); i++)
109 {
110 p0[i] = static_cast<typename T::BaseType>(i);
111 p1[i] = static_cast<typename T::BaseType>(10 * T::dimensions () - i - 1);
112 }
113
114 IMATH_INTERNAL_NAMESPACE::Box<T> b (p0, p1);
115 assert (b.min == p0 && b.max == p1);
116 }
117 }
118
119 template <class T>
120 void
121 testMakeEmpty (const char* type)
122 {
123 cout << " makeEmpty() for type " << type << endl;
124
125 //
126 // Empty box
127 //
128 {
129 IMATH_INTERNAL_NAMESPACE::Box<T> b;
130 b.makeEmpty();
131 assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest()));
132 }
133
134 //
135 // Non-empty, has volume
136 //
137 {
138 IMATH_INTERNAL_NAMESPACE::Box<T> b (T (-1), T (1));
139 b.makeEmpty();
140 assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest()));
141 }
142
143 //
144 // Non-empty, no volume
145 // Boxes are:
146 // 2D: [(0, 0), (0, 1) ]
147 // 3D: [(0, 0, 0), (0, 0, 1) ]
148 // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
149 //
150 {
151 T min (0);
152 T max (0);
153 max[T::dimensions() - 1] = 1;
154
155 IMATH_INTERNAL_NAMESPACE::Box<T> b (min, max);
156 b.makeEmpty();
157 assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest()));
158 }
159 }
160
161 template <class T>
162 void
163 testMakeInfinite (const char* type)
164 {
165 cout << " makeInfinite() for type " << type << endl;
166
167 //
168 // Infinite box
169 //
170 {
171 IMATH_INTERNAL_NAMESPACE::Box<T> b;
172 b.makeInfinite ();
173 assert (
174 b.min == T (T::baseTypeLowest ()) &&
175 b.max == T (T::baseTypeMax ()));
176
177 for (unsigned int i=0; i<b.min.dimensions(); i++)
178 {
179 IMATH_INTERNAL_NAMESPACE::Box<T> c = b;
180 c.max[i] = 0;
181 assert (!c.isInfinite());
182
183 c = b;
184 c.min[i] = 0;
185 assert (!c.isInfinite());
186 }
187 }
188
189 //
190 // Non-empty, has volume
191 //
192 {
193 IMATH_INTERNAL_NAMESPACE::Box<T> b (T (-1), T (1));
194 b.makeInfinite();
195 assert (b.min == T (T::baseTypeLowest()) && b.max == T (T::baseTypeMax()));
196 }
197
198 //
199 // Non-empty, no volume
200 // Boxes are:
201 // 2D: [(0, 0), (0, 1) ]
202 // 3D: [(0, 0, 0), (0, 0, 1) ]
203 // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
204 //
205 {
206 T min (0);
207 T max (0);
208 max[T::dimensions() - 1] = 1;
209
210 IMATH_INTERNAL_NAMESPACE::Box<T> b (min, max);
211 b.makeInfinite();
212 assert (b.min == T (T::baseTypeLowest()) && b.max == T (T::baseTypeMax()));
213 }
214 }
215
216 template <class T>
217 void
218 testExtendByPoint (const char* type)
219 {
220 cout << " extendBy() point for type " << type << endl;
221
222 IMATH_INTERNAL_NAMESPACE::Rand32 rand (0);
223
224 const unsigned int iters = 10;
225
226 //
227 // Extend empty box with a single point.
228 //
229 for (unsigned int i = 0; i < iters; i++)
230 {
231 T p;
232 for (unsigned int j = 0; j < T::dimensions(); j++)
233 p[j] = typename T::BaseType (rand.nextf (-12345, 12345));
234
235 IMATH_INTERNAL_NAMESPACE::Box<T> b;
236 b.extendBy (p);
237 assert (b.min == p && b.max == p);
238 }
239
240 //
241 // Extend empty box with a number of random points. Note that
242 // this also covers extending a non-empty box.
243 //
244 for (unsigned int i = 0; i < iters; i++)
245 {
246 IMATH_INTERNAL_NAMESPACE::Box<T> b;
247
248 T min;
249 T max;
250
251 for (unsigned int j = 0; j < i; j++)
252 {
253 T p;
254 for (unsigned int k = 0; k < T::dimensions(); k++)
255 p[k] = typename T::BaseType (rand.nextf (-12345, 12345));
256
257 if (j == 0)
258 {
259 min = p;
260 max = p;
261 }
262 for (unsigned int k = 0; k < T::dimensions(); k++)
263 {
264 min[k] = std::min (min[k], p[k]);
265 max[k] = std::max (max[k], p[k]);
266 }
267
268 b.extendBy (p);
269
270 assert (b.min == min && b.max == max);
271 }
272 }
273 }
274
275 template <class T>
276 void
277 testExtendByBox (const char* type)
278 {
279 cout << " extendBy() box for type " << type << endl;
280
281 //
282 // Extend empty box with an empty box;
283 //
284 {
285 IMATH_INTERNAL_NAMESPACE::Box<T> b;
286 b.extendBy (IMATH_INTERNAL_NAMESPACE::Box<T>());
287 assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest()));
288 }
289
290 //
291 // Extend empty box with a non-empty box and vice versa.
292 //
293 {
294 std::vector<T> perms;
295 permutations (perms);
296
297 for (unsigned int i = 0; i < perms.size(); i++)
298 {
299 for (unsigned int j = 0; j < perms.size(); j++)
300 {
301 T p0 = -perms[i];
302 T p1 = perms[j];
303
304 IMATH_INTERNAL_NAMESPACE::Box<T> b0;
305 b0.extendBy (IMATH_INTERNAL_NAMESPACE::Box<T> (p0, p1));
306 assert (b0.min == p0 && b0.max == p1);
307
308 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
309 b1.extendBy (IMATH_INTERNAL_NAMESPACE::Box<T>());
310 assert (b1.min == p0 && b1.max == p1);
311 }
312 }
313 }
314
315 //
316 // Extend non-empty box with non-empty box. Starts with empty, then builds.
317 //
318 IMATH_INTERNAL_NAMESPACE::Rand32 rand (0);
319 const unsigned int iters = 10;
320 {
321 IMATH_INTERNAL_NAMESPACE::Box<T> b;
322
323 T min, max;
324
325 for (unsigned int i = 1; i < iters; i++)
326 {
327 T p0;
328 T p1;
329 for (unsigned int k = 0; k < T::dimensions(); k++)
330 {
331 p0[k] = typename T::BaseType (rand.nextf (0, 999));
332 p1[k] = typename T::BaseType (rand.nextf (1000, 1999));
333 }
334
335 min = b.min;
336 max = b.max;
337 for (unsigned int k = 0; k < T::dimensions(); k++)
338 {
339 min[k] = std::min (min[k], p0[k]);
340 max[k] = std::max (max[k], p1[k]);
341 }
342 b.extendBy (IMATH_INTERNAL_NAMESPACE::Box<T> (p0, p1));
343
344 assert (b.min == min && b.max == max);
345 }
346 }
347 }
348
349 template <class T>
350 void
351 testComparators (const char* type)
352 {
353 cout << " comparators for type " << type << endl;
354
355 IMATH_INTERNAL_NAMESPACE::Rand32 rand (0);
356
357 //
358 // Compare empty.
359 //
360 {
361 IMATH_INTERNAL_NAMESPACE::Box<T> b0;
362 IMATH_INTERNAL_NAMESPACE::Box<T> b1;
363
364 assert (b0 == b1);
365 assert (!(b0 != b1));
366 }
367
368 //
369 // Compare empty to non-empty.
370 //
371 {
372 std::vector<T> perms;
373 permutations (perms);
374
375 for (unsigned int i = 0; i < perms.size(); i++)
376 {
377 for (unsigned int j = 0; j < perms.size(); j++)
378 {
379 T p0 = -perms[i];
380 T p1 = perms[j];
381
382 IMATH_INTERNAL_NAMESPACE::Box<T> b0;
383 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
384 assert (!(b0 == b1));
385 assert (b0 != b1);
386 }
387 }
388 }
389
390 //
391 // Compare two non-empty
392 //
393 {
394 std::vector<T> perms;
395 permutations (perms);
396
397 for (unsigned int i = 0; i < perms.size(); i++)
398 {
399 for (unsigned int j = 0; j < perms.size(); j++)
400 {
401 T p0 = -perms[i];
402 T p1 = perms[j];
403
404 T p2 = -perms[j];
405 T p3 = perms[i];
406
407 IMATH_INTERNAL_NAMESPACE::Box<T> b0 (p0, p1);
408 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p2, p3);
409 IMATH_INTERNAL_NAMESPACE::Box<T> b2 (p0, p1);
410
411 if (i == j)
412 {
413 assert (b0 == b1);
414 assert (!(b0 != b1));
415 }
416 else
417 {
418 assert (b0 != b1);
419 assert (!(b0 == b1));
420 }
421 assert (b0 == b2);
422 assert (!(b0 != b2));
423 }
424 }
425 }
426 }
427
428 template <class T>
429 void
430 testIntersects (const char* type)
431 {
432 cout << " intersects() for type " << type << endl;
433
434 IMATH_INTERNAL_NAMESPACE::Rand32 rand (0);
435
436 //
437 // Intersect point with empty box.
438 //
439 {
440 IMATH_INTERNAL_NAMESPACE::Box<T> b;
441 T p (1);
442
443 assert (!b.intersects (p));
444 }
445
446 //
447 // Intersect point with non-empty, has-volume box.
448 //
449 {
450 IMATH_INTERNAL_NAMESPACE::Box<T> b (T (-1), T (1));
451 T p0 (0);
452 T p1 (5);
453 T p2 (-5);
454
455 assert (b.intersects (p0));
456 assert (!b.intersects (p1));
457 assert (!b.intersects (p2));
458 }
459
460 //
461 // Intersect point with non-empty, no-volume box.
462 // Boxes are:
463 // 2D: [(0, 0), (0, 1) ]
464 // 3D: [(0, 0, 0), (0, 0, 1) ]
465 // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
466 //
467 {
468 T min (0);
469 T max = min;
470 max[T::dimensions() - 1] = 1;
471
472 T p0 (0);
473 T p1 (5);
474 IMATH_INTERNAL_NAMESPACE::Box<T> b (min, max);
475
476 assert (b.intersects (p0));
477 assert (!b.intersects (p1));
478 }
479
480 //
481 // Intersect empty box with empty box.
482 //
483 {
484 IMATH_INTERNAL_NAMESPACE::Box<T> b0;
485 IMATH_INTERNAL_NAMESPACE::Box<T> b1;
486
487 assert (!b0.intersects (b1));
488 assert (!b1.intersects (b0));
489 }
490
491 //
492 // Intersect empty box with non-empty has-volume boxes.
493 //
494 {
495 IMATH_INTERNAL_NAMESPACE::Box<T> b0;
496 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (T (-1), T (1));
497 IMATH_INTERNAL_NAMESPACE::Box<T> b2 (T (1), T (2));
498
499 assert (!b0.intersects (b1));
500 assert (!b0.intersects (b2));
501
502 assert (!b1.intersects (b0));
503 assert (!b2.intersects (b0));
504 }
505
506 //
507 // Intersect empty box with non-empty no-volume box.
508 // Boxes are:
509 // 2D: [(0, 0), (0, 1) ]
510 // 3D: [(0, 0, 0), (0, 0, 1) ]
511 // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
512 //
513 {
514 T min (0);
515 T max = min;
516 max[T::dimensions() - 1] = 1;
517
518 IMATH_INTERNAL_NAMESPACE::Box<T> b0;
519 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (min, max);
520
521 assert (!b0.intersects (b1));
522 assert (!b1.intersects (b0));
523 }
524
525 //
526 // Intersect non-empty has-volume box with non-empty has-volume box.
527 //
528 {
529 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (T (-1), T (1));
530 IMATH_INTERNAL_NAMESPACE::Box<T> b2 (T (-1), T (1));
531 IMATH_INTERNAL_NAMESPACE::Box<T> b3 (T (1), T (2));
532 IMATH_INTERNAL_NAMESPACE::Box<T> b4 (T (2), T (3));
533
534 assert (b1.intersects (b1));
535 assert (b1.intersects (b3));
536 assert (!b1.intersects (b4));
537
538 assert (b3.intersects (b1));
539 assert (!b4.intersects (b1));
540 }
541
542 //
543 // Intersect non-empty has-volume box with non-empty no-volume box.
544 //
545 // Boxes are:
546 // 2D: [(0, 0), (0, 1) ]
547 // 3D: [(0, 0, 0), (0, 0, 1) ]
548 // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
549 //
550 {
551 IMATH_INTERNAL_NAMESPACE::Box<T> b0 (T (-1), T (1));
552
553 T min (0);
554 T max = min;
555 max[T::dimensions() - 1] = 1;
556
557 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (min, max);
558 IMATH_INTERNAL_NAMESPACE::Box<T> b2 (min + T (2), max + T (2));
559
560 assert (b0.intersects (b1));
561 assert (b1.intersects (b0));
562
563 assert (!b0.intersects (b2));
564 assert (!b2.intersects (b1));
565 }
566
567 //
568 // Intersect non-empty no-volume box with non-empty no-volume box.
569 //
570 // Boxes are:
571 // 2D: [(0, 0), (0, 1) ]
572 // 3D: [(0, 0, 0), (0, 0, 1) ]
573 // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
574 //
575 {
576 T min (0);
577 T max = min;
578 max[T::dimensions() - 1] = 1;
579
580 IMATH_INTERNAL_NAMESPACE::Box<T> b0 (min, max);
581 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (min, max + T (2));
582 IMATH_INTERNAL_NAMESPACE::Box<T> b2 (min + T (2), max + T (2));
583
584 assert (b0.intersects (b1));
585 assert (b1.intersects (b0));
586
587 assert (!b0.intersects (b2));
588 assert (!b2.intersects (b0));
589 }
590 }
591
592 template <class T>
593 void
594 testSize (const char* type)
595 {
596 cout << " size() for type " << type << endl;
597
598 //
599 // Size of empty box.
600 //
601 {
602 IMATH_INTERNAL_NAMESPACE::Box<T> b;
603 assert (b.size() == T (0));
604 }
605
606 //
607 // Size of non-empty, has-volume box.
608 // Boxes are:
609 // 2D: [(-1, -1), (1, 1) ]
610 // 3D: [(-1, -1, -1), (1, 1, 1) ]
611 // 4D: [(-1, -1, -1, -1), (1, 1, 1, 1) ]
612 //
613 // and
614 //
615 // 2D: [(-1, -2), (1, 2) ]
616 // 3D: [(-1, -2, -3), (1, 2, 3) ]
617 // 4D: [(-1, -2, -3, -4), (1, 2, 3, 4) ]
618 //
619 {
620 IMATH_INTERNAL_NAMESPACE::Box<T> b0 (T (-1), T (1));
621 assert (b0.size() == T (2));
622
623 T p;
624 for (unsigned int i = 0; i < T::dimensions(); i++)
625 {
626 p[i] = static_cast<typename T::BaseType>(i);
627 }
628 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (-p, p);
629 assert (b1.size() == p * T (2));
630 }
631
632 //
633 // Size of non-empty, no-volume box.
634 // Boxes are:
635 // 2D: [(0, 0), (0, 1) ]
636 // 3D: [(0, 0, 0), (0, 0, 1) ]
637 // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
638 //
639 {
640 T min (0);
641 T max = min;
642 max[T::dimensions() - 1] = 1;
643
644 IMATH_INTERNAL_NAMESPACE::Box<T> b (min, max);
645
646 assert (b.size() == max);
647 }
648 }
649
650 template <class T>
651 void
652 testCenter (const char* type)
653 {
654 cout << " center() for type " << type << endl;
655
656 //
657 // Center of empty box.
658 //
659 {
660 IMATH_INTERNAL_NAMESPACE::Box<T> b;
661 assert (b.center() == T (0));
662 }
663
664 //
665 // Center of non-empty, has-volume box.
666 // Boxes are:
667 // 2D: [(-1, -1), (1, 1) ]
668 // 3D: [(-1, -1, -1), (1, 1, 1) ]
669 // 4D: [(-1, -1, -1, -1), (1, 1, 1, 1) ]
670 //
671 // and
672 //
673 // 2D: [(-2, -4), ( 8, 2) ]
674 // 3D: [(-2, -4, -6), (12, 8, 2) ]
675 // 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]
676 //
677 {
678 IMATH_INTERNAL_NAMESPACE::Box<T> b0 (T (-1), T (1));
679 assert (b0.center() == T (0));
680
681 T p0;
682 T p1;
683 for (unsigned int i = 0; i < T::dimensions(); i++)
684 {
685 int lo = 1 << (i + 1);
686 int hi = 1 << (T::dimensions () - i);
687 p0[i] = -static_cast<typename T::BaseType>(lo);
688 p1[i] = static_cast<typename T::BaseType>(hi);
689 }
690 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
691 assert (b1.center() == (p1 + p0) / 2);
692 }
693
694 //
695 // Center of non-empty, no-volume box.
696 // Boxes are:
697 // 2D: [(0, 0), (0, 2) ]
698 // 3D: [(0, 0, 0), (0, 0, 2) ]
699 // 4D: [(0, 0, 0, 0), (0, 0, 0, 2)]
700 //
701 {
702 T min (0);
703 T max = min;
704 max[T::dimensions() - 1] = 2;
705
706 IMATH_INTERNAL_NAMESPACE::Box<T> b (min, max);
707
708 assert (b.center() == max / 2);
709 }
710 }
711
712 template <class T>
713 void
714 testIsEmpty (const char* type)
715 {
716 cout << " isEmpty() for type " << type << endl;
717
718 //
719 // Empty box.
720 //
721 {
722 IMATH_INTERNAL_NAMESPACE::Box<T> b;
723 assert (b.isEmpty());
724 }
725
726 //
727 // Non-empty, has-volume box.
728 // 2D: [(-2, -4), ( 8, 2) ]
729 // 3D: [(-2, -4, -6), (12, 8, 2) ]
730 // 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]
731 //
732 {
733 IMATH_INTERNAL_NAMESPACE::Box<T> b0 (T (-1), T (1));
734 assert (!b0.isEmpty());
735
736 T p0;
737 T p1;
738 for (unsigned int i = 0; i < T::dimensions(); i++)
739 {
740 int lo = 1 << (i + 1);
741 int hi = 1 << (T::dimensions () - i);
742 p0[i] = -static_cast<typename T::BaseType>(lo);
743 p1[i] = static_cast<typename T::BaseType>(hi);
744 }
745 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
746 assert (!b1.isEmpty());
747 }
748
749 //
750 // Non-empty, no-volume box.
751 // Boxes are:
752 // 2D: [(0, 0), (0, 2) ]
753 // 3D: [(0, 0, 0), (0, 0, 2) ]
754 // 4D: [(0, 0, 0, 0), (0, 0, 0, 2)]
755 //
756 {
757 T min (0);
758 T max = min;
759 max[T::dimensions() - 1] = 2;
760
761 IMATH_INTERNAL_NAMESPACE::Box<T> b (min, max);
762
763 assert (!b.isEmpty());
764 }
765 }
766
767 template <class T>
768 void
769 testIsInfinite (const char* type)
770 {
771 cout << " isInfinite() for type " << type << endl;
772
773 //
774 // Infinite box.
775 //
776 {
777 IMATH_INTERNAL_NAMESPACE::Box<T> b;
778 b.makeInfinite();
779 assert (b.isInfinite());
780 }
781
782 //
783 // Non-empty, has-volume box.
784 // 2D: [(-2, -4), ( 8, 2) ]
785 // 3D: [(-2, -4, -6), (12, 8, 2) ]
786 // 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]
787 //
788 {
789 IMATH_INTERNAL_NAMESPACE::Box<T> b0 (T (-1), T (1));
790 assert (!b0.isInfinite());
791
792 T p0;
793 T p1;
794 for (unsigned int i = 0; i < T::dimensions(); i++)
795 {
796 int lo = 1 << (i + 1);
797 int hi = 1 << (T::dimensions () - i);
798 p0[i] = -static_cast<typename T::BaseType>(lo);
799 p1[i] = static_cast<typename T::BaseType>(hi);
800 }
801 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
802 assert (!b1.isInfinite());
803 }
804
805 //
806 // Non-empty, no-volume box.
807 // Boxes are:
808 // 2D: [(0, 0), (0, 2) ]
809 // 3D: [(0, 0, 0), (0, 0, 2) ]
810 // 4D: [(0, 0, 0, 0), (0, 0, 0, 2)]
811 //
812 {
813 T min (0);
814 T max = min;
815 max[T::dimensions() - 1] = 2;
816
817 IMATH_INTERNAL_NAMESPACE::Box<T> b (min, max);
818
819 assert (!b.isInfinite());
820 }
821 }
822
823 template <class T>
824 void
825 testHasVolume (const char* type)
826 {
827 cout << " hasVolume() for type " << type << endl;
828
829 //
830 // Empty box.
831 //
832 {
833 IMATH_INTERNAL_NAMESPACE::Box<T> b;
834 assert (!b.hasVolume());
835 }
836
837 //
838 // Infinite box.
839 //
840 {
841 IMATH_INTERNAL_NAMESPACE::Box<T> b;
842 b.makeInfinite();
843 assert (b.hasVolume());
844 }
845
846 //
847 // Non-empty, has-volume box.
848 // 2D: [(-2, -4), ( 8, 2) ]
849 // 3D: [(-2, -4, -6), (12, 8, 2) ]
850 // 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]
851 //
852 {
853 IMATH_INTERNAL_NAMESPACE::Box<T> b0 (T (-1), T (1));
854 assert (b0.hasVolume());
855
856 T p0;
857 T p1;
858 for (unsigned int i = 0; i < T::dimensions(); i++)
859 {
860 int lo = 1 << (i + 1);
861 int hi = 1 << (T::dimensions () - i);
862 p0[i] = -static_cast<typename T::BaseType>(lo);
863 p1[i] = static_cast<typename T::BaseType>(hi);
864 }
865 IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
866 assert (b1.hasVolume());
867 }
868
869 //
870 // Non-empty, no-volume box.
871 // Boxes are:
872 // 2D: [(0, 0), (0, 2) ]
873 // 3D: [(0, 0, 0), (0, 0, 2) ]
874 // 4D: [(0, 0, 0, 0), (0, 0, 0, 2)]
875 //
876 {
877 T min (0);
878 T max = min;
879 max[T::dimensions() - 1] = 2;
880
881 IMATH_INTERNAL_NAMESPACE::Box<T> b (min, max);
882
883 assert (!b.hasVolume());
884 }
885 }
886
887 template <class T>
888 void
889 testMajorAxis (const char* type)
890 {
891 cout << " majorAxis() for type " << type << endl;
892
893 //
894 // Empty box.
895 //
896 {
897 IMATH_INTERNAL_NAMESPACE::Box<T> b;
898 assert (b.majorAxis() == 0);
899 }
900
901 //
902 // Non-empty, has-volume box.
903 // Boxes are [ (0, 0, ...), (<all permutations of 1..T::dimensions()>) ]
904 //
905 {
906 std::vector<T> perms;
907 permutations (perms);
908
909 for (unsigned int i = 0; i < perms.size(); i++)
910 {
911 IMATH_INTERNAL_NAMESPACE::Box<T> b (T (0), perms[i]);
912
913 unsigned int major = 0;
914 T size = perms[i] - T (0);
915 for (unsigned int j = 1; j < T::dimensions(); j++)
916 if (size[j] > size[major])
917 major = j;
918
919 assert (b.majorAxis() == major);
920 }
921 }
922
923 //
924 // Non-empty, no-volume box.
925 // Boxes are:
926 // 2D: [(0, 0), (1, 0) ]
927 // 2D: [(0, 0), (0, 1) ]
928 //
929 // 3D: [(0, 0), (1, 0, 0) ]
930 // 3D: [(0, 0), (0, 1, 0) ]
931 // 3D: [(0, 0), (0, 0, 1) ]
932 //
933 // and similarly for 4D
934 //
935 {
936 for (unsigned int i = 0; i < T::dimensions(); i++)
937 {
938 for (unsigned int j = 0; j < T::dimensions(); j++)
939 {
940 T max (0);
941 max[j] = 1;
942
943 IMATH_INTERNAL_NAMESPACE::Box<T> b (T (0), max);
944 assert (b.majorAxis() == j);
945 }
946 }
947 }
948 }
949
950 } // anonymous namespace
951
952 void
953 testBox()
954 {
955 cout << "Testing box methods" << endl;
956
957 //
958 // Constructors
959 //
960 testConstructors<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
961 testConstructors<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
962 testConstructors<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
963 testConstructors<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
964 testConstructors<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
965
966 testConstructors<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
967 testConstructors<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
968 testConstructors<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
969 testConstructors<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
970 testConstructors<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
971
972 testConstructors<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
973 testConstructors<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
974 testConstructors<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
975 testConstructors<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
976 testConstructors<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
977
978 //
979 // makeEmpty()
980 //
981 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
982 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
983 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
984 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
985 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
986
987 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
988 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
989 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
990 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
991 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
992
993 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
994 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
995 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
996 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
997 testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
998
999 //
1000 // makeInfinite()
1001 //
1002 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1003 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1004 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1005 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1006 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1007
1008 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1009 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1010 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1011 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1012 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1013
1014 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1015 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1016 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1017 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1018 testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1019
1020 //
1021 // extendBy() (point)
1022 //
1023 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1024 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1025 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1026 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1027 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1028
1029 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1030 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1031 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1032 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1033 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1034
1035 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1036 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1037 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1038 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1039 testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1040
1041 //
1042 // extendBy() box
1043 //
1044 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1045 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1046 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1047 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1048 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1049
1050 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1051 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1052 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1053 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1054 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1055
1056 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1057 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1058 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1059 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1060 testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1061
1062 //
1063 // == and !==
1064 //
1065 testComparators<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1066 testComparators<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1067 testComparators<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1068 testComparators<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1069 testComparators<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1070
1071 testComparators<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1072 testComparators<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1073 testComparators<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1074 testComparators<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1075 testComparators<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1076
1077 testComparators<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1078 testComparators<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1079 testComparators<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1080 testComparators<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1081 testComparators<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1082
1083 //
1084 // size()
1085 //
1086 testSize<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1087 testSize<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1088 testSize<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1089 testSize<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1090 testSize<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1091
1092 testSize<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1093 testSize<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1094 testSize<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1095 testSize<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1096 testSize<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1097
1098 testSize<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1099 testSize<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1100 testSize<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1101 testSize<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1102 testSize<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1103
1104 //
1105 // center()
1106 //
1107 testCenter<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1108 testCenter<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1109 testCenter<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1110 testCenter<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1111 testCenter<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1112
1113 testCenter<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1114 testCenter<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1115 testCenter<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1116 testCenter<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1117 testCenter<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1118
1119 testCenter<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1120 testCenter<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1121 testCenter<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1122 testCenter<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1123 testCenter<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1124
1125 //
1126 // isEmpty()
1127 //
1128 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1129 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1130 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1131 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1132 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1133
1134 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1135 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1136 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1137 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1138 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1139
1140 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1141 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1142 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1143 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1144 testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1145
1146 //
1147 // isInfinite()
1148 //
1149 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1150 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1151 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1152 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1153 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1154
1155 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1156 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1157 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1158 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1159 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1160
1161 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1162 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1163 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1164 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1165 testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1166
1167 //
1168 // hasVolume()
1169 //
1170 testHasVolume<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1171 testHasVolume<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1172 testHasVolume<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1173 testHasVolume<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1174 testHasVolume<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1175
1176 testHasVolume<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1177 testHasVolume<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1178 testHasVolume<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1179 testHasVolume<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1180 testHasVolume<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1181
1182 testHasVolume<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1183 testHasVolume<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1184 testHasVolume<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1185 testHasVolume<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1186 testHasVolume<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1187
1188 //
1189 // majorAxis()
1190 //
1191 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2s> ("V2s");
1192 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2i> ("V2i");
1193 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2i64> ("V2i64");
1194 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2f> ("V2f");
1195 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2d> ("V2d");
1196
1197 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3s> ("V3s");
1198 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3i> ("V3i");
1199 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3i64> ("V3i64");
1200 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3f> ("V3f");
1201 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3d> ("V3d");
1202
1203 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4s> ("V4s");
1204 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4i> ("V4i");
1205 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4i64> ("V4i64");
1206 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4f> ("V4f");
1207 testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4d> ("V4d");
1208
1209 cout << "ok\n" << endl;
1210 }