Struct Layer 

pub struct Layer {
    pub paths: Vec<Path>,
    /* private fields */
}

Fields

paths: Vec<Path>

Implementations

impl Layer

pub fn flatten(&self, tolerance: f64) -> FlattenedLayer

pub fn bezier_handles(&self) -> FlattenedLayer

pub fn display_vertices(&self) -> Vec<Point>

pub fn crop( &mut self, x_min: impl Into<f64>, y_min: impl Into<f64>, x_max: impl Into<f64>, y_max: impl Into<f64>, ) -> &Self

impl Layer

pub fn sort(&mut self, flip: bool)

Sort the paths such as to minimize the pen up distance

This is done using a greedy algorithm, starting with the layer’s first path. Any path that cannot be spatially indexed (empty or otherwise degenerate) is moved at the end.

pub fn sort_with_builder(&mut self, builder: IndexBuilder)

Trait Implementations

impl Clone for Layer

fn clone(&self) -> Layer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Layer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Layer

fn default() -> Layer

Returns the “default value” for a type.

impl DocumentTrait<Layer, Path, BezPath> for Document

fn layers(&self) -> &BTreeMap<LayerID, Layer>

fn layers_mut(&mut self) -> &mut BTreeMap<LayerID, Layer>

fn metadata(&self) -> &DocumentMetadata

fn metadata_mut(&mut self) -> &mut DocumentMetadata

fn push_path(&mut self, id: LayerID, path: impl Into<P>)

fn try_get(&self, id: LayerID) -> Option<&L>

fn get_mut(&mut self, id: LayerID) -> &mut L

fn ensure_exists(&mut self, id: LayerID)

fn for_each<F>(&mut self, f: F)

where F: Fn(&mut L),

fn merge_layers(&mut self)

Merge all existing layers into layer 0, if any.

fn bounds(&self) -> Option<Rect>

fn stats(&self) -> BTreeMap<LayerID, LayerStats>

fn to_svg_string(&self) -> Result<String, Error>

fn to_svg(&self, writer: impl Write) -> Result<()>

fn to_svg_file(&self, file_path: impl AsRef<Path>) -> Result<()>

impl Draw for Layer

Implementing this trait allows drawing directly into a layer.

Each Draw method will append a new path with default metadata to the layer.

Example

use vsvg::{Draw, DocumentTrait};

let mut doc = vsvg::Document::default();
let layer = doc.get_mut(0);
layer.circle(5.0, 5.0, 10.0);

fn add_path<T: IntoBezPathTolerance>(&mut self, path: T) -> &mut Self

fn cubic_bezier( &mut self, x1: impl Into<f64>, y1: impl Into<f64>, x2: impl Into<f64>, y2: impl Into<f64>, x3: impl Into<f64>, y3: impl Into<f64>, x4: impl Into<f64>, y4: impl Into<f64>, ) -> &mut Self

Draw a cubic Bézier curve from (x1, y1) to (x4, y4) with control points at (x2, y2) and (x3, y3).

fn quadratic_bezier( &mut self, x1: impl Into<f64>, y1: impl Into<f64>, x2: impl Into<f64>, y2: impl Into<f64>, x3: impl Into<f64>, y3: impl Into<f64>, ) -> &mut Self

Draw a quadratic Bézier curve from (x1, y1) to (x3, y3) with control point at (x2, y2).

fn arc( &mut self, x: impl Into<f64>, y: impl Into<f64>, rx: impl Into<f64>, ry: impl Into<f64>, start: f64, sweep: f64, x_rot: f64, ) -> &mut Self

Draw an elliptical arc centered on (x, y) with radii rx and ry. The arc starts at start and sweeps sweep radians. x_rot is the rotation of the ellipse in radians.

fn circle( &mut self, x: impl Into<f64>, y: impl Into<f64>, r: impl Into<f64>, ) -> &mut Self

Draw a circle centered on (x, y) with radius r.

fn ellipse( &mut self, x: impl Into<f64>, y: impl Into<f64>, rx: impl Into<f64>, ry: impl Into<f64>, x_rot: impl Into<f64>, ) -> &mut Self

Draw an ellipse centered on (x, y) with radii rx and ry. x_rot is the rotation of the ellipse in radians.

fn line( &mut self, x1: impl Into<f64>, y1: impl Into<f64>, x2: impl Into<f64>, y2: impl Into<f64>, ) -> &mut Self

Draw a line from (x1, y1) to (x2, y2).

fn polyline( &mut self, points: impl IntoIterator<Item = impl Into<Point>>, close: bool, ) -> &mut Self

Draw a polyline from a sequence of points, optionally closing it.

fn rect( &mut self, x: impl Into<f64>, y: impl Into<f64>, w: impl Into<f64>, h: impl Into<f64>, ) -> &mut Self

Draw a rectangle centered on (x, y) with width w and height h.

fn rounded_rect( &mut self, x: impl Into<f64>, y: impl Into<f64>, w: impl Into<f64>, h: impl Into<f64>, tl: impl Into<f64>, tr: impl Into<f64>, br: impl Into<f64>, bl: impl Into<f64>, ) -> &mut Self

Draw a rounded rectangle centered on (x, y) with width w and height h. The corners are rounded with radii tl, tr, br, bl.

fn catmull_rom( &mut self, points: impl IntoIterator<Item = impl Into<Point>>, tension: f64, ) -> &mut Self

Draw a Catmull-Rom spline from a sequence of points and a tension parameter.

fn svg_path(&mut self, path: &str) -> Result<&mut Self, SvgParseError>

Draw from an SVG path representation.

impl From<FlattenedLayer> for Layer

fn from(flattened_layer: FlattenedLayer) -> Self

Converts to this type from the input type.

impl LayerTrait<Path, BezPath> for Layer

fn from_paths_and_metadata(paths: Vec<Path>, metadata: LayerMetadata) -> Self

fn paths(&self) -> &[Path]

fn paths_mut(&mut self) -> &mut Vec<Path>

fn metadata(&self) -> &LayerMetadata

fn metadata_mut(&mut self) -> &mut LayerMetadata

fn new() -> Self

fn for_each<F>(&mut self, f: F)

where F: Fn(&mut P),

fn bounds(&self) -> Option<Rect>

fn push_path(&mut self, path: impl Into<P>)

fn merge(&mut self, other: &Self)

Merge another layer into this one.

fn sort(&mut self, flip: bool)

fn sort_with_builder(&mut self, builder: IndexBuilder)

fn pen_up_trajectories(&self) -> Vec<(Point, Point)>

fn stats(&self) -> LayerStats

impl Transforms for Layer

Implementing this trait allows applying affine transforms to the layer content.

fn transform(&mut self, affine: &Affine) -> &mut Self

Apply a 2D affine transform

fn translate(&mut self, dx: impl Into<f64>, dy: impl Into<f64>) -> &mut Self

Translate the geometry by dx and dy.

fn scale(&mut self, s: impl Into<f64>) -> &mut Self

Scale the geometry by s around the origin.

fn scale_non_uniform( &mut self, sx: impl Into<f64>, sy: impl Into<f64>, ) -> &mut Self

Scale the geometry by sx and sy around the origin.

fn scale_around( &mut self, sx: impl Into<f64>, sy: impl Into<f64>, cx: impl Into<f64>, cy: impl Into<f64>, ) -> &mut Self

Scale the geometry by sx and sy around the point (cx, cy).

fn rotate(&mut self, theta: impl Into<f64>) -> &mut Self

Rotate the geometry by theta radians around the origin.

fn rotate_around( &mut self, theta: impl Into<f64>, cx: impl Into<f64>, cy: impl Into<f64>, ) -> &mut Self

Rotate the geometry by theta radians around the point (cx, cy).

fn skew(&mut self, kx: impl Into<f64>, ky: impl Into<f64>) -> &mut Self

Skew the geometry by kx and ky radians around the origin.

fn skew_around( &mut self, kx: impl Into<f64>, ky: impl Into<f64>, cx: impl Into<f64>, cy: impl Into<f64>, ) -> &mut Self

Skew the geometry by kx and ky radians around the point (cx, cy).