embedded_graphics_core::primitives::rectangle

Struct Rectangle

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

Expand description

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§

source §

impl Rectangle

source

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

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

source

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

Creates a new rectangle from two corners.

source

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.

source

pub const fn zero() -> Rectangle

Returns a zero sized rectangle.

source

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.

source

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.

source

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

Return whether the rectangle contains a given point.

source

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());

source

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))
);

source

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))
);

source

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))
);

source

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

Offset the rectangle by a given value.

Negative values will shrink the rectangle.

source

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)
);

source

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);

source

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);

source

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
    }
}

source

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
    }
}

source

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);