Struct Polyline 

pub struct Polyline<T>(pub Vec<T>);

A curve composed of a chain of line segments.

The polyline is represented as a list of points, or vertices, with each pair of consecutive vertices sharing an edge.

Tuple Fields

0: Vec<T>

Implementations

impl<T> Polyline<T>

pub fn new(verts: impl IntoIterator<Item = T>) -> Self

Creates a new polyline from an iterator of vertex points.

pub fn edges(&self) -> impl Iterator<Item = Edge<&T>> + '_

Returns an iterator over the line segments of self.

Examples

use retrofire_core::geom::{Polyline, Edge};
use retrofire_core::math::{pt2, Point2};

let pts: [Point2; _] = [pt2(0.0, 0.0), pt2(1.0, 1.0), pt2(2.0, 1.0)];

let pline = Polyline::new(pts);
let mut edges = pline.edges();

assert_eq!(edges.next(), Some(Edge(&pts[0], &pts[1])));
assert_eq!(edges.next(), Some(Edge(&pts[1], &pts[2])));
assert_eq!(edges.next(), None);

Trait Implementations

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

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

Returns a duplicate 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: Lerp + Clone> Parametric<T> for Polyline<T>

fn eval(&self, t: f32) -> T

Returns the point on self at t.

If the number of vertices in self is n > 1, the vertex at index k < n corresponds to t = k / (n - 1). Intermediate values of t are linearly interpolated between the two closest vertices. Values t < 0 and t > 1 are clamped to 0 and 1 respectively. A polyline with a single vertex returns the value of that vertex for any value of t.

Panics

If self has no vertices.

Examples

use retrofire_core::geom::{Polyline, Edge};
use retrofire_core::math::{pt2, Point2, Parametric};

let pl = Polyline::<Point2>(
    vec![pt2(0.0, 0.0), pt2(1.0, 2.0), pt2(2.0, 1.0)]);

assert_eq!(pl.eval(0.0), pl.0[0]);
assert_eq!(pl.eval(0.5), pl.0[1]);
assert_eq!(pl.eval(1.0), pl.0[2]);

// Values not corresponding to a vertex are interpolated:
assert_eq!(pl.eval(0.25), pt2(0.5, 1.0));
assert_eq!(pl.eval(0.75), pt2(1.5, 1.5));

// Values of t outside 0.0..=1.0 are clamped:
assert_eq!(pl.eval(-1.23), pl.eval(0.0));
assert_eq!(pl.eval(7.68), pl.eval(1.0));

impl<T: PartialEq> PartialEq for Polyline<T>

fn eq(&self, other: &Polyline<T>) -> 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<T: Eq> Eq for Polyline<T>

impl<T> StructuralPartialEq for Polyline<T>