Module lyon_path::iterator

Tools to iterate over paths.

Lyon path iterators

Overview

This module provides a collection of traits to extend the Iterator trait when iterating over paths.

Examples

use lyon_path::iterator::*;
use lyon_path::math::{point, vector};
use lyon_path::geom::BezierSegment;
use lyon_path::{Path, PathEvent};

fn main() {
    // Start with a path.
    let mut builder = Path::builder();
    builder.move_to(point(0.0, 0.0));
    builder.line_to(point(10.0, 0.0));
    builder.cubic_bezier_to(point(10.0, 10.0), point(0.0, 10.0), point(0.0, 5.0));
    builder.close();
    let path = builder.build();

    // A simple std::iter::Iterator<PathEvent>,
    let simple_iter = path.iter();

    // Make it an iterator over simpler primitives flattened events,
    // which do not contain any curve. To do so we approximate each curve
    // linear segments according to a tolerance threshold which controls
    // the tradeoff between fidelity of the approximation and amount of
    // generated events. Let's use a tolerance threshold of 0.01.
    // The beauty of this approach is that the flattening happens lazily
    // while iterating without allocating memory for the path.
    let flattened_iter = path.iter().flattened(0.01);

    for evt in flattened_iter {
        match evt {
            PathEvent::Begin { at } => { println!(" - move to {:?}", at); }
            PathEvent::Line { from, to } => { println!(" - line {:?} -> {:?}", from, to); }
            PathEvent::End { last, first, close } => {
                if close {
                    println!(" - close {:?} -> {:?}", last, first);
                } else {
                    println!(" - end");
                }
            }
            _ => { panic!() }
        }
    }

    // Sometimes, working with segments directly without dealing with Begin/End events
    // can be more convenient:
    for segment in path.iter().bezier_segments() {
        match segment {
            BezierSegment::Linear(segment) => { println!("{:?}", segment); }
            BezierSegment::Quadratic(segment) => { println!("{:?}", segment); }
            BezierSegment::Cubic(segment) => { println!("{:?}", segment); }
        }
    }
}

Chaining the provided iterators allow performing some path manipulations lazily without allocating actual path objects to hold the result of the transformations.

extern crate lyon_path;
use lyon_path::iterator::*;
use lyon_path::math::{point, Angle, Rotation};
use lyon_path::Path;

fn main() {
    // In practice it is more common to iterate over Path objects than vectors
    // of SVG commands (the former can be constructed from the latter).
    let mut builder = Path::builder();
    builder.move_to(point(1.0, 1.0));
    builder.line_to(point(2.0, 1.0));
    builder.quadratic_bezier_to(point(2.0, 2.0), point(1.0, 2.0));
    builder.cubic_bezier_to(point(0.0, 2.0), point(0.0, 0.0), point(1.0, 0.0));
    builder.close();
    let path = builder.build();

    let transform = Rotation::new(Angle::radians(1.0));

    for evt in path.iter().transformed(&transform).bezier_segments() {
        // ...
    }
}

Structs

BezierSegments	Turns an iterator of Event into an iterator of BezierSegment<f32>.
Flattened	An iterator that consumes Event iterator and yields flattend path events (with no curves).
FromPolyline	An iterator that consumes an iterator of Points and produces Events.
Transformed	Applies a 2D transform to a path iterator and yields the resulting path iterator.

Traits

PathIterator

An extension trait for PathEvent iterators.