Struct linestring::cgmath_2d::LineString2

pub struct LineString2<T> where
    T: BaseFloat + Sync,  {
    pub connected: bool,
    // some fields omitted
}

A 2d line string, aka polyline. If the ‘connected’ field is set the ‘as_lines()’ method will connect start point with the end-point. Todo: The builder structure of this struct needs to be revisited

Fields

connected: bool

if connected is set the as_lines() method will add an extra line connecting the first and last point

Implementations

impl<T> LineString2<T> where
    T: BaseFloat + Sync, 

pub fn with_capacity(capacity: usize) -> Self

pub fn with_points(self, points: Vec<Point2<T>>) -> Self

pub fn with_connected(self, connected: bool) -> Self

pub fn with_iter<'a, I>(iter: I) -> Self where
    T: 'a,
    I: Iterator<Item = &'a Point2<T>>, 

Copies the points of the iterator into the LineString2 from_iter is already claimed for into() objects.

pub fn append(&mut self, other: Self)

Moves all the elements of other into Self, leaving other empty. TODO: currently ignores if other is connected or not.

Panics

Panics if the number of elements in the points vector overflows a usize.

pub fn is_self_intersecting(&self) -> Result<bool, LinestringError>

Returns true if the lines are self intersecting If number of points < 10 then the intersections are tested using brute force O(n²) If more than that a sweep-line algorithm is used O(nlog(n)+ilog(n))

pub fn points(&self) -> &Vec<Point2<T>>

pub fn len(&self) -> usize

returns the number of points in the point list not the number of segments (add one if connected)

pub fn is_empty(&self) -> bool

returns true if the point list is empty

pub fn as_lines(&self) -> Vec<Line2<T>>

Returns the line string as a Vec of lines Will be deprecated at some time, use self.as_lines_iter().collect() instead

pub fn as_lines_iter<'a>(&'a self) -> Box<dyn Iterator<Item = Line2<T>> + 'a>

Returns the line string as a iterator of lines

pub fn as_lines_iter_len(&self) -> usize

The iterator of as_lines_iter() does not implement ExactSizeIterator. This can be used as a work around for that problem

pub fn copy_to_3d(&self, plane: Plane) -> LineString3<T>

Copy this linestring2 into a linestring3, populating the axes defined by ‘plane’ An axis will always try to keep it’s position (e.g. y goes to y if possible). That way the operation is reversible (with regards to axis positions).

pub fn push(&mut self, point: Point2<T>)

pub fn transform(&self, matrix3x3: &Matrix3<T>) -> Self

pub fn simplify(&self, distance_predicate: T) -> Self

Simplify using Ramer–Douglas–Peucker algorithm

pub fn simplify_vw(&self, points_to_delete: usize) -> Self

Simplify using Visvalingam–Whyatt algorithm. This algorithm will delete ‘points_to_delete’ of points from the polyline with the smallest area defined by one point and it’s neighbours.

pub fn operation<F>(&mut self, f: F) where
    F: Fn(T) -> T, 

Trait Implementations

impl<T: Clone> Clone for LineString2<T> where
    T: BaseFloat + Sync, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for LineString2<T> where
    T: BaseFloat + Sync, 

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

Formats the value using the given formatter.

impl<T> Default for LineString2<T> where
    T: BaseFloat + Sync, 

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<Aabb2<T>> for LineString2<T> where
    T: BaseFloat + Sync, 

fn from(other: Aabb2<T>) -> Self

creates a connected LineString2 from the outlines of the Aabb2

impl<T, IC> FromIterator<IC> for LineString2<T> where
    T: BaseFloat + Sync,
    IC: Into<Point2<T>>, 

fn from_iter<I: IntoIterator<Item = IC>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Hash> Hash for LineString2<T> where
    T: BaseFloat + Sync, 

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, 

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq<LineString2<T>> for LineString2<T> where
    T: BaseFloat + Sync, 

fn eq(&self, other: &LineString2<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &LineString2<T>) -> bool

This method tests for !=.

impl<T: Eq> Eq for LineString2<T> where
    T: BaseFloat + Sync, 

impl<T> StructuralEq for LineString2<T> where
    T: BaseFloat + Sync, 

impl<T> StructuralPartialEq for LineString2<T> where
    T: BaseFloat + Sync,