Struct geo_types::Rect

pub struct Rect<T> where
    T: CoordinateType,  { /* fields omitted */ }

A bounded 2D quadrilateral whose area is defined by minimum and maximum Coordinates.

The constructors and setters ensure the maximum Coordinate is greater than or equal to the minimum. Thus, a Rects width, height, and area is guaranteed to be greater than or equal to zero.

Examples

use geo_types::{Coordinate, Rect};

let rect = Rect::new(
    Coordinate { x: 0., y: 4.},
    Coordinate { x: 3., y: 10.},
);

assert_eq!(3., rect.width());
assert_eq!(6., rect.height());
assert_eq!(
    Coordinate { x: 1.5, y: 7. },
    rect.center()
);

Implementations

impl<T: CoordinateType> Rect<T>

pub fn new<C>(min: C, max: C) -> Rect<T> where
    C: Into<Coordinate<T>>, 

Constructor to creates a new rectangle from coordinates, where min denotes to the coordinates of the bottom-left corner, and max denotes to the coordinates of the top-right corner

Panics

Panics if min's x/y coordinate is larger than that of the max's.

Examples

use geo_types::{Coordinate, Rect};

let rect = Rect::new(
    Coordinate { x: 0., y: 0. },
    Coordinate { x: 10., y: 20. }
);

pub fn try_new<C>(
    min: C,
    max: C
) -> Result<Rect<T>, InvalidRectCoordinatesError> where
    C: Into<Coordinate<T>>, 

pub fn min(self) -> Coordinate<T>

Returns the minimum Coordinate (bottom-left corner) of the Rect.

Examples

use geo_types::{Coordinate, Rect};

let rect = Rect::new(
    Coordinate { x: 5., y: 5. },
    Coordinate { x: 15., y: 15. },
);

assert_eq!(rect.min(), Coordinate { x: 5., y: 5. });

pub fn set_min<C>(&mut self, min: C) where
    C: Into<Coordinate<T>>, 

Set the Rect’s minimum coordinate.

Panics

Panics if min’s x/y is greater than the maximum coordinate’s x/y.

pub fn max(self) -> Coordinate<T>

Returns the maximum Coordinate (top-right corner) of the Rect.

Examples

use geo_types::{Coordinate, Rect};

let rect = Rect::new(
    Coordinate { x: 5., y: 5. },
    Coordinate { x: 15., y: 15. },
);

assert_eq!(rect.max(), Coordinate { x: 15., y: 15. });

pub fn set_max<C>(&mut self, max: C) where
    C: Into<Coordinate<T>>, 

Set the Rect’s maximum coordinate.

Panics

Panics if max’s x/y is less than the minimum coordinate’s x/y.

pub fn width(self) -> T

Returns the width of the Rect.

Examples

use geo_types::{Coordinate, Rect};

let rect = Rect::new(
    Coordinate { x: 5., y: 5. },
    Coordinate { x: 15., y: 15. },
);

assert_eq!(rect.width(), 10.);

pub fn height(self) -> T

Returns the height of the Rect.

Examples

use geo_types::{Coordinate, Rect};

let rect = Rect::new(
    Coordinate { x: 5., y: 5. },
    Coordinate { x: 15., y: 15. },
);

assert_eq!(rect.height(), 10.);

pub fn to_polygon(self) -> Polygon<T>

Create a Polygon from the Rect.

Examples

use geo_types::{Coordinate, Rect, polygon};

let rect = Rect::new(
    Coordinate { x: 0., y: 0. },
    Coordinate { x: 10., y: 20. },
);

assert_eq!(
    rect.to_polygon(),
    polygon![
        (x: 0., y: 0.),
        (x: 0., y: 20.),
        (x: 10., y: 20.),
        (x: 10., y: 0.),
        (x: 0., y: 0.),
    ],
);

impl<T: CoordinateType + Float> Rect<T>

pub fn center(self) -> Coordinate<T>

Returns the center Coordinate of the Rect.

Examples

use geo_types::{Coordinate, Rect};

let rect = Rect::new(
    Coordinate { x: 5., y: 5. },
    Coordinate { x: 15., y: 15. },
);

assert_eq!(
    rect.center(),
    Coordinate { x: 10., y: 10. }
);

Trait Implementations

impl<T: Clone> Clone for Rect<T> where
    T: CoordinateType, 

fn clone(&self) -> Rect<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Rect<T> where
    T: CoordinateType, 

impl<T: Debug> Debug for Rect<T> where
    T: CoordinateType, 

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Rect<T> where
    T: CoordinateType, 

impl<T: CoordinateType> From<Rect<T>> for Polygon<T>

fn from(r: Rect<T>) -> Polygon<T>

Performs the conversion.

impl<T: CoordinateType> From<Rect<T>> for Geometry<T>

fn from(x: Rect<T>) -> Geometry<T>

Performs the conversion.

impl<T: Hash> Hash for Rect<T> where
    T: CoordinateType, 

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: PartialEq> PartialEq<Rect<T>> for Rect<T> where
    T: CoordinateType, 

fn eq(&self, other: &Rect<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rect<T>) -> bool

This method tests for !=.

impl<T> StructuralEq for Rect<T> where
    T: CoordinateType, 

impl<T> StructuralPartialEq for Rect<T> where
    T: CoordinateType,