Struct Aabb2

pub struct Aabb2<F>
where
    F: OutputType,
{ /* private fields */ }

A simple 2d axis aligned bounding box.

If min_max is None no data has been assigned.

Implementations

impl<F> Aabb2<F>

where F: OutputType,

pub fn new<I>(p1: &Point<I>, p2: &Point<I>) -> Aabb2<F>

where I: InputType,

Creates a new AABB with the limits defined by p1 & p2

pub fn new_from_i32<I>(x1: i32, y1: i32, x2: i32, y2: i32) -> Aabb2<F>

where I: InputType,

Creates a new AABB with i32 coordinates

pub fn update_point<I>(&mut self, point: &Point<I>)

where I: InputType,

pub fn update_coordinate<I>(&mut self, x: i32, y: i32)

where I: InputType,

pub fn update_vertex(&mut self, x: F, y: F)

pub fn update_i64(&mut self, x: i64, y: i64)

pub fn update_f64(&mut self, x: f64, y: f64)

pub fn update_line<I>(&mut self, line: &Line<I>)

where I: InputType,

pub fn get_high(&self) -> Option<[F; 2]>

pub fn get_low(&self) -> Option<[F; 2]>

pub fn grow_percent<I>(&mut self, percent: i32)

where I: InputType,

grows the aabb uniformly by some percent. method does nothing if not initialized

pub fn contains_point<I>(&self, point: &Point<I>) -> Option<bool>

where I: InputType,

returns Some(true) if the aabb contains the point (inclusive) returns None if the aabb is uninitialized

 let p0 = Point::from([0,0]);
 let p1 = Point::from([1,1]);

 let aabb = Aabb2::<f32>::new(&p0,&p1);
 assert!(aabb.contains_point(&Point::from([1,1])).unwrap_or(false));
 assert!(!aabb.contains_point(&Point::from([2,1])).unwrap_or(true));

pub fn contains_line<I>(&self, line: &Line<I>) -> Option<bool>

where I: InputType,

returns Some(true) if the aabb contains the line (inclusive) returns None if the aabb is uninitialized

let p0 = Point::from([0,0]);
let p1 = Point::from([10,10]);

let aabb = Aabb2::<f32>::new(&p0,&p1);
assert!( aabb.contains_line(&Line::from([1,1,10,10])).unwrap_or(false));
assert!(!aabb.contains_line(&Line::from([1,-1,10,10])).unwrap_or(true));

Trait Implementations

impl<F> Clone for Aabb2<F>

where F: Clone + OutputType,

fn clone(&self) -> Aabb2<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> Debug for Aabb2<F>

where F: Debug + OutputType,

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

Formats the value using the given formatter.

impl<F> Default for Aabb2<F>

where F: OutputType,

fn default() -> Aabb2<F>

Returns the “default value” for a type.

impl<F> PartialEq for Aabb2<F>

where F: PartialEq + OutputType,

fn eq(&self, other: &Aabb2<F>) -> 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<F> Eq for Aabb2<F>

where F: Eq + OutputType,

impl<F> StructuralPartialEq for Aabb2<F>

where F: OutputType,