Struct Context

pub struct Context { /* private fields */ }

Context

A Context is a drawing context, used to perform operations against a pseudo-canvas. Those operations are later collected up and turned into an SVG, including line strokes, fills, and all the other useful tools that we need to drive a plotter robot.

Example

use aoer_plotty_rs::context::Context;

let mut ctx = Context::new();
ctx.stroke("black")
   .fill("red")
   .pen(0.5)
   .outline(Some(5.0))
   .poly(vec![(0.0,0.0),
          (25.0,0.0),
          (25.0,25.0),
          (0.0,25.0)],
vec![])
   .outline(None)
   .hatch(135.0)
   .stroke("blue")
   .fill("yellow")
   .circle(12.5,12.5, 5.0)
   .push()
   .hatch(180.0)
   .stroke("red")
   .fill("green")
   .circle(17.5,12.5,2.5)
   .pop().unwrap()
   .hatch(0.0)
   .clip(true)
   .circle(7.5,12.5,2.5)
   .clip(false)
   .stroke("brown")
   .pen(1.0)
   .line(0.0, 0.0, 3.0, 3.0)
   .pen(0.1)
   .outline(Some(1.0))
   .stroke("pink")
   .line(3.0, 0.0, 0.0, 3.0)
   .stroke("purple")
   .spline(&vec![(0.0, 25.0), (0.0, 25.0), (10.0, 20.0), (20.0,25.0), (25.0, 25.0)],
           8, 0.5)
   .push()  // Prepare for this transformation stuff...
   .transform(Some(
       &(Context::translate_matrix(25.0, 25.0)
       * Context::rotate_matrix(45.0)
       * Context::scale_matrix(1.0, 0.5)
   ))) // Holy crap we can multiply these?! ;)
   .stroke("cyan")
   .circle(0.0, 0.0, 8.0)
   .pop().unwrap() // We're back to purple and regular coords
   .outline(None)
    .stroke("green")
    .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
    .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
;

Implementations

impl Context

pub fn accuracy(&mut self, accuracy: f64) -> &mut Self

Set accuracy (allowed tolerance) in mm

Examples found in repository

examples/carlson_smith_gallery_nannou.rs (line 49)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

pub fn default_font() -> Font

Default font

pub fn finalize_arrangement( &self, arrangement: &Arrangement<f64>, ) -> Arrangement<f64>

Finalize Arrangement

Examples found in repository

examples/ga_09_hours_of_dark.rs (lines 59-63)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/ga_08_piet_mondrian.rs (lines 129-133)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn viewbox(x0: f64, y0: f64, x1: f64, y1: f64) -> Rect<f64>

Viewbox helper. Useful to create an arbitrary viewbox for your SVGs.

Examples found in repository

examples/ga_09_hours_of_dark.rs (line 61)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/ga_08_piet_mondrian.rs (line 131)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn scale_matrix(sx: f64, sy: f64) -> Affine2<f64>

Helper to create a scaling matrix

Examples found in repository

examples/carlson_smith_gallery_nannou.rs (line 66)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

examples/context_basic.rs (line 59)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn unit_matrix() -> Affine2<f64>

Unit matrix. Basically a no-op

pub fn translate_matrix(tx: f64, ty: f64) -> Affine2<f64>

Helper to create a translation matrix

Examples found in repository

examples/carlson_smith_gallery_nannou.rs (line 66)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

examples/ga_09_hours_of_dark.rs (line 44)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 57)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn rotate_matrix(degrees: f64) -> Affine2<f64>

Angle is in degrees because I am a terrible person. Also, compass degrees. For an SVG anyhow. I am a bastard.

Examples found in repository

examples/ga_09_hours_of_dark.rs (line 47)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 58)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn new() -> Context

I can haz a new default drawing context?

Examples found in repository

examples/typography.rs (line 9)

fn main() {
    let mut ctx = Context::new();
    let mut typ = Typography::new();
    typ.size(2.0);
    typ.close(true);

    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .pattern(Hatches::none())
        // .pattern(LineHatch::gen())
        // .typography(&"i".to_string(), 50.0, 50.0, &typ);
        .typography(&"Left".to_string(), 50.0, 50.0, &typ);
    typ.align(TextAlignment::Right);
    ctx.typography(&"Right".to_string(), 50.0, 90.0, &typ);
    typ.align(TextAlignment::Center);
    ctx.typography(&"Center".to_string(), 50.0, 70.0, &typ);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/carlson_smith_fibo_nannou.rs (line 28)

    fn generate(&mut self) {
        let /*mut*/ _ctx = Context::new();
        let mut fibval = 1;
        let mut lastfib = 0;
        let mut angle = 0.0f64;

        for _i in 0..self.settings.fibdepth {
            let scale = self.settings.scale * (<f64 as From<i32>>::from(fibval));
            // let translation = Context::translate_matrix(scale, scale) * Context::rotate_matrix(angle);
            let _origin = coord! {
                x: scale*(angle*(PI/180.0)).cos(),
                y: scale*(angle*(PI/180.0)).sin()
            };
            // let base_scale = 2.0f64 * (f64::from(fibval)/2.0).floor();
            let base_scale = 2.0f64.pow(<f64 as From<i32>>::from(fibval).log2().floor());
            println!(
                "FIB {} would have a base_scale of {} with a rootval of {} and logval of {}",
                fibval,
                base_scale,
                <f64 as From<i32>>::from(fibval).log2().floor(),
                f64::from(fibval).log2()
            );

            let tmp = fibval;
            fibval = fibval + lastfib;
            lastfib = tmp;
            angle += 90.0;
        }
    }

examples/carlson_smith_gallery_nannou.rs (line 46)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

examples/ga_09_hours_of_dark.rs (line 17)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 8)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_08_piet_mondrian.rs (line 67)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn bounds(&self) -> Result<Rect<f64>, Box<dyn Error>>

Bounds returns a Rect defining the bounds of all operations drawn on the context. Note: Since this has to iterate over ALL geometry in the drawing, it’s kind of expensive. I’ll probably cache this per operation at some point, but for now it’s pricy.

pub fn mask_poly( &mut self, exterior: Vec<(f64, f64)>, interiors: Vec<Vec<(f64, f64)>>, ) -> &mut Self

Masks any further operations with a clipping polygon. Only items inside the clipping poly will be used.

pub fn mask_box(&mut self, x0: f64, y0: f64, x1: f64, y1: f64) -> &mut Self

Examples found in repository

examples/ga_09_hours_of_dark.rs (line 45)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn set_mask(&mut self, mask: &Option<Geometry<f64>>) -> &mut Self

Sets the mask to Geometry, or None.

pub fn push(&mut self) -> &mut Self

Pushes the current context onto the stack.

Examples found in repository

examples/ga_09_hours_of_dark.rs (line 43)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 24)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn pop(&mut self) -> Result<&mut Self, ContextError>

Pops the previous context off the stack

Examples found in repository

examples/ga_09_hours_of_dark.rs (line 51)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 29)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn transform(&mut self, transformation: Option<&Affine2<f64>>) -> &mut Self

Set the transformation matrix for subsequent ops. Take a look at the transformation helpers (crate::context::Context::scale_matrix, crate::context::Context::translate_matrix, and crate::context::Context::rotate_matrix, which are great if you don’t want to generate your own unsafe Affine2 transformations. Also, usefully, these transformations can be COMPOSED via multiplication. Note that the order of the compositions is right-to-left, so the last in the chain of multiplications is the first one to be performed. See the example in context_basic.rs for more info.

Examples found in repository

examples/carlson_smith_gallery_nannou.rs (line 68)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

examples/ga_09_hours_of_dark.rs (line 44)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (lines 56-60)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn mul_transform(&mut self, transformation: &Affine2<f64>) -> &mut Self

Similar to transform, but multiplies the CURRENT transformation matrix by the new one. If the current matrix is None, then multiplies by the UNIT matrix. This is really useful for stepping through relative positions, or rotations. Couples well with push/pop to make an addition relative to current matrix, then resetting to origin.

pub fn geometry(&mut self, geometry: &Geometry<f64>) -> &mut Self

Adds a geometry to the operations list. Has some checking to make it safe for general users.

Examples found in repository

examples/carlson_smith_gallery_nannou.rs (line 68)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

examples/ga_08_piet_mondrian.rs (lines 117-120)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn line(&mut self, x0: f64, y0: f64, x1: f64, y1: f64) -> &mut Self

Draws a simple line from x0,y0 to x1,y1

Examples found in repository

examples/context_basic.rs (line 38)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn typography( &mut self, text: &String, x0: f64, y0: f64, typography: &Typography, ) -> &mut Self

Draws a line of text

Examples found in repository

examples/typography.rs (line 20)

fn main() {
    let mut ctx = Context::new();
    let mut typ = Typography::new();
    typ.size(2.0);
    typ.close(true);

    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .pattern(Hatches::none())
        // .pattern(LineHatch::gen())
        // .typography(&"i".to_string(), 50.0, 50.0, &typ);
        .typography(&"Left".to_string(), 50.0, 50.0, &typ);
    typ.align(TextAlignment::Right);
    ctx.typography(&"Right".to_string(), 50.0, 90.0, &typ);
    typ.align(TextAlignment::Center);
    ctx.typography(&"Center".to_string(), 50.0, 70.0, &typ);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/carlson_smith_gallery_nannou.rs (line 71)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

pub fn glyph(&mut self, glyph: char, close: bool) -> &mut Self

Glyph Draws a single glyph on the Context, at 0,0

Examples found in repository

examples/context_basic.rs (line 74)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn path(&mut self, bezier: &BezPath) -> &mut Self

Way more useful path interface. Uses Kurbo’s BezierPath module. After creation, uses GEOS polygonize_full to generate polygons and line segments from the drawing, ensuring that we can have filled geometry as an output.

pub fn spline( &mut self, points: &Vec<(f64, f64)>, num_interpolated_segments: u32, tension: f64, ) -> &mut Self

Generates a spline from a set of points and renders as a multi line string. Doesn’t do errors very well, just silently fails to draw. First and last point in points are NOT drawn, and set the ‘tension’ points which the line pulls from.

Examples found in repository

examples/context_basic.rs (lines 44-54)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn arc_center( &mut self, x0: f64, y0: f64, radius: f64, deg0: f64, deg1: f64, ) -> &mut Self

centerpoint arc Draw an arc around x0,y0 with the given radius, from deg0 to deg1. Arcs will always be coords oriented clockwise from “north” on an SVG. ie: 45 to 135 will be NE to SE.

pub fn rect(&mut self, x0: f64, y0: f64, x1: f64, y1: f64) -> &mut Self

What it says on the box. Draws a simple rectangle on the context.

Examples found in repository

examples/ga_09_hours_of_dark.rs (line 50)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/ga_08_piet_mondrian.rs (lines 105-110)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn poly( &mut self, exterior: Vec<(f64, f64)>, interiors: Vec<Vec<(f64, f64)>>, ) -> &mut Self

Draws a polygon

Examples found in repository

examples/context_basic.rs (lines 14-17)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn circle(&mut self, x0: f64, y0: f64, radius: f64) -> &mut Self

Draws a circle. Actually just buffers a point, and returns a polygon which it draws on the context.

Examples found in repository

examples/context_basic.rs (line 23)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn regular_poly( &mut self, sides: usize, x: f64, y: f64, radius: f64, rotation: f64, ) -> &mut Self

Circumscribed regular polygon. The vertices of the polygon will be situated on a circle defined by the given radius. Polygon will be centered at x,y.

Examples found in repository

examples/context_basic.rs (line 67)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn star_poly( &mut self, sides: usize, x: f64, y: f64, inner_radius: f64, outer_radius: f64, rotation: f64, ) -> &mut Self

Regular star polygon. This is effectively a star shape with the number of points indicated, and with inner and outer radiuses which correspond to the valleys and tips of the star respectively. Note: this is not a star polygon in the strict mathematical sense. This is just a polygon that is in the shape of a star. I may or may not get to regular star polygons (in the canonical mathematical sense) at some point.

Examples found in repository

examples/context_basic.rs (line 68)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn clip(&mut self, clip: bool) -> &mut Self

Sets the clipping state. Any subsequent objects will clip their predecessors. Note that this is an EXPENSIVE operation, so you might want to leave it off if you’re sure you won’t have intersections.

Examples found in repository

examples/context_basic.rs (line 33)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn stroke(&mut self, color: &str) -> &mut Self

Sets the stroke color

Examples found in repository

examples/typography.rs (line 14)

fn main() {
    let mut ctx = Context::new();
    let mut typ = Typography::new();
    typ.size(2.0);
    typ.close(true);

    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .pattern(Hatches::none())
        // .pattern(LineHatch::gen())
        // .typography(&"i".to_string(), 50.0, 50.0, &typ);
        .typography(&"Left".to_string(), 50.0, 50.0, &typ);
    typ.align(TextAlignment::Right);
    ctx.typography(&"Right".to_string(), 50.0, 90.0, &typ);
    typ.align(TextAlignment::Center);
    ctx.typography(&"Center".to_string(), 50.0, 70.0, &typ);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_09_hours_of_dark.rs (line 20)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 9)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_08_piet_mondrian.rs (line 90)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn fill(&mut self, color: &str) -> &mut Self

Sets the fill color

Examples found in repository

examples/typography.rs (line 15)

fn main() {
    let mut ctx = Context::new();
    let mut typ = Typography::new();
    typ.size(2.0);
    typ.close(true);

    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .pattern(Hatches::none())
        // .pattern(LineHatch::gen())
        // .typography(&"i".to_string(), 50.0, 50.0, &typ);
        .typography(&"Left".to_string(), 50.0, 50.0, &typ);
    typ.align(TextAlignment::Right);
    ctx.typography(&"Right".to_string(), 50.0, 90.0, &typ);
    typ.align(TextAlignment::Center);
    ctx.typography(&"Center".to_string(), 50.0, 70.0, &typ);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_09_hours_of_dark.rs (line 24)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 10)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_08_piet_mondrian.rs (line 105)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn hatch(&mut self, angle: f64) -> &mut Self

Sets the hatch state, either None for no hatching or Some(angle) to set a hatching angle. Will use the current pen width as the spacing between hatch lines.

Examples found in repository

examples/ga_09_hours_of_dark.rs (line 21)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 13)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_08_piet_mondrian.rs (line 90)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn pen(&mut self, width: f64) -> &mut Self

Sets the pen width

Examples found in repository

examples/typography.rs (line 16)

fn main() {
    let mut ctx = Context::new();
    let mut typ = Typography::new();
    typ.size(2.0);
    typ.close(true);

    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .pattern(Hatches::none())
        // .pattern(LineHatch::gen())
        // .typography(&"i".to_string(), 50.0, 50.0, &typ);
        .typography(&"Left".to_string(), 50.0, 50.0, &typ);
    typ.align(TextAlignment::Right);
    ctx.typography(&"Right".to_string(), 50.0, 90.0, &typ);
    typ.align(TextAlignment::Center);
    ctx.typography(&"Center".to_string(), 50.0, 70.0, &typ);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/carlson_smith_gallery_nannou.rs (line 49)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

examples/ga_09_hours_of_dark.rs (line 22)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 11)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_08_piet_mondrian.rs (line 90)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn pattern(&mut self, pattern: Hatches) -> &mut Self

Set the hatch pattern

Examples found in repository

examples/typography.rs (line 17)

fn main() {
    let mut ctx = Context::new();
    let mut typ = Typography::new();
    typ.size(2.0);
    typ.close(true);

    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .pattern(Hatches::none())
        // .pattern(LineHatch::gen())
        // .typography(&"i".to_string(), 50.0, 50.0, &typ);
        .typography(&"Left".to_string(), 50.0, 50.0, &typ);
    typ.align(TextAlignment::Right);
    ctx.typography(&"Right".to_string(), 50.0, 90.0, &typ);
    typ.align(TextAlignment::Center);
    ctx.typography(&"Center".to_string(), 50.0, 70.0, &typ);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/carlson_smith_gallery_nannou.rs (line 51)

    fn generate(&self) -> AOERCTX {
        let mut ctx = AOERCTX::new();
        let mut count = 0;

        ctx.pen(1.5).accuracy(0.3);
        if self.settings.draft {
            ctx.pattern(Hatches::none());
        } else {
            ctx.pattern(Hatches::line());
        }
        let mut typo = Typography::new();
        typo.size(4.5).align(Center);

        for (name, geo) in CarlsonSmithTruchet::full_set()
            .iter()
            .filter(|(x, _y)| !x.starts_with("^"))
        {
            println!("Plotting {}", name);
            let yofs: f64 = -256.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64 + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            // println!("xy is {},{}", xofs, yofs);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(64.0, 64.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 60.0, &typo);
        }
        count = 0;
        for (name, geo) in self
            .full_set
            .clone()
            .iter()
            .filter(|(x, _y)| x.starts_with("^"))
        {
            println!("Plotting inverse scale/2 {}", name);
            let yofs: f64 =
                -256.0f64 - 16.0f64 + 128.0f64 * <f64 as From<i32>>::from((count / 6) as i32);
            let xofs: f64 = -512.0f64
                + (96.0f64 * 6.0f64)
                + 96.0f64 * <f64 as From<i32>>::from((count % 6) as i32);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(32.0, 32.0);
            count += 1;
            ctx.transform(Some(&tx)).geometry(&geo);
            ctx.transform(Some(&tx)).geometry(&geo);
            let tx = AOERCTX::translate_matrix(xofs, yofs) * AOERCTX::scale_matrix(1.0, -1.0);

            ctx.transform(Some(&tx)).typography(&name, 0.0, 40.0, &typo);
        }
        ctx
    }

examples/ga_09_hours_of_dark.rs (line 23)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (line 19)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_08_piet_mondrian.rs (line 99)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

pub fn outline(&mut self, stroke: Option<f64>) -> &mut Self

Neat option. Instead of drawing a complex poly, why not just set outline, and have the lines/polys/whatever you subsequently draw get buffered and hatched to imitate a really thick pen? I knew you’d like this one :D

Examples found in repository

examples/context_basic.rs (line 12)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

pub fn flatten(&self) -> Self

Flatten will take a context and “flatten” together all polygons of a given color and “depth”. What that means is that we watch for changes to fill/color/etc, and set those as boundaries. Then every geometry within a set of boundaries is flattened as “unions” into a single geometry. This is nice because overlapping polygons get turned into a single unified polygon, and their fills are no longer disjoint (and they don’t have unexpected overlapping boundary lines). See the 10_hello example for more details. Unlike the other methods, this one generates an entirely new context including a NEW HISTORY, so you can’t use push/pop to go back, and the individual operations are (obviously) lost.

Examples found in repository

examples/carlson_smith_gallery_nannou.rs (line 101)

    fn on_change(&self) -> Layers {
        let ctx = self.generate();
        println!("Flattening...");
        let layers = if self.settings.draft {
            ctx.flatten().to_layers()
        } else {
            ctx.to_layers()
        };
        println!("Done flattening");

        let mut out = Layers::new();
        for layer in &layers {
            let (strokes, fills) = layer.to_lines();
            if self.settings.draft {
                if out.contains_key(&layer.stroke()) {
                    let (mut orig_stroke, _orig_fill) =
                        out.get_mut(&layer.stroke()).unwrap().clone();
                    orig_stroke.0.append(&mut strokes.0.clone());
                    out.insert(
                        layer.stroke().clone(),
                        (orig_stroke.clone(), MultiLineString::new(vec![])),
                    );
                } else {
                    out.insert(
                        layer.stroke().clone(),
                        (strokes.clone(), MultiLineString::new(vec![])),
                    );
                }
            } else {
                if out.contains_key(&layer.stroke()) {
                    let (mut orig_stroke, mut orig_fill) =
                        out.get_mut(&layer.stroke()).unwrap().clone();
                    orig_stroke.0.append(&mut strokes.0.clone());
                    orig_fill.0.append(&mut fills.0.clone());
                    out.insert(layer.stroke(), (orig_stroke.clone(), orig_fill.clone()));
                } else {
                    out.insert(layer.stroke(), (strokes.clone(), fills.clone()));
                }
            }
        }
        out
    }

pub fn to_geo(&self) -> Result<Geometry<f64>, Box<dyn Error>>

pub fn to_layers(&self) -> Vec<OPLayer>

Generate layers of perimeters and fills

Examples found in repository

examples/carlson_smith_gallery_nannou.rs (line 101)

    fn on_change(&self) -> Layers {
        let ctx = self.generate();
        println!("Flattening...");
        let layers = if self.settings.draft {
            ctx.flatten().to_layers()
        } else {
            ctx.to_layers()
        };
        println!("Done flattening");

        let mut out = Layers::new();
        for layer in &layers {
            let (strokes, fills) = layer.to_lines();
            if self.settings.draft {
                if out.contains_key(&layer.stroke()) {
                    let (mut orig_stroke, _orig_fill) =
                        out.get_mut(&layer.stroke()).unwrap().clone();
                    orig_stroke.0.append(&mut strokes.0.clone());
                    out.insert(
                        layer.stroke().clone(),
                        (orig_stroke.clone(), MultiLineString::new(vec![])),
                    );
                } else {
                    out.insert(
                        layer.stroke().clone(),
                        (strokes.clone(), MultiLineString::new(vec![])),
                    );
                }
            } else {
                if out.contains_key(&layer.stroke()) {
                    let (mut orig_stroke, mut orig_fill) =
                        out.get_mut(&layer.stroke()).unwrap().clone();
                    orig_stroke.0.append(&mut strokes.0.clone());
                    orig_fill.0.append(&mut fills.0.clone());
                    out.insert(layer.stroke(), (orig_stroke.clone(), orig_fill.clone()));
                } else {
                    out.insert(layer.stroke(), (strokes.clone(), fills.clone()));
                }
            }
        }
        out
    }

pub fn to_svg( &self, arrangement: &Arrangement<f64>, ) -> Result<Document, ContextError>

Take this giant complex thing and generate and SVG Document, or an error. Whatever.

Examples found in repository

examples/typography.rs (lines 27-30)

fn main() {
    let mut ctx = Context::new();
    let mut typ = Typography::new();
    typ.size(2.0);
    typ.close(true);

    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .pattern(Hatches::none())
        // .pattern(LineHatch::gen())
        // .typography(&"i".to_string(), 50.0, 50.0, &typ);
        .typography(&"Left".to_string(), 50.0, 50.0, &typ);
    typ.align(TextAlignment::Right);
    ctx.typography(&"Right".to_string(), 50.0, 90.0, &typ);
    typ.align(TextAlignment::Center);
    ctx.typography(&"Center".to_string(), 50.0, 70.0, &typ);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_09_hours_of_dark.rs (line 65)

fn main() {
    let pen_width = 0.3;
    let cols = 23;
    let rows = 16;
    let size = (cols * rows) / 2;
    let days = 365;
    let cellw = f64::from(size) / f64::from(cols);
    let cellh = f64::from(size) / f64::from(rows);

    let mut ctx = Context::new();

    // Set the default stroke/hatch/pen.
    ctx.stroke("black")
        .hatch(45.0)
        .pen(pen_width)
        .pattern(Hatches::line())
        .fill("black");

    for day in 0..days {
        let col = f64::from(day / rows);
        let row = f64::from(day % rows);
        let x = col * cellw;
        let y = row * cellh;
        let w = 2.0f64;
        let h = 30.0f64;

        let phi = (f64::from(day) / f64::from(days)) * PI;
        let theta = phi.sin() * 80.0 + 45.0;

        // We scale w and h by the scale here because of implementation differences
        // between JS canvas context and our context.
        let scale = phi.cos().abs() * 2.0 + 1.0;
        let w = scale * w;
        let h = scale * h;

        ctx.push()
            .transform(Some(&(Context::translate_matrix(x, y))))
            .mask_box(cellw * -0.5, cellh * -0.5, cellw * 0.5, cellh * 0.5)
            .transform(Some(
                &(Context::translate_matrix(x, y) * Context::rotate_matrix(theta)),
            ))
            .hatch(-90.0 + theta)
            .rect(w * -0.5, h * -0.5, w * 0.5, h * 0.5)
            .pop()
            .expect("Somehow lost track of my internal stack");
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

examples/context_basic.rs (lines 77-80)

fn main() {
    let mut ctx = Context::new();
    ctx.stroke("black")
        .fill("red")
        .pen(0.5)
        .outline(Some(5.0))
        .hatch(45.0)
        .poly(
            vec![(0.0, 0.0), (25.0, 0.0), (25.0, 25.0), (0.0, 25.0)],
            vec![],
        )
        .outline(None)
        .pattern(Hatches::line())
        .hatch(135.0)
        .stroke("blue")
        .fill("yellow")
        .circle(12.5, 12.5, 5.0)
        .push()
        .hatch(180.0)
        .stroke("red")
        .fill("green")
        .circle(17.5, 12.5, 2.5)
        .pop()
        .unwrap()
        .hatch(0.0)
        .pattern(Hatches::none())
        .clip(true)
        .circle(7.5, 12.5, 2.5)
        .clip(false)
        .stroke("brown")
        .pen(1.0)
        .line(0.0, 0.0, 3.0, 3.0)
        .pen(0.1)
        .outline(Some(1.0))
        .stroke("pink")
        .line(3.0, 0.0, 0.0, 3.0)
        .stroke("purple")
        .spline(
            &vec![
                (0.0, 25.0),
                (0.0, 25.0),
                (10.0, 20.0),
                (20.0, 25.0),
                (25.0, 25.0),
            ],
            8,
            0.5,
        )
        .push() // Prepare for this transformation stuff...
        .transform(Some(
            &(Context::translate_matrix(25.0, 25.0)
                * Context::rotate_matrix(45.0)
                * Context::scale_matrix(1.0, 0.5)),
        )) // Holy crap we can multiply these?! ;)
        .stroke("cyan")
        .circle(0.0, 0.0, 8.0)
        .pop()
        .unwrap() // We're back to purple and regular coords
        .outline(None)
        .stroke("green")
        .regular_poly(8, 80.0, 80.0, 20.0, 0.0)
        .star_poly(5, 30.0, 80.0, 10.0, 20.0, 0.0)
        .transform(Some(
            &(Context::translate_matrix(50.0, 50.0) * Context::scale_matrix(0.02, -0.02)),
        ))
        .pattern(Hatches::none())
        .pattern(Hatches::line())
        .glyph('Q', false);

    let svg = ctx
        .to_svg(&Arrangement::<f64>::unit(&Rect::<f64>::new(
            coord! {x:0.0, y:0.0},
            coord! {x:100.0, y:100.0},
        )))
        .unwrap();
    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &svg).unwrap();
}

examples/ga_08_piet_mondrian.rs (line 135)

fn main() {
    let pen_width = 0.5f64;
    let size: i32 = 224;
    let square_count = 8;
    let white = "#F2F5F1";
    let colors = vec!["#D40920", "#1356A2", "#F7D842"];
    let square_weight = 2.0f64; // How thick the dividing lines are

    // We're using a static random generator here so that our SVG files
    // don't get regenerated every time we run the examples.
    let mut rng = SmallRng::seed_from_u64(1234567);
    let mut ctx = Context::new();

    let mut squares: Vec<Rect<f64>> = vec![Rect::new(
        coord! {x:0.0, y:0.0},
        coord! {x: f64::from(size), y: f64::from(size)},
    )];

    // split_squares_at(&mut squares, coord!{x: f64::from(size)/2.0, y: -1.0});
    // split_squares_at(&mut squares, coord!{x:-1.0, y: f64::from(size)/2.0});
    for i in (0..(size)).step_by((size / square_count) as usize) {
        split_squares_at(&mut squares, coord! {x: f64::from(i), y: -1.0}, &mut rng);
        split_squares_at(&mut squares, coord! {x:-1.0, y: f64::from(i)}, &mut rng);
    }

    // Create an array of the same length as the squares array, and fill it with "white"
    let mut square_colors: Vec<&str> = squares.iter().map(|_s| white.clone()).collect();

    for color in colors.clone() {
        // Note, this might overlap an existing colored square. More often than you'd think actually.
        square_colors[rng.gen_range(0..squares.len())] = color;
    }

    // Set the default stroke/hatch/pen.
    ctx.stroke("black").hatch(45.0).pen(pen_width);

    // for square in squares {
    for i in 0..squares.len() {
        let square = squares[i].clone();
        let color = square_colors[i].clone();

        // Don't bother hatching if it's white.
        if color != white {
            ctx.pattern(Hatches::line());
        } else {
            ctx.pattern(Hatches::none());
        }

        // And set the fill color.
        ctx.fill(color).rect(
            square.min().x + square_weight,
            square.min().y + square_weight,
            square.max().x - square_weight,
            square.max().y - square_weight,
        );

        // Now we just draw the rest of the outlines, inside to outside, no fill.
        ctx.pattern(Hatches::none());
        let mut remaining_width = square_weight - (pen_width / 2.0);
        let s = squares[i].clone();
        while remaining_width >= 0.0 {
            ctx.geometry(&Geometry::Rect(Rect::new(
                coord! {x: &s.min().x+remaining_width, y: &s.min().y+remaining_width},
                coord! {x: &s.max().x-remaining_width, y: &s.max().y-remaining_width},
            )));
            remaining_width -= pen_width;
        }
    }

    // We're using a new feature here: Create a FitCenterMargin Arrangement that matches
    // the paper size we're using (8.5" square). Then, finalize it's transformation matrix
    // to match the context's bounds, giving us back an Arrangement::Transform with the
    // affine txform that gives us a nicely centered drawing.
    let arrangement = ctx.finalize_arrangement(&Arrangement::FitCenterMargin(
        25.4,
        Context::viewbox(0.0, 0.0, 216.0, 216.0),
        false,
    ));

    let document = ctx.to_svg(&arrangement).unwrap();

    // Write it to the images folder, so we can use it as an example!
    // Write it out to /images/$THIS_EXAMPLE_FILE.svg
    let fname = Path::new(file!()).file_stem().unwrap().to_str().unwrap();
    svg::save(format!("images/{}.svg", fname), &document).unwrap();
}

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a duplicate of the value.

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

Performs copy-assignment from source.