Struct gut::mesh::uniform_poly_mesh::TriMeshExt

pub struct TriMeshExt<T: Real> {
    pub base_mesh: TriMesh<T>,
    pub face_indices: Vec<usize>,
    pub face_offsets: Vec<usize>,
}

Fields

base_mesh: TriMesh<T>

Vertex positions.

face_indices: Vec<usize>

Lists of face indices for each vertex. Since each vertex can have a variable number of face neighbours, the face_offsets field keeps track of where each subarray of indices begins.

face_offsets: Vec<usize>

Offsets into the face_indices array, one for each vertex. The last offset is always equal to the size of face_indices for convenience.

Methods

impl<T: Real> TriMeshExt<T>

pub fn new(verts: Vec<[T; 3]>, indices: Vec<usize>) -> TriMeshExt<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(&self, fidx: FaceIndex) -> &[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(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> TriMeshExt<T>

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

Triangle iterator.

use gut::mesh::TriMeshExt;
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 = TriMeshExt::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> Merge for TriMeshExt<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 TriMeshExt<T>

fn num_vertices(&self) -> usize

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

fn num_faces(&self) -> usize

impl<T: Real> Attrib for TriMeshExt<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 TriMeshExt<T>

type Element = <TriMesh<T> as VertexPositions>::Element

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> FaceVertex for TriMeshExt<T>

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

Index of the destination element.

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, fidx: FI) -> usize where
    FI: Copy + Into<FaceIndex>, 

Topology quantifier. Number of connectors at a particular element.

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

Generate the reverse topology structure.

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

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

Index of the destination element.

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, fidx: FI) -> usize where
    FI: Copy + Into<FaceIndex>, 

Topology quantifier. Number of connectors at a particular element.

impl<T: Real> VertexFace for TriMeshExt<T>

fn vertex_to_face<VI>(&self, vidx: VI, which: usize) -> Option<FaceIndex> where
    VI: Copy + Into<VertexIndex>, 

Index of the destination element.

fn vertex_face<VI>(&self, vidx: VI, which: usize) -> Option<VertexFaceIndex> where
    VI: Copy + Into<VertexIndex>, 

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

fn num_vertex_faces(&self) -> usize

Topology quantifier. Number of connectors in total.

fn num_faces_at_vertex<VI>(&self, vidx: VI) -> usize where
    VI: Copy + Into<VertexIndex>, 

Topology quantifier. Number of connectors at a particular element.

impl<T: Real> VertexAttrib for TriMeshExt<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> FaceAttrib for TriMeshExt<T>

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary mutable getter.

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

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary mutable getter.

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

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary mutable getter.

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

Convert a triangle mesh to a polygon mesh.

fn from(mesh: PolyMesh<T>) -> TriMeshExt<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: Clone + Real> Clone for TriMeshExt<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Real> Default for TriMeshExt<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: PartialEq + Real> PartialEq<TriMeshExt<T>> for TriMeshExt<T>

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

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

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

This method tests for !=.

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

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

Formats the value using the given formatter.

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