[−][src]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`[src]

`pub const ZERO: Rect`[src]

The empty rectangle at the origin.

`pub const fn new(x0: f64, y0: f64, x1: f64, y1: f64) -> Rect`[src]

A new rectangle from minimum and maximum coordinates.

`pub fn from_points(p0: impl Into<Point>, p1: impl Into<Point>) -> Rect`[src]

A new rectangle from two points.

The result will have non-negative width and height.

`pub fn from_origin_size(origin: impl Into<Point>, size: impl Into<Size>) -> Rect`[src]

A new rectangle from origin and size.

The result will have non-negative width and height.

`pub fn with_origin(self, origin: impl Into<Point>) -> Rect`[src]

Create a new Rect with the same size as self and a new origin.

`pub fn with_size(self, size: impl Into<Size>) -> Rect`[src]

Create a new Rect with the same origin as self and a new size.

`pub fn inset(self, insets: impl Into<Insets>) -> Rect`[src]

Create a new Rect by applying the Insets.

This will not preserve negative width and height.

Examples

use kurbo::Rect;
let inset_rect = Rect::new(0., 0., 10., 10.,).inset(2.);
assert_eq!(inset_rect.width(), 14.0);
assert_eq!(inset_rect.x0, -2.0);
assert_eq!(inset_rect.x1, 12.0);

`pub fn width(&self) -> f64`[src]

The width of the rectangle.

Note: nothing forbids negative width.

`pub fn height(&self) -> f64`[src]

The height of the rectangle.

Note: nothing forbids negative height.

`pub fn min_x(&self) -> f64`[src]

Returns the minimum value for the x-coordinate of the rectangle.

`pub fn max_x(&self) -> f64`[src]

Returns the maximum value for the x-coordinate of the rectangle.

`pub fn min_y(&self) -> f64`[src]

Returns the minimum value for the y-coordinate of the rectangle.

`pub fn max_y(&self) -> f64`[src]

Returns the maximum value for the y-coordinate of the rectangle.

`pub fn origin(&self) -> Point`[src]

The origin of the rectangle.

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

`pub fn size(&self) -> Size`[src]

The size of the rectangle.

`pub fn area(&self) -> f64`[src]

The area of the rectangle.

`pub fn center(&self) -> Point`[src]

The center point of the rectangle.

`pub fn contains(&self, point: Point) -> bool`[src]

Returns true if point lies within self.

`pub fn abs(&self) -> Rect`[src]

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`[src]

The smallest rectangle enclosing two rectangles.

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

`pub fn union_pt(&self, pt: Point) -> Rect`[src]

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`[src]

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`[src]

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.

`pub fn round(self) -> Rect`[src]

Returns a new Rect, with each coordinate value rounded to the nearest integer.

Examples

use kurbo::Rect;
let rect = Rect::new(3.3, 3.6, 3.0, -3.1).round();
assert_eq!(rect.x0, 3.0);
assert_eq!(rect.y0, 4.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -3.0);

`pub fn ceil(self) -> Rect`[src]

Returns a new Rect, with each coordinate value rounded up to the nearest integer, unless they are already an integer.

Examples

use kurbo::Rect;
let rect = Rect::new(3.3, 3.6, 3.0, -3.1).ceil();
assert_eq!(rect.x0, 4.0);
assert_eq!(rect.y0, 4.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -3.0);

`pub fn floor(self) -> Rect`[src]

Returns a new Rect, with each coordinate value rounded down to the nearest integer, unless they are already an integer.

Examples

use kurbo::Rect;
let rect = Rect::new(3.3, 3.6, 3.0, -3.1).floor();
assert_eq!(rect.x0, 3.0);
assert_eq!(rect.y0, 3.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -4.0);

`pub fn expand(self) -> Rect`[src]

Returns a new Rect, with each coordinate value rounded away from zero to the nearest integer, unless they are already an integer.

Examples

use kurbo::Rect;
let rect = Rect::new(3.3, 3.6, 3.0, -3.1).expand();
assert_eq!(rect.x0, 4.0);
assert_eq!(rect.y0, 4.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -4.0);

`pub fn trunc(self) -> Rect`[src]

Returns a new Rect, with each coordinate value rounded towards zero to the nearest integer, unless they are already an integer.

Examples

use kurbo::Rect;
let rect = Rect::new(3.3, 3.6, 3.0, -3.1).trunc();
assert_eq!(rect.x0, 3.0);
assert_eq!(rect.y0, 3.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -3.0);