Struct Path 

pub struct Path { /* private fields */ }

Represents a geometric path, composed of one or more subpaths.

A Path can be created from an SVG path string and can be iterated over to process its individual subpaths. It also provides utilities for analyzing path properties, such as finding the outermost contour.

Implementations

impl Path

pub fn iter(&self) -> impl Iterator<Item = Path> + '_

Returns an iterator over the subpaths of this path.

Each item in the iterator is a Path representing a single subpath.

pub fn is_closed(&self) -> bool

Checks if the path is closed.

A path is considered closed if it ends with a Close event.

pub fn find_outer_shell(&self) -> Option<Path>

Find and return the subpath that represents the outermost shell.

This method first attempts to use a fast “largest area” heuristic. If that fails to produce a result, it falls back to a more accurate but slower “geometric containment” algorithm.

Returns

An Option<Path> containing the outermost shell if found, otherwise None.

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl Display for Path

Formats the Path as an SVG path data string.

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

Formats the value using the given formatter.

impl From<&(Coord2, Vec<(Coord2, Coord2, Coord2)>)> for Path

Converts a flo_curves::SimpleBezierPath back into a Path.

This reconstructs a lyon path from the flo_curves representation. It handles both lines and cubic curves. The resulting path is explicitly closed by adding a line segment back to the start point and calling close().

fn from(value: &SimpleBezierPath) -> Self

Converts to this type from the input type.

impl From<&Path> for SimpleBezierPath

Converts a reference to a Path into a flo_curves::SimpleBezierPath.

This conversion processes the lyon::path::Event stream of the input path:

• Event::Line, Event::Cubic: Translated directly to flo_curves equivalents.
• Event::Quadratic: Mathematically converted into a cubic Bézier curve, as flo_curves primarily works with cubic curves.
• Event::End: If the path is not marked as closed by lyon, a closing line segment is added to ensure the flo_curves path is properly closed, which is often a requirement for path algorithms.

fn from(path: &Path) -> SimpleBezierPath

Converts to this type from the input type.

impl From<&Vec<Curve<Coord2>>> for Path

Converts a vector of flo_curves::Curves into a Path.

Each Curve is assumed to be a cubic Bézier segment. The conversion creates a new Path where each curve becomes a separate, unclosed subpath consisting of a single cubic Bézier segment.

fn from(value: &Vec<Curve<Coord2>>) -> Self

Converts to this type from the input type.

impl From<Path> for Path

Converts a lyon::path::Path into this crate’s Path type.

Since crate::path::Path is a wrapper around lyon::path::Path, this is a straightforward conversion.

fn from(value: Path) -> Self

Converts to this type from the input type.

impl FromStr for Path

Parses a Path from an SVG path data string.

Errors

Returns a PathError if the SVG path data is invalid.

type Err = PathError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<'a> IntoIterator for &'a Path

Implements the IntoIterator trait for references to our Path type.

This is what allows a &Path to be used directly in a for loop, transparently creating a SubpathIter to drive the iteration.

fn into_iter(self) -> Self::IntoIter

Defines how to create a SubpathIter from a &Path.

type Item = Path

The type of the elements being iterated over.

type IntoIter = SubpathIter<'a>

Which kind of iterator are we turning this into?