Struct Bounds

pub struct Bounds {
    pub x: (isize, isize),
    pub y: (isize, isize),
}

Rectangular bounds describing the number of cells in each direction of the map.

These bounds are a half-open range, i.e. satisfied in the ranges:

• $x_0 <= x < x_1$
• $y_0 <= y < y_1$

Fields

x: (isize, isize)

The bounds on the x axis, in the format (min, max),

y: (isize, isize)

The bounds on the y axis, in the format (min, max),

Implementations

impl Bounds

pub fn empty() -> Self

Creates a new empty (zero sized) bound

pub fn is_valid(&self) -> bool

Returns if the bounds are valid or not, i.e. if the minimum is larger than the maximum.

pub fn new(x: (isize, isize), y: (isize, isize)) -> Result<Self, Error>

Creates a new bound from the given max and min cell indices in the x and y axes.

Must satisfy:

• $x_0 <= x_1$
• $y_0 <= y_1$

Examples found in repository

examples/map_rotations_check.rs (line 18)

fn main() {
    let translated = CellMap::<Layers, f64>::new(CellMapParams {
        cell_size: Vector2::new(1.0, 1.0),
        cell_bounds: Bounds::new((0, 10), (0, 10)).unwrap(),
        position_in_parent: Vector2::new(5.0, 5.0),
        ..Default::default()
    });

    let rotated = CellMap::<Layers, f64>::new(CellMapParams {
        cell_bounds: Bounds::new((0, 10), (0, 10)).unwrap(),
        cell_size: Vector2::new(1.0, 1.0),
        position_in_parent: Vector2::new(5.0, 5.0),
        rotation_in_parent_rad: std::f64::consts::FRAC_PI_4,
        ..Default::default()
    });

    let scaled = CellMap::<Layers, f64>::new(CellMapParams {
        cell_bounds: Bounds::new((0, 10), (0, 10)).unwrap(),
        cell_size: Vector2::new(0.5, 0.5),
        position_in_parent: Vector2::new(5.0, 5.0),
        rotation_in_parent_rad: std::f64::consts::FRAC_PI_4,
        ..Default::default()
    });

    #[cfg(all(feature = "debug_maps"))]
    {
        use cell_map::write_debug_map;

        write_debug_map(&translated, "translated");
        write_debug_map(&rotated, "rotated");
        write_debug_map(&scaled, "scaled");
    }
}

pub fn from_corners( bottom_left: Point2<isize>, upper_right: Point2<isize>, ) -> Result<Self, Error>

Creates a new bound from the given opposing corners of the a rectangle.

If the corners do not satisfy all(bottom_left <= upper_right) the bounds will be invalid and an error is returned.

pub fn from_corners_unsorted(a: Point2<isize>, b: Point2<isize>) -> Self

Creates a new bound from the given opposing corners of the a rectangle, but the corners do not have to be sorted in bottom_left, upper_right order.

This function will automatically decide which points are provided such that the bounds will be valid.

pub fn as_corners(&self) -> (Point2<isize>, Point2<isize>)

Converts this bounds into a pair of corners, the bottom left and upper right corners respectively.

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

Checks if the given point is inside the bounds

pub fn get_index(&self, point: Point2<isize>) -> Option<Point2<usize>>

Gets the value of the point as an index into an array bounded by this Bounds.

If the point is outside the bounds None is returned

pub unsafe fn get_index_unchecked(&self, point: Point2<isize>) -> Point2<isize>

Gets the value of the point as an index into an array bounded by this Bounds.

Safety

This function will not panic if point is outside the map, but use of the result to index into the map is not guaranteed to be safe. It is possible for this function to return a negative index value, which would indicate that the cell is outside the map.

pub fn get_shape(&self) -> (usize, usize)

Gets the shape of this rectangle in a format that ndarray will accept.

NOTE: shape order is (y, x), not (x, y).

pub fn get_num_cells(&self) -> Vector2<usize>

Gets the number of cells as a vector.

pub fn intersect(&self, other: &Bounds) -> Option<Bounds>

Gets the intersection of self with other, returning None if the two do not intersect.

pub fn union(&self, other: &Bounds) -> Bounds

Get the union of self with other, effectively this is the axis aligned bounding box of self and other.

If both bounds are empty this bound will be empty.

pub fn get_slice_of_other( &self, other: &Bounds, ) -> Option<Vector2<(usize, usize)>>

Gets the slice of other within self, cropping other so it fits within self.

Note that slices are a pair of (min, max) half-open bounds that describe the slice into an array, i.e. they are indices.

Trait Implementations

impl Clone for Bounds

fn clone(&self) -> Bounds

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Bounds

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

Formats the value using the given formatter.

impl Default for Bounds

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Bounds

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Bounds

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Bounds

impl Eq for Bounds

impl StructuralPartialEq for Bounds