HDK
ImathBox.h
Go to the documentation of this file.
1 //
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 //
7 // Axis-aligned bounding box
8 //
9
10 #ifndef INCLUDED_IMATHBOX_H
11 #define INCLUDED_IMATHBOX_H
12
13 #include "ImathExport.h"
14 #include "ImathNamespace.h"
15
16 #include "ImathVec.h"
17
19
20 ///
21 /// The `Box<V>` template represents an axis-aligned bounding box defined by
22 /// minimum and maximum values of type `V`. The `min` and `max` members are
23 /// public.
24 ///
25 /// The type `V` is typically an Imath vector (i.e. `V2i`, `V3f`, etc) and must
26 /// implement an index `operator[]` that returns a type (typically as scalar)
27 /// that supports assignment, comparison, and arithmetic operators.
28 ///
29 /// `V` must also provide a constructor that takes a float and/or double for
30 /// use in initializing the box.
31 ///
32 /// `V` must also provide a function `V::dimensions()` which returns the
33 /// number of dimensions in the class (since its assumed its a vector) --
34 /// preferably, this returns a constant expression, typically 2 or 3.
35 ///
36
37 template <class V> class IMATH_EXPORT_TEMPLATE_TYPE Box
38 {
39  public:
40
41  /// @{
43
44  /// The minimum value of the box.
45  V min;
46
47  /// The maximum value of the box.
48  V max;
49
50  /// @}
51
52  /// @{
53  /// @name Constructors
54
55  /// Construct an empty bounding box. This initializes the mimimum to
56  /// std::numeric_limits<V::baseType>::max() and the maximum to
57  /// std::numeric_limits<V::baseType>::lowest().
58  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box() IMATH_NOEXCEPT;
59
60  /// Construct a bounding box that contains a single point.
61  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const V& point) IMATH_NOEXCEPT;
62
63  /// Construct a bounding box with the given minimum and maximum values.
64  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const V& minV, const V& maxV) IMATH_NOEXCEPT;
65
66  /// @}
67
68  /// @{
69  /// @name Comparison
70
71  /// Equality
72  IMATH_HOSTDEVICE constexpr bool operator== (const Box<V>& src) const IMATH_NOEXCEPT;
73
74  /// Inequality
75  IMATH_HOSTDEVICE constexpr bool operator!= (const Box<V>& src) const IMATH_NOEXCEPT;
76
77  /// @}
78
79  /// @{
80  /// @name Manipulation
81
82  /// Set the box to be empty. A box is empty if the mimimum is greater
83  /// than the maximum. makeEmpty() sets the mimimum to `V::baseTypeMax()`
84  /// and the maximum to `V::baseTypeLowest()`.
85  IMATH_HOSTDEVICE void makeEmpty() IMATH_NOEXCEPT;
86
87  /// Extend the box to include the given point.
88  IMATH_HOSTDEVICE void extendBy (const V& point) IMATH_NOEXCEPT;
89
90  /// Extend the box to include the given box.
91  IMATH_HOSTDEVICE void extendBy (const Box<V>& box) IMATH_NOEXCEPT;
92
93  /// Make the box include the entire range of `V`.
94  IMATH_HOSTDEVICE void makeInfinite() IMATH_NOEXCEPT;
95
96  /// @}
97
98  /// @{
99  /// @name Query
100
101  /// Return the size of the box. The size is of type `V`, defined
102  /// as `(max-min)`. An empty box has a size of `V(0)`, i.e. 0 in
103  /// each dimension.
104  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 V size() const IMATH_NOEXCEPT;
105
106  /// Return the center of the box. The center is defined as
107  /// `(max+min)/2`. The center of an empty box is undefined.
108  IMATH_HOSTDEVICE constexpr V center() const IMATH_NOEXCEPT;
109
110  /// Return true if the given point is inside the box, false otherwise.
111  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const V& point) const IMATH_NOEXCEPT;
112
113  /// Return true if the given box is inside the box, false otherwise.
114  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Box<V>& box) const IMATH_NOEXCEPT;
115
116  /// Return the major axis of the box. The major axis is the dimension with
117  /// the greatest difference between maximum and minimum.
118  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 unsigned int majorAxis() const IMATH_NOEXCEPT;
119
120  /// Return true if the box is empty, false otherwise. An empty box's
121  /// minimum is greater than its maximum.
122  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isEmpty() const IMATH_NOEXCEPT;
123
124  /// Return true if the box is larger than a single point, false otherwise.
125  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool hasVolume() const IMATH_NOEXCEPT;
126
127  /// Return true if the box contains all points, false otherwise.
128  /// An infinite box has a mimimum of`V::baseTypeLowest()`
129  /// and a maximum of `V::baseTypeMax()`.
130  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isInfinite() const IMATH_NOEXCEPT;
131
132  /// @}
133 };
134
135 //--------------------
136 // Convenient typedefs
137 //--------------------
138
139 /// 2D box of base type `short`.
140 typedef Box<V2s> Box2s;
141
142 /// 2D box of base type `int`.
143 typedef Box<V2i> Box2i;
144
145 /// 2D box of base type `int64_t`.
146 typedef Box<V2i64> Box2i64;
147
148 /// 2D box of base type `float`.
149 typedef Box<V2f> Box2f;
150
151 /// 2D box of base type `double`.
152 typedef Box<V2d> Box2d;
153
154 /// 3D box of base type `short`.
155 typedef Box<V3s> Box3s;
156
157 /// 3D box of base type `int`.
158 typedef Box<V3i> Box3i;
159
160 /// 3D box of base type `int64_t`.
161 typedef Box<V3i64> Box3i64;
162
163 /// 3D box of base type `float`.
164 typedef Box<V3f> Box3f;
165
166 /// 3D box of base type `double`.
167 typedef Box<V3d> Box3d;
168
169 template <class V>
170 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<V>::Box() IMATH_NOEXCEPT
171 {
172  makeEmpty();
173 }
174
175 template <class V>
176 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<V>::Box (const V& point) IMATH_NOEXCEPT
177 {
178  min = point;
179  max = point;
180 }
181
182 template <class V>
183 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<V>::Box (const V& minV, const V& maxV) IMATH_NOEXCEPT
184 {
185  min = minV;
186  max = maxV;
187 }
188
189 template <class V>
190 IMATH_HOSTDEVICE constexpr inline bool
192 {
193  return (min == src.min && max == src.max);
194 }
195
196 template <class V>
197 IMATH_HOSTDEVICE constexpr inline bool
199 {
200  return (min != src.min || max != src.max);
201 }
202
203 template <class V>
204 IMATH_HOSTDEVICE inline void
206 {
207  min = V (V::baseTypeMax());
208  max = V (V::baseTypeLowest());
209 }
210
211 template <class V>
212 IMATH_HOSTDEVICE inline void
214 {
215  min = V (V::baseTypeLowest());
216  max = V (V::baseTypeMax());
217 }
218
219 template <class V>
220 IMATH_HOSTDEVICE inline void
222 {
223  for (unsigned int i = 0; i < min.dimensions(); i++)
224  {
225  if (point[i] < min[i])
226  min[i] = point[i];
227
228  if (point[i] > max[i])
229  max[i] = point[i];
230  }
231 }
232
233 template <class V>
234 IMATH_HOSTDEVICE inline void
236 {
237  for (unsigned int i = 0; i < min.dimensions(); i++)
238  {
239  if (box.min[i] < min[i])
240  min[i] = box.min[i];
241
242  if (box.max[i] > max[i])
243  max[i] = box.max[i];
244  }
245 }
246
247 template <class V>
248 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
249 Box<V>::intersects (const V& point) const IMATH_NOEXCEPT
250 {
251  for (unsigned int i = 0; i < min.dimensions(); i++)
252  {
253  if (point[i] < min[i] || point[i] > max[i])
254  return false;
255  }
256
257  return true;
258 }
259
260 template <class V>
261 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
263 {
264  for (unsigned int i = 0; i < min.dimensions(); i++)
265  {
266  if (box.max[i] < min[i] || box.min[i] > max[i])
267  return false;
268  }
269
270  return true;
271 }
272
273 template <class V>
274 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline V
276 {
277  if (isEmpty())
278  return V (0);
279
280  return max - min;
281 }
282
283 template <class V>
284 IMATH_HOSTDEVICE constexpr inline V
286 {
287  return (max + min) / 2;
288 }
289
290 template <class V>
291 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
293 {
294  for (unsigned int i = 0; i < min.dimensions(); i++)
295  {
296  if (max[i] < min[i])
297  return true;
298  }
299
300  return false;
301 }
302
303 template <class V>
304 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
306 {
307  for (unsigned int i = 0; i < min.dimensions(); i++)
308  {
309  if (min[i] != V::baseTypeLowest() || max[i] != V::baseTypeMax())
310  return false;
311  }
312
313  return true;
314 }
315
316 template <class V>
317 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
319 {
320  for (unsigned int i = 0; i < min.dimensions(); i++)
321  {
322  if (max[i] <= min[i])
323  return false;
324  }
325
326  return true;
327 }
328
329 template <class V>
330 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline unsigned int
332 {
333  unsigned int major = 0;
334  V s = size();
335
336  for (unsigned int i = 1; i < min.dimensions(); i++)
337  {
338  if (s[i] > s[major])
339  major = i;
340  }
341
342  return major;
343 }
344
345 //-------------------------------------------------------------------
346 //
347 // Partial class specializations for Imath::Vec2<T> and Imath::Vec3<T>
348 //
349 //-------------------------------------------------------------------
350
351 template <typename V> class Box;
352
353 ///
354 /// The Box<Vec2<T>> template represents a 2D bounding box defined by
355 /// minimum and maximum values of type Vec2<T>. The min and max members are
356 /// public.
357 ///
358
359 template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Box<Vec2<T>>
360 {
361  public:
362
363  /// @{
365
366  /// The minimum value of the box.
368
369  /// The maximum value of the box.
371
372  /// @}
373
374  /// @{
375  /// @name Constructors and Assignment
376
377  /// Empty by default
378  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box() IMATH_NOEXCEPT;
379
380  /// Construct a bounding box that contains a single point.
381  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const Vec2<T>& point) IMATH_NOEXCEPT;
382
383  /// Construct a bounding box with the given minimum and maximum points
384  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const Vec2<T>& minT, const Vec2<T>& maxT) IMATH_NOEXCEPT;
385
386  /// @}
387
388  /// @{
389  /// @name Comparison
390
391  /// Equality
392  IMATH_HOSTDEVICE constexpr bool operator== (const Box<Vec2<T>>& src) const IMATH_NOEXCEPT;
393
394  /// Inequality
395  IMATH_HOSTDEVICE constexpr bool operator!= (const Box<Vec2<T>>& src) const IMATH_NOEXCEPT;
396
397  /// @}
398
399  /// @{
400  /// @name Manipulation
401
402  /// Set the Box to be empty. A Box is empty if the mimimum is
403  /// greater than the maximum. makeEmpty() sets the mimimum to
404  /// std::numeric_limits<T>::max() and the maximum to
405  /// std::numeric_limits<T>::lowest().
406  IMATH_HOSTDEVICE void makeEmpty() IMATH_NOEXCEPT;
407
408  /// Extend the Box to include the given point.
409  IMATH_HOSTDEVICE void extendBy (const Vec2<T>& point) IMATH_NOEXCEPT;
410
411  /// Extend the Box to include the given box.
412  IMATH_HOSTDEVICE void extendBy (const Box<Vec2<T>>& box) IMATH_NOEXCEPT;
413
414  /// Make the box include the entire range of T.
415  IMATH_HOSTDEVICE void makeInfinite() IMATH_NOEXCEPT;
416
417  /// @}
418
419  /// @{
420  /// @name Query
421
422  /// Return the size of the box. The size is of type `V`, defined as
423  /// `(max-min)`. An empty box has a size of `V(0)`, i.e. 0 in each dimension.
424  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec2<T> size() const IMATH_NOEXCEPT;
425
426  /// Return the center of the box. The center is defined as
427  /// `(max+min)/2`. The center of an empty box is undefined.
428  IMATH_HOSTDEVICE constexpr Vec2<T> center() const IMATH_NOEXCEPT;
429
430  /// Return true if the given point is inside the box, false otherwise.
431  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Vec2<T>& point) const IMATH_NOEXCEPT;
432
433  /// Return true if the given box is inside the box, false otherwise.
434  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Box<Vec2<T>>& box) const IMATH_NOEXCEPT;
435
436  /// Return the major axis of the box. The major axis is the dimension with
437  /// the greatest difference between maximum and minimum.
438  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 unsigned int majorAxis() const IMATH_NOEXCEPT;
439
440  /// Return true if the box is empty, false otherwise. An empty box's
441  /// minimum is greater than its maximum.
442  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isEmpty() const IMATH_NOEXCEPT;
443
444  /// Return true if the box is larger than a single point, false otherwise.
445  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool hasVolume() const IMATH_NOEXCEPT;
446
447  /// Return true if the box contains all points, false otherwise.
448  /// An infinite box has a mimimum of `V::baseTypeMin()`
449  /// and a maximum of `V::baseTypeMax()`.
450  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isInfinite() const IMATH_NOEXCEPT;
451
452  /// @}
453 };
454
455 //----------------
456 // Implementation
457 //----------------
458
459 template <class T> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<Vec2<T>>::Box() IMATH_NOEXCEPT
460 {
461  makeEmpty();
462 }
463
464 template <class T> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<Vec2<T>>::Box (const Vec2<T>& point) IMATH_NOEXCEPT
465 {
466  min = point;
467  max = point;
468 }
469
470 template <class T>
471 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<Vec2<T>>::Box (const Vec2<T>& minT, const Vec2<T>& maxT) IMATH_NOEXCEPT
472 {
473  min = minT;
474  max = maxT;
475 }
476
477 template <class T>
478 IMATH_HOSTDEVICE constexpr inline bool
479 Box<Vec2<T>>::operator== (const Box<Vec2<T>>& src) const IMATH_NOEXCEPT
480 {
481  return (min == src.min && max == src.max);
482 }
483
484 template <class T>
485 IMATH_HOSTDEVICE constexpr inline bool
486 Box<Vec2<T>>::operator!= (const Box<Vec2<T>>& src) const IMATH_NOEXCEPT
487 {
488  return (min != src.min || max != src.max);
489 }
490
491 template <class T>
492 IMATH_HOSTDEVICE inline void
494 {
497 }
498
499 template <class T>
500 IMATH_HOSTDEVICE inline void
501 Box<Vec2<T>>::makeInfinite() IMATH_NOEXCEPT
502 {
505 }
506
507 template <class T>
508 IMATH_HOSTDEVICE inline void
509 Box<Vec2<T>>::extendBy (const Vec2<T>& point) IMATH_NOEXCEPT
510 {
511  if (point[0] < min[0])
512  min[0] = point[0];
513
514  if (point[0] > max[0])
515  max[0] = point[0];
516
517  if (point[1] < min[1])
518  min[1] = point[1];
519
520  if (point[1] > max[1])
521  max[1] = point[1];
522 }
523
524 template <class T>
525 IMATH_HOSTDEVICE inline void
526 Box<Vec2<T>>::extendBy (const Box<Vec2<T>>& box) IMATH_NOEXCEPT
527 {
528  if (box.min[0] < min[0])
529  min[0] = box.min[0];
530
531  if (box.max[0] > max[0])
532  max[0] = box.max[0];
533
534  if (box.min[1] < min[1])
535  min[1] = box.min[1];
536
537  if (box.max[1] > max[1])
538  max[1] = box.max[1];
539 }
540
541 template <class T>
542 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
544 {
545  if (point[0] < min[0] || point[0] > max[0] || point[1] < min[1] || point[1] > max[1])
546  return false;
547
548  return true;
549 }
550
551 template <class T>
552 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
554 {
555  if (box.max[0] < min[0] || box.min[0] > max[0] || box.max[1] < min[1] || box.min[1] > max[1])
556  return false;
557
558  return true;
559 }
560
561 template <class T>
562 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec2<T>
564 {
565  if (isEmpty())
566  return Vec2<T> (0);
567
568  return max - min;
569 }
570
571 template <class T>
572 IMATH_HOSTDEVICE constexpr inline Vec2<T>
574 {
575  return (max + min) / 2;
576 }
577
578 template <class T>
579 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
580 Box<Vec2<T>>::isEmpty() const IMATH_NOEXCEPT
581 {
582  if (max[0] < min[0] || max[1] < min[1])
583  return true;
584
585  return false;
586 }
587
588 template <class T>
589 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
591 {
592  if (min[0] != std::numeric_limits<T>::lowest() ||
594  min[1] != std::numeric_limits<T>::lowest() ||
596  return false;
597
598  return true;
599 }
600
601 template <class T>
602 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
603 Box<Vec2<T>>::hasVolume() const IMATH_NOEXCEPT
604 {
605  if (max[0] <= min[0] || max[1] <= min[1])
606  return false;
607
608  return true;
609 }
610
611 template <class T>
612 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline unsigned int
613 Box<Vec2<T>>::majorAxis() const IMATH_NOEXCEPT
614 {
615  unsigned int major = 0;
616  Vec2<T> s = size();
617
618  if (s[1] > s[major])
619  major = 1;
620
621  return major;
622 }
623
624 ///
625 /// The Box<Vec3> template represents a 3D bounding box defined by
626 /// minimum and maximum values of type Vec3.
627 ///
628 template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Box<Vec3<T>>
629 {
630  public:
631
632  /// @{
634
635  /// The minimum value of the box.
637
638  /// The maximum value of the box.
640
641  /// @}
642
643  /// @{
644  /// @name Constructors
645
646  /// Empty by default
647  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box() IMATH_NOEXCEPT;
648
649  /// Construct a bounding box that contains a single point.
650  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const Vec3<T>& point) IMATH_NOEXCEPT;
651
652  /// Construct a bounding box with the given minimum and maximum points
653  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const Vec3<T>& minT, const Vec3<T>& maxT) IMATH_NOEXCEPT;
654
655  /// @}
656
657  /// Equality
658  IMATH_HOSTDEVICE constexpr bool operator== (const Box<Vec3<T>>& src) const IMATH_NOEXCEPT;
659
660  /// Inequality
661  IMATH_HOSTDEVICE constexpr bool operator!= (const Box<Vec3<T>>& src) const IMATH_NOEXCEPT;
662
663  /// Set the Box to be empty. A Box is empty if the mimimum is
664  /// greater than the maximum. makeEmpty() sets the mimimum to
665  /// std::numeric_limits<T>::max() and the maximum to
666  /// std::numeric_limits<T>::lowest().
667  IMATH_HOSTDEVICE void makeEmpty() IMATH_NOEXCEPT;
668
669  /// Extend the Box to include the given point.
670  IMATH_HOSTDEVICE void extendBy (const Vec3<T>& point) IMATH_NOEXCEPT;
671  /// Extend the Box to include the given box.
672
673  IMATH_HOSTDEVICE void extendBy (const Box<Vec3<T>>& box) IMATH_NOEXCEPT;
674
675  /// Make the box include the entire range of T.
676  IMATH_HOSTDEVICE void makeInfinite() IMATH_NOEXCEPT;
677
678  /// Return the size of the box. The size is of type `V`, defined as
679  /// (max-min). An empty box has a size of V(0), i.e. 0 in each dimension.
680  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3<T> size() const IMATH_NOEXCEPT;
681
682  /// Return the center of the box. The center is defined as
683  /// (max+min)/2. The center of an empty box is undefined.
684  IMATH_HOSTDEVICE constexpr Vec3<T> center() const IMATH_NOEXCEPT;
685
686  /// Return true if the given point is inside the box, false otherwise.
687  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Vec3<T>& point) const IMATH_NOEXCEPT;
688
689  /// Return true if the given box is inside the box, false otherwise.
690  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Box<Vec3<T>>& box) const IMATH_NOEXCEPT;
691
692  /// Return the major axis of the box. The major axis is the dimension with
693  /// the greatest difference between maximum and minimum.
694  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 unsigned int majorAxis() const IMATH_NOEXCEPT;
695
696  /// Return true if the box is empty, false otherwise. An empty box's
697  /// minimum is greater than its maximum.
698  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isEmpty() const IMATH_NOEXCEPT;
699
700  /// Return true if the box is larger than a single point, false otherwise.
701  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool hasVolume() const IMATH_NOEXCEPT;
702
703  /// Return true if the box contains all points, false otherwise.
704  /// An infinite box has a mimimum of`V::baseTypeMin()`
705  /// and a maximum of `V::baseTypeMax()`.
706  IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isInfinite() const IMATH_NOEXCEPT;
707 };
708
709 //----------------
710 // Implementation
711 //----------------
712
713 template <class T> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<Vec3<T>>::Box() IMATH_NOEXCEPT
714 {
715  makeEmpty();
716 }
717
718 template <class T> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<Vec3<T>>::Box (const Vec3<T>& point) IMATH_NOEXCEPT
719 {
720  min = point;
721  max = point;
722 }
723
724 template <class T>
725 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box<Vec3<T>>::Box (const Vec3<T>& minT, const Vec3<T>& maxT) IMATH_NOEXCEPT
726 {
727  min = minT;
728  max = maxT;
729 }
730
731 template <class T>
732 IMATH_HOSTDEVICE constexpr inline bool
733 Box<Vec3<T>>::operator== (const Box<Vec3<T>>& src) const IMATH_NOEXCEPT
734 {
735  return (min == src.min && max == src.max);
736 }
737
738 template <class T>
739 IMATH_HOSTDEVICE constexpr inline bool
740 Box<Vec3<T>>::operator!= (const Box<Vec3<T>>& src) const IMATH_NOEXCEPT
741 {
742  return (min != src.min || max != src.max);
743 }
744
745 template <class T>
746 IMATH_HOSTDEVICE inline void
748 {
751 }
752
753 template <class T>
754 IMATH_HOSTDEVICE inline void
755 Box<Vec3<T>>::makeInfinite() IMATH_NOEXCEPT
756 {
759 }
760
761 template <class T>
762 IMATH_HOSTDEVICE inline void
763 Box<Vec3<T>>::extendBy (const Vec3<T>& point) IMATH_NOEXCEPT
764 {
765  if (point[0] < min[0])
766  min[0] = point[0];
767
768  if (point[0] > max[0])
769  max[0] = point[0];
770
771  if (point[1] < min[1])
772  min[1] = point[1];
773
774  if (point[1] > max[1])
775  max[1] = point[1];
776
777  if (point[2] < min[2])
778  min[2] = point[2];
779
780  if (point[2] > max[2])
781  max[2] = point[2];
782 }
783
784 template <class T>
785 IMATH_HOSTDEVICE inline void
786 Box<Vec3<T>>::extendBy (const Box<Vec3<T>>& box) IMATH_NOEXCEPT
787 {
788  if (box.min[0] < min[0])
789  min[0] = box.min[0];
790
791  if (box.max[0] > max[0])
792  max[0] = box.max[0];
793
794  if (box.min[1] < min[1])
795  min[1] = box.min[1];
796
797  if (box.max[1] > max[1])
798  max[1] = box.max[1];
799
800  if (box.min[2] < min[2])
801  min[2] = box.min[2];
802
803  if (box.max[2] > max[2])
804  max[2] = box.max[2];
805 }
806
807 template <class T>
808 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
810 {
811  if (point[0] < min[0] || point[0] > max[0] || point[1] < min[1] || point[1] > max[1] ||
812  point[2] < min[2] || point[2] > max[2])
813  return false;
814
815  return true;
816 }
817
818 template <class T>
819 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
821 {
822  if (box.max[0] < min[0] || box.min[0] > max[0] || box.max[1] < min[1] || box.min[1] > max[1] ||
823  box.max[2] < min[2] || box.min[2] > max[2])
824  return false;
825
826  return true;
827 }
828
829 template <class T>
830 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec3<T>
832 {
833  if (isEmpty())
834  return Vec3<T> (0);
835
836  return max - min;
837 }
838
839 template <class T>
840 IMATH_HOSTDEVICE constexpr inline Vec3<T>
842 {
843  return (max + min) / 2;
844 }
845
846 template <class T>
847 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
848 Box<Vec3<T>>::isEmpty() const IMATH_NOEXCEPT
849 {
850  if (max[0] < min[0] || max[1] < min[1] || max[2] < min[2])
851  return true;
852
853  return false;
854 }
855
856 template <class T>
857 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
859 {
860  if (min[0] != std::numeric_limits<T>::lowest() ||
862  min[1] != std::numeric_limits<T>::lowest() ||
864  min[2] != std::numeric_limits<T>::lowest() ||
866  return false;
867
868  return true;
869 }
870
871 template <class T>
872 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
873 Box<Vec3<T>>::hasVolume() const IMATH_NOEXCEPT
874 {
875  if (max[0] <= min[0] || max[1] <= min[1] || max[2] <= min[2])
876  return false;
877
878  return true;
879 }
880
881 template <class T>
882 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline unsigned int
883 Box<Vec3<T>>::majorAxis() const IMATH_NOEXCEPT
884 {
885  unsigned int major = 0;
886  Vec3<T> s = size();
887
888  if (s[1] > s[major])
889  major = 1;
890
891  if (s[2] > s[major])
892  major = 2;
893
894  return major;
895 }
896
898
899 #endif // INCLUDED_IMATHBOX_H
IMATH_HOSTDEVICE constexpr bool operator!=(const Box< V > &src) const IMATH_NOEXCEPT
Inequality.
Definition: ImathBox.h:198
Vec2< T > max
The maximum value of the box.
Definition: ImathBox.h:370
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 V size() const IMATH_NOEXCEPT
Definition: ImathBox.h:275
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects(const V &point) const IMATH_NOEXCEPT
Return true if the given point is inside the box, false otherwise.
Definition: ImathBox.h:249
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box() IMATH_NOEXCEPT
Definition: ImathBox.h:170
#define IMATH_NOEXCEPT
Definition: ImathConfig.h:72
Definition: ImathVec.h:32
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the and then *wait for them to all complete We provide a helper class
Vec2< T > min
The minimum value of the box.
Definition: ImathBox.h:367
IMATH_HOSTDEVICE void makeEmpty() IMATH_NOEXCEPT
Definition: ImathBox.h:205
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isEmpty() const IMATH_NOEXCEPT
Definition: ImathBox.h:292
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 unsigned int majorAxis() const IMATH_NOEXCEPT
Definition: ImathBox.h:331
IMATH_HOSTDEVICE void extendBy(const V &point) IMATH_NOEXCEPT
Extend the box to include the given point.
Definition: ImathBox.h:221
GLdouble s
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
#define IMATH_HOSTDEVICE
Definition: ImathConfig.h:102
IMATH_HOSTDEVICE void makeInfinite() IMATH_NOEXCEPT
Make the box include the entire range of V.
Definition: ImathBox.h:213
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isInfinite() const IMATH_NOEXCEPT
Definition: ImathBox.h:305
V max
The maximum value of the box.
Definition: ImathBox.h:48
bool isInfinite(const float x)
Return true if x is an infinity value (either positive infinity or negative infinity).
Definition: Math.h:385
Vec3< T > max
The maximum value of the box.
Definition: ImathBox.h:639
V min
The minimum value of the box.
Definition: ImathBox.h:45
Vec3< T > min
The minimum value of the box.
Definition: ImathBox.h:636
IMATH_HOSTDEVICE static constexpr T baseTypeMax() IMATH_NOEXCEPT
Largest possible positive value.
Definition: ImathVec.h:277
IMATH_HOSTDEVICE static constexpr T baseTypeMax() IMATH_NOEXCEPT
Largest possible positive value.
Definition: ImathVec.h:549
IMATH_HOSTDEVICE static constexpr T baseTypeLowest() IMATH_NOEXCEPT
Largest possible negative value.
Definition: ImathVec.h:274
GLsizeiptr size
Definition: glcorearb.h:664
UT_BoxT< FT > Box
Definition: UT_RTreeImpl.h:674
Definition: ImathVec.h:31
IMATH_HOSTDEVICE constexpr bool operator==(const Box< V > &src) const IMATH_NOEXCEPT
Equality.
Definition: ImathBox.h:191
IMATH_HOSTDEVICE static constexpr T baseTypeLowest() IMATH_NOEXCEPT
Largest possible negative value.
Definition: ImathVec.h:546
#define IMATH_EXPORT_TEMPLATE_TYPE
Definition: ImathExport.h:60
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
IMATH_HOSTDEVICE constexpr V center() const IMATH_NOEXCEPT
Definition: ImathBox.h:285
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool hasVolume() const IMATH_NOEXCEPT
Return true if the box is larger than a single point, false otherwise.
Definition: ImathBox.h:318
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects(const Box< Vec3< T >> &b, const Line3< T > &r, Vec3< T > &ip) IMATH_NOEXCEPT
Definition: ImathBoxAlgo.h:642
Definition: ImathBox.h:37
GLenum src
Definition: glcorearb.h:1793