pub struct Aabb<T: BHValue, const D: usize> {
pub min: Point<T, D>,
pub max: Point<T, D>,
}
Expand description
Aabb
struct.
Fields§
§min: Point<T, D>
Minimum coordinates
max: Point<T, D>
Maximum coordinates
Implementations§
source§impl<T: BHValue, const D: usize> Aabb<T, D>
impl<T: BHValue, const D: usize> Aabb<T, D>
sourcepub fn with_bounds(min: Point<T, D>, max: Point<T, D>) -> Self
pub fn with_bounds(min: Point<T, D>, max: Point<T, D>) -> Self
sourcepub fn empty() -> Self
pub fn empty() -> Self
Creates a new empty Aabb
.
§Examples
use bvh::aabb::Aabb;
let aabb = Aabb::<f32,3>::empty();
let min = &aabb.min;
let max = &aabb.max;
// For any point
let x = rand::random();
let y = rand::random();
let z = rand::random();
// An empty `Aabb` should not contain it
assert!(x < min.x && y < min.y && z < min.z);
assert!(max.x < x && max.y < y && max.z < z);
sourcepub fn infinite() -> Self
pub fn infinite() -> Self
Creates a new infinite Aabb
.
§Examples
use bvh::aabb::Aabb;
let aabb :Aabb<f32,3> = Aabb::infinite();
let min = &aabb.min;
let max = &aabb.max;
// For any point
let x = rand::random();
let y = rand::random();
let z = rand::random();
// An infinite `Aabb` should contain it
assert!(x > min.x && y > min.y && z > min.z);
assert!(max.x > x && max.y > y && max.z > z);
sourcepub fn contains(&self, p: &Point<T, D>) -> bool
pub fn contains(&self, p: &Point<T, D>) -> bool
Returns true if the Point
is inside the Aabb
.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let aabb = Aabb::with_bounds(Point3::new(-1.0, -1.0, -1.0), Point3::new(1.0, 1.0, 1.0));
let point_inside = Point3::new(0.125, -0.25, 0.5);
let point_outside = Point3::new(1.0, -2.0, 4.0);
assert!(aabb.contains(&point_inside));
assert!(!aabb.contains(&point_outside));
sourcepub fn approx_contains_eps(&self, p: &Point<T, D>, epsilon: T) -> bool
pub fn approx_contains_eps(&self, p: &Point<T, D>, epsilon: T) -> bool
Returns true if the Point3
is approximately inside the Aabb
with respect to some epsilon
.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let aabb = Aabb::with_bounds(Point3::new(-1.0, -1.0, -1.0), Point3::new(1.0, 1.0, 1.0));
let point_barely_outside = Point3::new(1.000_000_1, -1.000_000_1, 1.000_000_001);
let point_outside = Point3::new(1.0, -2.0, 4.0);
assert!(aabb.approx_contains_eps(&point_barely_outside, 0.00001));
assert!(!aabb.approx_contains_eps(&point_outside, 0.00001));
sourcepub fn approx_contains_aabb_eps(&self, other: &Aabb<T, D>, epsilon: T) -> bool
pub fn approx_contains_aabb_eps(&self, other: &Aabb<T, D>, epsilon: T) -> bool
Returns true if the other
Aabb
is approximately inside this Aabb
with respect to some epsilon
.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let aabb = Aabb::with_bounds(Point3::new(-1.0, -1.0, -1.0), Point3::new(1.0, 1.0, 1.0));
let point_barely_outside = Point3::new(1.000_000_1, 1.000_000_1, 1.000_000_1);
let center = aabb.center();
let inner_aabb = Aabb::with_bounds(center, point_barely_outside);
assert!(aabb.approx_contains_aabb_eps(&inner_aabb, 0.00001));
sourcepub fn relative_eq(&self, other: &Aabb<T, D>, epsilon: T) -> bool
pub fn relative_eq(&self, other: &Aabb<T, D>, epsilon: T) -> bool
Returns true if the other
Aabb
is approximately equal to this Aabb
with respect to some epsilon
.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let aabb = Aabb::with_bounds(Point3::new(-1.0, -1.0, -1.0), Point3::new(1.0, 1.0, 1.0));
let point_barely_outside_min = Point3::new(-1.000_000_1, -1.000_000_1, -1.000_000_1);
let point_barely_outside_max = Point3::new(1.000_000_1, 1.000_000_1, 1.000_000_1);
let other = Aabb::with_bounds(point_barely_outside_min, point_barely_outside_max);
assert!(aabb.relative_eq(&other, 0.00001));
sourcepub fn join(&self, other: &Aabb<T, D>) -> Aabb<T, D>
pub fn join(&self, other: &Aabb<T, D>) -> Aabb<T, D>
Returns a new minimal Aabb
which contains both this Aabb
and other
.
The result is the convex hull of the both Aabb
s.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let aabb1 = Aabb::with_bounds(Point3::new(-101.0, 0.0, 0.0), Point3::new(-100.0, 1.0, 1.0));
let aabb2 = Aabb::with_bounds(Point3::new(100.0, 0.0, 0.0), Point3::new(101.0, 1.0, 1.0));
let joint = aabb1.join(&aabb2);
let point_inside_aabb1 = Point3::new(-100.5, 0.5, 0.5);
let point_inside_aabb2 = Point3::new(100.5, 0.5, 0.5);
let point_inside_joint = Point3::new(0.0, 0.5, 0.5);
assert!(joint.contains(&point_inside_aabb1));
assert!(joint.contains(&point_inside_aabb2));
assert!(joint.contains(&point_inside_joint));
sourcepub fn join_mut(&mut self, other: &Aabb<T, D>)
pub fn join_mut(&mut self, other: &Aabb<T, D>)
Mutable version of Aabb::join
.
§Examples
use bvh::aabb::Aabb;
use nalgebra::{Point3, Vector3};
let size = Vector3::new(1.0, 1.0, 1.0);
let aabb_pos = Point3::new(-101.0, 0.0, 0.0);
let mut aabb = Aabb::with_bounds(aabb_pos, aabb_pos + size);
let other_pos = Point3::new(100.0, 0.0, 0.0);
let other = Aabb::with_bounds(other_pos, other_pos + size);
let point_inside_aabb = aabb_pos + size / 2.0;
let point_inside_other = other_pos + size / 2.0;
let point_inside_joint = Point3::new(0.0, 0.0, 0.0) + size / 2.0;
aabb.join_mut(&other);
assert!(aabb.contains(&point_inside_aabb));
assert!(aabb.contains(&point_inside_other));
assert!(aabb.contains(&point_inside_joint));
sourcepub fn grow(&self, other: &Point<T, D>) -> Aabb<T, D>
pub fn grow(&self, other: &Point<T, D>) -> Aabb<T, D>
Returns a new minimal Aabb
which contains both
this Aabb
and the Point3
other
.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let point1 = Point3::new(0.0, 0.0, 0.0);
let point2 = Point3::new(1.0, 1.0, 1.0);
let point3 = Point3::new(2.0, 2.0, 2.0);
let aabb = Aabb::empty();
assert!(!aabb.contains(&point1));
let aabb1 = aabb.grow(&point1);
assert!(aabb1.contains(&point1));
let aabb2 = aabb.grow(&point2);
assert!(aabb2.contains(&point2));
assert!(!aabb2.contains(&point3));
sourcepub fn grow_mut(&mut self, other: &Point<T, D>)
pub fn grow_mut(&mut self, other: &Point<T, D>)
Mutable version of Aabb::grow
.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let point1 = Point3::new(0.0, 0.0, 0.0);
let point2 = Point3::new(1.0, 1.0, 1.0);
let point3 = Point3::new(2.0, 2.0, 2.0);
let mut aabb = Aabb::empty();
assert!(!aabb.contains(&point1));
aabb.grow_mut(&point1);
assert!(aabb.contains(&point1));
assert!(!aabb.contains(&point2));
aabb.grow_mut(&point2);
assert!(aabb.contains(&point2));
assert!(!aabb.contains(&point3));
sourcepub fn join_bounded<B: Bounded<T, D>>(&self, other: &B) -> Aabb<T, D>
pub fn join_bounded<B: Bounded<T, D>>(&self, other: &B) -> Aabb<T, D>
Returns a new minimal Aabb
which contains both this Aabb
and the Bounded
other
.
§Examples
use bvh::aabb::{Aabb, Bounded};
use nalgebra::Point3;
struct Something;
impl Bounded<f32,3> for Something {
fn aabb(&self) -> Aabb<f32,3> {
let point1 = Point3::new(0.0,0.0,0.0);
let point2 = Point3::new(1.0,1.0,1.0);
Aabb::with_bounds(point1, point2)
}
}
let aabb = Aabb::empty();
let something = Something;
let aabb1 = aabb.join_bounded(&something);
let center = something.aabb().center();
assert!(aabb1.contains(¢er));
sourcepub fn center(&self) -> Point<T, D>
pub fn center(&self) -> Point<T, D>
Returns the center Point3
of the Aabb
.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let min = Point3::new(41.0,41.0,41.0);
let max = Point3::new(43.0,43.0,43.0);
let aabb = Aabb::with_bounds(min, max);
let center = aabb.center();
assert!(center.x == 42.0 && center.y == 42.0 && center.z == 42.0);
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
An empty Aabb
is an Aabb
where the lower bound is greater than
the upper bound in at least one component
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let empty_aabb: Aabb<f32,3> = Aabb::empty();
assert!(empty_aabb.is_empty());
let min = Point3::new(41.0,41.0,41.0);
let max = Point3::new(43.0,43.0,43.0);
let aabb = Aabb::with_bounds(min, max);
assert!(!aabb.is_empty());
sourcepub fn surface_area(&self) -> T
pub fn surface_area(&self) -> T
sourcepub fn largest_axis(&self) -> usize
pub fn largest_axis(&self) -> usize
Trait Implementations§
source§impl<T: BHValue, const D: usize> Bounded<T, D> for Aabb<T, D>
impl<T: BHValue, const D: usize> Bounded<T, D> for Aabb<T, D>
Implementation of Bounded
for Aabb
.
§Examples
use bvh::aabb::{Aabb, Bounded};
use nalgebra::Point3;
let point_a = Point3::new(3.0,4.0,5.0);
let point_b = Point3::new(17.0,18.0,19.0);
let aabb = Aabb::empty().grow(&point_a).grow(&point_b);
let aabb_aabb = aabb.aabb();
assert_eq!(aabb_aabb.min, aabb.min);
assert_eq!(aabb_aabb.max, aabb.max);
source§impl<T: BHValue, const D: usize> Index<usize> for Aabb<T, D>
impl<T: BHValue, const D: usize> Index<usize> for Aabb<T, D>
Make Aabb
s indexable. aabb[0]
gives a reference to the minimum bound.
All other indices return a reference to the maximum bound.
§Examples
use bvh::aabb::Aabb;
use nalgebra::Point3;
let min = Point3::new(3.0,4.0,5.0);
let max = Point3::new(123.0,123.0,123.0);
let aabb = Aabb::with_bounds(min, max);
assert_eq!(aabb[0], min);
assert_eq!(aabb[1], max);
impl<T: Copy + BHValue, const D: usize> Copy for Aabb<T, D>
Auto Trait Implementations§
impl<T, const D: usize> Freeze for Aabb<T, D>where
T: Freeze,
impl<T, const D: usize> RefUnwindSafe for Aabb<T, D>where
T: RefUnwindSafe,
impl<T, const D: usize> Send for Aabb<T, D>where
T: Send,
impl<T, const D: usize> Sync for Aabb<T, D>where
T: Sync,
impl<T, const D: usize> Unpin for Aabb<T, D>where
T: Unpin,
impl<T, const D: usize> UnwindSafe for Aabb<T, D>where
T: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
source§fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read moresource§fn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).source§fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.source§fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.