Struct embedded_graphics_core::primitives::rectangle::Rectangle

pub struct Rectangle {
    pub top_left: Point,
    pub size: Size,
}

Rectangle primitive

Examples

Create some rectangles with different styles

use embedded_graphics::{
    pixelcolor::Rgb565, prelude::*, primitives::{Rectangle, PrimitiveStyleBuilder},
};

// Rectangle with red 3 pixel wide stroke and green fill with the top left corner at (30, 20) and
// a size of (10, 15)
let style = PrimitiveStyleBuilder::new()
    .stroke_color(Rgb565::RED)
    .stroke_width(3)
    .fill_color(Rgb565::GREEN)
    .build();

Rectangle::new(Point::new(30, 20), Size::new(10, 15))
    .into_styled(style)
    .draw(&mut display)?;

// Rectangle with translation applied
Rectangle::new(Point::new(30, 20), Size::new(10, 15))
    .translate(Point::new(-20, -10))
    .into_styled(style)
    .draw(&mut display)?;

Fields

top_left: Point

Top left point of the rectangle.

size: Size

Size of the rectangle.

Implementations

impl Rectangle

pub const fn new(top_left: Point, size: Size) -> Self

Creates a new rectangle from the top left point and the size.

pub fn with_corners(corner_1: Point, corner_2: Point) -> Self

Creates a new rectangle from two corners.

pub const fn with_center(center: Point, size: Size) -> Self

Creates a new rectangle from the center point and the size.

For rectangles with even width and/or height the top left corner doesn’t align with the pixel grid. Because of this the coordinates of the top left corner will be rounded up to the nearest integer coordinate.

pub const fn zero() -> Rectangle

Returns a zero sized rectangle.

pub fn center(&self) -> Point

Returns the center of this rectangle.

For rectangles with even width and/or height the returned value is rounded down to the nearest integer coordinate.

pub fn bottom_right(&self) -> Option<Point>

Returns the bottom right corner of this rectangle.

Because the smallest rectangle that can be represented by its corners has a size of 1 x 1 pixels, this function returns None if the width or height of the rectangle is zero.

pub fn contains(&self, point: Point) -> bool

Return whether the rectangle contains a given point.

pub fn intersection(&self, other: &Rectangle) -> Rectangle

Returns a new Rectangle containing the intersection of self and other.

If no intersection is present, this method will return a zero sized rectangle.

Examples

Intersection

This example draws two rectangles to a mock display using the . character, along with their intersection shown with # characters.

use embedded_graphics::{
    mock_display::MockDisplay, pixelcolor::BinaryColor, prelude::*,
    primitives::{Rectangle, PrimitiveStyle},
};

let mut display = MockDisplay::new();

let rect1 = Rectangle::new(Point::zero(), Size::new(7, 8));
let rect2 = Rectangle::new(Point::new(2, 3), Size::new(10, 7));

let intersection = rect1.intersection(&rect2);

rect1
    .into_styled(PrimitiveStyle::with_stroke(BinaryColor::Off, 1))
    .draw(&mut display)?;

rect2
    .into_styled(PrimitiveStyle::with_stroke(BinaryColor::Off, 1))
    .draw(&mut display)?;

intersection
    .into_styled(PrimitiveStyle::with_stroke(BinaryColor::On, 1))
    .draw(&mut display)?;

display.assert_pattern(&[
    ".......     ",
    ".     .     ",
    ".     .     ",
    ". #####.....",
    ". #   #    .",
    ". #   #    .",
    ". #   #    .",
    "..#####    .",
    "  .        .",
    "  ..........",
]);

No intersection

This example creates two rectangles with no intersection between them. In this case, intersection returns a zero-sized rectangle.

use embedded_graphics::{prelude::*, primitives::{Rectangle, PrimitiveStyle}};

let rect1 = Rectangle::new(Point::zero(), Size::new(7, 8));
let rect2 = Rectangle::new(Point::new(10, 15), Size::new(10, 7));

let intersection = rect1.intersection(&rect2);

assert!(intersection.is_zero_sized());

pub fn resized(&self, size: Size, anchor_point: AnchorPoint) -> Self

Returns a resized copy of this rectangle.

The rectangle is resized relative to the given anchor point.

Examples

use embedded_graphics::{
    prelude::*,
    primitives::rectangle::Rectangle,
    geometry::AnchorPoint,
};

let rect = Rectangle::new(Point::new(20, 20), Size::new(10, 20));
let resized = rect.resized(Size::new(20, 10), AnchorPoint::Center);

assert_eq!(
    resized,
    Rectangle::new(Point::new(15, 25), Size::new(20, 10))
);

pub fn resized_width(&self, width: u32, anchor_x: AnchorX) -> Self

Returns a new rectangle with the given width, resized relative to the given anchor edge.

Examples

use embedded_graphics::{
    prelude::*,
    primitives::rectangle::Rectangle,
    geometry::AnchorX,
};

let rect = Rectangle::new(Point::new(20, 20), Size::new(10, 20));
let resized = rect.resized_width(20, AnchorX::Center);

assert_eq!(
    resized,
    Rectangle::new(Point::new(15, 20), Size::new(20, 20))
);

pub fn resized_height(&self, height: u32, anchor_y: AnchorY) -> Self

Returns a new rectangle with the given height, resized relative to the given anchor edge.

Examples

use embedded_graphics::{
    prelude::*,
    primitives::rectangle::Rectangle,
    geometry::AnchorY,
};

let rect = Rectangle::new(Point::new(20, 20), Size::new(10, 20));
let resized = rect.resized_height(10, AnchorY::Center);

assert_eq!(
    resized,
    Rectangle::new(Point::new(20, 25), Size::new(10, 10))
);

pub fn offset(&self, offset: i32) -> Self

Offset the rectangle by a given value.

Negative values will shrink the rectangle.

pub fn anchor_point(&self, anchor_point: AnchorPoint) -> Point

Returns an anchor point.

Examples

use embedded_graphics::{
    prelude::*,
    primitives::rectangle::Rectangle,
    geometry::AnchorPoint,
};

let mut rect = Rectangle::new(Point::new(20, 20), Size::new(11, 21));

assert_eq!(rect.anchor_point(AnchorPoint::TopLeft), Point::new(20, 20));
assert_eq!(
    rect.anchor_point(AnchorPoint::BottomCenter),
    Point::new(25, 40)
);

pub fn anchor_x(&self, anchor_x: AnchorX) -> i32

Returns the X coordinate of a given anchor edge of the rectangle.

Examples

use embedded_graphics::{
    prelude::*,
    primitives::rectangle::Rectangle,
    geometry::AnchorX,
};

let mut rect = Rectangle::new(Point::new(20, 20), Size::new(11, 21));

assert_eq!(rect.anchor_x(AnchorX::Left), 20);
assert_eq!(rect.anchor_x(AnchorX::Center), 25);

pub fn anchor_y(&self, anchor_y: AnchorY) -> i32

Returns the Y coordinate of a given anchor edge of the rectangle.

Examples

use embedded_graphics::{
    prelude::*,
    primitives::rectangle::Rectangle,
    geometry::AnchorY,
};

let mut rect = Rectangle::new(Point::new(20, 20), Size::new(11, 21));

assert_eq!(rect.anchor_y(AnchorY::Top), 20);
assert_eq!(rect.anchor_y(AnchorY::Bottom), 40);

pub fn rows(&self) -> Range<i32>

Returns the range of Y coordinates in this rectangle.

Examples

use embedded_graphics::{prelude::*, primitives::Rectangle};

let rect = Rectangle::new(Point::new(10, 20), Size::new(3, 4));
assert_eq!(rect.rows(), 20..24);

By combining this method with columns it is possible to iterate over all pixels inside the rectangle. This can be more flexible than using the points iterator, for example, if a different iteration order is required or some operations should be called once per row.

use embedded_graphics::{prelude::*, primitives::Rectangle};

let rect = Rectangle::new(Point::new(10, 20), Size::new(3, 4));

// Iterate over the y coordinates of the rows in reverse order.
for y in rect.rows().rev() {
    for x in rect.columns() {
        // use x, y coordinates
    }
}

pub fn columns(&self) -> Range<i32>

Returns the range of X coordinates in this rectangle.

Examples

use embedded_graphics::{prelude::*, primitives::Rectangle};

let rect = Rectangle::new(Point::new(10, 20), Size::new(3, 4));

assert_eq!(rect.columns(), 10..13);

By combining this method with rows it is possible to iterator over all pixels inside the rectangle. This can be more flexible than using the points iterator, for example, if a different iteration order is required or some operations should be called once per row.

use embedded_graphics::{prelude::*, primitives::Rectangle};

let rect = Rectangle::new(Point::new(10, 20), Size::new(3, 4));

// Iterate over all points starting from the top right corner and advancing downwards.
for x in rect.columns().rev() {
    for y in rect.rows() {
        // use x, y coordinates
    }
}

pub const fn is_zero_sized(&self) -> bool

Returns true is the rectangle is zero sized.

A rectangle is zero sized if the width or height are zero.

Examples

use embedded_graphics::{prelude::*, primitives::Rectangle};

let rect = Rectangle::new(Point::new(10, 20), Size::new(10, 20));
assert_eq!(rect.is_zero_sized(), false);

let rect = Rectangle::new(Point::new(10, 20), Size::zero());
assert_eq!(rect.is_zero_sized(), true);

Trait Implementations

impl Clone for Rectangle

fn clone(&self) -> Rectangle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rectangle

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

Formats the value using the given formatter.

impl Default for Rectangle

fn default() -> Rectangle

Returns the “default value” for a type.

impl Dimensions for Rectangle

fn bounding_box(&self) -> Rectangle

Returns the bounding box.

impl Hash for Rectangle

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given [Hasher].

impl Ord for Rectangle

fn cmp(&self, other: &Rectangle) -> Ordering

This method returns an [Ordering] between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Rectangle

fn eq(&self, other: &Rectangle) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Rectangle

fn partial_cmp(&self, other: &Rectangle) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PointsIter for Rectangle

type Iter = Points

Iterator over all points inside the primitive.

fn points(&self) -> Self::Iter

Returns an iterator over all points inside the primitive.

impl Copy for Rectangle

impl Eq for Rectangle

impl StructuralPartialEq for Rectangle