Struct Concat 

pub struct Concat<A, B> { /* private fields */ }

Two paths joined end-to-end into a single continuous path.

The combined path has length first.length() + second.length(). Sampling below first.length() delegates to the first path; the remainder delegates to the second with a shifted arc-length.

Implementations

impl<A, B> Concat<A, B>

pub fn new(first: A, second: B) -> Self

Create a new concatenated path.

Trait Implementations

impl<A: Path, B: Path<Scalar = A::Scalar, Point = A::Point, Error = A::Error>> Path for Concat<A, B>

type Scalar = <A as Path>::Scalar

The scalar type for arc-length, parameter, and distance computations.

type Point = <A as Path>::Point

The point type representing positions on the path.

type Error = <A as Path>::Error

The error type for fallible operations. Must be convertible from PathError<Self::Scalar>.

fn length(&self) -> Self::Scalar

Total arc-length of the path.

fn sample_at(&self, s: Self::Scalar) -> Result<Self::Point, Self::Error>

Sample the path at arc-length s ∈ [0, length].

fn start(&self) -> Result<Self::Point, Self::Error>

The start point of the path, equivalent to sample_at(0).

fn end(&self) -> Result<Self::Point, Self::Error>

The end point of the path, equivalent to sample_at(length).

fn domain(&self) -> RangeInclusive<Self::Scalar>

The valid domain for arc-length sampling: [0, length].

impl<A, B> SegmentedPath for Concat<A, B>

where A: Path + SegmentedPath, B: Path<Scalar = A::Scalar, Point = A::Point, Error = A::Error> + SegmentedPath<Segment = A::Segment>, A::Segment: PathSegment<Scalar = A::Scalar, Point = A::Point, Error = A::Error>,

type Segment = <A as SegmentedPath>::Segment

The type of individual segments making up this path.

fn segment_count(&self) -> usize

Number of segments in this path.

fn segments(&self) -> impl Iterator<Item = &Self::Segment> + '_

Iterator over all segments.

fn locate(&self, s: Self::Scalar) -> Result<(usize, Self::Scalar), Self::Error>

Map global arc-length s to (segment_index, local_s).

fn segment(&self, i: usize) -> Option<&Self::Segment>

Get the segment at index i, or None if out of bounds.