[][src]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.


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.


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

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

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[src]

pub fn upper_bound(&self) -> S[src]

pub fn lower_bound(&self) -> S[src]

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

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[src]

Trait Implementations

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

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

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

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

type Output = (Scalar<S>, Scalar<S>)

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, aabb: &Aabb<S>) -> Option<Self::Output>[src]

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})$.


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

use nalgebra::Point2;
use theon::space::{Basis, 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::try_from_inner(Basis::x()).unwrap(),
let (min, _) = ray.intersection(&aabb).unwrap();
let point = ray.origin + (ray.direction.get() * min);

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

type Output = Self

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

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

Auto Trait Implementations

impl<S> RefUnwindSafe for Aabb<S> where
    S: RefUnwindSafe,
    <S as EuclideanSpace>::CoordinateSpace: RefUnwindSafe

impl<S> Send for Aabb<S> where
    S: Send,
    <S as EuclideanSpace>::CoordinateSpace: Send

impl<S> Sync for Aabb<S> where
    S: Sync,
    <S as EuclideanSpace>::CoordinateSpace: Sync

impl<S> Unpin for Aabb<S> where
    S: Unpin,
    <S as EuclideanSpace>::CoordinateSpace: Unpin

impl<S> UnwindSafe for Aabb<S> where
    S: UnwindSafe,
    <S as EuclideanSpace>::CoordinateSpace: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>, 

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,