Struct Size 

pub struct Size {
    pub width: f64,
    pub height: f64,
}

A 2D size.

Fields

width: f64

The width.

height: f64

The height.

Implementations

impl Size

pub const ZERO: Size

A size with zero width or height.

pub const INFINITY: Size

A size with width and height set to f64::INFINITY.

pub const fn new(width: f64, height: f64) -> Size

Create a new Size with the provided width and height.

pub fn max_side(self) -> f64

Returns the max of width and height.

Examples

use kurbo::Size;
let size = Size::new(-10.5, 42.0);
assert_eq!(size.max_side(), 42.0);

pub fn min_side(self) -> f64

Returns the min of width and height.

Examples

use kurbo::Size;
let size = Size::new(-10.5, 42.0);
assert_eq!(size.min_side(), -10.5);

pub fn area(self) -> f64

The area covered by this size.

pub fn is_zero_area(self) -> bool

Whether this size has zero area.

pub fn min(self, other: Size) -> Size

Returns the component-wise minimum of self and other.

Examples

use kurbo::Size;

let this = Size::new(0., 100.);
let other = Size::new(10., 10.);

assert_eq!(this.min(other), Size::new(0., 10.));

pub fn max(self, other: Size) -> Size

Returns the component-wise maximum of self and other.

Examples

use kurbo::Size;

let this = Size::new(0., 100.);
let other = Size::new(10., 10.);

assert_eq!(this.max(other), Size::new(10., 100.));

pub fn clamp(self, min: Size, max: Size) -> Size

Returns a new size bounded by min and max.

Examples

use kurbo::Size;

let this = Size::new(0., 100.);
let min = Size::new(10., 10.,);
let max = Size::new(50., 50.);
assert_eq!(this.clamp(min, max), Size::new(10., 50.))

pub const fn to_vec2(self) -> Vec2

Convert this size into a Vec2, with width mapped to x and height mapped to y.

pub fn round(self) -> Size

Returns a new Size, with width and height rounded to the nearest integer.

Examples

use kurbo::Size;
let size_pos = Size::new(3.3, 3.6).round();
assert_eq!(size_pos.width, 3.0);
assert_eq!(size_pos.height, 4.0);
let size_neg = Size::new(-3.3, -3.6).round();
assert_eq!(size_neg.width, -3.0);
assert_eq!(size_neg.height, -4.0);

pub fn ceil(self) -> Size

Returns a new Size, with width and height rounded up to the nearest integer, unless they are already an integer.

Examples

use kurbo::Size;
let size_pos = Size::new(3.3, 3.6).ceil();
assert_eq!(size_pos.width, 4.0);
assert_eq!(size_pos.height, 4.0);
let size_neg = Size::new(-3.3, -3.6).ceil();
assert_eq!(size_neg.width, -3.0);
assert_eq!(size_neg.height, -3.0);

pub fn floor(self) -> Size

Returns a new Size, with width and height rounded down to the nearest integer, unless they are already an integer.

Examples

use kurbo::Size;
let size_pos = Size::new(3.3, 3.6).floor();
assert_eq!(size_pos.width, 3.0);
assert_eq!(size_pos.height, 3.0);
let size_neg = Size::new(-3.3, -3.6).floor();
assert_eq!(size_neg.width, -4.0);
assert_eq!(size_neg.height, -4.0);

pub fn expand(self) -> Size

Returns a new Size, with width and height rounded away from zero to the nearest integer, unless they are already an integer.

Examples

use kurbo::Size;
let size_pos = Size::new(3.3, 3.6).expand();
assert_eq!(size_pos.width, 4.0);
assert_eq!(size_pos.height, 4.0);
let size_neg = Size::new(-3.3, -3.6).expand();
assert_eq!(size_neg.width, -4.0);
assert_eq!(size_neg.height, -4.0);

pub fn trunc(self) -> Size

Returns a new Size, with width and height rounded towards zero to the nearest integer, unless they are already an integer.

Examples

use kurbo::Size;
let size_pos = Size::new(3.3, 3.6).trunc();
assert_eq!(size_pos.width, 3.0);
assert_eq!(size_pos.height, 3.0);
let size_neg = Size::new(-3.3, -3.6).trunc();
assert_eq!(size_neg.width, -3.0);
assert_eq!(size_neg.height, -3.0);

pub fn aspect_ratio_width(self) -> f64

Returns the aspect ratio of a rectangle with this size.

The aspect ratio is the ratio of the width to the height.

If the height is 0, the output will be sign(self.width) * infinity. If the width and height are both 0, then the output will be NaN.

pub fn aspect_ratio(self) -> f64

👎Deprecated since 0.12.0: You should use aspect_ratio_width instead, as this method returns a potentially unexpected value.

Returns the inverse of the aspect ratio of a rectangle with this size.

Aspect ratios are usually defined as the ratio of the width to the height, but this method incorrectly returns the ratio of height to width. You should generally prefer aspect_ratio_width.

If the width is 0, the output will be sign(self.height) * infinity. If the width and height are both 0, then the output will be NaN.

pub const fn to_rect(self) -> Rect

Convert this Size into a Rect with origin (0.0, 0.0).

pub fn to_rounded_rect(self, radii: impl Into<RoundedRectRadii>) -> RoundedRect

Convert this Size into a RoundedRect with origin (0.0, 0.0) and the provided corner radius.

pub fn is_finite(self) -> bool

Is this size finite?

pub fn is_nan(self) -> bool

Is this size NaN?

pub fn get_coord(self, axis: Axis) -> f64

Get the member matching the given axis.

pub fn get_coord_mut(&mut self, axis: Axis) -> &mut f64

Get a mutable reference to the member matching the given axis.

pub fn set_coord(&mut self, axis: Axis, value: f64)

Set the member matching the given axis to the given value.

Trait Implementations

impl Add for Size

type Output = Size

The resulting type after applying the + operator.

fn add(self, other: Size) -> Size

Performs the + operation.

impl AddAssign for Size

fn add_assign(&mut self, other: Size)

Performs the += operation.

impl Clone for Size

fn clone(&self) -> Size

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Size

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

Formats the value using the given formatter.

impl Default for Size

fn default() -> Size

Returns the “default value” for a type.

impl Display for Size

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

Formats the value using the given formatter.

impl Div<f64> for Size

type Output = Size

The resulting type after applying the / operator.

fn div(self, other: f64) -> Size

Performs the / operation.

impl DivAssign<f64> for Size

fn div_assign(&mut self, other: f64)

Performs the /= operation.

impl From<(f64, f64)> for Size

fn from(v: (f64, f64)) -> Size

Converts to this type from the input type.

impl Mul<f64> for Size

type Output = Size

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Size

Performs the * operation.

impl MulAssign<f64> for Size

fn mul_assign(&mut self, other: f64)

Performs the *= operation.

impl PartialEq for Size

fn eq(&self, other: &Size) -> 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 Sub for Size

type Output = Size

The resulting type after applying the - operator.

fn sub(self, other: Size) -> Size

Performs the - operation.

impl SubAssign for Size

fn sub_assign(&mut self, other: Size)

Performs the -= operation.

impl Copy for Size

impl StructuralPartialEq for Size