# Struct libreda_db::prelude::Rect

``````pub struct Rect<T> {
pub lower_left: Point<T>,
pub upper_right: Point<T>,
}``````
Expand description

A rectangle which is oriented along the x an y axis and represented by its lower left and upper right corner.

## Fields§

§`lower_left: Point<T>`

Lower left corner of the rectangle.

§`upper_right: Point<T>`

Upper right corner of the rectangle.

## Implementations§

§

### impl<T> Rect<T>where T: PartialOrd<T> + Copy,

#### pub fn new<C>(c1: C, c2: C) -> Rect<T>where C: Into<Point<T>>,

Construct the bounding box of the two points. Order does not matter.

##### Examples
``````use iron_shapes::prelude::*;

// Create a rectangle based on two corner points.
let rect1 = Rect::new(Point::new(0, 0), Point::new(1, 2));
// Any type that implements `Into<Point<T>>` can be used for the corner points.
let rect2 = Rect::new((1, 2), (0, 0));
// Ordering of the corner points does not matter.
assert_eq!(rect1, rect2);
// Even though `(0, 0)` was passed as second argument it is recognized as lower left corner.
assert_eq!(rect2.lower_left(), Point::new(0, 0));``````
§

### impl<T> Rect<T>where T: Copy,

#### pub fn lower_left(&self) -> Point<T>

Get the lower left corner.

#### pub fn upper_left(&self) -> Point<T>

Get the upper left corner.

#### pub fn upper_right(&self) -> Point<T>

Get the upper right corner.

#### pub fn lower_right(&self) -> Point<T>

Get the lower right corner.

§

### impl<T> Rect<T>where T: PartialOrd<T> + Copy,

#### pub fn contains_point(&self, p: Point<T>) -> bool

Check if rectangle contains the point. Inclusive boundaries.

##### Example
``````use iron_shapes::prelude::*;
let rect = Rect::new((0, 0), (10, 20));
// Contains point somewhere in the center.
assert!(rect.contains_point(Point::new(5, 5)));
// Also contains point on the boundaries.
assert!(rect.contains_point(Point::new(0, 0)));
// Does not contain point outside of the rectangle.
assert!(!rect.contains_point(Point::new(10, 21)));``````

#### pub fn contains_point_exclusive(&self, p: Point<T>) -> bool

Check if rectangle contains the point. Exclusive boundaries.

##### Example
``````use iron_shapes::prelude::*;
let rect = Rect::new((0, 0), (10, 20));
// Contains point somewhere in the center.
assert!(rect.contains_point_exclusive(Point::new(5, 5)));
// Does not contain points on boundaries.
assert!(!rect.contains_point_exclusive(Point::new(0, 0)));
// Does not contain point outside of the rectangle.
assert!(!rect.contains_point_exclusive(Point::new(10, 21)));``````

#### pub fn contains_rectangle(&self, other: &Rect<T>) -> bool

Check if rectangle contains other rectangle. Inclusive boundaries.

##### Example
``````use iron_shapes::prelude::*;

let outer = Rect::new((0, 0), (2, 2));
let inner = Rect::new((0, 0), (1, 1));
assert!(outer.contains_rectangle(&inner));
assert!(!inner.contains_rectangle(&outer));``````

#### pub fn contains_rectangle_exclusive(&self, other: &Rect<T>) -> bool

Check if rectangle contains other rectangle. Exclusive boundaries.

##### Example
``````use iron_shapes::prelude::*;

let outer = Rect::new((0, 0), (3, 3));
let inner = Rect::new((1, 1), (2, 2));
assert!(outer.contains_rectangle_exclusive(&inner));
assert!(!inner.contains_rectangle_exclusive(&outer));

let not_inner = Rect::new((0, 0), (1, 1)); // This shares the boundary with `outer`.
assert!(!outer.contains_rectangle_exclusive(&not_inner));``````

#### pub fn touches(&self, other: &Rect<T>) -> bool

Test if the both rectangles touch each other, i.e. if they either share a boundary or are overlapping.

#### pub fn intersection(&self, other: &Rect<T>) -> Option<Rect<T>>

Compute the boolean intersection of two rectangles. This function excludes the boundaries, hence a zero-area intersection is considered `None`. See `intersection_inclusive_bounds()` zero-area intersections should be returned as `Some(rectangle)`.

##### Example
``````use iron_shapes::prelude::*;

// Create two overlapping rectangles.
let a = Rect::new((0, 0), (2, 2));
let b = Rect::new((1, 1), (3, 3));

// Compute the intersection.
assert_eq!(a.intersection(&b), Some(Rect::new((1, 1), (2, 2))));

// Create a non-overlapping rectangle.
let c = Rect::new((100, 100), (200, 200));
// The intersection with a non-overlapping rectangle is `None`.
assert_eq!(a.intersection(&c), None);``````

#### pub fn intersection_inclusive_bounds(&self, other: &Rect<T>) -> Option<Rect<T>>

Compute the boolean intersection of two rectangles and include the boundaries. This allows to get zero-area intersection results for example if the two rectangles touch on a boundary or one of the rectangle is already zero-area.

##### Example
``````use iron_shapes::prelude::*;

// Create two rectangles which intersect in a single point.
let a = Rect::new((0, 0), (2, 2));
let b = Rect::new((2, 2), (3, 3));

// Compute the intersection.
assert_eq!(a.intersection_inclusive_bounds(&b), Some(Rect::new((2, 2), (2, 2))));
``````

#### pub fn add_point(&self, point: Point<T>) -> Rect<T>

Create the smallest `Rect` that contains the original `Rect` and the `point`.

##### Example
``````use iron_shapes::prelude::*;

let r1 = Rect::new((0,0), (1,2));

assert_eq!(r2, Rect::new((0,0), (10,11)));
``````

#### pub fn add_rect(&self, rect: &Rect<T>) -> Rect<T>

Get the smallest `Rect` that contains both rectangles `self` and `rect`.

##### Example
``````use iron_shapes::prelude::*;

let r1 = Rect::new((0,0), (1,2));
let r2 = Rect::new((4,5), (6,7));

assert_eq!(r3, Rect::new((0,0), (6,7)));
``````
§

### impl<T> Rect<T>where T: Sub<T, Output = T> + Copy + Ord + Zero,

#### pub fn distance_to_point(&self, p: Point<T>) -> Vector<T>

Compute the shortest from the rectangle to the point `p`. The distance is zero if the point is inside the rectangle.

##### Example
``````use iron_shapes::prelude::*;

let r = Rect::new((0,0), (10, 10));

assert_eq!(r.distance_to_point((5, 15).into()), Vector::new(0, 5));

// Distance to point inside the rectangle is zero.
assert_eq!(r.distance_to_point((5, 5).into()), Vector::new(0, 0));
``````
§

### impl<T> Rect<T>where T: Copy + Sub<T, Output = T>,

#### pub fn width(&self) -> T

Compute the width of the rectangle.

#### pub fn height(&self) -> T

Compute the height of the rectangle.

§

### impl<T> Rect<T>where T: Add<T, Output = T> + Div<T, Output = T> + Copy + One,

#### pub fn center(&self) -> Point<T>

Get the center point of the rectangle. When using integer coordinates the resulting coordinates will be truncated to the next integers.

§

### impl<T> Rect<T>where T: Add<T, Output = T> + Sub<T, Output = T> + Copy + PartialOrd<T>,

Create an enlarged copy of this rectangle. The vertical boundaries will be shifted towards the outside by `add_x`. The horizontal boundaries will be shifted towards the outside by `add_y`.

#### pub fn sized_isotropic(&self, add: T) -> Rect<T>

Create an enlarged copy of this rectangle.

## Trait Implementations§

§

### impl<T> BoundingBox<T> for Rect<T>where T: Copy,

§

#### fn bounding_box(&self) -> Rect<T>

Get bounding box of rectangle (which is equal to the rectangle itself).

§

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

§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
§

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

§

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

Formats the value using the given formatter. Read more
§

### impl<'de, T> Deserialize<'de> for Rect<T>where T: Deserialize<'de>,

§

#### fn deserialize<__D>( __deserializer: __D ) -> Result<Rect<T>, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
§

### impl<T> DoubledOrientedArea<T> for Rect<T>where T: Sub<T, Output = T> + Copy + Mul<T, Output = T> + Add<T, Output = T>,

§

#### fn area_doubled_oriented(&self) -> T

Calculate doubled oriented area of rectangle.

§

### impl<T> From<&Rect<T>> for Polygon<T>where T: Copy,

Create a polygon from a rectangle.

§

#### fn from(rect: &Rect<T>) -> Polygon<T>

Converts to this type from the input type.
§

### impl<T> From<Rect<T>> for Geometry<T>

§

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

Converts to this type from the input type.
§

### impl<T> From<Rect<T>> for Polygon<T>where T: Copy,

Create a polygon from a rectangle.

§

#### fn from(rect: Rect<T>) -> Polygon<T>

Converts to this type from the input type.
§

### impl<T> From<Rect<T>> for SimpleRPolygon<T>where T: CoordinateType,

§

#### fn from(r: Rect<T>) -> SimpleRPolygon<T>

Converts to this type from the input type.
§

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

§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given `Hasher`. Read more
§

### impl<T> IntoEdges<T> for &Rect<T>where T: CoordinateType,

§

#### type Edge = REdge<T>

Type of edge which will be returned.
§

Iterator type.
§

#### fn into_edges(self) -> <&Rect<T> as IntoEdges<T>>::EdgeIter

Get an iterator over edges.
§

### impl<'a, T> IntoIterator for &'a Rect<T>where T: Copy,

Iterate over all points of the rectangle. Starts with the lower left corner and iterates counter clock-wise.

§

#### type Item = Point<T>

The type of the elements being iterated over.
§

#### type IntoIter = IntoIter<<&'a Rect<T> as IntoIterator>::Item, Global>

Which kind of iterator are we turning this into?
§

#### fn into_iter(self) -> <&'a Rect<T> as IntoIterator>::IntoIter

Creates an iterator from a value. Read more
§

### impl<T> IntoIterator for Rect<T>where T: Copy,

Iterate over all points of the rectangle. Starts with the lower left corner and iterates counter clock-wise.

§

#### type Item = Point<T>

The type of the elements being iterated over.
§

#### type IntoIter = IntoIter<<Rect<T> as IntoIterator>::Item, Global>

Which kind of iterator are we turning this into?
§

#### fn into_iter(self) -> <Rect<T> as IntoIterator>::IntoIter

Creates an iterator from a value. Read more
§

### impl<C> IntoPoints<C> for Rect<<C as CoordinateBase>::Coord>where C: CoordinateConcept,

§

#### type Point = Point<<C as CoordinateBase>::Coord>

Type of the points.
§

#### type PointIter = <Rect<<C as CoordinateBase>::Coord> as IntoIterator>::IntoIter

Iterator over points.
§

#### fn into_points( self ) -> <Rect<<C as CoordinateBase>::Coord> as IntoPoints<C>>::PointIter

Iterate over points.
§

### impl<C> IntoSegments<C> for Rect<<C as CoordinateBase>::Coord>where C: CoordinateConcept,

§

#### type Segment = REdge<<C as CoordinateBase>::Coord>

Type which represents the segments.
§

#### type SegmentIter = RectEdgeIterator<<C as CoordinateBase>::Coord>

Iterator over segments.
§

#### fn into_segments( self ) -> <Rect<<C as CoordinateBase>::Coord> as IntoSegments<C>>::SegmentIter

Iterate over segments/edges of a polygon.
§

### impl<T> MapPointwise<T> for Rect<T>where T: Copy + PartialOrd<T>,

Point wise transformation of the two corner points.

§

#### fn transform<F>(&self, transformation: F) -> Rect<T>where F: Fn(Point<T>) -> Point<T>,

Point wise transformation.

§

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

§

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

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

### impl<C> Polygon<C> for Rect<<C as CoordinateBase>::Coord>where C: CoordinateConcept,

§

#### fn set( &mut self, _iter: impl Iterator<Item = <Rect<<C as CoordinateBase>::Coord> as PolygonSet<C>>::Point> )

Set points from an iterator.
§

### impl<C> Polygon90<C> for Rect<<C as CoordinateBase>::Coord>where C: CoordinateConcept,

§

#### type CompactIterator = IntoIter<<C as CoordinateBase>::Coord, Global>

Iterator over alternating x/y coordinates of the points. Starts with an x coordinate.
§

#### fn compact_iter( &self ) -> <Rect<<C as CoordinateBase>::Coord> as Polygon90<C>>::CompactIterator

Iterate over alternating x/y coordinates of the polygon vertices. Start with an x coordinate.
§

### impl<C> PolygonSet<C> for Rect<<C as CoordinateBase>::Coord>where C: CoordinateConcept,

§

#### type Point = Point<<C as CoordinateBase>::Coord>

Point type used for the vertices.
§

#### type Segment = REdge<<C as CoordinateBase>::Coord>

Type used for the polygon segments.
§

#### type AllPoints = <Rect<<C as CoordinateBase>::Coord> as IntoIterator>::IntoIter

Iterator over all points.
§

#### fn num_polygons(&self) -> usize

Get number of polygons.
§

#### fn convolved( self, p: &<Rect<<C as CoordinateBase>::Coord> as PolygonSet<C>>::Point ) -> Rect<<C as CoordinateBase>::Coord>

Add the point `p` to all vertices.
§

#### fn convolve( &mut self, p: &<Rect<<C as CoordinateBase>::Coord> as PolygonSet<C>>::Point )

Add the point `p` to all vertices.
§

#### fn scaled( self, scale: <C as CoordinateBase>::Coord ) -> Rect<<C as CoordinateBase>::Coord>

Multiply all vertices with a factor.
§

#### fn scale(&mut self, scale: <C as CoordinateBase>::Coord)

Multiply all vertices with a factor.
§

#### fn all_points( &self ) -> <Rect<<C as CoordinateBase>::Coord> as PolygonSet<C>>::AllPoints

Iterate over all vertices.
§

### impl<C> PolygonWithHoles<C> for Rect<<C as CoordinateBase>::Coord>where C: CoordinateConcept,

§

#### fn num_holes(&self) -> usize

Get the number of holes.
§

### impl<C> Rectangle<C> for Rect<<C as CoordinateBase>::Coord>where C: CoordinateConcept,

§

#### type Interval = Interval<<C as CoordinateBase>::Coord>

Type used for representing a one-dimensional interval.
§

#### fn get( &self, orientation: Orientation2D ) -> <Rect<<C as CoordinateBase>::Coord> as Rectangle<C>>::Interval

Get the interval which is spanned by the rectangle in the given orientation.
§

### impl<T> Serialize for Rect<T>where T: 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. Read more
§

### impl<T> ToPolygon<T> for Rect<T>where T: Copy,

§

#### fn to_polygon(&self) -> Polygon<T>

Convert the geometric object into a polygon.
§

### impl<T> TryBoundingBox<T> for Rect<T>where T: Copy,

§

#### fn try_bounding_box(&self) -> Option<Rect<T>>

Get bounding box of rectangle (always exists).

§

### impl<T, Dst> TryCastCoord<T, Dst> for Rect<T>where T: CoordinateType + NumCast, Dst: CoordinateType + NumCast,

§

#### type Output = Rect<Dst>

Output type of the cast. This is likely the same geometrical type just with other coordinate types.
§

#### fn try_cast(&self) -> Option<<Rect<T> as TryCastCoord<T, Dst>>::Output>

Try to cast to target data type. Read more
§

#### fn cast(&self) -> Self::Output

Cast to target data type. Read more
§

§

§

§

§

§

§

§

§

§

§

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

const: unstable · source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

const: unstable · source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

const: unstable · source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

const: unstable · source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

§

### impl<S, T> Mirror<T> for Swhere T: Copy + Zero + Sub<T, Output = T>, S: MapPointwise<T>,

§

#### fn mirror_x(&self) -> S

Return the geometrical object mirrored at the `x` axis.

§

#### fn mirror_y(&self) -> S

Return the geometrical object mirrored at the `y` axis.

§

### impl<S, T> RotateOrtho<T> for Swhere T: Copy + Zero + Sub<T, Output = T>, S: MapPointwise<T>,

§

#### fn rotate_ortho(&self, a: Angle) -> S

Rotate the geometrical shape by a multiple of 90 degrees.
§

### impl<S, T> Scale<T> for Swhere T: Copy + Mul<T, Output = T>, S: MapPointwise<T>,

§

#### fn scale(&self, factor: T) -> S

Scale the geometrical shape. Scaling center is the origin `(0, 0)`.
source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

### impl<S, T> Translate<T> for Swhere T: Copy + Add<T, Output = T>, S: MapPointwise<T>,

§

#### fn translate(&self, v: Vector<T>) -> S

Translate the geometrical object by a vector `v`.
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

source§

source§

§