1// Copyright 2013 The Servo Project Developers. See the COPYRIGHT
2// file at the top-level directory of this distribution.
3//
4// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
5// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
7// option. This file may not be copied, modified, or distributed
8// except according to those terms.
9
10use super::UnknownUnit;
11use crate::approxord::{max, min};
12use crate::num::*;
13use crate::point::{point3, Point3D};
14use crate::scale::Scale;
15use crate::size::Size3D;
16use crate::vector::Vector3D;
17
18use num_traits::{NumCast, Float};
19#[cfg(feature = "serde")]
20use serde::{Deserialize, Serialize};
21#[cfg(feature = "bytemuck")]
22use bytemuck::{Zeroable, Pod};
23
24use core::borrow::Borrow;
25use core::cmp::PartialOrd;
26use core::fmt;
27use core::hash::{Hash, Hasher};
28use core::ops::{Add, Div, DivAssign, Mul, MulAssign, Sub, Range};
29
30/// An axis aligned 3D box represented by its minimum and maximum coordinates.
31#[repr(C)]
32#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
33#[cfg_attr(
34 feature = "serde",
35 serde(bound(serialize = "T: Serialize", deserialize = "T: Deserialize<'de>"))
36)]
37pub struct Box3D<T, U> {
38 pub min: Point3D<T, U>,
39 pub max: Point3D<T, U>,
40}
41
42impl<T: Hash, U> Hash for Box3D<T, U> {
43 fn hash<H: Hasher>(&self, h: &mut H) {
44 self.min.hash(state:h);
45 self.max.hash(state:h);
46 }
47}
48
49impl<T: Copy, U> Copy for Box3D<T, U> {}
50
51impl<T: Clone, U> Clone for Box3D<T, U> {
52 fn clone(&self) -> Self {
53 Self::new(self.min.clone(), self.max.clone())
54 }
55}
56
57impl<T: PartialEq, U> PartialEq for Box3D<T, U> {
58 fn eq(&self, other: &Self) -> bool {
59 self.min.eq(&other.min) && self.max.eq(&other.max)
60 }
61}
62
63impl<T: Eq, U> Eq for Box3D<T, U> {}
64
65impl<T: fmt::Debug, U> fmt::Debug for Box3D<T, U> {
66 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
67 f&mut DebugTuple<'_, '_>.debug_tuple(name:"Box3D")
68 .field(&self.min)
69 .field(&self.max)
70 .finish()
71 }
72}
73
74#[cfg(feature = "bytemuck")]
75unsafe impl<T: Zeroable, U> Zeroable for Box3D<T, U> {}
76
77#[cfg(feature = "bytemuck")]
78unsafe impl<T: Pod, U: 'static> Pod for Box3D<T, U> {}
79
80impl<T, U> Box3D<T, U> {
81 /// Constructor.
82 #[inline]
83 pub const fn new(min: Point3D<T, U>, max: Point3D<T, U>) -> Self {
84 Box3D { min, max }
85 }
86
87 /// Creates a Box3D of the given size, at offset zero.
88 #[inline]
89 pub fn from_size(size: Size3D<T, U>) -> Self where T: Zero {
90 Box3D {
91 min: Point3D::zero(),
92 max: point3(x:size.width, y:size.height, z:size.depth),
93 }
94 }
95}
96
97impl<T, U> Box3D<T, U>
98where
99 T: PartialOrd,
100{
101 /// Returns true if the box has a negative volume.
102 ///
103 /// The common interpretation for a negative box is to consider it empty. It can be obtained
104 /// by calculating the intersection of two boxes that do not intersect.
105 #[inline]
106 pub fn is_negative(&self) -> bool {
107 self.max.x < self.min.x || self.max.y < self.min.y || self.max.z < self.min.z
108 }
109
110 /// Returns true if the size is zero, negative or NaN.
111 #[inline]
112 pub fn is_empty(&self) -> bool {
113 !(self.max.x > self.min.x && self.max.y > self.min.y && self.max.z > self.min.z)
114 }
115
116 #[inline]
117 pub fn intersects(&self, other: &Self) -> bool {
118 self.min.x < other.max.x
119 && self.max.x > other.min.x
120 && self.min.y < other.max.y
121 && self.max.y > other.min.y
122 && self.min.z < other.max.z
123 && self.max.z > other.min.z
124 }
125
126 /// Returns `true` if this box3d contains the point. Points are considered
127 /// in the box3d if they are on the front, left or top faces, but outside if they
128 /// are on the back, right or bottom faces.
129 #[inline]
130 pub fn contains(&self, other: Point3D<T, U>) -> bool {
131 self.min.x <= other.x
132 && other.x < self.max.x
133 && self.min.y <= other.y
134 && other.y < self.max.y
135 && self.min.z <= other.z
136 && other.z < self.max.z
137 }
138
139 /// Returns `true` if this box3d contains the interior of the other box3d. Always
140 /// returns `true` if other is empty, and always returns `false` if other is
141 /// nonempty but this box3d is empty.
142 #[inline]
143 pub fn contains_box(&self, other: &Self) -> bool {
144 other.is_empty()
145 || (self.min.x <= other.min.x
146 && other.max.x <= self.max.x
147 && self.min.y <= other.min.y
148 && other.max.y <= self.max.y
149 && self.min.z <= other.min.z
150 && other.max.z <= self.max.z)
151 }
152}
153
154impl<T, U> Box3D<T, U>
155where
156 T: Copy + PartialOrd,
157{
158 #[inline]
159 pub fn to_non_empty(&self) -> Option<Self> {
160 if self.is_empty() {
161 return None;
162 }
163
164 Some(*self)
165 }
166
167 #[inline]
168 pub fn intersection(&self, other: &Self) -> Option<Self> {
169 let b = self.intersection_unchecked(other);
170
171 if b.is_empty() {
172 return None;
173 }
174
175 Some(b)
176 }
177
178 pub fn intersection_unchecked(&self, other: &Self) -> Self {
179 let intersection_min = Point3D::new(
180 max(self.min.x, other.min.x),
181 max(self.min.y, other.min.y),
182 max(self.min.z, other.min.z),
183 );
184
185 let intersection_max = Point3D::new(
186 min(self.max.x, other.max.x),
187 min(self.max.y, other.max.y),
188 min(self.max.z, other.max.z),
189 );
190
191 Box3D::new(intersection_min, intersection_max)
192 }
193
194 /// Computes the union of two boxes.
195 ///
196 /// If either of the boxes is empty, the other one is returned.
197 #[inline]
198 pub fn union(&self, other: &Self) -> Self {
199 if other.is_empty() {
200 return *self;
201 }
202 if self.is_empty() {
203 return *other;
204 }
205
206 Box3D::new(
207 Point3D::new(
208 min(self.min.x, other.min.x),
209 min(self.min.y, other.min.y),
210 min(self.min.z, other.min.z),
211 ),
212 Point3D::new(
213 max(self.max.x, other.max.x),
214 max(self.max.y, other.max.y),
215 max(self.max.z, other.max.z),
216 ),
217 )
218 }
219}
220
221impl<T, U> Box3D<T, U>
222where
223 T: Copy + Add<T, Output = T>,
224{
225 /// Returns the same box3d, translated by a vector.
226 #[inline]
227 #[must_use]
228 pub fn translate(&self, by: Vector3D<T, U>) -> Self {
229 Box3D {
230 min: self.min + by,
231 max: self.max + by,
232 }
233 }
234}
235
236impl<T, U> Box3D<T, U>
237where
238 T: Copy + Sub<T, Output = T>,
239{
240 #[inline]
241 pub fn size(&self) -> Size3D<T, U> {
242 Size3D::new(
243 self.max.x - self.min.x,
244 self.max.y - self.min.y,
245 self.max.z - self.min.z,
246 )
247 }
248
249 #[inline]
250 pub fn width(&self) -> T {
251 self.max.x - self.min.x
252 }
253
254 #[inline]
255 pub fn height(&self) -> T {
256 self.max.y - self.min.y
257 }
258
259 #[inline]
260 pub fn depth(&self) -> T {
261 self.max.z - self.min.z
262 }
263}
264
265impl<T, U> Box3D<T, U>
266where
267 T: Copy + Add<T, Output = T> + Sub<T, Output = T>,
268{
269 /// Inflates the box by the specified sizes on each side respectively.
270 #[inline]
271 #[must_use]
272 pub fn inflate(&self, width: T, height: T, depth: T) -> Self {
273 Box3D::new(
274 min:Point3D::new(self.min.x - width, self.min.y - height, self.min.z - depth),
275 max:Point3D::new(self.max.x + width, self.max.y + height, self.max.z + depth),
276 )
277 }
278}
279
280impl<T, U> Box3D<T, U>
281where
282 T: Copy + Zero + PartialOrd,
283{
284 /// Returns the smallest box containing all of the provided points.
285 pub fn from_points<I>(points: I) -> Self
286 where
287 I: IntoIterator,
288 I::Item: Borrow<Point3D<T, U>>,
289 {
290 let mut points = points.into_iter();
291
292 let (mut min_x, mut min_y, mut min_z) = match points.next() {
293 Some(first) => first.borrow().to_tuple(),
294 None => return Box3D::zero(),
295 };
296 let (mut max_x, mut max_y, mut max_z) = (min_x, min_y, min_z);
297
298 for point in points {
299 let p = point.borrow();
300 if p.x < min_x {
301 min_x = p.x
302 }
303 if p.x > max_x {
304 max_x = p.x
305 }
306 if p.y < min_y {
307 min_y = p.y
308 }
309 if p.y > max_y {
310 max_y = p.y
311 }
312 if p.z < min_z {
313 min_z = p.z
314 }
315 if p.z > max_z {
316 max_z = p.z
317 }
318 }
319
320 Box3D {
321 min: point3(min_x, min_y, min_z),
322 max: point3(max_x, max_y, max_z),
323 }
324 }
325}
326
327impl<T, U> Box3D<T, U>
328where
329 T: Copy + One + Add<Output = T> + Sub<Output = T> + Mul<Output = T>,
330{
331 /// Linearly interpolate between this box3d and another box3d.
332 #[inline]
333 pub fn lerp(&self, other: Self, t: T) -> Self {
334 Self::new(self.min.lerp(other.min, t), self.max.lerp(other:other.max, t))
335 }
336}
337
338impl<T, U> Box3D<T, U>
339where
340 T: Copy + One + Add<Output = T> + Div<Output = T>,
341{
342 pub fn center(&self) -> Point3D<T, U> {
343 let two: T = T::one() + T::one();
344 (self.min + self.max.to_vector()) / two
345 }
346}
347
348impl<T, U> Box3D<T, U>
349where
350 T: Copy + Mul<T, Output = T> + Sub<T, Output = T>,
351{
352 #[inline]
353 pub fn volume(&self) -> T {
354 let size = self.size();
355 size.width * size.height * size.depth
356 }
357
358 #[inline]
359 pub fn xy_area(&self) -> T {
360 let size = self.size();
361 size.width * size.height
362 }
363
364 #[inline]
365 pub fn yz_area(&self) -> T {
366 let size = self.size();
367 size.depth * size.height
368 }
369
370 #[inline]
371 pub fn xz_area(&self) -> T {
372 let size = self.size();
373 size.depth * size.width
374 }
375}
376
377impl<T, U> Box3D<T, U>
378where
379 T: Zero,
380{
381 /// Constructor, setting all sides to zero.
382 pub fn zero() -> Self {
383 Box3D::new(min:Point3D::zero(), max:Point3D::zero())
384 }
385}
386
387impl<T: Copy + Mul, U> Mul<T> for Box3D<T, U> {
388 type Output = Box3D<T::Output, U>;
389
390 #[inline]
391 fn mul(self, scale: T) -> Self::Output {
392 Box3D::new(self.min * scale, self.max * scale)
393 }
394}
395
396impl<T: Copy + MulAssign, U> MulAssign<T> for Box3D<T, U> {
397 #[inline]
398 fn mul_assign(&mut self, scale: T) {
399 self.min *= scale;
400 self.max *= scale;
401 }
402}
403
404impl<T: Copy + Div, U> Div<T> for Box3D<T, U> {
405 type Output = Box3D<T::Output, U>;
406
407 #[inline]
408 fn div(self, scale: T) -> Self::Output {
409 Box3D::new(self.min / scale.clone(), self.max / scale)
410 }
411}
412
413impl<T: Copy + DivAssign, U> DivAssign<T> for Box3D<T, U> {
414 #[inline]
415 fn div_assign(&mut self, scale: T) {
416 self.min /= scale;
417 self.max /= scale;
418 }
419}
420
421impl<T: Copy + Mul, U1, U2> Mul<Scale<T, U1, U2>> for Box3D<T, U1> {
422 type Output = Box3D<T::Output, U2>;
423
424 #[inline]
425 fn mul(self, scale: Scale<T, U1, U2>) -> Self::Output {
426 Box3D::new(self.min * scale.clone(), self.max * scale)
427 }
428}
429
430impl<T: Copy + MulAssign, U> MulAssign<Scale<T, U, U>> for Box3D<T, U> {
431 #[inline]
432 fn mul_assign(&mut self, scale: Scale<T, U, U>) {
433 self.min *= scale.clone();
434 self.max *= scale;
435 }
436}
437
438impl<T: Copy + Div, U1, U2> Div<Scale<T, U1, U2>> for Box3D<T, U2> {
439 type Output = Box3D<T::Output, U1>;
440
441 #[inline]
442 fn div(self, scale: Scale<T, U1, U2>) -> Self::Output {
443 Box3D::new(self.min / scale.clone(), self.max / scale)
444 }
445}
446
447impl<T: Copy + DivAssign, U> DivAssign<Scale<T, U, U>> for Box3D<T, U> {
448 #[inline]
449 fn div_assign(&mut self, scale: Scale<T, U, U>) {
450 self.min /= scale.clone();
451 self.max /= scale;
452 }
453}
454
455impl<T, U> Box3D<T, U>
456where
457 T: Copy,
458{
459 #[inline]
460 pub fn x_range(&self) -> Range<T> {
461 self.min.x..self.max.x
462 }
463
464 #[inline]
465 pub fn y_range(&self) -> Range<T> {
466 self.min.y..self.max.y
467 }
468
469 #[inline]
470 pub fn z_range(&self) -> Range<T> {
471 self.min.z..self.max.z
472 }
473
474 /// Drop the units, preserving only the numeric value.
475 #[inline]
476 pub fn to_untyped(&self) -> Box3D<T, UnknownUnit> {
477 Box3D {
478 min: self.min.to_untyped(),
479 max: self.max.to_untyped(),
480 }
481 }
482
483 /// Tag a unitless value with units.
484 #[inline]
485 pub fn from_untyped(c: &Box3D<T, UnknownUnit>) -> Box3D<T, U> {
486 Box3D {
487 min: Point3D::from_untyped(c.min),
488 max: Point3D::from_untyped(c.max),
489 }
490 }
491
492 /// Cast the unit
493 #[inline]
494 pub fn cast_unit<V>(&self) -> Box3D<T, V> {
495 Box3D::new(self.min.cast_unit(), self.max.cast_unit())
496 }
497
498 #[inline]
499 pub fn scale<S: Copy>(&self, x: S, y: S, z: S) -> Self
500 where
501 T: Mul<S, Output = T>,
502 {
503 Box3D::new(
504 Point3D::new(self.min.x * x, self.min.y * y, self.min.z * z),
505 Point3D::new(self.max.x * x, self.max.y * y, self.max.z * z),
506 )
507 }
508}
509
510impl<T: NumCast + Copy, U> Box3D<T, U> {
511 /// Cast from one numeric representation to another, preserving the units.
512 ///
513 /// When casting from floating point to integer coordinates, the decimals are truncated
514 /// as one would expect from a simple cast, but this behavior does not always make sense
515 /// geometrically. Consider using round(), round_in or round_out() before casting.
516 #[inline]
517 pub fn cast<NewT: NumCast>(&self) -> Box3D<NewT, U> {
518 Box3D::new(self.min.cast(), self.max.cast())
519 }
520
521 /// Fallible cast from one numeric representation to another, preserving the units.
522 ///
523 /// When casting from floating point to integer coordinates, the decimals are truncated
524 /// as one would expect from a simple cast, but this behavior does not always make sense
525 /// geometrically. Consider using round(), round_in or round_out() before casting.
526 pub fn try_cast<NewT: NumCast>(&self) -> Option<Box3D<NewT, U>> {
527 match (self.min.try_cast(), self.max.try_cast()) {
528 (Some(a), Some(b)) => Some(Box3D::new(a, b)),
529 _ => None,
530 }
531 }
532
533 // Convenience functions for common casts
534
535 /// Cast into an `f32` box3d.
536 #[inline]
537 pub fn to_f32(&self) -> Box3D<f32, U> {
538 self.cast()
539 }
540
541 /// Cast into an `f64` box3d.
542 #[inline]
543 pub fn to_f64(&self) -> Box3D<f64, U> {
544 self.cast()
545 }
546
547 /// Cast into an `usize` box3d, truncating decimals if any.
548 ///
549 /// When casting from floating point cuboids, it is worth considering whether
550 /// to `round()`, `round_in()` or `round_out()` before the cast in order to
551 /// obtain the desired conversion behavior.
552 #[inline]
553 pub fn to_usize(&self) -> Box3D<usize, U> {
554 self.cast()
555 }
556
557 /// Cast into an `u32` box3d, truncating decimals if any.
558 ///
559 /// When casting from floating point cuboids, it is worth considering whether
560 /// to `round()`, `round_in()` or `round_out()` before the cast in order to
561 /// obtain the desired conversion behavior.
562 #[inline]
563 pub fn to_u32(&self) -> Box3D<u32, U> {
564 self.cast()
565 }
566
567 /// Cast into an `i32` box3d, truncating decimals if any.
568 ///
569 /// When casting from floating point cuboids, it is worth considering whether
570 /// to `round()`, `round_in()` or `round_out()` before the cast in order to
571 /// obtain the desired conversion behavior.
572 #[inline]
573 pub fn to_i32(&self) -> Box3D<i32, U> {
574 self.cast()
575 }
576
577 /// Cast into an `i64` box3d, truncating decimals if any.
578 ///
579 /// When casting from floating point cuboids, it is worth considering whether
580 /// to `round()`, `round_in()` or `round_out()` before the cast in order to
581 /// obtain the desired conversion behavior.
582 #[inline]
583 pub fn to_i64(&self) -> Box3D<i64, U> {
584 self.cast()
585 }
586}
587
588impl<T: Float, U> Box3D<T, U> {
589 /// Returns true if all members are finite.
590 #[inline]
591 pub fn is_finite(self) -> bool {
592 self.min.is_finite() && self.max.is_finite()
593 }
594}
595
596impl<T, U> Box3D<T, U>
597where
598 T: Round,
599{
600 /// Return a box3d with edges rounded to integer coordinates, such that
601 /// the returned box3d has the same set of pixel centers as the original
602 /// one.
603 /// Values equal to 0.5 round up.
604 /// Suitable for most places where integral device coordinates
605 /// are needed, but note that any translation should be applied first to
606 /// avoid pixel rounding errors.
607 /// Note that this is *not* rounding to nearest integer if the values are negative.
608 /// They are always rounding as floor(n + 0.5).
609 #[must_use]
610 pub fn round(&self) -> Self {
611 Box3D::new(self.min.round(), self.max.round())
612 }
613}
614
615impl<T, U> Box3D<T, U>
616where
617 T: Floor + Ceil,
618{
619 /// Return a box3d with faces/edges rounded to integer coordinates, such that
620 /// the original box3d contains the resulting box3d.
621 #[must_use]
622 pub fn round_in(&self) -> Self {
623 Box3D {
624 min: self.min.ceil(),
625 max: self.max.floor(),
626 }
627 }
628
629 /// Return a box3d with faces/edges rounded to integer coordinates, such that
630 /// the original box3d is contained in the resulting box3d.
631 #[must_use]
632 pub fn round_out(&self) -> Self {
633 Box3D {
634 min: self.min.floor(),
635 max: self.max.ceil(),
636 }
637 }
638}
639
640impl<T, U> From<Size3D<T, U>> for Box3D<T, U>
641where
642 T: Copy + Zero + PartialOrd,
643{
644 fn from(b: Size3D<T, U>) -> Self {
645 Self::from_size(b)
646 }
647}
648
649impl<T: Default, U> Default for Box3D<T, U> {
650 fn default() -> Self {
651 Box3D {
652 min: Default::default(),
653 max: Default::default(),
654 }
655 }
656}
657
658/// Shorthand for `Box3D::new(Point3D::new(x1, y1, z1), Point3D::new(x2, y2, z2))`.
659pub fn box3d<T: Copy, U>(
660 min_x: T,
661 min_y: T,
662 min_z: T,
663 max_x: T,
664 max_y: T,
665 max_z: T,
666) -> Box3D<T, U> {
667 Box3D::new(
668 min:Point3D::new(min_x, min_y, min_z),
669 max:Point3D::new(max_x, max_y, max_z),
670 )
671}
672
673#[cfg(test)]
674mod tests {
675 use crate::default::{Box3D, Point3D};
676 use crate::{point3, size3, vec3};
677
678 #[test]
679 fn test_new() {
680 let b = Box3D::new(point3(-1.0, -1.0, -1.0), point3(1.0, 1.0, 1.0));
681 assert!(b.min.x == -1.0);
682 assert!(b.min.y == -1.0);
683 assert!(b.min.z == -1.0);
684 assert!(b.max.x == 1.0);
685 assert!(b.max.y == 1.0);
686 assert!(b.max.z == 1.0);
687 }
688
689 #[test]
690 fn test_size() {
691 let b = Box3D::new(point3(-10.0, -10.0, -10.0), point3(10.0, 10.0, 10.0));
692 assert!(b.size().width == 20.0);
693 assert!(b.size().height == 20.0);
694 assert!(b.size().depth == 20.0);
695 }
696
697 #[test]
698 fn test_width_height_depth() {
699 let b = Box3D::new(point3(-10.0, -10.0, -10.0), point3(10.0, 10.0, 10.0));
700 assert!(b.width() == 20.0);
701 assert!(b.height() == 20.0);
702 assert!(b.depth() == 20.0);
703 }
704
705 #[test]
706 fn test_center() {
707 let b = Box3D::new(point3(-10.0, -10.0, -10.0), point3(10.0, 10.0, 10.0));
708 assert!(b.center() == Point3D::zero());
709 }
710
711 #[test]
712 fn test_volume() {
713 let b = Box3D::new(point3(-10.0, -10.0, -10.0), point3(10.0, 10.0, 10.0));
714 assert!(b.volume() == 8000.0);
715 }
716
717 #[test]
718 fn test_area() {
719 let b = Box3D::new(point3(-10.0, -10.0, -10.0), point3(10.0, 10.0, 10.0));
720 assert!(b.xy_area() == 400.0);
721 assert!(b.yz_area() == 400.0);
722 assert!(b.xz_area() == 400.0);
723 }
724
725 #[test]
726 fn test_from_points() {
727 let b = Box3D::from_points(&[point3(50.0, 160.0, 12.5), point3(100.0, 25.0, 200.0)]);
728 assert!(b.min == point3(50.0, 25.0, 12.5));
729 assert!(b.max == point3(100.0, 160.0, 200.0));
730 }
731
732 #[test]
733 fn test_min_max() {
734 let b = Box3D::from_points(&[point3(50.0, 25.0, 12.5), point3(100.0, 160.0, 200.0)]);
735 assert!(b.min.x == 50.0);
736 assert!(b.min.y == 25.0);
737 assert!(b.min.z == 12.5);
738 assert!(b.max.x == 100.0);
739 assert!(b.max.y == 160.0);
740 assert!(b.max.z == 200.0);
741 }
742
743 #[test]
744 fn test_round_in() {
745 let b =
746 Box3D::from_points(&[point3(-25.5, -40.4, -70.9), point3(60.3, 36.5, 89.8)]).round_in();
747 assert!(b.min.x == -25.0);
748 assert!(b.min.y == -40.0);
749 assert!(b.min.z == -70.0);
750 assert!(b.max.x == 60.0);
751 assert!(b.max.y == 36.0);
752 assert!(b.max.z == 89.0);
753 }
754
755 #[test]
756 fn test_round_out() {
757 let b = Box3D::from_points(&[point3(-25.5, -40.4, -70.9), point3(60.3, 36.5, 89.8)])
758 .round_out();
759 assert!(b.min.x == -26.0);
760 assert!(b.min.y == -41.0);
761 assert!(b.min.z == -71.0);
762 assert!(b.max.x == 61.0);
763 assert!(b.max.y == 37.0);
764 assert!(b.max.z == 90.0);
765 }
766
767 #[test]
768 fn test_round() {
769 let b =
770 Box3D::from_points(&[point3(-25.5, -40.4, -70.9), point3(60.3, 36.5, 89.8)]).round();
771 assert!(b.min.x == -25.0);
772 assert!(b.min.y == -40.0);
773 assert!(b.min.z == -71.0);
774 assert!(b.max.x == 60.0);
775 assert!(b.max.y == 37.0);
776 assert!(b.max.z == 90.0);
777 }
778
779 #[test]
780 fn test_from_size() {
781 let b = Box3D::from_size(size3(30.0, 40.0, 50.0));
782 assert!(b.min == Point3D::zero());
783 assert!(b.size().width == 30.0);
784 assert!(b.size().height == 40.0);
785 assert!(b.size().depth == 50.0);
786 }
787
788 #[test]
789 fn test_translate() {
790 let size = size3(15.0, 15.0, 200.0);
791 let mut center = (size / 2.0).to_vector().to_point();
792 let b = Box3D::from_size(size);
793 assert!(b.center() == center);
794 let translation = vec3(10.0, 2.5, 9.5);
795 let b = b.translate(translation);
796 center += translation;
797 assert!(b.center() == center);
798 assert!(b.max.x == 25.0);
799 assert!(b.max.y == 17.5);
800 assert!(b.max.z == 209.5);
801 assert!(b.min.x == 10.0);
802 assert!(b.min.y == 2.5);
803 assert!(b.min.z == 9.5);
804 }
805
806 #[test]
807 fn test_union() {
808 let b1 = Box3D::from_points(&[point3(-20.0, -20.0, -20.0), point3(0.0, 20.0, 20.0)]);
809 let b2 = Box3D::from_points(&[point3(0.0, 20.0, 20.0), point3(20.0, -20.0, -20.0)]);
810 let b = b1.union(&b2);
811 assert!(b.max.x == 20.0);
812 assert!(b.max.y == 20.0);
813 assert!(b.max.z == 20.0);
814 assert!(b.min.x == -20.0);
815 assert!(b.min.y == -20.0);
816 assert!(b.min.z == -20.0);
817 assert!(b.volume() == (40.0 * 40.0 * 40.0));
818 }
819
820 #[test]
821 fn test_intersects() {
822 let b1 = Box3D::from_points(&[point3(-15.0, -20.0, -20.0), point3(10.0, 20.0, 20.0)]);
823 let b2 = Box3D::from_points(&[point3(-10.0, 20.0, 20.0), point3(15.0, -20.0, -20.0)]);
824 assert!(b1.intersects(&b2));
825 }
826
827 #[test]
828 fn test_intersection_unchecked() {
829 let b1 = Box3D::from_points(&[point3(-15.0, -20.0, -20.0), point3(10.0, 20.0, 20.0)]);
830 let b2 = Box3D::from_points(&[point3(-10.0, 20.0, 20.0), point3(15.0, -20.0, -20.0)]);
831 let b = b1.intersection_unchecked(&b2);
832 assert!(b.max.x == 10.0);
833 assert!(b.max.y == 20.0);
834 assert!(b.max.z == 20.0);
835 assert!(b.min.x == -10.0);
836 assert!(b.min.y == -20.0);
837 assert!(b.min.z == -20.0);
838 assert!(b.volume() == (20.0 * 40.0 * 40.0));
839 }
840
841 #[test]
842 fn test_intersection() {
843 let b1 = Box3D::from_points(&[point3(-15.0, -20.0, -20.0), point3(10.0, 20.0, 20.0)]);
844 let b2 = Box3D::from_points(&[point3(-10.0, 20.0, 20.0), point3(15.0, -20.0, -20.0)]);
845 assert!(b1.intersection(&b2).is_some());
846
847 let b1 = Box3D::from_points(&[point3(-15.0, -20.0, -20.0), point3(-10.0, 20.0, 20.0)]);
848 let b2 = Box3D::from_points(&[point3(10.0, 20.0, 20.0), point3(15.0, -20.0, -20.0)]);
849 assert!(b1.intersection(&b2).is_none());
850 }
851
852 #[test]
853 fn test_scale() {
854 let b = Box3D::from_points(&[point3(-10.0, -10.0, -10.0), point3(10.0, 10.0, 10.0)]);
855 let b = b.scale(0.5, 0.5, 0.5);
856 assert!(b.max.x == 5.0);
857 assert!(b.max.y == 5.0);
858 assert!(b.max.z == 5.0);
859 assert!(b.min.x == -5.0);
860 assert!(b.min.y == -5.0);
861 assert!(b.min.z == -5.0);
862 }
863
864 #[test]
865 fn test_zero() {
866 let b = Box3D::<f64>::zero();
867 assert!(b.max.x == 0.0);
868 assert!(b.max.y == 0.0);
869 assert!(b.max.z == 0.0);
870 assert!(b.min.x == 0.0);
871 assert!(b.min.y == 0.0);
872 assert!(b.min.z == 0.0);
873 }
874
875 #[test]
876 fn test_lerp() {
877 let b1 = Box3D::from_points(&[point3(-20.0, -20.0, -20.0), point3(-10.0, -10.0, -10.0)]);
878 let b2 = Box3D::from_points(&[point3(10.0, 10.0, 10.0), point3(20.0, 20.0, 20.0)]);
879 let b = b1.lerp(b2, 0.5);
880 assert!(b.center() == Point3D::zero());
881 assert!(b.size().width == 10.0);
882 assert!(b.size().height == 10.0);
883 assert!(b.size().depth == 10.0);
884 }
885
886 #[test]
887 fn test_contains() {
888 let b = Box3D::from_points(&[point3(-20.0, -20.0, -20.0), point3(20.0, 20.0, 20.0)]);
889 assert!(b.contains(point3(-15.3, 10.5, 18.4)));
890 }
891
892 #[test]
893 fn test_contains_box() {
894 let b1 = Box3D::from_points(&[point3(-20.0, -20.0, -20.0), point3(20.0, 20.0, 20.0)]);
895 let b2 = Box3D::from_points(&[point3(-14.3, -16.5, -19.3), point3(6.7, 17.6, 2.5)]);
896 assert!(b1.contains_box(&b2));
897 }
898
899 #[test]
900 fn test_inflate() {
901 let b = Box3D::from_points(&[point3(-20.0, -20.0, -20.0), point3(20.0, 20.0, 20.0)]);
902 let b = b.inflate(10.0, 5.0, 2.0);
903 assert!(b.size().width == 60.0);
904 assert!(b.size().height == 50.0);
905 assert!(b.size().depth == 44.0);
906 assert!(b.center() == Point3D::zero());
907 }
908
909 #[test]
910 fn test_is_empty() {
911 for i in 0..3 {
912 let mut coords_neg = [-20.0, -20.0, -20.0];
913 let mut coords_pos = [20.0, 20.0, 20.0];
914 coords_neg[i] = 0.0;
915 coords_pos[i] = 0.0;
916 let b = Box3D::from_points(&[Point3D::from(coords_neg), Point3D::from(coords_pos)]);
917 assert!(b.is_empty());
918 }
919 }
920
921 #[test]
922 fn test_nan_empty_or_negative() {
923 use std::f32::NAN;
924 assert!(Box3D { min: point3(NAN, 2.0, 1.0), max: point3(1.0, 3.0, 5.0) }.is_empty());
925 assert!(Box3D { min: point3(0.0, NAN, 1.0), max: point3(1.0, 2.0, 5.0) }.is_empty());
926 assert!(Box3D { min: point3(1.0, -2.0, NAN), max: point3(3.0, 2.0, 5.0) }.is_empty());
927 assert!(Box3D { min: point3(1.0, -2.0, 1.0), max: point3(NAN, 2.0, 5.0) }.is_empty());
928 assert!(Box3D { min: point3(1.0, -2.0, 1.0), max: point3(0.0, NAN, 5.0) }.is_empty());
929 assert!(Box3D { min: point3(1.0, -2.0, 1.0), max: point3(0.0, 1.0, NAN) }.is_empty());
930 }
931}
932