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

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

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

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 where
    Scalar<S>: IntrinsicOrd
[src]

pub fn lower_bound(&self) -> S where
    Scalar<S>: IntrinsicOrd
[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 where
    Scalar<S>: IntrinsicOrd
[src]

Trait Implementations

impl<S: Clone> Clone for Aabb<S> where
    S: EuclideanSpace
[src]

impl<S: Copy> Copy for Aabb<S> where
    S: EuclideanSpace
[src]

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

impl<S> Default for Aabb<S> where
    S: EuclideanSpace
[src]

impl<S> Intersection<Aabb<S>> for S where
    S: EuclideanSpace,
    Aabb<S>: Intersection<S>, 
[src]

Symmetrical intersection.

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

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

Intersection of axis-aligned bounding boxes.

type Output = Self

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

Symmetrical intersection.

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

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

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

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, ray: &Ray<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}$.

Examples

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<S> for Aabb<S> where
    S: EuclideanSpace,
    Scalar<S>: IntrinsicOrd + Signed
[src]

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

type Output = Vector<S>

impl<S: PartialEq> PartialEq<Aabb<S>> for Aabb<S> where
    S: EuclideanSpace
[src]

impl<S> StructuralPartialEq for Aabb<S> where
    S: EuclideanSpace
[src]

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

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

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

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> Scalar for T where
    T: PartialEq<T> + Copy + Any + Debug
[src]

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

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

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>,