Struct theon::query::Aabb

pub struct Aabb<S> where
    S: EuclideanSpace,  {
    pub origin: S,
    pub extent: Vector<S>,
}

Axis-aligned bounding box.

Represents an $n$-dimensional volume along each basis vector of a Euclidean space. The bounding box is defined by the region between its origin and endpoint.

Fields

origin: S

The origin of the bounding box.

The origin does not necessarily represent the lower or upper bound of the Aabb. See lower_bound and upper_bound.

extent: Vector<S>

The extent of the bounding box.

The extent describes the endpoint as a translation from the origin. The endpoint $P_E$ is formed by $P_0 + \vec{v}$, where $P_0$ is the origin and $\vec{v}$ is the extent.

Implementations

impl<S> Aabb<S> where
    S: EuclideanSpace, 

pub fn from_points<I>(points: I) -> Self where
    I: IntoIterator<Item = S>,
    Scalar<S>: IntrinsicOrd, 

Creates an Aabb from a set of points.

The bounding box is formed from the lower and upper bounds of the points. If the set of points is empty, then the Aabb will sit at the origin with zero volume.

pub fn endpoint(&self) -> S

pub fn upper_bound(&self) -> S where
    Scalar<S>: IntrinsicOrd, 

pub fn lower_bound(&self) -> S where
    Scalar<S>: IntrinsicOrd, 

pub fn volume(&self) -> Scalar<S>

Gets the Lebesgue measure ($n$-dimensional volume) of the bounding box.

This value is analogous to length, area, and volume in one, two, and three dimensions, respectively.

pub fn union(&self, aabb: &Self) -> Self where
    Scalar<S>: IntrinsicOrd, 

Trait Implementations

impl<S: Clone> Clone for Aabb<S> where
    S: EuclideanSpace, 

fn clone(&self) -> Aabb<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Aabb<S> where
    S: Debug + EuclideanSpace,
    Vector<S>: Debug, 

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

Formats the value using the given formatter.

impl<S> Default for Aabb<S> where
    S: EuclideanSpace, 

fn default() -> Self

Returns the “default value” for a type.

impl<S> Intersection<Aabb<S>> for S where
    S: EuclideanSpace,
    Aabb<S>: Intersection<S>, 

Symmetrical intersection.

type Output = <Aabb<S> as Intersection<S>>::Output

fn intersection(&self, other: &Aabb<S>) -> Option<Self::Output>

impl<S> Intersection<Aabb<S>> for Aabb<S> where
    S: EuclideanSpace,
    Scalar<S>: IntrinsicOrd + Signed, 

Intersection of axis-aligned bounding boxes.

type Output = Aabb<S>

fn intersection(&self, other: &Aabb<S>) -> Option<Self::Output>

impl<S> Intersection<Aabb<S>> for Ray<S> where
    S: EuclideanSpace,
    Aabb<S>: Intersection<Ray<S>>, 

Symmetrical intersection.

type Output = <Aabb<S> as Intersection<Ray<S>>>::Output

fn intersection(&self, other: &Aabb<S>) -> Option<Self::Output>

impl<S> Intersection<Ray<S>> for Aabb<S> where
    S: EuclideanSpace,
    Scalar<S>: Bounded + Infinite + IntrinsicOrd + Signed, 

Intersection of an axis-aligned bounding box and a ray.

type Output = (<<S as EuclideanSpace>::CoordinateSpace as VectorSpace>::Scalar, <<S as EuclideanSpace>::CoordinateSpace as VectorSpace>::Scalar)

The minimum and maximum times of impact of the intersection.

The times of impact $t_{min}$ and $t_{max}$ describe the distance along the half-line from the ray’s origin at which the intersection occurs.

fn intersection(&self, ray: &Ray<S>) -> Option<Self::Output>

Determines the minimum and maximum times of impact of a Ray intersection with an Aabb.

Given a ray formed by an origin $P_0$ and a unit direction $\hat{u}$, the nearest point of intersection is $P_0 + t_{min}\hat{u}$.

Examples

Determine the point of impact between a ray and axis-aligned bounding box:

use nalgebra::Point2;
use theon::space::{EuclideanSpace, VectorSpace};
use theon::query::{Aabb, Intersection, Ray, Unit};

type E2 = Point2<f64>;

let aabb = Aabb::<E2> {
    origin: EuclideanSpace::from_xy(1.0, -1.0),
    extent: VectorSpace::from_xy(2.0, 2.0),
};
let ray = Ray::<E2> {
    origin: EuclideanSpace::origin(),
    direction: Unit::x(),
};
let (min, _) = ray.intersection(&aabb).unwrap();
let point = ray.origin + (ray.direction.get() * min);

impl<S> Intersection<S> for Aabb<S> where
    S: EuclideanSpace,
    Scalar<S>: IntrinsicOrd + Signed, 

Intersection of an axis-aligned bounding box and a point.

type Output = <S as EuclideanSpace>::CoordinateSpace

fn intersection(&self, point: &S) -> Option<Self::Output>

impl<S: PartialEq> PartialEq<Aabb<S>> for Aabb<S> where
    S: EuclideanSpace, 

fn eq(&self, other: &Aabb<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Aabb<S>) -> bool

This method tests for !=.

impl<S: Copy> Copy for Aabb<S> where
    S: EuclideanSpace, 

impl<S> StructuralPartialEq for Aabb<S> where
    S: EuclideanSpace,