Struct Paths

pub struct Paths<P: PointScaler = Centi>(/* private fields */);

A collection of paths.

Examples

use clipper2::*;

let paths_from_single_vec: Paths = vec![(0.0, 0.0), (5.0, 0.0), (5.0, 6.0), (0.0, 6.0)].into();
let paths_from_vec_of_vecs: Paths = vec![vec![(0.0, 0.0), (5.0, 0.0), (5.0, 6.0), (0.0, 6.0)]].into();

Implementations

impl<P: PointScaler> Paths<P>

pub fn new(paths: Vec<Path<P>>) -> Self

Create a new paths from a vector of paths.

pub fn push(&mut self, paths: impl Into<Paths<P>>)

In place push paths onto this set of paths.

pub fn append(&mut self, paths: impl Into<Vec<Path<P>>>)

Append another set of paths onto this one, cloning the other set.

pub fn len(&self) -> usize

Returns the number of paths.

pub fn is_empty(&self) -> bool

Returns true if there are no paths added.

pub fn contains_points(&self) -> bool

Returns true if at least one of the paths contains a point.

pub fn first(&self) -> Option<&Path<P>>

Returns a reference to the first path in the set of paths wrapped in an option.

pub fn get(&self, index: usize) -> Option<&Path<P>>

Returns a reference to the path at the given index in the set of paths wrapped in an option.

pub fn iter(&self) -> Iter<'_, Path<P>>

Returns an iterator over the paths in the paths.

pub fn translate(&self, x: f64, y: f64) -> Self

Construct a clone with each point offset by a x/y distance.

pub fn scale(&self, scale_x: f64, scale_y: f64) -> Self

Construct a scaled clone of the path with the origin at the path center.

pub fn scale_around_point( &self, scale_x: f64, scale_y: f64, point: Point<P>, ) -> Self

Construct a scaled clone of the path with the origin at a given point.

pub fn rotate(&self, radians: f64) -> Self

Construct a rotated clone of the path with the origin at the path center.

pub fn flip_x(&self) -> Self

Construct a clone with each point x value flipped.

pub fn flip_y(&self) -> Self

Construct a clone with each point y value flipped.

pub fn bounds(&self) -> Bounds<P>

Returns the bounds for this path.

pub fn inflate( &self, delta: f64, join_type: JoinType, end_type: EndType, miter_limit: f64, ) -> Self

Construct a new set of paths offset from this one by a delta distance.

For closed paths passing a positive delta number will inflate the path where passing a negative number will shrink the path.

NOTE: Inflate calls will frequently generate a large amount of very close extra points and it is therefore recommented to almost always call Paths::simplify on the path after inflating/shrinking it.

Examples

use clipper2::*;

let paths: Paths = vec![vec![(0.0, 0.0), (5.0, 0.0), (5.0, 6.0), (0.0, 6.0)]].into();
let inflated = paths
    .inflate(1.0, JoinType::Square, EndType::Polygon, 2.0)
    .simplify(0.01, false);

For more details see the original inflate paths docs.

pub fn simplify(&self, epsilon: f64, is_open: bool) -> Self

Construct a new set of paths from these ones but with a reduced set of points.

Examples

use clipper2::*;

let paths: Paths = vec![vec![(0.0, 0.0), (5.0, 0.002), (5.0, 0.01), (5.1, 0.0), (5.0, 6.0), (0.0, 6.0)]].into();
let simplified = paths.simplify(1.0, true);

For more details see the original simplify docs.

pub fn to_clipper_subject(&self) -> Clipper<WithSubjects, P>

Create a Clipper builder with this set of paths as the subject that will allow for making boolean operations on this set of paths.

Examples

use clipper2::*;

let path: Paths = vec![vec![(0.0, 0.0), (5.0, 6.0), (0.0, 6.0)]].into();
let path2: Paths = vec![vec![(1.0, 1.0), (4.0, 1.0), (1.0, 4.0)]].into();
let result = path.to_clipper_subject().add_clip(path2).union(FillRule::default());

pub fn to_clipper_open_subject(&self) -> Clipper<WithSubjects, P>

Create a Clipper builder with this set of paths as the open subject that will allow for making boolean operations on this set of paths.

Examples

use clipper2::*;

let path: Paths =  vec![vec![(0.0, 0.0), (5.0, 6.0), (0.0, 6.0)]].into();
let path2: Paths = vec![vec![(1.0, 1.0), (4.0, 1.0), (1.0, 4.0)]].into();
let result = path.to_clipper_open_subject().add_clip(path2).difference(FillRule::default());

pub fn signed_area(&self) -> f64

This function returns the area of the supplied paths. It’s assumed that the paths are closed and do not self-intersect.

Depending on the paths’ winding orientations, this value may be positive or negative. Assuming paths are displayed in a Cartesian plane (with X values increasing heading right and Y values increasing heading up) then clockwise winding will have negative areas and counter-clockwise winding have positive areas.

Conversely, when paths are displayed where Y values increase heading down, then clockwise paths will have positive areas, and counter-clockwise paths will have negative areas.

Examples

use clipper2::*;

let paths: Paths = vec![vec![(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)]].into();

assert_eq!(paths.signed_area(), 1.0);

Trait Implementations

impl<P: Clone + PointScaler> Clone for Paths<P>

fn clone(&self) -> Paths<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug + PointScaler> Debug for Paths<P>

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

Formats the value using the given formatter.

impl<P: Default + PointScaler> Default for Paths<P>

fn default() -> Paths<P>

Returns the “default value” for a type.

impl<P: PointScaler> From<Path<P>> for Paths<P>

fn from(path: Path<P>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Paths<P>> for Vec<Path<P>>

fn from(paths: Paths<P>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Paths<P>> for Vec<Vec<[f64; 2]>>

fn from(paths: Paths<P>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Paths<P>> for Vec<Vec<(f64, f64)>>

fn from(paths: Paths<P>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Vec<[f64; 2]>> for Paths<P>

fn from(points: Vec<[f64; 2]>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Vec<(f64, f64)>> for Paths<P>

fn from(points: Vec<(f64, f64)>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Vec<Path<P>>> for Paths<P>

fn from(points: Vec<Path<P>>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Vec<Point<P>>> for Paths<P>

fn from(points: Vec<Point<P>>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Vec<Vec<[f64; 2]>>> for Paths<P>

fn from(points: Vec<Vec<[f64; 2]>>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Vec<Vec<(f64, f64)>>> for Paths<P>

fn from(points: Vec<Vec<(f64, f64)>>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> From<Vec<Vec<Point<P>>>> for Paths<P>

fn from(points: Vec<Vec<Point<P>>>) -> Self

Converts to this type from the input type.

impl<P: PointScaler> FromIterator<Path<P>> for Paths<P>

fn from_iter<T: IntoIterator<Item = Path<P>>>(iter: T) -> Self

Creates a value from an iterator.

impl<P: Hash + PointScaler> Hash for Paths<P>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<P: PointScaler> IntoIterator for Paths<P>

type Item = Path<P>

The type of the elements being iterated over.

type IntoIter = IntoIter<<Paths<P> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<P: PartialEq + PointScaler> PartialEq for Paths<P>

fn eq(&self, other: &Paths<P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P: Eq + PointScaler> Eq for Paths<P>

impl<P: PointScaler> StructuralPartialEq for Paths<P>