Struct gut::mesh::tetmesh::TetMesh

pub struct TetMesh<T: Real> {
    pub vertex_positions: IntrinsicAttribute<[T; 3], VertexIndex>,
    pub indices: IntrinsicAttribute<[usize; 4], CellIndex>,
    pub vertex_attributes: AttribDict<VertexIndex>,
    pub cell_attributes: AttribDict<CellIndex>,
    pub cell_vertex_attributes: AttribDict<CellVertexIndex>,
    pub cell_face_attributes: AttribDict<CellFaceIndex>,
}

A basic mesh composed of tetrahedra. This mesh is based on vertex positions and a list of vertex indices representing tetrahedra.

Fields

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

Vertex positions.

indices: IntrinsicAttribute<[usize; 4], CellIndex>

Quadruples of indices into vertices representing tetrahedra. The canonical non-inverted tetrahedron is indexed as follows:

      3
     /|\
    / | \
   /  |  \
 2/...|...\0
  \   |   /
   \  |  /
    \ | /
     \|/
      1

(the dotted line is behind the dashed).

vertex_attributes: AttribDict<VertexIndex>

Vertex Attributes.

cell_attributes: AttribDict<CellIndex>

Cell Attributes.

cell_vertex_attributes: AttribDict<CellVertexIndex>

Cell vertex Attributes.

cell_face_attributes: AttribDict<CellFaceIndex>

Cell face Attributes.

Methods

impl<T: Real> TetMesh<T>

pub fn surface_topo(&self) -> Vec<[usize; 3]>

Extract the surface topology (triangles) of the TetMesh. This function assumes that the given tetmesh is a manifold.

pub fn surface_triangle_data(&self) -> (Vec<[usize; 3]>, Vec<usize>, Vec<usize>)

Extract the surface triangle information of the TetMesh. This includes the triangle topology, which tet each triangle came from and which face on the originating tet it belongs to. The returned vectors have the same size. This function assumes that the given tetmesh is a manifold.

pub fn surface_vertices(&self) -> Vec<usize>

Extract indices of vertices that are on the surface of this TetMesh.

pub fn surface_trimesh(&self) -> TriMesh<T>

Convert into a mesh of triangles representing the surface of this TetMesh.

pub fn surface_trimesh_with_mapping(
    &self,
    original_vertex_index_name: Option<&str>,
    original_tet_index_name: Option<&str>,
    original_tet_vertex_index_name: Option<&str>,
    original_tet_face_index_name: Option<&str>
) -> TriMesh<T>

Convert into a mesh of triangles representing the surface of this TetMesh. Additionally this function adds attributes that map the new triangle mesh to the original tetmesh.

Note that if the given attribute name coincides with an existing vertex attribute, that attribute will be replaced with the original tetmesh vertex attribute.

impl<T: Real> TetMesh<T>

pub const TET_FACES: [[usize; 3]; 4]

This constant defines the triangle faces of each tet. The rule is that ith face of the tet is the one opposite to the ith vertex. The triangle starts with the smallest index.

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

pub fn cell_iter(&self) -> Iter<[usize; 4]>

pub fn cell_iter_mut(&mut self) -> IterMut<[usize; 4]>

pub fn cell<CI: Into<CellIndex>>(&self, cidx: CI) -> &[usize; 4]

Cell accessor. These are vertex indices.

pub fn cells(&self) -> &[[usize; 4]]

Return a slice of individual cells.

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

Tetrahedron iterator.

pub fn tet_from_indices(&self, indices: &[usize; 4]) -> Tetrahedron<T>

Get a tetrahedron primitive corresponding to the given vertex indices.

pub fn tet<CI: Into<CellIndex>>(&self, cidx: CI) -> Tetrahedron<T>

Get a tetrahedron primitive corresponding to the given cell index.

pub fn inverted(self) -> TetMesh<T>

Consumes the current mesh to produce a mesh with inverted tetrahedra.

pub fn invert(&mut self)

Non consuming verion of the inverted function which simply modifies the given mesh.

pub fn canonicalized(self) -> TetMesh<T>

Convert this mesh into canonical form. This function inverts any inverted tetrahedron such that all tetrahedra are in canonical (non-inverted) form. The canonical form is determined by the shape matrix determinant of each tetrahedron. Canonical tetrahedra have a positive shape matrix determinant (see the gut::ops::ShapeMatrix trait and the gut::prim::tetrahedron module).

pub fn canonicalize(&mut self)

Convert this mesh into canonical form. This function inverts any inverted tetrahedron such that all tetrahedra are in canonical (non-inverted) form. This is a non-consuming version of canonicalized.

Trait Implementations

impl<T: Real> SplitIntoConnectedComponents<VertexCellIndex> for TetMesh<T>

fn split_into_connected_components(self) -> Vec<Self>

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

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

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

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

Merge a Vec of objecs 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> NumVertices for TetMesh<T>

Define TetMesh topology

fn num_vertices(&self) -> usize

impl<T: Real> NumCells for TetMesh<T>

fn num_cells(&self) -> usize

impl<T: Real> Attrib for TetMesh<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 add_attrib<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    def: T
) -> Result<&mut Attribute<I>, Error> where
    T: Any + Clone, 

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: Any + Clone + 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: Any + Clone, 

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: Any + Clone + Default, 

Set an attribute to the given data slice. 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. Return a mutable reference to the new attribute if successful.

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

Remove an attribute from the attribute dictionary. From there you can use methods defined on the returned attribute, and if desired return it back to the dictionary with insert_attrib.

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. This means that if an attribute with the same name exists, it will be returned and the current table entry is updated with the new value. If it doesn't already exist, None is returned.

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

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: Any + Clone + 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_iter<'a, 'b, T, I: 'b + AttribIndex<Self>>(
    &'b self,
    name: &'a str
) -> Result<Iter<T>, Error> where
    T: 'static + Clone, 

Get the attribute iterator. This is essentially a safe version of attrib(loc, name).unwrap().iter::<T>().

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

Get the attribute mutable iterator. This is essentially a safe version of attrib_mut(name).unwrap().iter_mut::<T>().

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<(), 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 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 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: 'static + Clone, 

Clone 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> VertexPositions for TetMesh<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.

impl<T: Real> CellVertex for TetMesh<T>

fn cell_to_vertex<CI>(&self, cidx: CI, which: usize) -> Option<VertexIndex> where
    CI: Copy + Into<CellIndex>, 

Index of the destination element.

fn cell_vertex<CI>(&self, cidx: CI, which: usize) -> Option<CellVertexIndex> where
    CI: Copy + Into<CellIndex>, 

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

fn num_cell_vertices(&self) -> usize

Topology quantifier. Number of connectors in total.

fn num_vertices_at_cell<CI>(&self, _: CI) -> usize where
    CI: Copy + Into<CellIndex>, 

Topology quantifier. Number of connectors at a particular element.

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

Generate the reverse topology structure.

impl<T: Real> CellFace for TetMesh<T>

fn cell_to_face<CI>(&self, cidx: CI, which: usize) -> Option<FaceIndex> where
    CI: Copy + Into<CellIndex>, 

Index of the destination element.

fn cell_face<CI>(&self, cidx: CI, which: usize) -> Option<CellFaceIndex> where
    CI: Copy + Into<CellIndex>, 

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

fn num_cell_faces(&self) -> usize

Topology quantifier. Number of connectors in total.

fn num_faces_at_cell<CI>(&self, _: CI) -> usize where
    CI: Copy + Into<CellIndex>, 

Topology quantifier. Number of connectors at a particular element.

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

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary mutable getter.

impl<T: Real> CellAttrib for TetMesh<T>

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn impl_attrib_dict(&self) -> &AttribDict<CellIndex>

Mesh implementation of the attribute dictionary getter.

fn impl_attrib_dict_mut(&mut self) -> &mut AttribDict<CellIndex>

Mesh implementation of the attribute dictionary mutable getter.

impl<T: Real> CellVertexAttrib for TetMesh<T>

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn impl_attrib_dict(&self) -> &AttribDict<CellVertexIndex>

Mesh implementation of the attribute dictionary getter.

fn impl_attrib_dict_mut(&mut self) -> &mut AttribDict<CellVertexIndex>

Mesh implementation of the attribute dictionary mutable getter.

impl<T: Real> CellFaceAttrib for TetMesh<T>

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn impl_attrib_dict(&self) -> &AttribDict<CellFaceIndex>

Mesh implementation of the attribute dictionary getter.

fn impl_attrib_dict_mut(&mut self) -> &mut AttribDict<CellFaceIndex>

Mesh implementation of the attribute dictionary mutable getter.

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

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

fn from(mesh: TetMesh<T>) -> PointCloud<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<TetMesh<T>> for PolyMesh<T>

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

Performs the conversion.

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

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

Performs the conversion.

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

fn from(ext: TetMeshExt<T>) -> TetMesh<T>

Performs the conversion.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

fn default() -> Self

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

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

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

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

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

This method tests for !=.

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

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

Formats the value using the given formatter.

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