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

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

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. 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.
§

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

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

§

impl<T> StructuralPartialEq for Rect<T>

Auto Trait Implementations§

§

impl<T> RefUnwindSafe for Rect<T>where T: RefUnwindSafe,

§

impl<T> Send for Rect<T>where T: Send,

§

impl<T> Sync for Rect<T>where T: Sync,

§

impl<T> Unpin for Rect<T>where T: Unpin,

§

impl<T> UnwindSafe for Rect<T>where T: UnwindSafe,

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§

impl<T> DeserializeOwned for Twhere T: for<'de> Deserialize<'de>,

source§

impl<T> IdType for Twhere T: Debug + Clone + Eq + Hash + 'static,

source§

impl<T> IdTypeMT for Twhere T: IdType + Sync + Send,

§

impl<T> TextType for Twhere T: Eq + Hash + Clone + Debug,