[][src]Struct plexus::primitive::decompose::Decompose

pub struct Decompose<I, P, Q, R> where
    R: IntoIterator<Item = Q>, 
{ /* fields omitted */ }

Methods

impl<I, P, R> Decompose<I, P, P, R> where
    I: Iterator<Item = P>,
    R: IntoIterator<Item = P>, 
[src]

Important traits for Decompose<I, P, Q, R>
pub fn remap(self, n: usize) -> Decompose<impl Iterator<Item = P>, P, P, R>[src]

Reapplies a congruent decomposition.

A decomposition is congruent if its input and output types are the same. This is useful when the number of applications is somewhat large or variable, in which case chaining calls is impractical or impossible.

Examples

use decorum::N64;
use nalgebra::Point3;
use plexus::index::{Flat4, HashIndexer};
use plexus::prelude::*;
use plexus::primitive::cube::Cube;
use plexus::primitive::generate::Position;

let (indices, positions) = Cube::new()
    .polygons::<Position<Point3<N64>>>()
    .subdivide()
    .remap(7) // 8 subdivision operations are applied.
    .index_vertices::<Flat4, _>(HashIndexer::default());

Trait Implementations

impl<I, P, Q, R> Iterator for Decompose<I, P, Q, R> where
    I: Iterator<Item = P>,
    R: IntoIterator<Item = Q>, 
[src]

type Item = Q

The type of the elements being iterated over.

Auto Trait Implementations

impl<I, P, Q, R> Send for Decompose<I, P, Q, R> where
    I: Send,
    Q: Send

impl<I, P, Q, R> Sync for Decompose<I, P, Q, R> where
    I: Sync,
    Q: Sync

impl<I, P, Q, R> Unpin for Decompose<I, P, Q, R> where
    I: Unpin,
    Q: Unpin

impl<I, P, Q, R> UnwindSafe for Decompose<I, P, Q, R> where
    I: UnwindSafe,
    Q: UnwindSafe

impl<I, P, Q, R> RefUnwindSafe for Decompose<I, P, Q, R> where
    I: RefUnwindSafe,
    Q: RefUnwindSafe

Blanket Implementations

impl<R, P, I> GroupedIndexVertices<R, P> for I where
    I: Iterator<Item = P>,
    P: Map<<Vec<<R as Grouping>::Item> as IndexBuffer<R>>::Index> + Topological,
    R: Grouping,
    <P as Map<<Vec<<R as Grouping>::Item> as IndexBuffer<R>>::Index>>::Output: Topological,
    Vec<<R as Grouping>::Item>: Push<R, <P as Map<<Vec<<R as Grouping>::Item> as IndexBuffer<R>>::Index>>::Output>,
    <<P as Map<<Vec<<R as Grouping>::Item> as IndexBuffer<R>>::Index>>::Output as Topological>::Vertex == <Vec<<R as Grouping>::Item> as IndexBuffer<R>>::Index
[src]

impl<P, I> IndexVertices<P> for I where
    I: Iterator<Item = P>,
    P: Topological
[src]

impl<P, Q, I> CollectWithIndexer<P, Q> for I where
    I: Iterator<Item = P>,
    P: Topological,
    Q: Topological<Vertex = <P as Topological>::Vertex>, 
[src]

impl<I, P> Vertices<P> for I where
    I: Iterator<Item = P>,
    P: IntoVertices
[src]

impl<I, P> Edges<P> for I where
    I: Iterator<Item = P>,
    P: IntoEdges,
    <P as Topological>::Vertex: Clone
[src]

impl<I, P> Triangulate<P> for I where
    I: Iterator<Item = P>,
    P: IntoTrigons
[src]

impl<I, P> Subdivide<P> for I where
    I: Iterator<Item = P>,
    P: IntoSubdivisions
[src]

impl<I, T> Tetrahedrons<T> for I where
    I: Iterator<Item = NGon<[T; 4]>>,
    T: Clone + Interpolate<T, Output = T>, 
[src]

impl<I, T, U> MapVertices<T, U> for I where
    I: Iterator,
    <I as Iterator>::Item: Map<U>,
    <I as Iterator>::Item: Topological,
    <<I as Iterator>::Item as Map<U>>::Output: Topological,
    <<I as Iterator>::Item as Topological>::Vertex == T,
    <<<I as Iterator>::Item as Map<U>>::Output as Topological>::Vertex == U, 
[src]

impl<T> FromGeometry<T> for T[src]

impl<T, U> IntoGeometry<U> for T where
    U: FromGeometry<T>, 
[src]

impl<I> IteratorExt for I where
    I: Iterator
[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> From<T> for T[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Itertools for T where
    T: Iterator + ?Sized
[src]

impl<I> IteratorRandom for I where
    I: Iterator
[src]

impl<T> Itertools for T where
    T: Iterator + ?Sized
[src]

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<I> IteratorRandom for I where
    I: Iterator
[src]

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>, 

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,