Struct Obb3 

pub struct Obb3<S> {
    pub center: Point3<S>,
    pub extents: Vec3<Positive<S>>,
    pub orientation: Angles3<S>,
}

Available on crate feature math-utils only.

3D oriented bounding box

Fields

center: Point3<S>

extents: Vec3<Positive<S>>

orientation: Angles3<S>

Implementations

impl<S> Obb3<S>

pub fn numcast<T>(self) -> Option<Obb3<T>>

where S: NumCast + PartialOrd + Zero, T: NumCast + PartialOrd + Zero,

impl<S> Obb3<S>

where S: OrderedRing,

pub const fn new( center: Point3<S>, extents: Vec3<Positive<S>>, orientation: Angles3<S>, ) -> Obb3<S>

Construct a new OBB

pub fn containing_points_with_orientation( points: &[Point3<S>], orientation: Angles3<S>, ) -> Option<Obb3<S>>

where S: Real + Real + MaybeSerDes,

Compute the OBB of a given orientation.

Returns None if the points span an empty set.

pub fn containing_points_approx(points: &[Point3<S>]) -> Option<Obb3<S>>

where S: Real + Real + RelativeEq<Epsilon = S> + MaybeSerDes,

Construct an approximate minimum OBB containing the convex hull of a given set of points.

Returns None if fewer than 4 points are given or if points span an empty set:

assert!(Obb3::containing_points_approx (
  &[[0.0, 1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]].map (Point3::from)
).is_none());

assert!(Obb3::containing_points_approx (
  &[[1.0, 0.0, 1.0], [0.0, 1.0, 0.0], [0.0, -1.0, 0.0], [-1.0,  0.0, -1.0]]
    .map (Point3::from)
).is_none());

pub fn containing_approx( hull: &Hull3<S>, mesh: &VertexEdgeTriangleMesh, ) -> Option<Obb3<S>>

where S: Real + NumCast + RelativeEq<Epsilon = S> + MaybeSerDes,

Construct an approximate minimum OBB containing the given convex hull and corresponding mesh.

Returns None if fewer than 4 points are given or if points span an empty set:

let (hull, mesh) = Hull3::from_points_with_mesh (
  &[[0.0, 1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]].map (Point3::from)
).unwrap();
assert!(Obb3::containing_approx (&hull, &mesh).is_none());

let (hull, mesh) = Hull3::from_points_with_mesh (
  &[[1.0, 0.0, 1.0], [0.0, 1.0, 0.0], [0.0, -1.0, 0.0], [-1.0,  0.0, -1.0]]
    .map (Point3::from)
).unwrap();
assert!(Obb3::containing_approx (&hull, &mesh).is_none());

pub fn containing_approx_pca(hull: &Hull3<S>) -> Option<Obb3<S>>

where S: Real + Real + NumCast + RelativeEq<Epsilon = S> + MaybeSerDes,

Construct an approximate minimum OBB containing the given convex hull of points oriented according to principal component analysis bases.

Returns None if fewer than 4 points are given or if points span an empty set:

let hull = Hull3::from_points (
  &[[0.0, 1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]].map (Point3::from)
).unwrap();
assert!(Obb3::containing_approx_pca (&hull).is_none());

let hull = Hull3::from_points (
  &[[1.0, 0.0, 1.0], [0.0, 1.0, 0.0], [0.0, -1.0, 0.0], [-1.0,  0.0, -1.0]]
    .map (Point3::from)
).unwrap();
assert!(Obb3::containing_approx_pca (&hull).is_none());

pub fn dimensions(self) -> Vec3<Positive<S>>

pub fn width(self) -> Positive<S>

X dimension

pub fn depth(self) -> Positive<S>

Y dimension

pub fn height(self) -> Positive<S>

Z dimension

pub fn volume(self) -> Positive<S>

pub fn corners(self) -> [Point3<S>; 8]

where S: Real + Real + MaybeSerDes,

pub fn aabb(self) -> Aabb3<S>

where S: Real + Real + MaybeSerDes,

pub fn contains(self, point: Point3<S>) -> bool

where S: Real + Real + MaybeSerDes,

Check if point is contained by the bounding box

pub fn dilate(self, amount: S) -> Obb3<S>

Increase or decrease each extent by the given amount.

Panics if any extent would become zero or negative:

let x = Obb3::new (
  Point3::origin(),
  [0.5, 0.5, 0.5].map (Positive::noisy).into(),
  Angles3::zero()
);
let y = x.dilate (-1.0); // panic!

Trait Implementations

impl<S> Clone for Obb3<S>

where S: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Obb3<S>

where S: Debug,

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

Formats the value using the given formatter.

impl<S> From<Aabb3<S>> for Obb3<S>

where S: Real,

fn from(aabb: Aabb3<S>) -> Obb3<S>

Panics if AABB has a zero dimension:

let x = Aabb3::with_minmax (
  [0.0, 0.0, 0.0].into(),
  [0.0, 1.0, 1.0].into()
).unwrap();
let y = Obb3::from (x); // panic!

impl<S> PartialEq for Obb3<S>

where S: PartialEq,

fn eq(&self, other: &Obb3<S>) -> 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<S> Primitive<S, Point3<S>> for Obb3<S>

where S: Real + Real + MaybeSerDes,

fn translate(&mut self, displacement: Vec3<S>)

fn scale(&mut self, scale: Positive<S>)

fn support(&self, direction: NonZero3<S>) -> (Point3<S>, S)

Returns the point with largeest dot product in search direction

impl<S> Copy for Obb3<S>

where S: Copy,

impl<S> Eq for Obb3<S>

where S: Eq,

impl<S> StructuralPartialEq for Obb3<S>