Struct gut::mesh::LineMesh[−][src]

pub struct LineMesh<T> where
    T: Real,  {
    pub vertex_positions: IntrinsicAttribute<[T; 3], VertexIndex>,
    pub indices: IntrinsicAttribute<[usize; 2], FaceIndex>,
    pub vertex_attributes: HashMap<String, Attribute<VertexIndex>, RandomState, Global>,
    pub face_attributes: HashMap<String, Attribute<FaceIndex>, RandomState, Global>,
    pub face_vertex_attributes: HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>,
    pub face_edge_attributes: HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>,
    pub attribute_value_cache: HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>,
}

Fields

vertex_positions: IntrinsicAttribute<[T; 3], VertexIndex>

Vertex positions.

indices: IntrinsicAttribute<[usize; 2], FaceIndex>

Pairs of indices into vertices representing line segments.

vertex_attributes: HashMap<String, Attribute<VertexIndex>, RandomState, Global>

Vertex attributes.

face_attributes: HashMap<String, Attribute<FaceIndex>, RandomState, Global>

Line segment attributes.

face_vertex_attributes: HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>

Line segment vertex attributes.

face_edge_attributes: HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>

Line segment edge attributes.

A line segment can be seen as having two directed edges.

attribute_value_cache: HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>

Indirect attribute value cache

Implementations

[src]

impl<T> LineMesh<T> where
T: Real,

[src]

pub fn new(
verts: Vec<[T; 3], Global>,
indices: Vec<[usize ; 2], Global>
) -> LineMesh<T>

[src]

pub fn face_iter(&self) -> Iter<'_, [usize ; 2]>

Iterate over each face.

[src]

pub fn face_iter_mut(&mut self) -> IterMut<'_, [usize ; 2]>

Iterate mutably over each face.

[src]

pub fn face<FI>(&self, fidx: FI) -> &[usize ; 2] where
FI: Into<FaceIndex>,

Face accessor. These are vertex indices.

[src]

pub fn faces(&self) -> &[[usize ; 2]]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

Return a slice of individual faces.

[src]

pub fn reverse(&mut self)

Reverse the order of each polygon in this mesh.

[src]

pub fn reversed(self) -> LineMesh<T>

Reverse the order of each polygon in this mesh. This is the consuming version of the reverse method.

[src]

pub fn sort_vertices_by_key<K, F>(&mut self, f: F) where
F: FnMut(usize) -> K,
K: Ord,

Sort vertices by the given key values.

Trait Implementations

[src]

impl<T> Attrib for LineMesh<T> where
T: Real,

[src]

pub fn attrib_size(&self) -> usize where
I: AttribIndex<LineMesh<T>>,

Get the size of the attribute at the appropriate mesh location determined by I.

[src]

pub fn attrib_dict(
&self
) -> &HashMap<String, Attribute, RandomState, Global> where
I: AttribIndex<LineMesh<T>>,

Read only access to the attribute dictionary.

[src]

pub fn attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute, RandomState, Global> where
I: AttribIndex<LineMesh<T>>,

Read and write access to the attribute dictionary.

[src]

pub fn attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>) where
I: AttribIndex<LineMesh<T>>,

Read and write access to the attribute dictionary along with a cache for indirect attribute values. Read more

[src]

fn add_attrib<T, I>(
 &mut self,
 name: &'a str,
 def: T
) -> Result<&mut Attribute, Error> where
 I: AttribIndex<Self>,
 T: AttributeValue,

Add an attribute at the appropriate location with a given default.

[src]

fn add_attrib_data<T, I>(
 &mut self,
 name: &'a str,
 data: Vec<T, Global>
) -> Result<&mut Attribute, Error> where
 I: AttribIndex<Self>,
 T: AttributeValue + Default,

Construct an attribute from a given data Vec<T>. data must have exactly the right size for the attribute to be added successfully. Read more

[src]

fn set_attrib<T, I>(
 &mut self,
 name: &'a str,
 def: T
) -> Result<&mut Attribute, Error> where
 I: AttribIndex<Self>,
 T: AttributeValue,

Sets the attribute to the specified default value whether or not it already exists. Read more

[src]

fn set_attrib_data<T, I>(
 &mut self,
 name: &'a str,
 data: &[T]
) -> Result<&mut Attribute, Error> where
 I: AttribIndex<Self>,
 T: AttributeValue + Default,

Set an attribute to the given data slice. data must have exactly the right size for the attribute to be set successfully. Read more

[src]

fn add_indirect_attrib<T, I>(
 &mut self,
 name: &'a str,
 def: T
) -> Result<(&mut Attribute, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
 I: AttribIndex<Self>,
 T: AttributeValueHash,

Add an indirect attribute at the appropriate location with a given default.

[src]

fn set_indirect_attrib<T, I>(
 &mut self,
 name: &'a str,
 def: T
) -> Result<(&mut Attribute, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
 I: AttribIndex<Self>,
 T: AttributeValueHash,

Sets the indirect attribute to the specified default value whether or not it already exists. Read more

[src]

fn add_indirect_attrib_data(
 &mut self,
 name: &'a str,
 data: IndirectData
) -> Result<(&mut Attribute, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
 I: AttribIndex<Self>,

Construct an indirect attribute from a given IndirectData. data must have exactly the right size for the attribute to be added successfully. Read more

[src]

fn set_indirect_attrib_data(
 &mut self,
 name: &'a str,
 data: IndirectData
) -> Result<(&mut Attribute, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
 I: AttribIndex<Self>,

Set an indirect attribute to the given IndirectData instance. data must have exactly the right size for the attribute to be set successfully. Read more

[src]

fn duplicate_attrib<T, I>(
 &mut self,
 name: &'a str,
 new_name: &'b str
) -> Result<&mut Attribute, Error> where
 I: AttribIndex<Self>,
 T: Any + Clone,

Makes a copy of an existing attribute. Read more

[src]

fn remove_attrib(&mut self, name: &str) -> Result<Attribute, Error> where
I: AttribIndex<Self>,

Remove an attribute from the attribute dictionary. Read more

[src]

fn insert_attrib(
 &mut self,
 name: &str,
 attrib: Attribute
) -> Result<Option<Attribute>, Error> where
 I: AttribIndex<Self>,

Inserts an attribute into the dictionary with the usual HashMap semantics. Read more

[src]

fn attrib_or_add<T, I>(
 &mut self,
 name: &'a str,
 def: T
) -> Result<&mut Attribute, Error> where
 I: AttribIndex<Self>,
 T: AttributeValue,

Retrieve the attribute with the given name and if it doesn’t exist, add a new one and set it to a given default value. In either case the mutable reference to the attribute is returned. Read more

[src]

fn attrib_or_add_data<T, I>(
 &mut self,
 name: &'a str,
 data: &[T]
) -> Result<&mut Attribute, Error> where
 I: AttribIndex<Self>,
 T: AttributeValue + Default,

Retrieve the attribute with the given name and if it doesn’t exist, set its data to what’s in the given slice. In either case the mutable reference to the attribute is returned. Read more

[src]

fn attrib_or_add_indirect<T, I>(
 &mut self,
 name: &'a str,
 def: T
) -> Result<(&mut Attribute, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
 I: AttribIndex<Self>,
 T: AttributeValueHash,

Retrieve the indirect attribute with the given name and if it doesn’t exist, add a new one and set it to a given default value. In either case the mutable reference to the attribute is returned. Read more

[src]

fn direct_attrib_iter<'b, T, I>(
 &'b self,
 name: &'a str
) -> Result<Iter<'b, T>, Error> where
 I: 'b + AttribIndex<Self>,
 T: Any + Clone,

Get the attribute iterator for a direct attribute.

[src]

fn attrib_iter_mut<'b, T, I>(
 &'b mut self,
 name: &'a str
) -> Result<IterMut<'b, T>, Error> where
 I: 'b + AttribIndex<Self>,
 T: Any + Clone,

Get the attribute mutable iterator for a direct attribute. Read more

[src]

fn attrib_iter<'b, T, I>(
 &'b self,
 name: &str
) -> Result<Box<dyn Iterator<Item = &'b T> + 'b, Global>, Error> where
 I: 'b + AttribIndex<Self>,
 T: Any + Clone,

Get the iterator for an attribute no matter what kind.

[src]

fn indirect_attrib_update_with<'b, T, I, F>(
 &'b mut self,
 name: &'a str,
 f: F
) -> Result<(&'b mut Attribute, &'b mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
 T: AttributeValueHash,
 I: 'b + AttribIndex<Self>,
 F: FnMut(usize, &Arc<T>) -> Option<Arc<T>>,

Update indirect attribute entries with the given closure. Read more

[src]

fn attrib_exists(&self, name: &str) -> bool where
I: AttribIndex<Self>,

Return true if the given attribute exists at the given location, and false otherwise, even if the specified attribute location is invalid for the mesh. Read more

[src]

fn attrib_check<T, I>(&self, name: &'a str) -> Result<&Attribute, Error> where
T: Any,
I: AttribIndex<Self>,

Determine if the given attribute is valid and exists at the given location. Read more

[src]

fn attrib_as_slice<'b, T, I>(&'b self, name: &'a str) -> Result<&'b [T], Error> where
T: 'static,
I: 'b + AttribIndex<Self>,

Expose the underlying direct attribute as a slice.

[src]

fn attrib_as_mut_slice<'b, T, I>(
 &'b mut self,
 name: &'a str
) -> Result<&'b mut [T], Error> where
 T: 'static,
 I: 'b + AttribIndex<Self>,

Expose the underlying direct attribute as a mutable slice.

[src]

fn attrib_clone_into_vec<'b, T, I>(
 &'b self,
 name: &'a str
) -> Result<Vec<T, Global>, Error> where
 I: 'b + AttribIndex<Self>,
 T: AttributeValueHash,

Clone attribute data into a Vec<T>. Read more

[src]

fn direct_attrib_clone_into_vec<'b, T, I>(
 &'b self,
 name: &'a str
) -> Result<Vec<T, Global>, Error> where
 I: 'b + AttribIndex<Self>,
 T: AttributeValue,

Clone direct attribute data into a Vec<T>.

[src]

fn attrib(&self, name: &'a str) -> Result<&Attribute, Error> where
I: AttribIndex<Self>,

Borrow the raw attribute from the attribute dictionary. From there you can use methods defined on the attribute itself. Read more

[src]

fn attrib_mut(&mut self, name: &'a str) -> Result<&mut Attribute, Error> where
I: AttribIndex<Self>,

Get the raw mutable attribute from the attribute dictionary. From there you can use methods defined on the attribute itself. Read more

[src]

impl<T> Clone for LineMesh<T> where
T: Clone + Real,

[src]

pub fn clone(&self) -> LineMesh<T>

Returns a copy of the value. Read more

1.0.0[src]

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

Performs copy-assignment from source. Read more

[src]

impl<T> Debug for LineMesh<T> where
T: Debug + Real,

[src]

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

Formats the value using the given formatter. Read more

[src]

impl<T> Default for LineMesh<T> where
T: Real,

[src]

pub fn default() -> LineMesh<T>

Produce an empty mesh. This is not particularly useful on its own, however it can be used as a null case for various mesh algorithms.

[src]

impl<T> FaceAttrib for LineMesh<T> where
T: Real,

[src]

pub fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

[src]

pub fn topo_attrib_dict(
&self
) -> &HashMap<String, Attribute<FaceIndex>, RandomState, Global>

Mesh implementation of the attribute dictionary getter.

[src]

pub fn topo_attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute<FaceIndex>, RandomState, Global>

Mesh implementation of the attribute dictionary mutable getter.

[src]

pub fn topo_attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute<FaceIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

Mesh implementation of the attribute dictionary and cache mutable getter.

[src]

impl<T> FaceEdge for LineMesh<T> where
T: Real,

[src]

pub fn edge<FEI>(&self, fe_idx: FEI) -> EdgeIndex where
FEI: Copy + Into<FaceEdgeIndex>,

Index of the destination element given the topology index.

[src]

pub fn face_edge<FI>(&self, fidx: FI, which: usize) -> Option<FaceEdgeIndex> where
FI: Copy + Into<FaceIndex>,

Toplogy index: where the data lives in an attribute array.

[src]

pub fn num_face_edges(&self) -> usize

Topology quantifier. Number of connectors in total.

[src]

pub fn num_edges_at_face<FI>(&self, FI) -> usize where
FI: Copy + Into<FaceIndex>,

Topology quantifier. Number of connectors at a particular element.

[src]

fn face_to_edge(&self, i: I, k: usize) -> Option<EdgeIndex> where
I: Copy + Into<FaceIndex>,

Index of the destination element from the source index.

[src]

impl<T> FaceEdgeAttrib for LineMesh<T> where
T: Real,

[src]

pub fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

[src]

pub fn topo_attrib_dict(
&self
) -> &HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>

Mesh implementation of the attribute dictionary getter.

[src]

pub fn topo_attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>

Mesh implementation of the attribute dictionary mutable getter.

[src]

pub fn topo_attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

Mesh implementation of the attribute dictionary and cache mutable getter.

[src]

impl<T> FaceVertex for LineMesh<T> where
T: Real,

[src]

pub fn vertex<FVI>(&self, fv_idx: FVI) -> VertexIndex where
FVI: Copy + Into<FaceVertexIndex>,

Index of the destination element given the topology index.

[src]

pub fn face_vertex<FI>(&self, fidx: FI, which: usize) -> Option<FaceVertexIndex> where
FI: Copy + Into<FaceIndex>,

Toplogy index: where the data lives in an attribute array.

[src]

pub fn num_face_vertices(&self) -> usize

Topology quantifier. Number of connectors in total.

[src]

pub fn num_vertices_at_face<FI>(&self, FI) -> usize where
FI: Copy + Into<FaceIndex>,

Topology quantifier. Number of connectors at a particular element.

[src]

fn face_to_vertex(&self, i: I, k: usize) -> Option<VertexIndex> where
I: Copy + Into<FaceIndex>,

Index of the destination element from the source index.

[src]

fn reverse_topo(&self) -> (Vec<usize, Global>, Vec<usize, Global>) where
Self: NumFaces + NumVertices,

Generate the reverse topology structure.

[src]

fn reverse_source_topo(&self) -> (Vec<usize, Global>, Vec<usize, Global>) where
Self: NumVertices,

Generate the reverse topology structure from the destination element to the source topology element. Read more

[src]

impl<T> FaceVertexAttrib for LineMesh<T> where
T: Real,

[src]

pub fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

[src]

pub fn topo_attrib_dict(
&self
) -> &HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>

Mesh implementation of the attribute dictionary getter.

[src]

pub fn topo_attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>

Mesh implementation of the attribute dictionary mutable getter.

[src]

pub fn topo_attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

Mesh implementation of the attribute dictionary and cache mutable getter.

[src]

impl<T> From<PolyMesh<T>> for LineMesh<T> where
T: Real,

[src]

pub fn from(mesh: PolyMesh<T>) -> LineMesh<T>

Convert a PolyMesh into a LineMesh. This is effectively a wireframe construction.

Note that this conversion does not merge any attributes, each face will generate its own edge. This means that two neighbouring faces will generate two overlapping edges. This is done to preserve all attribute data during the conversion, which means that some of it is duplicated.

[src]

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

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

[src]

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

This method tests for !=.

[src]

impl<T> VertexAttrib for LineMesh<T> where
T: Real,

[src]

pub fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

[src]

pub fn topo_attrib_dict(
&self
) -> &HashMap<String, Attribute<VertexIndex>, RandomState, Global>

Mesh implementation of the attribute dictionary getter.

[src]

pub fn topo_attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute<VertexIndex>, RandomState, Global>

Mesh implementation of the attribute dictionary mutable getter.

[src]

pub fn topo_attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute<VertexIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

Mesh implementation of the attribute dictionary and cache mutable getter.

[src]

impl<T> VertexPositions for LineMesh<T> where
T: Real,

type Element = [T; 3]

[src]

pub fn vertex_positions(&self) -> &[<LineMesh<T> as VertexPositions>::Element ]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

Vertex positions as a slice of triplets.

[src]

pub fn vertex_positions_mut(
&mut self
) -> &mut [<LineMesh<T> as VertexPositions>::Element ]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

Vertex positions as a mutable slice of triplets.

[src]

fn vertex_position_iter(&self) -> Iter<'_, Self::Element>

Vertex iterator.

[src]

fn vertex_position_iter_mut(&mut self) -> IterMut<'_, Self::Element>

Mutable vertex iterator.

[src]

fn vertex_position<VI>(&self, vidx: VI) -> Self::Element where
VI: Into<VertexIndex>,
Self::Element: Clone,

Vertex accessor.

[src]

impl<T> StructuralPartialEq for LineMesh<T> where
T: Real,

Auto Trait Implementations

impl<T> RefUnwindSafe for LineMesh<T> where
T: RefUnwindSafe,

impl<T> Send for LineMesh<T>

impl<T> Sync for LineMesh<T>

impl<T> Unpin for LineMesh<T> where
T: Unpin,

impl<T> UnwindSafe for LineMesh<T> where
T: UnwindSafe,

Blanket Implementations

[src]

impl<T> Any for T where
T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

impl<T> Borrow<T> for T where
T: ?Sized,

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

impl<T> BorrowMut<T> for T where
T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

impl<M, T> BoundingBox<T> for M where
T: Real,
M: VertexPositions<Element = [T; 3]>,

[src]

pub fn bounding_box(&self) -> BBox<T>

Compute the bounding box of this object.

[src]

impl<T> Bytes for T

[src]

fn as_bytes(&self) -> &[u8 ]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

Get a slice of bytes representing Self.

[src]

fn interpret_bytes(bytes: &[u8 ]) -> &Self

Panics if the size of the given bytes slice is not equal to the size of Self.

impl<T> CloneBytes for T where
T: 'static + Clone,

pub unsafe fn clone_bytes(
src: &[MaybeUninit<u8>]
) -> Box<[MaybeUninit<u8>], Global>

pub unsafe fn clone_from_bytes(
dst: &mut [MaybeUninit<u8>],
src: &[MaybeUninit<u8>]
)

pub unsafe fn clone_into_raw_bytes(
src: &[MaybeUninit<u8>],
dst: &mut [MaybeUninit<u8>]
)

[src]

impl<M> Connectivity<FaceVertexIndex, VertexIndex> for M where
M: FaceVertex + NumFaces + NumVertices,

type Topo = (Vec<usize, Global>, Vec<usize, Global>)

Additional topology that may aid in computing connectivity. Read more

[src]

pub fn precompute_topo(
&self
) -> <M as Connectivity<FaceVertexIndex, VertexIndex>>::Topo

Precompute additional topology information prior to determining connectivity. Read more

[src]

pub fn num_elements(&self) -> usize

Get the number of elements which are considered for connectivity Read more

[src]

pub fn push_neighbours<T>(
 &self,
 index: FaceVertexIndex,
 stack: &mut Vec<FaceVertexIndex, Global>,
 topo: &<M as Connectivity<FaceVertexIndex, VertexIndex>>::Topo,
 attrib: Option<&[T]>
) where
 T: Default + PartialEq<T>,

Push all neighbours of the element at the given index to the given stack. Read more

[src]

fn connectivity(&self) -> (Vec<usize, Global>, usize )

Determine the connectivity of a set of meshes. Read more

[src]

fn connectivity_via_attrib<T>(
 &self,
 attrib: Option<&str>
) -> (Vec<usize, Global>, usize ) where
 Self: Attrib,
 Src: AttribIndex<Self>,
 T: 'static + Default + PartialEq<T>,

Determine the connectivity of a set of meshes. Read more

[src]

fn connectivity_via_attrib_fn<'a, T, F>(
 &self,
 f: F
) -> (Vec<usize, Global>, usize ) where
 T: 'a + Default + PartialEq<T>,
 F: FnOnce() -> Option<&'a [T]>,

Determine the connectivity of a set of meshes. Read more

[src]

impl<M> Connectivity<VertexIndex, FaceIndex> for M where
M: FaceVertex + NumVertices + NumFaces,

type Topo = (Vec<usize, Global>, Vec<usize, Global>)

Additional topology that may aid in computing connectivity. Read more

[src]

pub fn precompute_topo(
&self
) -> <M as Connectivity<VertexIndex, FaceIndex>>::Topo

Precompute additional topology information prior to determining connectivity. Read more

[src]

pub fn num_elements(&self) -> usize

Get the number of elements which are considered for connectivity Read more

[src]

pub fn push_neighbours<T>(
 &self,
 index: VertexIndex,
 stack: &mut Vec<VertexIndex, Global>,
 topo: &<M as Connectivity<VertexIndex, FaceIndex>>::Topo,
 Option<&[T]>
) where
 T: Default + PartialEq<T>,

Push all neighbours of the element at the given index to the given stack. Read more

[src]

fn connectivity(&self) -> (Vec<usize, Global>, usize )

Determine the connectivity of a set of meshes. Read more

[src]

fn connectivity_via_attrib<T>(
 &self,
 attrib: Option<&str>
) -> (Vec<usize, Global>, usize ) where
 Self: Attrib,
 Src: AttribIndex<Self>,
 T: 'static + Default + PartialEq<T>,

Determine the connectivity of a set of meshes. Read more

[src]

fn connectivity_via_attrib_fn<'a, T, F>(
 &self,
 f: F
) -> (Vec<usize, Global>, usize ) where
 T: 'a + Default + PartialEq<T>,
 F: FnOnce() -> Option<&'a [T]>,

Determine the connectivity of a set of meshes. Read more

impl<T> DebugBytes for T where
T: 'static + Debug,

pub unsafe fn fmt_bytes(
bytes: &[MaybeUninit<u8>],
f: &mut Formatter<'_>
) -> Result<(), Error>

impl<T> Downcast for T where
T: Any,

pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more

pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more

pub fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s. Read more

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s. Read more

impl<T> DowncastSync for T where
T: Any + Send + Sync,

pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync + 'static>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait. Read more

impl<T> DropBytes for T where
T: 'static,

pub unsafe fn drop_bytes(bytes: &mut [MaybeUninit<u8>])

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

impl<'a, S, I> Get<'a, I> for S where
I: GetIndex<'a, S>,

type Output = >::Output

pub fn get(&self, idx: I) -> Option<>::Output>

fn at(&self, idx: I) -> Self::Output

Return a value at the given index. This is provided as the checked version of get that will panic if the equivalent get call is None, which typically means that the given index is out of bounds. Read more

unsafe fn at_unchecked(&self, idx: I) -> Self::Output

Return a value at the given index. This is provided as the unchecked version of get that has undefined behavior when the index is out of bounds. Read more

[src]

impl<T, U> Into for T where
U: From<T>,

[src]

pub fn into(self) -> U

Performs the conversion.

impl<S, I> Isolate for S where
I: IsolateIndex<S>,

type Output = >::Output

pub unsafe fn isolate_unchecked(self, idx: I) -> <S as Isolate>::Output

pub fn try_isolate(self, idx: I) -> Option<<S as Isolate>::Output>

fn isolate(self, idx: I) -> Self::Output

Return a value at the given index. This is provided as the checked version of try_isolate that will panic if the equivalent try_isolate call is None, which typically means that the given index is out of bounds. Read more

impl<T> PartialEqBytes for T where
T: 'static + PartialEq<T>,

pub unsafe fn eq_bytes(a: &[MaybeUninit<u8>], b: &[MaybeUninit<u8>]) -> bool

[src]

impl<M> Partition for M where
M: Attrib,

[src]

pub fn partition_by_attrib<T, Src>(
 &self,
 attrib: &str
) -> (Vec<usize, Global>, usize ) where
 T: AttributeValueHash,
 Src: AttribIndex<M>,

Returns a partitioning by unique values of the given attribute. Read more

[src]

pub fn partition_by_attrib_by_sort<T, Src>(
 &self,
 attrib: &str
) -> (Vec<usize, Global>, usize ) where
 T: PartialOrd<T> + AttributeValue,
 Src: AttribIndex<M>,

Returns a partitioning by unique values of the given attribute. Read more

impl<T> Pointable for T

pub const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

pub unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

pub unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

pub unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T, N> PushArrayToVec<N> for T where
T: Clone,
N: Array<T>,

pub fn push_to_vec(element: <N as Array<T>>::Array, set: &mut Vec<T, Global>)

This method tells this type how it can be pushed to a Vec as an array.

[src]

impl<T, M> Rotate<T> for M where
T: RealField + Float,
M: VertexPositions<Element = [T; 3]>,

[src]

pub fn rotate_by_matrix(&mut self, mtx: [[T; 3]; 3])

Rotate the mesh using the given column-major rotation matrix.

[src]

fn rotate(&mut self, axis: [T; 3], theta: T)

Rotate the object around the given unit vector u by the given angle theta (in radians). Read more

[src]

fn rotate_by_vector(&mut self, e: [T; 3]) where
T: Zero,

Rotate the object using the given Euler vector (or rotation vector) e. The direction of e specifies the axis of rotation and its magnitude is the angle in radians. Read more

[src]

impl<S, T> Rotated<T> for S where
T: RealField,
S: Rotate<T>,

[src]

pub fn rotated(self, u: [T; 3], theta: T) -> S

Return a version of self rotated about the unit vector u by the given angle theta (in radians). Read more

[src]

pub fn rotated_by_matrix(self, mtx: [[T; 3]; 3]) -> S

Return a version of self rotated using the given column-major rotation matrix

[src]

pub fn rotated_by_vector(self, e: [T; 3]) -> S

Return a version of self rotated about the Euler vector e.

[src]

impl<T> Same<T> for T

type Output = T

Should always be Self

[src]

impl<T, M> Scale<T> for M where
T: RealField,
M: VertexPositions<Element = [T; 3]>,

[src]

pub fn scale(&mut self, [T; 3])

Scale a mesh in 3D by a given vector of scale factors. s = [1.0; 3] corresponds to a noop.

[src]

fn uniform_scale(&mut self, s: T)

Uniformly scale the given object by the given factor in all dimensions.

[src]

impl<S, T> Scaled<T> for S where
T: Copy,
S: Scale<T>,

[src]

pub fn scaled(self, s: [T; 3]) -> S

Return a scaled version of self.

[src]

pub fn uniformly_scaled(self, s: T) -> S

Return a uniformly scaled version of self.

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

pub fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

pub fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).

pub fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

pub fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.

[src]

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

[src]

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

[src]

pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

[src]

impl<T, M> Translate<T> for M where
T: RealField,
M: VertexPositions<Element = [T; 3]>,

[src]

pub fn translate(&mut self, [T; 3])

Translate the mesh by the given translation vector (displacement) t.

[src]

impl<S, T> Translated<T> for S where
S: Translate<T>,

[src]

pub fn translated(self, t: [T; 3]) -> S

Return a version of self translated by the given translation vector t.

[src]

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

[src]

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

[src]

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

[src]

impl<T> AttributeValue for T where
T: 'static + Clone + PartialEq<T> + Debug + Send + Sync,

impl<T> Elem for T where
T: Any + DropBytes,

[src]

impl<T> Scalar for T where
T: 'static + Clone + PartialEq<T> + Debug,

[src]

Struct gut::mesh::LineMesh[−][src]

Fields

Implementations

impl<T> LineMesh<T> where T: Real,

pub fn new( verts: Vec<[T; 3], Global>, indices: Vec<[usize; 2], Global>) -> LineMesh<T>

pub fn face_iter(&self) -> Iter<'_, [usize; 2]>

pub fn face_iter_mut(&mut self) -> IterMut<'_, [usize; 2]>

pub fn face<FI>(&self, fidx: FI) -> &[usize; 2] where FI: Into<FaceIndex>,

pub fn faces(&self) -> &[[usize; 2]]ⓘNotable traits for &'_ [u8]impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]

pub fn reverse(&mut self)

pub fn reversed(self) -> LineMesh<T>

pub fn sort_vertices_by_key<K, F>(&mut self, f: F) where F: FnMut(usize) -> K, K: Ord,

Trait Implementations

impl<T> Attrib for LineMesh<T> where T: Real,

pub fn attrib_size<I>(&self) -> usize where I: AttribIndex<LineMesh<T>>,

pub fn attrib_dict<I>( &self) -> &HashMap<String, Attribute<I>, RandomState, Global> where I: AttribIndex<LineMesh<T>>,

pub fn attrib_dict_mut<I>( &mut self) -> &mut HashMap<String, Attribute<I>, RandomState, Global> where I: AttribIndex<LineMesh<T>>,

pub fn attrib_dict_and_cache_mut<I>( &mut self) -> (&mut HashMap<String, Attribute<I>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>) where I: AttribIndex<LineMesh<T>>,

fn add_attrib<T, I>( &mut self, name: &'a str, def: T) -> Result<&mut Attribute<I>, Error> where I: AttribIndex<Self>, T: AttributeValue,

fn add_attrib_data<T, I>( &mut self, name: &'a str, data: Vec<T, Global>) -> Result<&mut Attribute<I>, Error> where I: AttribIndex<Self>, T: AttributeValue + Default,

fn set_attrib<T, I>( &mut self, name: &'a str, def: T) -> Result<&mut Attribute<I>, Error> where I: AttribIndex<Self>, T: AttributeValue,

fn set_attrib_data<T, I>( &mut self, name: &'a str, data: &[T]) -> Result<&mut Attribute<I>, Error> where I: AttribIndex<Self>, T: AttributeValue + Default,

fn add_indirect_attrib<T, I>( &mut self, name: &'a str, def: T) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where I: AttribIndex<Self>, T: AttributeValueHash,

fn set_indirect_attrib<T, I>( &mut self, name: &'a str, def: T) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where I: AttribIndex<Self>, T: AttributeValueHash,

fn add_indirect_attrib_data<I>( &mut self, name: &'a str, data: IndirectData) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where I: AttribIndex<Self>,

fn set_indirect_attrib_data<I>( &mut self, name: &'a str, data: IndirectData) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where I: AttribIndex<Self>,

fn duplicate_attrib<T, I>( &mut self, name: &'a str, new_name: &'b str) -> Result<&mut Attribute<I>, Error> where I: AttribIndex<Self>, T: Any + Clone,

fn remove_attrib<I>(&mut self, name: &str) -> Result<Attribute<I>, Error> where I: AttribIndex<Self>,

fn insert_attrib<I>( &mut self, name: &str, attrib: Attribute<I>) -> Result<Option<Attribute<I>>, Error> where I: AttribIndex<Self>,

fn attrib_or_add<T, I>( &mut self, name: &'a str, def: T) -> Result<&mut Attribute<I>, Error> where I: AttribIndex<Self>, T: AttributeValue,

fn attrib_or_add_data<T, I>( &mut self, name: &'a str, data: &[T]) -> Result<&mut Attribute<I>, Error> where I: AttribIndex<Self>, T: AttributeValue + Default,

fn attrib_or_add_indirect<T, I>( &mut self, name: &'a str, def: T) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where I: AttribIndex<Self>, T: AttributeValueHash,

fn direct_attrib_iter<'b, T, I>( &'b self, name: &'a str) -> Result<Iter<'b, T>, Error> where I: 'b + AttribIndex<Self>, T: Any + Clone,

fn attrib_iter_mut<'b, T, I>( &'b mut self, name: &'a str) -> Result<IterMut<'b, T>, Error> where I: 'b + AttribIndex<Self>, T: Any + Clone,

fn attrib_iter<'b, T, I>( &'b self, name: &str) -> Result<Box<dyn Iterator<Item = &'b T> + 'b, Global>, Error> where I: 'b + AttribIndex<Self>, T: Any + Clone,

fn attrib_exists<I>(&self, name: &str) -> bool where I: AttribIndex<Self>,

fn attrib_check<T, I>(&self, name: &'a str) -> Result<&Attribute<I>, Error> where T: Any, I: AttribIndex<Self>,

fn attrib_as_slice<'b, T, I>(&'b self, name: &'a str) -> Result<&'b [T], Error> where T: 'static, I: 'b + AttribIndex<Self>,

fn attrib_as_mut_slice<'b, T, I>( &'b mut self, name: &'a str) -> Result<&'b mut [T], Error> where T: 'static, I: 'b + AttribIndex<Self>,

fn attrib_clone_into_vec<'b, T, I>( &'b self, name: &'a str) -> Result<Vec<T, Global>, Error> where I: 'b + AttribIndex<Self>, T: AttributeValueHash,

fn direct_attrib_clone_into_vec<'b, T, I>( &'b self, name: &'a str) -> Result<Vec<T, Global>, Error> where I: 'b + AttribIndex<Self>, T: AttributeValue,

fn attrib<I>(&self, name: &'a str) -> Result<&Attribute<I>, Error> where I: AttribIndex<Self>,

fn attrib_mut<I>(&mut self, name: &'a str) -> Result<&mut Attribute<I>, Error> where I: AttribIndex<Self>,

impl<T> Clone for LineMesh<T> where T: Clone + Real,

pub fn clone(&self) -> LineMesh<T>

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

impl<T> Debug for LineMesh<T> where T: Debug + Real,

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

impl<T> Default for LineMesh<T> where T: Real,

pub fn default() -> LineMesh<T>

impl<T> FaceAttrib for LineMesh<T> where T: Real,

pub fn topo_attrib_size(&self) -> usize

pub fn topo_attrib_dict( &self) -> &HashMap<String, Attribute<FaceIndex>, RandomState, Global>

pub fn topo_attrib_dict_mut( &mut self) -> &mut HashMap<String, Attribute<FaceIndex>, RandomState, Global>

pub fn topo_attrib_dict_and_cache_mut( &mut self) -> (&mut HashMap<String, Attribute<FaceIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

impl<T> FaceEdge for LineMesh<T> where T: Real,

pub fn edge<FEI>(&self, fe_idx: FEI) -> EdgeIndex where FEI: Copy + Into<FaceEdgeIndex>,

pub fn face_edge<FI>(&self, fidx: FI, which: usize) -> Option<FaceEdgeIndex> where FI: Copy + Into<FaceIndex>,

pub fn num_face_edges(&self) -> usize

pub fn num_edges_at_face<FI>(&self, FI) -> usize where FI: Copy + Into<FaceIndex>,

fn face_to_edge<I>(&self, i: I, k: usize) -> Option<EdgeIndex> where I: Copy + Into<FaceIndex>,

impl<T> FaceEdgeAttrib for LineMesh<T> where T: Real,

pub fn topo_attrib_size(&self) -> usize

pub fn topo_attrib_dict( &self) -> &HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>

pub fn topo_attrib_dict_mut( &mut self) -> &mut HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>

pub fn topo_attrib_dict_and_cache_mut( &mut self) -> (&mut HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

impl<T> FaceVertex for LineMesh<T> where T: Real,

pub fn vertex<FVI>(&self, fv_idx: FVI) -> VertexIndex where FVI: Copy + Into<FaceVertexIndex>,

pub fn face_vertex<FI>(&self, fidx: FI, which: usize) -> Option<FaceVertexIndex> where FI: Copy + Into<FaceIndex>,

pub fn num_face_vertices(&self) -> usize

pub fn num_vertices_at_face<FI>(&self, FI) -> usize where FI: Copy + Into<FaceIndex>,

fn face_to_vertex<I>(&self, i: I, k: usize) -> Option<VertexIndex> where I: Copy + Into<FaceIndex>,

fn reverse_topo(&self) -> (Vec<usize, Global>, Vec<usize, Global>) where Self: NumFaces + NumVertices,

fn reverse_source_topo(&self) -> (Vec<usize, Global>, Vec<usize, Global>) where Self: NumVertices,

impl<T> FaceVertexAttrib for LineMesh<T> where T: Real,

pub fn topo_attrib_size(&self) -> usize

pub fn topo_attrib_dict( &self) -> &HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>

pub fn topo_attrib_dict_mut( &mut self) -> &mut HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>

pub fn topo_attrib_dict_and_cache_mut( &mut self) -> (&mut HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

impl<T> From<PolyMesh<T>> for LineMesh<T> where T: Real,

impl<T> LineMesh<T> where
T: Real,

pub fn new(
verts: Vec<[T; 3], Global>,
indices: Vec<[usize ; 2], Global>
) -> LineMesh<T>

pub fn face_iter(&self) -> Iter<'_, [usize ; 2]>

pub fn face_iter_mut(&mut self) -> IterMut<'_, [usize ; 2]>

pub fn face<FI>(&self, fidx: FI) -> &[usize ; 2] where
FI: Into<FaceIndex>,

pub fn faces(&self) -> &[[usize ; 2]]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

pub fn sort_vertices_by_key<K, F>(&mut self, f: F) where
F: FnMut(usize) -> K,
K: Ord,

impl<T> Attrib for LineMesh<T> where
T: Real,

pub fn attrib_size<I>(&self) -> usize where
I: AttribIndex<LineMesh<T>>,

pub fn attrib_dict<I>(
&self
) -> &HashMap<String, Attribute<I>, RandomState, Global> where
I: AttribIndex<LineMesh<T>>,

pub fn attrib_dict_mut<I>(
&mut self
) -> &mut HashMap<String, Attribute<I>, RandomState, Global> where
I: AttribIndex<LineMesh<T>>,

pub fn attrib_dict_and_cache_mut<I>(
&mut self
) -> (&mut HashMap<String, Attribute<I>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>) where
I: AttribIndex<LineMesh<T>>,

fn add_attrib<T, I>(
&mut self,
name: &'a str,
def: T
) -> Result<&mut Attribute<I>, Error> where
I: AttribIndex<Self>,
T: AttributeValue,

fn add_attrib_data<T, I>(
&mut self,
name: &'a str,
data: Vec<T, Global>
) -> Result<&mut Attribute<I>, Error> where
I: AttribIndex<Self>,
T: AttributeValue + Default,

fn set_attrib<T, I>(
&mut self,
name: &'a str,
def: T
) -> Result<&mut Attribute<I>, Error> where
I: AttribIndex<Self>,
T: AttributeValue,

fn set_attrib_data<T, I>(
&mut self,
name: &'a str,
data: &[T]
) -> Result<&mut Attribute<I>, Error> where
I: AttribIndex<Self>,
T: AttributeValue + Default,

fn add_indirect_attrib<T, I>(
&mut self,
name: &'a str,
def: T
) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
I: AttribIndex<Self>,
T: AttributeValueHash,

fn set_indirect_attrib<T, I>(
&mut self,
name: &'a str,
def: T
) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
I: AttribIndex<Self>,
T: AttributeValueHash,

fn add_indirect_attrib_data<I>(
&mut self,
name: &'a str,
data: IndirectData
) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
I: AttribIndex<Self>,

fn set_indirect_attrib_data<I>(
&mut self,
name: &'a str,
data: IndirectData
) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
I: AttribIndex<Self>,

fn duplicate_attrib<T, I>(
&mut self,
name: &'a str,
new_name: &'b str
) -> Result<&mut Attribute<I>, Error> where
I: AttribIndex<Self>,
T: Any + Clone,

fn remove_attrib<I>(&mut self, name: &str) -> Result<Attribute<I>, Error> where
I: AttribIndex<Self>,

fn insert_attrib<I>(
&mut self,
name: &str,
attrib: Attribute<I>
) -> Result<Option<Attribute<I>>, Error> where
I: AttribIndex<Self>,

fn attrib_or_add<T, I>(
&mut self,
name: &'a str,
def: T
) -> Result<&mut Attribute<I>, Error> where
I: AttribIndex<Self>,
T: AttributeValue,

fn attrib_or_add_data<T, I>(
&mut self,
name: &'a str,
data: &[T]
) -> Result<&mut Attribute<I>, Error> where
I: AttribIndex<Self>,
T: AttributeValue + Default,

fn attrib_or_add_indirect<T, I>(
&mut self,
name: &'a str,
def: T
) -> Result<(&mut Attribute<I>, &mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>), Error> where
I: AttribIndex<Self>,
T: AttributeValueHash,

fn direct_attrib_iter<'b, T, I>(
&'b self,
name: &'a str
) -> Result<Iter<'b, T>, Error> where
I: 'b + AttribIndex<Self>,
T: Any + Clone,

fn attrib_iter_mut<'b, T, I>(
&'b mut self,
name: &'a str
) -> Result<IterMut<'b, T>, Error> where
I: 'b + AttribIndex<Self>,
T: Any + Clone,

fn attrib_iter<'b, T, I>(
&'b self,
name: &str
) -> Result<Box<dyn Iterator<Item = &'b T> + 'b, Global>, Error> where
I: 'b + AttribIndex<Self>,
T: Any + Clone,

fn attrib_exists<I>(&self, name: &str) -> bool where
I: AttribIndex<Self>,

fn attrib_check<T, I>(&self, name: &'a str) -> Result<&Attribute<I>, Error> where
T: Any,
I: AttribIndex<Self>,

fn attrib_as_slice<'b, T, I>(&'b self, name: &'a str) -> Result<&'b [T], Error> where
T: 'static,
I: 'b + AttribIndex<Self>,

fn attrib_as_mut_slice<'b, T, I>(
&'b mut self,
name: &'a str
) -> Result<&'b mut [T], Error> where
T: 'static,
I: 'b + AttribIndex<Self>,

fn attrib_clone_into_vec<'b, T, I>(
&'b self,
name: &'a str
) -> Result<Vec<T, Global>, Error> where
I: 'b + AttribIndex<Self>,
T: AttributeValueHash,

fn direct_attrib_clone_into_vec<'b, T, I>(
&'b self,
name: &'a str
) -> Result<Vec<T, Global>, Error> where
I: 'b + AttribIndex<Self>,
T: AttributeValue,

fn attrib<I>(&self, name: &'a str) -> Result<&Attribute<I>, Error> where
I: AttribIndex<Self>,

fn attrib_mut<I>(&mut self, name: &'a str) -> Result<&mut Attribute<I>, Error> where
I: AttribIndex<Self>,

impl<T> Clone for LineMesh<T> where
T: Clone + Real,

impl<T> Debug for LineMesh<T> where
T: Debug + Real,

impl<T> Default for LineMesh<T> where
T: Real,

impl<T> FaceAttrib for LineMesh<T> where
T: Real,

pub fn topo_attrib_dict(
&self
) -> &HashMap<String, Attribute<FaceIndex>, RandomState, Global>

pub fn topo_attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute<FaceIndex>, RandomState, Global>

pub fn topo_attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute<FaceIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

impl<T> FaceEdge for LineMesh<T> where
T: Real,

pub fn edge<FEI>(&self, fe_idx: FEI) -> EdgeIndex where
FEI: Copy + Into<FaceEdgeIndex>,

pub fn face_edge<FI>(&self, fidx: FI, which: usize) -> Option<FaceEdgeIndex> where
FI: Copy + Into<FaceIndex>,

pub fn num_edges_at_face<FI>(&self, FI) -> usize where
FI: Copy + Into<FaceIndex>,

fn face_to_edge<I>(&self, i: I, k: usize) -> Option<EdgeIndex> where
I: Copy + Into<FaceIndex>,

impl<T> FaceEdgeAttrib for LineMesh<T> where
T: Real,

pub fn topo_attrib_dict(
&self
) -> &HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>

pub fn topo_attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>

pub fn topo_attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute<FaceEdgeIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

impl<T> FaceVertex for LineMesh<T> where
T: Real,

pub fn vertex<FVI>(&self, fv_idx: FVI) -> VertexIndex where
FVI: Copy + Into<FaceVertexIndex>,

pub fn face_vertex<FI>(&self, fidx: FI, which: usize) -> Option<FaceVertexIndex> where
FI: Copy + Into<FaceIndex>,

pub fn num_vertices_at_face<FI>(&self, FI) -> usize where
FI: Copy + Into<FaceIndex>,

fn face_to_vertex<I>(&self, i: I, k: usize) -> Option<VertexIndex> where
I: Copy + Into<FaceIndex>,

fn reverse_topo(&self) -> (Vec<usize, Global>, Vec<usize, Global>) where
Self: NumFaces + NumVertices,

fn reverse_source_topo(&self) -> (Vec<usize, Global>, Vec<usize, Global>) where
Self: NumVertices,

impl<T> FaceVertexAttrib for LineMesh<T> where
T: Real,

pub fn topo_attrib_dict(
&self
) -> &HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>

pub fn topo_attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>

pub fn topo_attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute<FaceVertexIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

impl<T> From<PolyMesh<T>> for LineMesh<T> where
T: Real,

impl<T> NumFaces for LineMesh<T> where
T: Real,

impl<T> NumVertices for LineMesh<T> where
T: Real,

impl<T> PartialEq<LineMesh<T>> for LineMesh<T> where
T: PartialEq<T> + Real,

impl<T> VertexAttrib for LineMesh<T> where
T: Real,

pub fn topo_attrib_dict(
&self
) -> &HashMap<String, Attribute<VertexIndex>, RandomState, Global>

pub fn topo_attrib_dict_mut(
&mut self
) -> &mut HashMap<String, Attribute<VertexIndex>, RandomState, Global>

pub fn topo_attrib_dict_and_cache_mut(
&mut self
) -> (&mut HashMap<String, Attribute<VertexIndex>, RandomState, Global>, Option<&mut HashSet<Value<MaybeUninit<usize>, AttributeValueHashVTable>, RandomState, Global>>)

impl<T> VertexPositions for LineMesh<T> where
T: Real,

pub fn vertex_positions(&self) -> &[<LineMesh<T> as VertexPositions>::Element ]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

pub fn vertex_positions_mut(
&mut self
) -> &mut [<LineMesh<T> as VertexPositions>::Element ]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

fn vertex_position<VI>(&self, vidx: VI) -> Self::Element where
VI: Into<VertexIndex>,
Self::Element: Clone,

impl<T> StructuralPartialEq for LineMesh<T> where
T: Real,

impl<T> RefUnwindSafe for LineMesh<T> where
T: RefUnwindSafe,

impl<T> Unpin for LineMesh<T> where
T: Unpin,

impl<T> UnwindSafe for LineMesh<T> where
T: UnwindSafe,