Struct descartes::LinePath

pub struct LinePath {
    pub points: VecLike<P2>,
    // some fields omitted
}

Fields

points: VecLike<P2>

Methods

impl LinePath

Creation

pub fn new(points: VecLike<P2>) -> Option<Self>

impl LinePath

Inspection

pub fn start(&self) -> P2

pub fn end(&self) -> P2

pub fn length(&self) -> N

pub fn segments<'a>(     &'a self ) -> impl Iterator<Item = LineSegment> + 'a

pub fn segments_with_distances(     &self ) -> impl Iterator<Item = (LineSegment, &[N])>

pub fn first_segment(&self) -> LineSegment

pub fn last_segment(&self) -> LineSegment

pub fn find_on_segment(&self, distance: N) -> Option<(LineSegment, N)>

pub fn along(&self, distance: N) -> P2

pub fn direction_along(&self, distance: N) -> V2

pub fn start_direction(&self) -> V2

pub fn end_direction(&self) -> V2

pub fn project_with_tolerance(&self, point: P2, tolerance: N) -> Option<(N, P2)>

pub fn project_with_max_distance(     &self,     point: P2,     tolerance: N,     max_distance: N ) -> Option<(N, P2)>

pub fn project(&self, point: P2) -> Option<(N, P2)>

pub fn includes(&self, point: P2) -> bool

pub fn distance_to(&self, point: P2) -> N

impl LinePath

Combination/Modification

pub fn concat(&self, other: &Self) -> Result<Self, ConcatError>

pub fn concat_weld(     &self,     other: &Self,     tolerance: N ) -> Result<Self, ConcatError>

pub fn reverse(&self) -> Self

pub fn subsection(&self, start: N, end: N) -> Option<Self>

Important traits for DashIterator<'a>

impl<'a> Iterator for DashIterator<'a> type Item = Option<LinePath>;

pub fn dash(&self, dash_length: N, gap_length: N) -> DashIterator

pub fn shift_orthogonally_vectors<'a>(     &'a self ) -> impl Iterator<Item = ShiftVector> + 'a

pub fn shift_orthogonally(&self, shift_to_right: N) -> Option<Self>

pub fn with_new_start_and_end(&self, new_start: P2, new_end: P2) -> Option<Self>

impl LinePath

pub fn from_svg(string: &str) -> Option<Self>

pub fn to_svg(&self) -> String

Trait Implementations

impl Compact for LinePath

fn is_still_compact(&self) -> bool

Is the object's dynamic part stored compactly?

fn dynamic_size_bytes(&self) -> usize

Size of the dynamic part in bytes

unsafe fn compact(source: *mut Self, dest: *mut Self, new_dynamic_part: *mut u8)

Copy the static part of source to dest and compactly store the dynamic part of source as the new dynamic part of dest at new_dynamic_part. This semantically moves source into dest.

unsafe fn decompact(source: *const Self) -> Self

Creates a clone of self with the dynamic part guaranteed to be stored freely.

fn total_size_bytes(&self) -> usize

Total size of the object (static part + dynamic part)

unsafe fn behind(ptr: *mut Self) -> *mut u8

Get a pointer to behind the static part of self (commonly used place for the dynamic part)

unsafe fn compact_behind(source: *mut Self, dest: *mut Self)

Like compact with new_dynamic_part set to dest.behind()

impl Clone for LinePath

fn clone(&self) -> LinePath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LinePath

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

Formats the value using the given formatter.

impl<'a> RoughEq for &'a LinePath

fn rough_eq_by(&self, other: Self, tolerance: N) -> bool

fn rough_eq(&self, other: Self) -> bool