Struct cavalier_contours::polyline::Polyline

pub struct Polyline<T = f64> {
    pub vertex_data: Vec<PlineVertex<T>>,
    pub is_closed: bool,
}

Basic polyline data representation that implements the core polyline traits: PlineSource, PlineSourceMut, and PlineCreation. See the traits documentation for all the polyline methods/operations available.

Fields

vertex_data: Vec<PlineVertex<T>>

Contiguous sequence of vertexes.

is_closed: bool

Bool to indicate whether the polyline is closed or open.

Implementations

impl<T> Polyline<T>

where T: Real,

pub fn new() -> Self

Create a new empty Polyline with is_closed set to false.

pub fn new_closed() -> Self

Create a new empty Polyline with is_closed set to true.

Trait Implementations

impl<T: Clone> Clone for Polyline<T>

fn clone(&self) -> Polyline<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Polyline<T>

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

Formats the value using the given formatter.

impl<T> Default for Polyline<T>

where T: Real,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Index<usize> for Polyline<T>

type Output = PlineVertex<T>

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Polyline<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> PlineCreation for Polyline<T>

where T: Real,

fn with_capacity(capacity: usize, is_closed: bool) -> Self

Create a new empty polyline with capacity given and is_closed indicating whether it is a closed or open polyline.

fn from_iter<I>(iter: I, is_closed: bool) -> Self

where I: Iterator<Item = PlineVertex<Self::Num>>,

Create a new polyline by constructing from vertexes given by an iterator, is_closed sets whether the created polyline is closed or open.

fn create_from<P>(pline: &P) -> Self

where P: PlineSource<Num = Self::Num> + ?Sized,

Create a new polyline by cloning from an existing polyline.

fn create_from_remove_repeat<P>(pline: &P, pos_equal_eps: Self::Num) -> Self

where P: PlineSource<Num = Self::Num> + ?Sized,

Same as PlineCreation::create_from but removes any repeat position vertexes in the process using pos_equal_eps for positional comparisons.

fn empty() -> Self

Create empty polyline with is_closed set to false.

impl<T> PlineSource for Polyline<T>

where T: Real,

type Num = T

Numeric type used for the polyline.

type OutputPolyline = Polyline<T>

Type used for output when invoking methods that return a new polyline.

fn vertex_count(&self) -> usize

Total number of vertexes.

fn is_closed(&self) -> bool

Whether the polyline is closed (true) or open (false).

fn get(&self, index: usize) -> Option<PlineVertex<Self::Num>>

Get the vertex at given index position. Returns None if index out of bounds.

fn at(&self, index: usize) -> PlineVertex<Self::Num>

Same as PlineSource::get but panics if index is out of bounds.

fn iter_segments(&self) -> SegmentIter<'_, Self>

Return iterator to iterate over all the polyline segments.

fn iter_vertexes(&self) -> VertexIter<'_, Self>

Return iterator to iterate over all the polyline vertexes.

fn is_empty(&self) -> bool

Returns true if vertex count is 0.

fn fuzzy_eq_eps<P>(&self, other: &P, eps: Self::Num) -> bool

where P: PlineSource<Num = Self::Num> + ?Sized,

Fuzzy compare with another polyline using eps epsilon value for fuzzy comparison of vertexes.

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

where P: PlineSource<Num = Self::Num> + ?Sized,

Same as PlineSource::fuzzy_eq_eps but uses default Self::Num::fuzzy_epsilon().

fn last(&self) -> Option<PlineVertex<Self::Num>>

Get the last vertex of the polyline or None if polyline is empty.

fn segment_count(&self) -> usize

Total number of segments in the polyline.

fn iter_segment_indexes(&self) -> PlineSegIndexIterator

Iterate through all the polyline segment vertex positional indexes.

fn next_wrapping_index(&self, i: usize) -> usize

Returns the next wrapping vertex index for the polyline.

fn prev_wrapping_index(&self, i: usize) -> usize

Returns the previous wrapping vertex index for the polyline.

fn fwd_wrapping_dist(&self, start_index: usize, end_index: usize) -> usize

Returns the forward wrapping distance between two vertex indexes.

fn fwd_wrapping_index(&self, start_index: usize, offset: usize) -> usize

Returns the vertex index after applying offset to start_index in a wrapping manner.

fn extents(&self) -> Option<AABB<Self::Num>>

Compute the XY extents of the polyline.

fn path_length(&self) -> Self::Num

Returns the total path length of the polyline.

fn area(&self) -> Self::Num

Compute the closed signed area of the polyline.

fn orientation(&self) -> PlineOrientation

Returns the orientation of the polyline.

fn remove_repeat_pos( &self, pos_equal_eps: Self::Num ) -> Option<Self::OutputPolyline>

Remove all repeat position vertexes from the polyline.

fn remove_redundant( &self, pos_equal_eps: Self::Num ) -> Option<Self::OutputPolyline>

Remove all redundant vertexes from the polyline.

fn rotate_start( &self, start_index: usize, point: Vector2<Self::Num>, pos_equal_eps: Self::Num ) -> Option<Self::OutputPolyline>

Rotates the vertexes in a closed polyline such that the first vertex’s position is at point. start_index indicates which segment point lies on before rotation. This does not change the shape of the polyline curve. pos_equal_eps is epsilon value used for comparing the positions of points. None is returned if the polyline is not closed, the polyline length is less than 2, or the start_index is out of bounds.

fn create_approx_aabb_index(&self) -> StaticAABB2DIndex<Self::Num>

Creates a fast approximate spatial index of all the polyline segments.

fn create_aabb_index(&self) -> StaticAABB2DIndex<Self::Num>

Creates a spatial index of all the polyline segments.

fn closest_point( &self, point: Vector2<Self::Num>, pos_equal_eps: Self::Num ) -> Option<ClosestPointResult<Self::Num>>

Find the closest segment point on a polyline to a point given.

fn winding_number(&self, point: Vector2<Self::Num>) -> i32

Calculate the winding number for a point relative to the polyline.

fn arcs_to_approx_lines( &self, error_distance: Self::Num ) -> Option<Self::OutputPolyline>

Returns a new polyline with all arc segments converted to line segments with some error_distance or None if Self::Num fails to cast to or from usize.

fn visit_self_intersects<C, V>(&self, visitor: &mut V) -> C

where C: ControlFlow, V: PlineIntersectVisitor<Self::Num, C>,

Visit self intersects of the polyline using default options.

fn visit_self_intersects_opt<C, V>( &self, visitor: &mut V, options: &PlineSelfIntersectOptions<'_, Self::Num> ) -> C

where C: ControlFlow, V: PlineIntersectVisitor<Self::Num, C>,

Visit self intersects of the polyline using options provided.

fn find_intersects<P>(&self, other: &P) -> PlineIntersectsCollection<Self::Num>

where P: PlineSource<Num = Self::Num> + ?Sized,

Find all intersects between two polylines using default options.

fn find_intersects_opt<P>( &self, other: &P, options: &FindIntersectsOptions<'_, Self::Num> ) -> PlineIntersectsCollection<Self::Num>

where P: PlineSource<Num = Self::Num> + ?Sized,

Find all intersects between two polylines using the options provided.

fn parallel_offset(&self, offset: Self::Num) -> Vec<Self::OutputPolyline>

Compute the parallel offset polylines of the polyline using default options.

fn parallel_offset_opt( &self, offset: Self::Num, options: &PlineOffsetOptions<'_, Self::Num> ) -> Vec<Self::OutputPolyline>

Compute the parallel offset polylines of the polyline with options given.

fn boolean<P>( &self, other: &P, operation: BooleanOp ) -> BooleanResult<Self::OutputPolyline>

where P: PlineSource<Num = Self::Num> + ?Sized,

Perform a boolean operation between this polyline and another using default options.

fn boolean_opt<P>( &self, other: &P, operation: BooleanOp, options: &PlineBooleanOptions<'_, Self::Num> ) -> BooleanResult<Self::OutputPolyline>

where P: PlineSource<Num = Self::Num> + ?Sized,

Perform a boolean operation between this polyline and another with options provided.

fn find_point_at_path_length( &self, target_path_length: Self::Num ) -> Result<(usize, Vector2<Self::Num>), Self::Num>

Find the segment index and point on the polyline corresponding to the path length given.

impl<T> PlineSourceMut for Polyline<T>

where T: Real,

fn set_vertex(&mut self, index: usize, vertex: PlineVertex<Self::Num>)

Set the vertex data at the given index position of the polyline.

fn insert_vertex(&mut self, index: usize, vertex: PlineVertex<Self::Num>)

Insert a new vertex into the polyline at the given index position.

fn remove(&mut self, index: usize) -> PlineVertex<Self::Num>

Remove vertex at the given index position and return it.

fn add_vertex(&mut self, vertex: PlineVertex<Self::Num>)

Add a vertex to the end of the polyline.

fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more vertexes.

fn set_is_closed(&mut self, is_closed: bool)

Set whether the polyline is closed (is_closed = true) or open (is_closed = false).

fn clear(&mut self)

Clear all vertexes of the polyline.

fn extend_vertexes<I>(&mut self, vertexes: I)

where I: IntoIterator<Item = PlineVertex<Self::Num>>,

Append all vertexes from an iterator to the end of this polyline.

fn set(&mut self, index: usize, x: Self::Num, y: Self::Num, bulge: Self::Num)

Same as PlineSourceMut::set_vertex but accepts each component of the vertex rather than a vertex structure.

fn set_last(&mut self, vertex: PlineVertex<Self::Num>)

Set the last vertex of the polyline.

fn insert(&mut self, index: usize, x: Self::Num, y: Self::Num, bulge: Self::Num)

Same as PlineSourceMut::insert_vertex but accepts each component of the vertex rather than a vertex structure.

fn remove_last(&mut self) -> PlineVertex<Self::Num>

Remove the last vertex from the polyline and return it.

fn add(&mut self, x: Self::Num, y: Self::Num, bulge: Self::Num)

Same as PlineSourceMut::add_vertex but accepts each component of the vertex rather than a vertex structure.

fn add_from_array(&mut self, data: [Self::Num; 3])

Same as PlineSourceMut::add_vertex but accepts each component as elements in an array, 0 = x, 1 = y, 2 = bulge.

fn extend<P>(&mut self, other: &P)

where P: PlineSource<Num = Self::Num> + ?Sized,

Copy all vertexes from other to the end of this polyline.

fn extend_remove_repeat<P>(&mut self, other: &P, pos_equal_eps: Self::Num)

where P: PlineSource<Num = Self::Num> + ?Sized,

Same as PlineSourceMut::extend but removes any consecutive repeat position vertexes in the process of copying (using pos_equal_eps for compare).

fn add_or_replace_vertex( &mut self, vertex: PlineVertex<Self::Num>, pos_equal_eps: Self::Num )

Add a vertex if it’s position is not fuzzy equal to the last vertex in the polyline.

fn add_or_replace( &mut self, x: Self::Num, y: Self::Num, bulge: Self::Num, pos_equal_eps: Self::Num )

Same as PlineSourceMut::add_or_replace_vertex but accepts each component of the vertex rather than a vertex structure.

fn scale_mut(&mut self, scale_factor: Self::Num)

Uniformly scale the polyline (mutably) in the xy plane by scale_factor.

fn translate_mut(&mut self, x: Self::Num, y: Self::Num)

Translate the polyline (mutably) by some x_offset and y_offset.

fn invert_direction_mut(&mut self)

Invert/reverse the direction of the polyline in place (mutably).