[−][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).

Implementations

`impl Rect`[src]

`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 from_center_size(center: impl Into<Point>, size: impl Into<Size>) -> Rect`[src]

A new rectangle from center and size.

`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 the center of the Rect to the nearest integer, unless they are already an integer. That is to say this function will return the smallest possible Rect with integer coordinates that is a superset of self.

Examples

use kurbo::Rect;

// In positive space
let rect = Rect::new(3.3, 3.6, 5.6, 4.1).expand();
assert_eq!(rect.x0, 3.0);
assert_eq!(rect.y0, 3.0);
assert_eq!(rect.x1, 6.0);
assert_eq!(rect.y1, 5.0);

// In both positive and negative space
let rect = Rect::new(-3.3, -3.6, 5.6, 4.1).expand();
assert_eq!(rect.x0, -4.0);
assert_eq!(rect.y0, -4.0);
assert_eq!(rect.x1, 6.0);
assert_eq!(rect.y1, 5.0);

// In negative space
let rect = Rect::new(-5.6, -4.1, -3.3, -3.6).expand();
assert_eq!(rect.x0, -6.0);
assert_eq!(rect.y0, -5.0);
assert_eq!(rect.x1, -3.0);
assert_eq!(rect.y1, -3.0);

// Inverse orientation
let rect = Rect::new(5.6, -3.6, 3.3, -4.1).expand();
assert_eq!(rect.x0, 6.0);
assert_eq!(rect.y0, -3.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -5.0);

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

Returns a new Rect, with each coordinate value rounded towards the center of the Rect to the nearest integer, unless they are already an integer. That is to say this function will return the biggest possible Rect with integer coordinates that is a subset of self.

Examples

use kurbo::Rect;

// In positive space
let rect = Rect::new(3.3, 3.6, 5.6, 4.1).trunc();
assert_eq!(rect.x0, 4.0);
assert_eq!(rect.y0, 4.0);
assert_eq!(rect.x1, 5.0);
assert_eq!(rect.y1, 4.0);

// In both positive and negative space
let rect = Rect::new(-3.3, -3.6, 5.6, 4.1).trunc();
assert_eq!(rect.x0, -3.0);
assert_eq!(rect.y0, -3.0);
assert_eq!(rect.x1, 5.0);
assert_eq!(rect.y1, 4.0);

// In negative space
let rect = Rect::new(-5.6, -4.1, -3.3, -3.6).trunc();
assert_eq!(rect.x0, -5.0);
assert_eq!(rect.y0, -4.0);
assert_eq!(rect.x1, -4.0);
assert_eq!(rect.y1, -4.0);

// Inverse orientation
let rect = Rect::new(5.6, -3.6, 3.3, -4.1).trunc();
assert_eq!(rect.x0, 5.0);
assert_eq!(rect.y0, -4.0);
assert_eq!(rect.x1, 4.0);
assert_eq!(rect.y1, -4.0);

`pub fn to_rounded_rect(self, radius: f64) -> RoundedRect`[src]

Creates a new RoundedRect from this Rect and the provided corner radius.

`pub fn to_ellipse(self) -> Ellipse`[src]

Returns the Ellipse that is bounded by this Rect.

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

The aspect ratio of the Rect.

This is defined as the height divided by the width. It measures the "squareness" of the rectangle (a value of 1 is square). If the width is 0 the output will be `sign(y1 - y0)

infinity. If The width and height are 0, the result will be NaN`.

`pub fn contained_rect_with_aspect_ratio(&self, aspect_ratio: f64) -> Rect`[src]

Returns the largest possible Rect that is fully contained in self with the given aspect_ratio.

The aspect ratio is specified fractionally, as height / width.

The resulting rectangle will be centered if it is smaller than the input rectangle.

For the special case where the aspect ratio is 1.0, the resulting Rect will be square.

Examples

let outer = Rect::new(0.0, 0.0, 10.0, 20.0);
let inner = outer.contained_rect_with_aspect_ratio(1.0);
// The new `Rect` is a square centered at the center of `outer`.
assert_eq!(inner, Rect::new(0.0, 5.0, 10.0, 15.0));