Struct libreda_db::layout::prelude::Rect

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

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 + 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 + 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));

let r2 = r1.add_point(Point::new(10, 11));

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));

let r3 = r1.add_rect(&r2);

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

impl<T> Rect<T>

where T: Sub<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<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<Output = T> + Div<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<Output = T> + Sub<Output = T> + Copy + PartialOrd,

pub fn sized(&self, add_x: T, add_y: T) -> Rect<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.

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

Performs copy-assignment from source.

impl<T> Debug for Rect<T>

where T: Debug,

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

Formats the value using the given formatter.

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.

impl<T> DoubledOrientedArea<T> for Rect<T>

where T: Sub<Output = T> + Copy + Mul<Output = T> + Add<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.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> IntoEdges<T> for &Rect<T>

where T: CoordinateType,

type Edge = REdge<T>

Type of edge which will be returned.

type EdgeIter = RectEdgeIterator<T>

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, 4>

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.

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, 4>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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,

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 for Rect<T>

where T: PartialEq,

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: &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>

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.

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.

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

Cast to target data type.

impl<T> Copy for Rect<T>

where T: Copy,

impl<T> Eq for Rect<T>

where T: Eq,

impl<C> Polygon90Set<C> for Rect<<C as CoordinateBase>::Coord>

where C: CoordinateConcept,

impl<C> Polygon90WithHoles<C> for Rect<<C as CoordinateBase>::Coord>

where C: CoordinateConcept,

impl<T> StructuralPartialEq for Rect<T>