Struct Canvas 

pub struct Canvas { /* private fields */ }

Implementations

impl Canvas

pub fn height(&self) -> usize

pub fn width(&self) -> usize

pub fn set_pixel(&mut self, x: usize, y: usize, r: u8, g: u8, b: u8)

Examples found in repository

examples/rotating_square.rs (lines 49-55)

fn main() {
    let config: RGBMatrixConfig = argh::from_env();
    let rows = config.rows as isize;
    let cols = config.cols as isize;
    let (mut matrix, mut canvas) = RGBMatrix::new(config, 0).expect("Matrix initialization failed");

    let [center_x, center_y] = [cols / 2, rows / 2];

    let rotate_square = (rows.min(cols) as f64 * 1.41) as isize;
    let min_rotate = center_x - rotate_square / 2;
    let max_rotate = center_x + rotate_square / 2;

    let display_square = (rows.min(cols) as f64 * 0.7) as isize;
    let min_display = center_x - display_square / 2;
    let max_display = center_x + display_square / 2;

    for step in 0.. {
        let rotation_deg = step as f64 / 2.0;
        for x in min_rotate..max_rotate {
            for y in min_rotate..max_rotate {
                let [rot_x, rot_y] =
                    rotate([x - center_x, y - center_x], rotation_deg.to_radians());
                let canvas_x = rot_x + center_x as f64;
                let canvas_y = rot_y + center_y as f64;
                if (min_display..max_display).contains(&x)
                    && (min_display..max_display).contains(&y)
                {
                    canvas.set_pixel(
                        canvas_x as usize,
                        canvas_y as usize,
                        scale_col(x, min_display, max_display),
                        255 - scale_col(y, min_display, max_display),
                        scale_col(y, min_display, max_display),
                    )
                } else {
                    canvas.set_pixel(canvas_x as usize, canvas_y as usize, 0, 0, 0)
                }
            }
        }

        canvas = matrix.update_on_vsync(canvas);

        if step % 120 == 0 {
            print!("\r{:>100}\rFramerate: {}", "", matrix.get_framerate());
            std::io::stdout().flush().unwrap();
        }
    }
}

pub fn fill(&mut self, r: u8, g: u8, b: u8)

Examples found in repository

examples/image.rs (line 30)

fn main() {
    let config: RGBMatrixConfig = argh::from_env();
    let rows = config.rows;
    let cols = config.cols;
    let (mut matrix, mut canvas) = RGBMatrix::new(config, 0).expect("Matrix initialization failed");

    let image_data = ImageRawBE::<Rgb888>::new(IMAGE_DATA, IMAGE_SIZE as u32);
    let image = Image::new(
        &image_data,
        Point::new(
            (cols / 2 - IMAGE_SIZE / 2) as i32,
            (rows / 2 - IMAGE_SIZE / 2) as i32,
        ),
    );

    for step in 0.. {
        canvas.fill(0, 0, 0);
        image.draw(canvas.as_mut()).unwrap();
        canvas = matrix.update_on_vsync(canvas);

        if step % 120 == 0 {
            print!("\r{:>100}\rFramerate: {}", "", matrix.get_framerate());
            std::io::stdout().flush().unwrap();
        }
    }
}

examples/drawing.rs (line 49)

fn main() {
    let config: RGBMatrixConfig = argh::from_env();
    let rows = config.rows as i32;
    let cols = config.cols as i32;

    let (mut matrix, mut canvas) = RGBMatrix::new(config, 0).expect("Matrix initialization failed");

    let circle = {
        let thin_stroke = PrimitiveStyle::with_stroke(Rgb888::CSS_GRAY, 1);
        Circle::with_center(
            Point::new(rows / 2 - 1, cols / 2 - 1),
            rows.min(cols) as u32 - 2,
        )
        .into_styled(thin_stroke)
    };
    let top = Line::new(Point::new(0, 0), Point::new(cols - 1, 0))
        .into_styled(PrimitiveStyle::with_stroke(Rgb888::GREEN, 1));
    let bottom = Line::new(Point::new(0, rows - 1), Point::new(cols - 1, rows - 1))
        .into_styled(PrimitiveStyle::with_stroke(Rgb888::CYAN, 1));
    let left = Line::new(Point::new(0, 0), Point::new(0, rows - 1))
        .into_styled(PrimitiveStyle::with_stroke(Rgb888::RED, 1));
    let right = Line::new(Point::new(cols - 1, 0), Point::new(cols - 1, rows - 1))
        .into_styled(PrimitiveStyle::with_stroke(Rgb888::BLUE, 1));
    let diagonal1 = Line::new(Point::new(0, 0), Point::new(cols - 1, rows - 1))
        .into_styled(PrimitiveStyle::with_stroke(Rgb888::YELLOW, 1));
    let diagonal2 = Line::new(Point::new(cols - 1, 0), Point::new(0, rows - 1))
        .into_styled(PrimitiveStyle::with_stroke(Rgb888::MAGENTA, 1));

    let text = Text::with_alignment(
        "Hello\nWorld",
        Point::new(cols / 2, rows / 2),
        MonoTextStyle::new(&FONT_6X10, Rgb888::WHITE),
        Alignment::Center,
    );

    for step in 0.. {
        canvas.fill(0, 0, 0);
        circle.draw(canvas.as_mut()).unwrap();
        [diagonal1, diagonal2, top, bottom, left, right]
            .iter()
            .for_each(|line| line.draw(canvas.as_mut()).unwrap());
        if (step / 100) % 2 == 0 {
            text.draw(canvas.as_mut()).unwrap();
        }
        canvas = matrix.update_on_vsync(canvas);

        if step % 120 == 0 {
            print!("\r{:>100}\rFramerate: {}", "", matrix.get_framerate());
            std::io::stdout().flush().unwrap();
        }
    }
}

pub fn set_pwm_bits(&mut self, pwm_bits: usize)

pub fn set_brightness(&mut self, brightness: u8)

Set the canvas’ brightness in percent.

Trait Implementations

impl Clone for Canvas

fn clone(&self) -> Canvas

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DrawTarget for Canvas

type Color = Rgb888

The pixel color type the targetted display supports.

type Error = Infallible

Error type to return when a drawing operation fails.

fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>

where I: IntoIterator<Item = Pixel<Self::Color>>,

Draw individual pixels to the display without a defined order.

fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error>

Fill the entire display with a solid color.

fn fill_contiguous<I>( &mut self, area: &Rectangle, colors: I, ) -> Result<(), Self::Error>

where I: IntoIterator<Item = Self::Color>,

Fill a given area with an iterator providing a contiguous stream of pixel colors.

fn fill_solid( &mut self, area: &Rectangle, color: Self::Color, ) -> Result<(), Self::Error>

Fill a given area with a solid color.

impl OriginDimensions for Canvas

fn size(&self) -> Size

Returns the size of the bounding box.