1/////////////////////////////////////////////////////////////////////////// 
2// 
3// Copyright (c) 2004-2012, Industrial Light & Magic, a division of Lucas 
4// Digital Ltd. LLC 
5//  
6// All rights reserved. 
7//  
8// Redistribution and use in source and binary forms, with or without 
9// modification, are permitted provided that the following conditions are 
10// met: 
11// * Redistributions of source code must retain the above copyright 
12// notice, this list of conditions and the following disclaimer. 
13// * Redistributions in binary form must reproduce the above 
14// copyright notice, this list of conditions and the following disclaimer 
15// in the documentation and/or other materials provided with the 
16// distribution. 
17// * Neither the name of Industrial Light & Magic nor the names of 
18// its contributors may be used to endorse or promote products derived 
19// from this software without specific prior written permission.  
20//  
21// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
22// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
23// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
24// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
25// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
26// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
27// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
28// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
29// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
30// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
31// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
32// 
33/////////////////////////////////////////////////////////////////////////// 
34 
35 
36#ifndef INCLUDED_IMATHBOX_H 
37#define INCLUDED_IMATHBOX_H 
38 
39//------------------------------------------------------------------- 
40// 
41// class Imath::Box<class T> 
42// -------------------------------- 
43// 
44// This class imposes the following requirements on its  
45// parameter class: 
46//  
47// 1) The class T must implement these operators: 
48// + - < > <= >= =  
49// with the signature (T,T) and the expected  
50// return values for a numeric type.  
51// 
52// 2) The class T must implement operator= 
53// with the signature (T,float and/or double) 
54// 
55// 3) The class T must have a constructor which takes 
56// a float (and/or double) for use in initializing the box. 
57// 
58// 4) The class T must have a function T::dimensions() 
59// which returns the number of dimensions in the class 
60// (since its assumed its a vector) -- preferably, this 
61// returns a constant expression. 
62// 
63//------------------------------------------------------------------- 
64 
65#include "ImathVec.h" 
66#include "ImathNamespace.h" 
67 
68IMATH_INTERNAL_NAMESPACE_HEADER_ENTER 
69 
70 
71template <class T>  
72class Box 
73{ 
74 public: 
75 
76 //------------------------- 
77 // Data Members are public 
78 //------------------------- 
79 
80 T min; 
81 T max; 
82 
83 //----------------------------------------------------- 
84 // Constructors - an "empty" box is created by default 
85 //----------------------------------------------------- 
86 
87 Box ();  
88 Box (const T &point); 
89 Box (const T &minT, const T &maxT); 
90 
91 //-------------------- 
92 // Operators: ==, != 
93 //-------------------- 
94  
95 bool operator == (const Box<T> &src) const; 
96 bool operator != (const Box<T> &src) const; 
97 
98 //------------------ 
99 // Box manipulation 
100 //------------------ 
101 
102 void makeEmpty (); 
103 void extendBy (const T &point); 
104 void extendBy (const Box<T> &box); 
105 void makeInfinite ();  
106 
107 //--------------------------------------------------- 
108 // Query functions - these compute results each time 
109 //--------------------------------------------------- 
110 
111 T size () const; 
112 T center () const; 
113 bool intersects (const T &point) const; 
114 bool intersects (const Box<T> &box) const; 
115 
116 unsigned int majorAxis () const; 
117 
118 //---------------- 
119 // Classification 
120 //---------------- 
121 
122 bool isEmpty () const; 
123 bool hasVolume () const; 
124 bool isInfinite () const; 
125}; 
126 
127 
128//-------------------- 
129// Convenient typedefs 
130//-------------------- 
131 
132typedef Box <V2s> Box2s; 
133typedef Box <V2i> Box2i; 
134typedef Box <V2f> Box2f; 
135typedef Box <V2d> Box2d; 
136typedef Box <V3s> Box3s; 
137typedef Box <V3i> Box3i; 
138typedef Box <V3f> Box3f; 
139typedef Box <V3d> Box3d; 
140 
141 
142//---------------- 
143// Implementation 
144 
145 
146template <class T> 
147inline Box<T>::Box() 
148{ 
149 makeEmpty(); 
150} 
151 
152 
153template <class T> 
154inline Box<T>::Box (const T &point) 
155{ 
156 min = point; 
157 max = point; 
158} 
159 
160 
161template <class T> 
162inline Box<T>::Box (const T &minT, const T &maxT) 
163{ 
164 min = minT; 
165 max = maxT; 
166} 
167 
168 
169template <class T> 
170inline bool 
171Box<T>::operator == (const Box<T> &src) const 
172{ 
173 return (min == src.min && max == src.max); 
174} 
175 
176 
177template <class T> 
178inline bool 
179Box<T>::operator != (const Box<T> &src) const 
180{ 
181 return (min != src.min || max != src.max); 
182} 
183 
184 
185template <class T> 
186inline void Box<T>::makeEmpty() 
187{ 
188 min = T(T::baseTypeMax()); 
189 max = T(T::baseTypeMin()); 
190} 
191 
192template <class T> 
193inline void Box<T>::makeInfinite() 
194{ 
195 min = T(T::baseTypeMin()); 
196 max = T(T::baseTypeMax()); 
197} 
198 
199 
200template <class T> 
201inline void 
202Box<T>::extendBy(const T &point) 
203{ 
204 for (unsigned int i = 0; i < min.dimensions(); i++) 
205 { 
206 if (point[i] < min[i]) 
207 min[i] = point[i]; 
208 
209 if (point[i] > max[i]) 
210 max[i] = point[i]; 
211 } 
212} 
213 
214 
215template <class T> 
216inline void 
217Box<T>::extendBy(const Box<T> &box) 
218{ 
219 for (unsigned int i = 0; i < min.dimensions(); i++) 
220 { 
221 if (box.min[i] < min[i]) 
222 min[i] = box.min[i]; 
223 
224 if (box.max[i] > max[i]) 
225 max[i] = box.max[i]; 
226 } 
227} 
228 
229 
230template <class T> 
231inline bool 
232Box<T>::intersects(const T &point) const 
233{ 
234 for (unsigned int i = 0; i < min.dimensions(); i++) 
235 { 
236 if (point[i] < min[i] || point[i] > max[i]) 
237 return false; 
238 } 
239 
240 return true; 
241} 
242 
243 
244template <class T> 
245inline bool 
246Box<T>::intersects(const Box<T> &box) const 
247{ 
248 for (unsigned int i = 0; i < min.dimensions(); i++) 
249 { 
250 if (box.max[i] < min[i] || box.min[i] > max[i]) 
251 return false; 
252 } 
253 
254 return true; 
255} 
256 
257 
258template <class T>  
259inline T 
260Box<T>::size() const  
261{  
262 if (isEmpty()) 
263 return T (0); 
264 
265 return max - min; 
266} 
267 
268 
269template <class T>  
270inline T 
271Box<T>::center() const  
272{  
273 return (max + min) / 2; 
274} 
275 
276 
277template <class T> 
278inline bool 
279Box<T>::isEmpty() const 
280{ 
281 for (unsigned int i = 0; i < min.dimensions(); i++) 
282 { 
283 if (max[i] < min[i]) 
284 return true; 
285 } 
286 
287 return false; 
288} 
289 
290template <class T> 
291inline bool 
292Box<T>::isInfinite() const 
293{ 
294 for (unsigned int i = 0; i < min.dimensions(); i++) 
295 { 
296 if (min[i] != T::baseTypeMin() || max[i] != T::baseTypeMax()) 
297 return false; 
298 } 
299 
300 return true; 
301} 
302 
303 
304template <class T> 
305inline bool 
306Box<T>::hasVolume() const 
307{ 
308 for (unsigned int i = 0; i < min.dimensions(); i++) 
309 { 
310 if (max[i] <= min[i]) 
311 return false; 
312 } 
313 
314 return true; 
315} 
316 
317 
318template<class T> 
319inline unsigned int 
320Box<T>::majorAxis() const 
321{ 
322 unsigned int major = 0; 
323 T s = size(); 
324 
325 for (unsigned int i = 1; i < min.dimensions(); i++) 
326 { 
327 if (s[i] > s[major]) 
328 major = i; 
329 } 
330 
331 return major; 
332} 
333 
334//------------------------------------------------------------------- 
335// 
336// Partial class specializations for Imath::Vec2<T> and Imath::Vec3<T> 
337// 
338//------------------------------------------------------------------- 
339 
340template <typename T> class Box; 
341 
342template <class T> 
343class Box<Vec2<T> > 
344{ 
345 public: 
346 
347 //------------------------- 
348 // Data Members are public 
349 //------------------------- 
350 
351 Vec2<T> min; 
352 Vec2<T> max; 
353 
354 //----------------------------------------------------- 
355 // Constructors - an "empty" box is created by default 
356 //----------------------------------------------------- 
357 
358 Box();  
359 Box (const Vec2<T> &point); 
360 Box (const Vec2<T> &minT, const Vec2<T> &maxT); 
361 
362 //-------------------- 
363 // Operators: ==, != 
364 //-------------------- 
365 
366 bool operator == (const Box<Vec2<T> > &src) const; 
367 bool operator != (const Box<Vec2<T> > &src) const; 
368 
369 //------------------ 
370 // Box manipulation 
371 //------------------ 
372 
373 void makeEmpty(); 
374 void extendBy (const Vec2<T> &point); 
375 void extendBy (const Box<Vec2<T> > &box); 
376 void makeInfinite(); 
377 
378 //--------------------------------------------------- 
379 // Query functions - these compute results each time 
380 //--------------------------------------------------- 
381 
382 Vec2<T> size() const; 
383 Vec2<T> center() const; 
384 bool intersects (const Vec2<T> &point) const; 
385 bool intersects (const Box<Vec2<T> > &box) const; 
386 
387 unsigned int majorAxis() const; 
388 
389 //---------------- 
390 // Classification 
391 //---------------- 
392 
393 bool isEmpty() const; 
394 bool hasVolume() const; 
395 bool isInfinite() const; 
396}; 
397 
398 
399//---------------- 
400// Implementation 
401 
402template <class T> 
403inline Box<Vec2<T> >::Box() 
404{ 
405 makeEmpty(); 
406} 
407 
408 
409template <class T> 
410inline Box<Vec2<T> >::Box (const Vec2<T> &point) 
411{ 
412 min = point; 
413 max = point; 
414} 
415 
416 
417template <class T> 
418inline Box<Vec2<T> >::Box (const Vec2<T> &minT, const Vec2<T> &maxT) 
419{ 
420 min = minT; 
421 max = maxT; 
422} 
423 
424 
425template <class T> 
426inline bool 
427Box<Vec2<T> >::operator == (const Box<Vec2<T> > &src) const 
428{ 
429 return (min == src.min && max == src.max); 
430} 
431 
432 
433template <class T> 
434inline bool 
435Box<Vec2<T> >::operator != (const Box<Vec2<T> > &src) const 
436{ 
437 return (min != src.min || max != src.max); 
438} 
439 
440 
441template <class T> 
442inline void Box<Vec2<T> >::makeEmpty() 
443{ 
444 min = Vec2<T>(Vec2<T>::baseTypeMax()); 
445 max = Vec2<T>(Vec2<T>::baseTypeMin()); 
446} 
447 
448template <class T> 
449inline void Box<Vec2<T> >::makeInfinite() 
450{ 
451 min = Vec2<T>(Vec2<T>::baseTypeMin()); 
452 max = Vec2<T>(Vec2<T>::baseTypeMax()); 
453} 
454 
455 
456template <class T> 
457inline void 
458Box<Vec2<T> >::extendBy (const Vec2<T> &point) 
459{ 
460 if (point[0] < min[0]) 
461 min[0] = point[0]; 
462 
463 if (point[0] > max[0]) 
464 max[0] = point[0]; 
465 
466 if (point[1] < min[1]) 
467 min[1] = point[1]; 
468 
469 if (point[1] > max[1]) 
470 max[1] = point[1]; 
471} 
472 
473 
474template <class T> 
475inline void 
476Box<Vec2<T> >::extendBy (const Box<Vec2<T> > &box) 
477{ 
478 if (box.min[0] < min[0]) 
479 min[0] = box.min[0]; 
480 
481 if (box.max[0] > max[0]) 
482 max[0] = box.max[0]; 
483 
484 if (box.min[1] < min[1]) 
485 min[1] = box.min[1]; 
486 
487 if (box.max[1] > max[1]) 
488 max[1] = box.max[1]; 
489} 
490 
491 
492template <class T> 
493inline bool 
494Box<Vec2<T> >::intersects (const Vec2<T> &point) const 
495{ 
496 if (point[0] < min[0] || point[0] > max[0] || 
497 point[1] < min[1] || point[1] > max[1]) 
498 return false; 
499 
500 return true; 
501} 
502 
503 
504template <class T> 
505inline bool 
506Box<Vec2<T> >::intersects (const Box<Vec2<T> > &box) const 
507{ 
508 if (box.max[0] < min[0] || box.min[0] > max[0] || 
509 box.max[1] < min[1] || box.min[1] > max[1]) 
510 return false; 
511 
512 return true; 
513} 
514 
515 
516template <class T>  
517inline Vec2<T> 
518Box<Vec2<T> >::size() const  
519{  
520 if (isEmpty()) 
521 return Vec2<T> (0); 
522 
523 return max - min; 
524} 
525 
526 
527template <class T>  
528inline Vec2<T> 
529Box<Vec2<T> >::center() const  
530{  
531 return (max + min) / 2; 
532} 
533 
534 
535template <class T> 
536inline bool 
537Box<Vec2<T> >::isEmpty() const 
538{ 
539 if (max[0] < min[0] || 
540 max[1] < min[1]) 
541 return true; 
542 
543 return false; 
544} 
545 
546template <class T> 
547inline bool 
548Box<Vec2<T> > ::isInfinite() const 
549{ 
550 if (min[0] != limits<T>::min() || max[0] != limits<T>::max() || 
551 min[1] != limits<T>::min() || max[1] != limits<T>::max()) 
552 return false; 
553  
554 return true; 
555} 
556 
557 
558template <class T> 
559inline bool 
560Box<Vec2<T> >::hasVolume() const 
561{ 
562 if (max[0] <= min[0] || 
563 max[1] <= min[1]) 
564 return false; 
565 
566 return true; 
567} 
568 
569 
570template <class T> 
571inline unsigned int 
572Box<Vec2<T> >::majorAxis() const 
573{ 
574 unsigned int major = 0; 
575 Vec2<T> s = size(); 
576 
577 if (s[1] > s[major]) 
578 major = 1; 
579 
580 return major; 
581} 
582 
583 
584template <class T> 
585class Box<Vec3<T> > 
586{ 
587 public: 
588 
589 //------------------------- 
590 // Data Members are public 
591 //------------------------- 
592 
593 Vec3<T> min; 
594 Vec3<T> max; 
595 
596 //----------------------------------------------------- 
597 // Constructors - an "empty" box is created by default 
598 //----------------------------------------------------- 
599 
600 Box();  
601 Box (const Vec3<T> &point); 
602 Box (const Vec3<T> &minT, const Vec3<T> &maxT); 
603 
604 //-------------------- 
605 // Operators: ==, != 
606 //-------------------- 
607 
608 bool operator == (const Box<Vec3<T> > &src) const; 
609 bool operator != (const Box<Vec3<T> > &src) const; 
610 
611 //------------------ 
612 // Box manipulation 
613 //------------------ 
614 
615 void makeEmpty(); 
616 void extendBy (const Vec3<T> &point); 
617 void extendBy (const Box<Vec3<T> > &box); 
618 void makeInfinite (); 
619 
620 //--------------------------------------------------- 
621 // Query functions - these compute results each time 
622 //--------------------------------------------------- 
623 
624 Vec3<T> size() const; 
625 Vec3<T> center() const; 
626 bool intersects (const Vec3<T> &point) const; 
627 bool intersects (const Box<Vec3<T> > &box) const; 
628 
629 unsigned int majorAxis() const; 
630 
631 //---------------- 
632 // Classification 
633 //---------------- 
634 
635 bool isEmpty() const; 
636 bool hasVolume() const; 
637 bool isInfinite() const; 
638}; 
639 
640 
641//---------------- 
642// Implementation 
643 
644 
645template <class T> 
646inline Box<Vec3<T> >::Box() 
647{ 
648 makeEmpty(); 
649} 
650 
651 
652template <class T> 
653inline Box<Vec3<T> >::Box (const Vec3<T> &point) 
654{ 
655 min = point; 
656 max = point; 
657} 
658 
659 
660template <class T> 
661inline Box<Vec3<T> >::Box (const Vec3<T> &minT, const Vec3<T> &maxT) 
662{ 
663 min = minT; 
664 max = maxT; 
665} 
666 
667 
668template <class T> 
669inline bool 
670Box<Vec3<T> >::operator == (const Box<Vec3<T> > &src) const 
671{ 
672 return (min == src.min && max == src.max); 
673} 
674 
675 
676template <class T> 
677inline bool 
678Box<Vec3<T> >::operator != (const Box<Vec3<T> > &src) const 
679{ 
680 return (min != src.min || max != src.max); 
681} 
682 
683 
684template <class T> 
685inline void Box<Vec3<T> >::makeEmpty() 
686{ 
687 min = Vec3<T>(Vec3<T>::baseTypeMax()); 
688 max = Vec3<T>(Vec3<T>::baseTypeMin()); 
689} 
690 
691template <class T> 
692inline void Box<Vec3<T> >::makeInfinite() 
693{ 
694 min = Vec3<T>(Vec3<T>::baseTypeMin()); 
695 max = Vec3<T>(Vec3<T>::baseTypeMax()); 
696} 
697 
698 
699template <class T> 
700inline void 
701Box<Vec3<T> >::extendBy (const Vec3<T> &point) 
702{ 
703 if (point[0] < min[0]) 
704 min[0] = point[0]; 
705 
706 if (point[0] > max[0]) 
707 max[0] = point[0]; 
708 
709 if (point[1] < min[1]) 
710 min[1] = point[1]; 
711 
712 if (point[1] > max[1]) 
713 max[1] = point[1]; 
714 
715 if (point[2] < min[2]) 
716 min[2] = point[2]; 
717 
718 if (point[2] > max[2]) 
719 max[2] = point[2]; 
720} 
721 
722 
723template <class T> 
724inline void 
725Box<Vec3<T> >::extendBy (const Box<Vec3<T> > &box) 
726{ 
727 if (box.min[0] < min[0]) 
728 min[0] = box.min[0]; 
729 
730 if (box.max[0] > max[0]) 
731 max[0] = box.max[0]; 
732 
733 if (box.min[1] < min[1]) 
734 min[1] = box.min[1]; 
735 
736 if (box.max[1] > max[1]) 
737 max[1] = box.max[1]; 
738 
739 if (box.min[2] < min[2]) 
740 min[2] = box.min[2]; 
741 
742 if (box.max[2] > max[2]) 
743 max[2] = box.max[2]; 
744} 
745 
746 
747template <class T> 
748inline bool 
749Box<Vec3<T> >::intersects (const Vec3<T> &point) const 
750{ 
751 if (point[0] < min[0] || point[0] > max[0] || 
752 point[1] < min[1] || point[1] > max[1] || 
753 point[2] < min[2] || point[2] > max[2]) 
754 return false; 
755 
756 return true; 
757} 
758 
759 
760template <class T> 
761inline bool 
762Box<Vec3<T> >::intersects (const Box<Vec3<T> > &box) const 
763{ 
764 if (box.max[0] < min[0] || box.min[0] > max[0] || 
765 box.max[1] < min[1] || box.min[1] > max[1] || 
766 box.max[2] < min[2] || box.min[2] > max[2]) 
767 return false; 
768 
769 return true; 
770} 
771 
772 
773template <class T>  
774inline Vec3<T> 
775Box<Vec3<T> >::size() const  
776{  
777 if (isEmpty()) 
778 return Vec3<T> (0); 
779 
780 return max - min; 
781} 
782 
783 
784template <class T>  
785inline Vec3<T> 
786Box<Vec3<T> >::center() const  
787{  
788 return (max + min) / 2; 
789} 
790 
791 
792template <class T> 
793inline bool 
794Box<Vec3<T> >::isEmpty() const 
795{ 
796 if (max[0] < min[0] || 
797 max[1] < min[1] || 
798 max[2] < min[2]) 
799 return true; 
800 
801 return false; 
802} 
803 
804template <class T> 
805inline bool 
806Box<Vec3<T> >::isInfinite() const 
807{ 
808 if (min[0] != limits<T>::min() || max[0] != limits<T>::max() || 
809 min[1] != limits<T>::min() || max[1] != limits<T>::max() || 
810 min[2] != limits<T>::min() || max[2] != limits<T>::max()) 
811 return false; 
812  
813 return true; 
814} 
815 
816 
817template <class T> 
818inline bool 
819Box<Vec3<T> >::hasVolume() const 
820{ 
821 if (max[0] <= min[0] || 
822 max[1] <= min[1] || 
823 max[2] <= min[2]) 
824 return false; 
825 
826 return true; 
827} 
828 
829 
830template <class T> 
831inline unsigned int 
832Box<Vec3<T> >::majorAxis() const 
833{ 
834 unsigned int major = 0; 
835 Vec3<T> s = size(); 
836 
837 if (s[1] > s[major]) 
838 major = 1; 
839 
840 if (s[2] > s[major]) 
841 major = 2; 
842 
843 return major; 
844} 
845 
846 
847IMATH_INTERNAL_NAMESPACE_HEADER_EXIT 
848 
849#endif // INCLUDED_IMATHBOX_H 
850