Struct kurbo::Rect

pub struct Rect {
    pub x0: f64,
    pub y0: f64,
    pub x1: f64,
    pub y1: f64,
}

A rectangle.

Fields

x0: f64

The minimum x coordinate (left edge).

y0: f64

The minimum y coordinate (top edge in y-down spaces).

x1: f64

The maximum x coordinate (right edge).

y1: f64

The maximum y coordinate (bottom edge in y-down spaces).

Methods

impl Rect

pub fn new(x0: f64, y0: f64, x1: f64, y1: f64) -> Rect

A new rectangle from minimum and maximum coordinates.

pub fn from_points(p0: Vec2, p1: Vec2) -> Rect

A new rectangle from two points.

The result will have non-negative width and height.

pub fn from_origin_size(origin: Vec2, size: Vec2) -> Rect

A new rectangle from origin and size.

The result will have non-negative width and height.

pub fn width(&self) -> f64

The width of the rectangle.

Note: nothing forbids negative width.

pub fn height(&self) -> f64

The height of the rectangle.

Note: nothing forbids negative height.

pub fn origin(&self) -> Vec2

The origin of the vector.

This is the top left corner in a y-down space and with non-negative width and height.

pub fn size(&self) -> Vec2

The size of the rectangle, as a vector.

pub fn area(&self) -> f64

The area of the rectangle.

pub fn center(&self) -> Vec2

The center point of the rectangle.

pub fn abs(&self) -> Rect

Take absolute value of width and height.

The resulting rect has the same extents as the original, but is guaranteed to have non-negative width and height.

pub fn union(&self, other: Rect) -> Rect

The smallest rectangle enclosing two rectangles.

Results are valid only if width and height are non-negative.

pub fn union_pt(&self, pt: Vec2) -> Rect

Compute the union with one point.

This method includes the perimeter of zero-area rectangles. Thus, a succession of union_pt operations on a series of points yields their enclosing rectangle.

Results are valid only if width and height are non-negative.

pub fn intersect(&self, other: Rect) -> Rect

The intersection of two rectangles.

The result is zero-area if either input has negative width or height. The result always has non-negative width and height.

pub fn inflate(&self, width: f64, height: f64) -> Rect

Expand a rectangle by a constant amount in both directions.

The logic simply applies the amount in each direction. If rectangle area or added dimensions are negative, this could give odd results.

Trait Implementations

impl Shape for Rect

type BezPathIter = RectPathIter

The iterator resulting from to_bez_path.

fn to_bez_path(&self, _tolerance: f64) -> RectPathIter

Convert to a Bézier path, as an iterator over path elements.

fn area(&self) -> f64

Signed area.

fn perimeter(&self, _accuracy: f64) -> f64

Total length of perimeter.

fn winding(&self, pt: Vec2) -> i32

Note: this function is carefully designed so that if the plane is tiled with rectangles, the winding number will be nonzero for exactly one of them.

fn bounding_box(&self) -> Rect

The smallest rectangle that encloses the shape.

fn as_rect(&self) -> Option<Rect>

If the shape is a rectangle, make it available.

fn into_bez_path(self, tolerance: f64) -> BezPath

fn as_line(&self) -> Option<Line>

If the shape is a line, make it available.

fn as_circle(&self) -> Option<Circle>

If the shape is a circle, make it available.

fn as_path_slice(&self) -> Option<&[PathEl]>

If the shape is stored as a slice of path elements, make that available.

impl Clone for Rect

fn clone(&self) -> Rect

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Rect

impl From<((f64, f64), (f64, f64))> for Rect

fn from(coords: ((f64, f64), (f64, f64))) -> Rect

Performs the conversion.

impl From<Rect> for ((f64, f64), (f64, f64))

fn from(r: Rect) -> ((f64, f64), (f64, f64))

Performs the conversion.

impl Default for Rect

fn default() -> Rect

Returns the "default value" for a type.

impl Debug for Rect

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

Formats the value using the given formatter.

impl Sub<Vec2> for Rect

type Output = Rect

The resulting type after applying the - operator.

fn sub(self, v: Vec2) -> Rect

Performs the - operation.

impl Add<Vec2> for Rect

type Output = Rect

The resulting type after applying the + operator.

fn add(self, v: Vec2) -> Rect

Performs the + operation.