Struct gut::mesh::uniform_poly_mesh::TriMesh

pub struct TriMesh<T: Real> {
    pub vertex_positions: IntrinsicAttribute<[T; 3], VertexIndex>,
    pub indices: IntrinsicAttribute<[usize; 3], FaceIndex>,
    pub vertex_attributes: AttribDict<VertexIndex>,
    pub face_attributes: AttribDict<FaceIndex>,
    pub face_vertex_attributes: AttribDict<FaceVertexIndex>,
    pub face_edge_attributes: AttribDict<FaceEdgeIndex>,
    pub attribute_value_cache: AttribValueCache,
}

Fields

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

Vertex positions.

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

Triples of indices into vertices representing triangles.

vertex_attributes: AttribDict<VertexIndex>

Vertex attributes.

face_attributes: AttribDict<FaceIndex>

Triangle attributes.

face_vertex_attributes: AttribDict<FaceVertexIndex>

Triangle vertex attributes.

face_edge_attributes: AttribDict<FaceEdgeIndex>

Triangle edge attributes.

attribute_value_cache: AttribValueCache

Indirect attribute value cache

Implementations

impl<T: Real> TriMesh<T>

pub fn vertex_connectivity(&self) -> (Vec<usize>, usize)

impl<T: Real> TriMesh<T>

pub fn merge_with_vertex_source<'a, I>(
    meshes: I,
    source_attrib: &str
) -> Result<Self, Error> where
    I: IntoIterator<Item = &'a Self>, 

Merge a iterator of meshes into a single distinct mesh.

This version of merge accepts an attribute name for the source index on vertices.

The mesh vertices will be merged in the order given by the source attribute. This is useful when merging previously split up meshes. The source attribute needs to have type usize.

If the source attribute does not exist in at least one of the given meshes, then None is returned and the merge is aborted.

This is a non-destructive merge --- both original meshes remain intact. This also means that this way of merging is somewhat more expensive than a merge without any source indices.

impl<T: Real> TriMesh<T>

pub fn split_vertices_by_face_vertex_attrib(&mut self, attrib_name: &str)

Split vertices by a given face-vertex attribute.

If a pair of face-vertices have different values for the same vertex, then they will be split into distinct vertices. New vertex positions are appended at the end of the vertex position array.

If the given attribute doesn't exist, then nothing is changed.

impl<T: Real> TriMesh<T>

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

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

Iterate over each face.

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

Iterate mutably over each face.

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

Face accessor. These are vertex indices.

pub fn faces(&self) -> &[[usize; 3]]

Return a slice of individual faces.

pub fn reverse(&mut self)

Reverse the order of each polygon in this mesh.

pub fn reversed(mut self: Self) -> Self

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

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.

impl<T: Real> TriMesh<T>

pub fn tri_iter<'a>(&'a self) -> impl Iterator<Item = Triangle<T>> + 'a

Triangle iterator.

use gut::mesh::TriMesh;
use gut::prim::Triangle;

let verts = vec![[0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 1.0, 0.0]];
let mesh = TriMesh::new(verts.clone(), vec![[0, 1, 2]]);
let tri = Triangle::from_indexed_slice(&[0, 1, 2], verts.as_slice());
assert_eq!(Some(tri), mesh.tri_iter().next());

pub fn tri_from_indices(&self, indices: &[usize; 3]) -> Triangle<T>

Get a tetrahedron primitive corresponding to the given vertex indices.

Trait Implementations

impl<T: Real> Attrib for TriMesh<T>

fn attrib_size<I: AttribIndex<Self>>(&self) -> usize

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

fn attrib_dict<I: AttribIndex<Self>>(&self) -> &AttribDict<I>

Read only access to the attribute dictionary.

fn attrib_dict_mut<I: AttribIndex<Self>>(&mut self) -> &mut AttribDict<I>

Read and write access to the attribute dictionary.

fn attrib_dict_and_cache_mut<I: AttribIndex<Self>>(
    &mut self
) -> (&mut AttribDict<I>, Option<&mut AttribValueCache>)

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

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

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

fn add_attrib_data<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    data: Vec<T>
) -> Result<&mut Attribute<I>, Error> where
    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.

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

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

fn set_attrib_data<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    data: &[T]
) -> Result<&mut Attribute<I>, Error> where
    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.

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

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

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

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

fn add_indirect_attrib_data<'a, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    data: IndirectData
) -> Result<(&mut Attribute<I>, &mut AttribValueCache), Error>

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

fn set_indirect_attrib_data<'a, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    data: IndirectData
) -> Result<(&mut Attribute<I>, &mut AttribValueCache), Error>

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

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

Makes a copy of an existing attribute.

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

Remove an attribute from the attribute dictionary.

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

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

fn attrib_or_add<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    def: T
) -> Result<&mut Attribute<I>, Error> where
    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.

fn attrib_or_add_data<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    data: &[T]
) -> Result<&mut Attribute<I>, Error> where
    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.

fn attrib_or_add_indirect<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    def: T
) -> Result<(&mut Attribute<I>, &mut AttribValueCache), Error> where
    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.

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

Get the attribute iterator for a direct attribute.

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

Get the attribute mutable iterator for a direct attribute.

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

Get the iterator for an attribute no matter what kind.

fn indirect_attrib_update_with<'a, 'b, T, I, F>(
    &'b mut self,
    name: &'a str,
    f: F
) -> Result<(&'b mut Attribute<I>, &'b mut AttribValueCache), Error> where
    T: AttributeValueHash,
    I: 'b + AttribIndex<Self>,
    F: FnMut(usize, &Irc<T>) -> Option<Irc<T>>, 

Update indirect attribute entries with the given closure.

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

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.

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

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

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

Expose the underlying direct attribute as a slice.

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

Expose the underlying direct attribute as a mutable slice.

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

Clone attribute data into a Vec<T>.

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

Clone direct attribute data into a Vec<T>.

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

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

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

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

impl<T: Real> AttribPromote<FaceVertexIndex, VertexIndex> for TriMesh<T>

fn attrib_promote<'a, U, F>(
    &mut self,
    name: &'a str,
    mut combine: F
) -> Result<&Attribute<VertexIndex>, Error> where
    U: Any + Clone,
    F: for<'b> FnMut(&'b mut U, &'b U), 

Promote the given attribute from source topology SI to target topology TI.

impl<T: Clone + Real> Clone for TriMesh<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Real> Debug for TriMesh<T>

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

Formats the value using the given formatter.

impl<T: Real> Default for TriMesh<T>

fn default() -> Self

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.

impl<T: Real> FaceAttrib for TriMesh<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<FaceIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<FaceIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut(
    &mut self
) -> (&mut AttribDict<FaceIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Real> FaceEdge for TriMesh<T>

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

Index of the destination element given the topology index.

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.

fn num_face_edges(&self) -> usize

Topology quantifier. Number of connectors in total.

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

Topology quantifier. Number of connectors at a particular element.

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

Index of the destination element from the source index.

impl<T: Real> FaceEdgeAttrib for TriMesh<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<FaceEdgeIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<FaceEdgeIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut(
    &mut self
) -> (&mut AttribDict<FaceEdgeIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Real> FaceVertex for TriMesh<T>

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

Index of the destination element given the topology index.

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.

fn num_face_vertices(&self) -> usize

Topology quantifier. Number of connectors in total.

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

Topology quantifier. Number of connectors at a particular element.

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

Index of the destination element from the source index.

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

Generate the reverse topology structure.

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

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

impl<T: Real> FaceVertexAttrib for TriMesh<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<FaceVertexIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<FaceVertexIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut(
    &mut self
) -> (&mut AttribDict<FaceVertexIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Real> From<PolyMesh<T>> for TriMesh<T>

Convert a triangle mesh to a polygon mesh.

fn from(mesh: PolyMesh<T>) -> TriMesh<T>

Performs the conversion.

impl<T: Real> From<TetMesh<T>> for TriMesh<T>

fn from(tetmesh: TetMesh<T>) -> TriMesh<T>

Performs the conversion.

impl<T: Real> From<TriMesh<T>> for PointCloud<T>

Convert a triangle mesh to a point cloud by erasing all triangle data.

fn from(mesh: TriMesh<T>) -> PointCloud<T>

Performs the conversion.

impl<T: Real> From<TriMesh<T>> for PolyMesh<T>

Convert a triangle mesh into a polygon mesh.

fn from(mesh: TriMesh<T>) -> PolyMesh<T>

Performs the conversion.

impl<T: Real> From<TriMesh<T>> for TriMeshExt<T>

fn from(base_mesh: TriMesh<T>) -> TriMeshExt<T>

Performs the conversion.

impl<T: Real> From<TriMeshExt<T>> for TriMesh<T>

fn from(ext: TriMeshExt<T>) -> TriMesh<T>

Performs the conversion.

impl<T: Real> Merge for TriMesh<T>

fn merge(&mut self, other: Self) -> &mut Self

Attributes with the same name but different types won't be merged.

fn merge_iter(iterable: impl IntoIterator<Item = Self>) -> Self where
    Self: Default, 

Merge an iterator of objects into one of the same type.

fn merge_vec(vec: Vec<Self>) -> Self where
    Self: Default, 

Merge a Vec of objects into one of the same type.

fn merge_slice(slice: &[Self]) -> Self where
    Self: Clone + Default, 

In contrast to merge_vec, this function takes an immutable reference to a collection of meshes, and creates a brand new mesh that is a union of all the given meshes.

impl<T: Real> NumFaces for TriMesh<T>

fn num_faces(&self) -> usize

impl<T: Real> NumVertices for TriMesh<T>

fn num_vertices(&self) -> usize

impl<T: PartialEq + Real> PartialEq<TriMesh<T>> for TriMesh<T>

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

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

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

This method tests for !=.

impl<T: Real> Split<VertexIndex> for TriMesh<T>

fn split(self, partition: &[usize], num_parts: usize) -> Vec<Self>

impl<T: Real> SplitIntoConnectedComponents<VertexIndex, FaceIndex> for TriMesh<T>

fn split_into_connected_components(self) -> Vec<Self>

impl<T: Real> StructuralPartialEq for TriMesh<T>

impl<T: Real> VertexAttrib for TriMesh<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<VertexIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<VertexIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut(
    &mut self
) -> (&mut AttribDict<VertexIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Real> VertexPositions for TriMesh<T>

type Element = [T; 3]

fn vertex_positions(&self) -> &[Self::Element]

Vertex positions as a slice of triplets.

fn vertex_positions_mut(&mut self) -> &mut [Self::Element]

Vertex positions as a mutable slice of triplets.

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

Vertex iterator.

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

Mutable vertex iterator.

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

Vertex accessor.