Struct AxisAlignedBoundingBox 

pub struct AxisAlignedBoundingBox<R: Scalar, const D: usize> { /* private fields */ }

Type representing an axis aligned bounding box in arbitrary dimensions

Implementations

impl<R, const D: usize> AxisAlignedBoundingBox<R, D>

where R: Real, SVector<R, D>: ThreadSafe,

pub fn par_from_points(points: &[SVector<R, D>]) -> Self

Constructs the smallest AABB fitting around all the given points, parallel version

impl<R, const D: usize> AxisAlignedBoundingBox<R, D>

where R: Real,

pub fn zeros() -> Self

Constructs a degenerate AABB with min and max set to zero

pub fn new(min: SVector<R, D>, max: SVector<R, D>) -> Self

Constructs an AABB with the given min and max bounding points

pub fn from_point(point: SVector<R, D>) -> Self

Constructs a degenerate AABB with zero extents centered at the given point

pub fn from_points(points: &[SVector<R, D>]) -> Self

Constructs the smallest AABB fitting around all the given points

use crate::splashsurf_lib::Aabb3d;
use nalgebra::Vector3;

assert_eq!(
    Aabb3d::<f64>::from_points(&[]),
    Aabb3d::<f64>::zeros()
);
assert_eq!(
    Aabb3d::<f64>::from_points(&[Vector3::new(1.0, 1.0, 1.0)]),
    Aabb3d::<f64>::from_point(Vector3::new(1.0, 1.0, 1.0))
);

let aabb = Aabb3d::<f64>::from_points(&[
    Vector3::new(1.0, 1.0, 1.0),
    Vector3::new(0.5, 3.0, 5.0),
    Vector3::new(-1.0, 1.0, 1.0)
]);
assert_eq!(aabb.min(), &Vector3::new(-1.0, 1.0, 1.0));
assert_eq!(aabb.max(), &Vector3::new(1.0, 3.0, 5.0));

pub fn try_convert<T>(&self) -> Option<AxisAlignedBoundingBox<T, D>>

where T: Real,

Tries to convert the AABB from one real type to another real type, returns None if conversion fails

pub fn min(&self) -> &SVector<R, D>

Returns the min coordinate of the bounding box

pub fn max(&self) -> &SVector<R, D>

Returns the max coordinate of the bounding box

pub fn is_consistent(&self) -> bool

Returns whether the AABB is consistent, i.e. aabb.min()[i] <= aabb.max()[i] for all i

use crate::splashsurf_lib::Aabb3d;
use nalgebra::Vector3;
assert_eq!(
    Aabb3d::<f64>::zeros().is_consistent(), true);
assert_eq!(Aabb3d::new(Vector3::new(-1.0, -1.0, -1.0), Vector3::new(1.0, 1.0, 1.0)).is_consistent(), true);
assert_eq!(Aabb3d::new(Vector3::new(-1.0, 1.0, -1.0), Vector3::new(1.0, -1.0, 1.0)).is_consistent(), false);

pub fn is_degenerate(&self) -> bool

Returns whether the AABB is degenerate in any dimension, i.e. aabb.min()[i] == aabb.max()[i] for any i

use crate::splashsurf_lib::Aabb3d;
use nalgebra::Vector3;
assert_eq!(Aabb3d::<f64>::zeros().is_degenerate(), true);
assert_eq!(Aabb3d::new(Vector3::new(1.0, 1.0, 1.0), Vector3::new(1.0, 1.0, 1.0)).is_degenerate(), true);
assert_eq!(Aabb3d::new(Vector3::new(-1.0, 0.0, -3.0), Vector3::new(2.0, 2.0, 4.0)).is_degenerate(), false);

pub fn extents(&self) -> SVector<R, D>

Returns the extents of the bounding box (vector connecting min and max point of the box)

use crate::splashsurf_lib::Aabb3d;
use nalgebra::Vector3;
assert_eq!(Aabb3d::<f64>::zeros().extents(), Vector3::new(0.0, 0.0, 0.0));
assert_eq!(Aabb3d::new(Vector3::new(-1.0, -1.0, -1.0), Vector3::new(1.0, 1.0, 1.0)).extents(), Vector3::new(2.0, 2.0, 2.0));
assert_eq!(Aabb3d::new(Vector3::new(-1.0, 0.0, -3.0), Vector3::new(2.0, 2.0, 4.0)).extents(), Vector3::new(3.0, 2.0, 7.0));
assert_eq!(Aabb3d::new(Vector3::new(-1.0, 5.0, -3.0), Vector3::new(2.0, 15.0, 4.0)).extents(), Vector3::new(3.0, 10.0, 7.0));

pub fn min_extent(&self) -> R

Returns the smallest scalar extent of the AABB over all of its dimensions

use crate::splashsurf_lib::Aabb3d;
use nalgebra::Vector3;
assert_eq!(Aabb3d::<f64>::zeros().min_extent(), 0.0);
assert_eq!(Aabb3d::new(Vector3::new(-1.0, -2.0, -3.0), Vector3::new(2.0, 3.0, 4.0)).min_extent(), 3.0);
assert_eq!(Aabb3d::new(Vector3::new(-1.0, 0.0, -3.0), Vector3::new(2.0, 2.0, 4.0)).min_extent(), 2.0);
assert_eq!(Aabb3d::new(Vector3::new(-1.0, 0.0, 1.0), Vector3::new(2.0, 1.0, 1.0)).min_extent(), 0.0);

pub fn max_extent(&self) -> R

Returns the largest scalar extent of the AABB over all of its dimensions

use crate::splashsurf_lib::Aabb3d;
use nalgebra::Vector3;
assert_eq!(Aabb3d::<f64>::zeros().max_extent(), 0.0);
assert_eq!(Aabb3d::new(Vector3::new(-10.0, 0.0, -3.0), Vector3::new(2.0, 2.0, 4.0)).max_extent(), 12.0);
assert_eq!(Aabb3d::new(Vector3::new(-1.0, -2.0, -3.0), Vector3::new(2.0, 3.0, 4.0)).max_extent(), 7.0);
assert_eq!(Aabb3d::new(Vector3::new(-1.0, 5.0, -3.0), Vector3::new(2.0, 15.0, 4.0)).max_extent(), 10.0);

pub fn centroid(&self) -> SVector<R, D>

Returns the geometric centroid of the AABB (mean of the corner points)

pub fn contains_aabb(&self, other: &Self) -> bool

Checks if the given AABB is inside the AABB, the AABB is considered to be half-open to its max coordinate

pub fn contains_point(&self, point: &SVector<R, D>) -> bool

Checks if the given point is inside the AABB, the AABB is considered to be half-open to its max coordinate

pub fn translate(&mut self, vector: &SVector<R, D>)

Translates the AABB by the given vector

pub fn center_at_origin(&mut self)

Translates the AABB to center it at the coordinate origin (moves the centroid to the coordinate origin)

pub fn scale_uniformly(&mut self, scaling: R)

Multiplies a uniform, local scaling to the AABB (i.e. multiplying its extents as if it was centered at the origin)

pub fn join(&mut self, other: &Self)

Enlarges this AABB to the smallest AABB enclosing both itself and another AABB

pub fn join_with_point(&mut self, point: &SVector<R, D>)

Enlarges this AABB to the smallest AABB enclosing both itself and another point

pub fn grow_uniformly(&mut self, margin: R)

Grows this AABB uniformly in all directions by the given scalar margin (i.e. adding the margin to min/max extents)

pub fn enclosing_cube(&self) -> Self

Returns the smallest cubical AABB with the same center that encloses this AABB

Trait Implementations

impl<R: Clone + Scalar, const D: usize> Clone for AxisAlignedBoundingBox<R, D>

fn clone(&self) -> AxisAlignedBoundingBox<R, D>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug + Scalar, const D: usize> Debug for AxisAlignedBoundingBox<R, D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, R, const D: usize> Deserialize<'de> for AxisAlignedBoundingBox<R, D>

where R: Deserialize<'de> + Scalar,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: PartialEq + Scalar, const D: usize> PartialEq for AxisAlignedBoundingBox<R, D>

fn eq(&self, other: &AxisAlignedBoundingBox<R, D>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R, const D: usize> Serialize for AxisAlignedBoundingBox<R, D>

where R: Serialize + Scalar,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: Eq + Scalar, const D: usize> Eq for AxisAlignedBoundingBox<R, D>

impl<R: Scalar, const D: usize> StructuralPartialEq for AxisAlignedBoundingBox<R, D>