Struct Canvas 

pub struct Canvas {
    pub pixmap: Pixmap,
    pub scale: f32,
    /* private fields */
}

A Canvas is an abstraction over a tiny-skia Pixmap that allows for drawing at different scales. This allows for using the same drawing commands to produce images of different sizes.

Example

use wassily_core::*;
use tiny_skia::Color;

fn draw(canvas: &mut Canvas) {
    canvas.fill(Color::from_rgba8(128, 128, 128, 255));
    let center = pt(canvas.width() / 2, canvas.height() / 2);
    Shape::new()
        .ellipse(center, 300.0, 200.0)
        .fill_color(Color::from_rgba8(75, 0, 130, 255))
        .stroke_color(Color::from_rgba8(255, 165, 0, 255))
        .stroke_weight(10.0)
        .draw(canvas);
}

fn main() {
   let mut canvas1 = Canvas::new(500, 500);
    // Draw a 300x200 ellipse at the center of a 500 x 500 canvas.
    draw(&mut canvas1);

    let mut canvas2 = Canvas::with_scale(500, 500, 2.0);
    // Draw a 600x400 ellipse at the center of a 1000 x 1000 canvas. That is,
    // the exact same image as above, but, double the width and height.
    draw(&mut canvas2);

    canvas1.save_png("./scale1.png");
    canvas2.save_png("./scale2.png");
}

Fields

pixmap: Pixmap

The underlying tiny-skia Pixmap.

scale: f32

The scale factor of the canvas. This is the factor by which the width and height are scaled. For example, a scale of 2.0 means that the width and height are doubled when rendering.

Implementations

impl Canvas

pub fn new(width: u32, height: u32) -> Canvas

Create a new unscaled Canvas.

pub fn from_image(image: &DynamicImage) -> Canvas

pub fn with_scale(width: u32, height: u32, scale: f32) -> Canvas

Create a new Canvas with a scale factor. The actual size of the canvas is the width times the scale and the height times the scale. However, all drawing commands should use the pre-scaled width and height.

pub fn width(&self) -> u32

pub fn height(&self) -> u32

The pre-scaled height of the canvas in pixels as a u32.

pub fn w_f32(&self) -> f32

The pre-scaled width of the canvas in pixels as a f32.

pub fn h_f32(&self) -> f32

The pre-scaled height of the canvas in pixels as a f32.

pub fn w_usize(&self) -> usize

The pre-scaled width of the canvas in pixels as a usize.

pub fn h_usize(&self) -> usize

The pre-scaled height of the canvas in pixels as a usize.

pub fn fill(&mut self, color: Color)

Fill the entire canvas with a Color.

pub fn fill_path( &mut self, path: &Path, paint: &mut Paint<'_>, fill_rule: FillRule, transform: Transform, clip_mask: Option<&Mask>, )

Fill the path with a Paint.

pub fn fill_rect( &mut self, rect: Rect, paint: &mut Paint<'_>, transform: Transform, clip_mask: Option<&Mask>, )

Fill a rectangle with a Paint.

pub fn stroke_path( &mut self, path: &Path, paint: &mut Paint<'_>, stroke: &Stroke, transform: Transform, clip_mask: Option<&Mask>, )

Stroke a path with a Paint.

pub fn dot(&mut self, x: f32, y: f32, color: Color)

Color a single pixel on the canvas. !!! Warning this function will not scale with the canvas.

pub fn save_png<P: AsRef<Path>>(&self, path: P)

Save the Canvas as a png.

pub fn save_jpg<P: AsRef<Path>>(&self, path: P)

Save the Canvas as a jpg.

pub fn save_tiff<P: AsRef<Path>>(&self, path: P)

Save the Canvas as a tiff.

pub fn data(&self) -> &[u8]

pub fn take(self) -> Vec<u8>

Trait Implementations

impl From<&Canvas> for RgbaImage

Convert a &Canvas to a RgbaImage.

fn from(canvas: &Canvas) -> Self

Converts to this type from the input type.

impl From<&ImageBuffer<Rgb<u8>, Vec<u8>>> for Canvas

Convert a &RgbImage to a Canvas.

fn from(ib: &RgbImage) -> Self

Converts to this type from the input type.

impl From<&ImageBuffer<Rgba<u8>, Vec<u8>>> for Canvas

Convert a &RgbaImage to a Canvas.

fn from(ib: &RgbaImage) -> Self

Converts to this type from the input type.

impl From<Canvas> for RgbaImage

Convert a Canvas to a RgbaImage.

fn from(canvas: Canvas) -> Self

Converts to this type from the input type.

impl From<ImageBuffer<Rgb<u8>, Vec<u8>>> for Canvas

Convert a RgbImage to a Canvas.

fn from(ib: RgbImage) -> Self

Converts to this type from the input type.

impl From<ImageBuffer<Rgba<u8>, Vec<u8>>> for Canvas

Convert a RgbaImage to a Canvas.

fn from(ib: RgbaImage) -> Self

Converts to this type from the input type.