Struct Obb2

pub struct Obb2<S> { /* private fields */ }

2D oriented bounding box

Implementations

impl<S> Obb2<S>

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

where S: NumCast, T: NumCast,

impl<S> Obb2<S>

where S: Ring,

pub fn new( center: Point2<S>, half_extent_x: Positive<S>, half_extent_y: Positive<S>, orientation: AngleWrapped<S>, ) -> Obb2<S>

Construct a new OBB

pub fn containing_points(points: &[Point2<S>]) -> Option<Obb2<S>>

where S: Real,

Construct the minimum OBB containing the convex hull of a given set of points using rotating calipers algorithm. To construct the OBB containing a convex hull directoy use the Obb2::containing method.

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

assert!(Obb2::containing_points (
  &[[0.0, 1.0], [1.0, 0.0]].map (Point2::from)
).is_none());

assert!(Obb2::containing_points (
  &[[1.0, 1.0], [0.0, 0.0], [-1.0, -1.0]].map (Point2::from)
).is_none());

pub fn containing(hull: &Hull2<S>) -> Option<Obb2<S>>

where S: Real,

Construct the minimum OBB containing the given convex hull of points using rotating calipers algorithm.

Returns None if if points span an empty set:

let hull = Hull2::from_points (
  &[[1.0, 1.0], [0.0, 0.0], [-1.0, -1.0]].map (Point2::from)).unwrap();
assert!(Obb2::containing (&hull).is_none());

pub fn center(&self) -> Point2<S>

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

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

pub fn orientation(&self) -> AngleWrapped<S>

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

where S: Field,

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

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

where S: Field,

X dimension

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

where S: Field,

Y dimension

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

where S: Field,

pub fn corners(&self) -> [Point2<S>; 4]

where S: Real + Real + MaybeSerDes,

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

where S: Real + Real + MaybeSerDes,

Check if point is contained by the bounding box.

let x = Obb2::new (
  [3.0, 6.0].into(),
  Positive::unchecked (2.0),
  Positive::unchecked (0.75),
  AngleWrapped::wrap (Rad (std::f32::consts::FRAC_PI_4)));
assert!(x.contains (&[2.0f32, 5.0].into()));
assert!(!x.contains (&[3.0f32, 2.0].into()));

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

where S: Field,

Increase or decrease each dimension by the given amount.

Panics if any dimension would become zero or negative:

let x = Obb2::new (
  Point2::origin(),
  Positive::unchecked (0.5),
  Positive::unchecked (0.5),
  AngleWrapped::zero()
);
let y = x.dilate (-1.0); // panic!

Trait Implementations

impl<S> Clone for Obb2<S>

where S: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Obb2<S>

where S: Debug,

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

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for Obb2<S>

where S: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Obb2<S>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> From<Aabb2<S>> for Obb2<S>

where S: Real,

fn from(aabb: Aabb2<S>) -> Obb2<S>

Panics if AABB has a zero dimension:

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

impl<S> PartialEq for Obb2<S>

where S: PartialEq,

fn eq(&self, other: &Obb2<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> Serialize for Obb2<S>

where S: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S> Copy for Obb2<S>

where S: Copy,

impl<S> StructuralPartialEq for Obb2<S>