Struct Rectangle 

pub struct Rectangle<T> {
    pub min: Point<T, T>,
    pub max: Point<T, T>,
}

Represents a rectangle in 2D space defined by its minimum (bottom-left) and maximum (top-right) corner points.

Fields

min: Point<T, T>

The minimum (bottom-left) corner point

max: Point<T, T>

The maximum (top-right) corner point

Implementations

impl<T: Clone + Ord + Copy + Add<Output = T>> Rectangle<T>

pub fn new(min: Point<T, T>, max: Point<T, T>) -> Self

Creates a new rectangle from min and max points

Arguments

• min - The minimum (bottom-left) corner
• max - The maximum (top-right) corner

Examples

use physdes::{Point, vlsi_ops::Rectangle};

let rect = Rectangle::new(
    Point::new(0, 0),
    Point::new(10, 20)
);

pub fn from_dimensions(origin: Point<T, T>, width: T, height: T) -> Self

Creates a rectangle from origin, width, and height

pub fn overlaps(&self, other: &Self) -> bool

Checks if this rectangle overlaps with another

Two rectangles overlap iff their projections on both axes overlap:

$$[a_x,b_x] \cap [c_x,d_x] \neq \varnothing \land [a_y,b_y] \cap [c_y,d_y] \neq \varnothing$$

Examples

use physdes::{Point, vlsi_ops::Rectangle};

let rect1 = Rectangle::new(Point::new(0, 0), Point::new(10, 10));
let rect2 = Rectangle::new(Point::new(5, 5), Point::new(15, 15));
assert!(rect1.overlaps(&rect2));

let rect3 = Rectangle::new(Point::new(20, 20), Point::new(30, 30));
assert!(!rect1.overlaps(&rect3));

pub fn contains(&self, other: &Self) -> bool

Checks if this rectangle contains another rectangle

$$A \supseteq B \iff A_{\min x} \le B_{\min x} \land A_{\max x} \ge B_{\max x}$$

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

Checks if this rectangle contains a point

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

where T: Add<Output = T>,

Computes the intersection with another rectangle

$$A \cap B = [\max(x_{A\min}, x_{B\min}),; \min(x_{A\max}, x_{B\max})] \times [\max(y_{A\min}, y_{B\min}),; \min(y_{A\max}, y_{B\max})]$$

Returns None if the rectangles don’t overlap

pub fn area(&self) -> T

where T: Sub<Output = T> + Mul<Output = T>,

Computes the area of the rectangle

$$A = w \times h = (x_{\max} - x_{\min}) \times (y_{\max} - y_{\min})$$

pub fn bounding_rect(&self, other: &Self) -> Self

Computes the bounding rectangle of two rectangles

$$\text{bbox}(A,B) = [\min(x_{A\min}, x_{B\min}),; \max(x_{A\max}, x_{B\max})] \times [\min(y_{A\min}, y_{B\min}),; \max(y_{A\max}, y_{B\max})]$$

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

where T: Clone + Add<Output = T> + Num + AddAssign + Ord,

Converts to a Polygon

Trait Implementations

impl<T: Clone> Clone for Rectangle<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Rectangle<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Rectangle<T>

impl<T: PartialEq> PartialEq for Rectangle<T>

fn eq(&self, other: &Rectangle<T>) -> 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<T: PartialEq> StructuralPartialEq for Rectangle<T>