Struct Obb3 

pub struct Obb3<S> {
    pub center: Point3<S>,
    pub half_extent_x: Positive<S>,
    pub half_extent_y: Positive<S>,
    pub half_extent_z: Positive<S>,
    pub orientation: Angles3<S>,
}

3D oriented bounding box

Fields

center: Point3<S>

half_extent_x: Positive<S>

half_extent_y: Positive<S>

half_extent_z: Positive<S>

orientation: Angles3<S>

Implementations

impl<S> Obb3<S>

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

where S: NumCast, T: NumCast,

impl<S: Ring> Obb3<S>

pub const fn new( center: Point3<S>, half_extent_x: Positive<S>, half_extent_y: Positive<S>, half_extent_z: Positive<S>, orientation: Angles3<S>, ) -> Self

Construct a new OBB

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

where S: Real + Real + MaybeSerDes,

Compute the OBB of a given orientation

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

where S: Real + Real + RelativeEq<Epsilon = S> + Debug + 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<Self>

where S: Real + NumCast + RelativeEq<Epsilon = S> + Debug + 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<Self>

where S: Real + Real + NumCast + RelativeEq<Epsilon = S> + Debug + 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 const fn center(&self) -> Point3<S>

pub const fn half_extent_x(&self) -> Positive<S>

pub const fn half_extent_y(&self) -> Positive<S>

pub const fn half_extent_z(&self) -> Positive<S>

pub const fn orientation(&self) -> Angles3<S>

pub fn dimensions(&self) -> Vector3<S>

where S: Field,

pub fn extents(&self) -> Vector3<S>

where S: Field,

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

where S: OrderedField,

X dimension

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

where S: OrderedField,

Y dimension

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

where S: OrderedField,

Z dimension

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

where S: OrderedField,

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

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) -> Self

where S: OrderedField,

Increase or decrease each dimension by the given amount.

Panics if any dimension would become zero or negative:

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

Trait Implementations

impl<S: Clone> Clone for Obb3<S>

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> Debug for Obb3<S>

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

Formats the value using the given formatter.

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

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

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()
);
let y = Obb3::from (x); // panic!

impl<S: PartialEq> PartialEq for Obb3<S>

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: Copy> Copy for Obb3<S>

impl<S: Eq> Eq for Obb3<S>

impl<S> StructuralPartialEq for Obb3<S>