Struct PolyMesh

pub struct PolyMesh<T, D>
where
    T: Scalar,
    D: DimName,
    DefaultAllocator: Allocator<T, D>,
{ /* private fields */ }

A volumetric polytopal mesh.

It is assumed that each polytopal cell is convex.

Implementations

impl<T, D> PolyMesh<T, D>

where T: Scalar, D: DimName, DefaultAllocator: Allocator<T, D>,

pub fn new_empty() -> Self

Creates an empty poly mesh without any vertices, faces or cells.

pub fn from_poly_data( vertices: Vec<OPoint<T, D>>, faces: NestedVec<usize>, cells: NestedVec<usize>, ) -> Self

pub fn vertices(&self) -> &[OPoint<T, D>]

pub fn vertices_mut(&mut self) -> &mut [OPoint<T, D>]

pub fn num_faces(&self) -> usize

pub fn num_cells(&self) -> usize

pub fn face_vertices<'a>( &'a self, face_idx: usize, ) -> impl 'a + Iterator<Item = &'a OPoint<T, D>>

pub fn face_connectivity_iter<'a>( &'a self, ) -> impl 'a + Iterator<Item = &'a [usize]>

pub fn cell_connectivity_iter<'a>( &'a self, ) -> impl 'a + Iterator<Item = &'a [usize]>

pub fn get_face_connectivity(&self, index: usize) -> Option<&[usize]>

pub fn get_cell_connectivity(&self, index: usize) -> Option<&[usize]>

pub fn get_face(&self, index: usize) -> Option<PolyMeshFace<'_, T, D>>

pub fn compute_face_cell_connectivity(&self) -> NestedVec<usize>

Returns a nested array, in which each array i contains the indices of the cells associated with face i.

pub fn dedup_faces(&mut self)

Removes duplicate instances of topologically equivalent faces.

Two faces are topologically equivalent if the sets of vertices connected by each face are equivalent.

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

Returns the indices of the faces which are only referenced by at most one cells.

pub fn concatenate<'a>( meshes: impl IntoIterator<Item = &'a PolyMesh<T, D>>, ) -> Self

Merges multiple meshes into a single instance of PolyMesh.

The mesh vertices, faces and cells are simply relabeled and glued together so that they form a well-defined PolyMesh. No mesh processing is performed.

impl<T, D> PolyMesh<T, D>

where T: Real, D: DimName, DefaultAllocator: Allocator<T, D>,

pub fn split_edges_n_times(&mut self, n_times: usize)

Recursively splits each edge in the mesh the specified number of times

pub fn split_edges(&mut self)

Splits the edges of all faces in the mesh by inserting a vertex at the midpoint of each edge

impl<T> PolyMesh<T, Const<3>>

where T: Scalar,

pub fn triangulate(&self) -> Result<PolyMesh3d<T>, Box<dyn Error>>

Triangulate the polyhedral mesh.

Note that the algorithm currently only gives non-degenerate results when each cell is strictly convex, in the sense that no two faces of a cell are co-planar.

TODO: Can we relax the strict convexity restriction without introducing additional Steiner points into the triangulation? The restriction is explained in the paper by Max (2000) (see comments in implementation).

pub fn keep_cells(&self, cell_indices: &[usize]) -> Self

impl<T> PolyMesh<T, Const<3>>

where T: Real,

pub fn translate(&mut self, translation: &Vector3<T>)

pub fn translated(self, translation: &Vector3<T>) -> Self

pub fn compute_volume(&self) -> T

pub fn intersect_convex_polyhedron<'a>( &self, polyhedron: &impl ConvexPolyhedron<'a, T>, ) -> Self

pub fn intersect_half_space(&self, half_space: &HalfSpace<T>) -> Self

Trait Implementations

impl<T, D> Clone for PolyMesh<T, D>

where T: Scalar + Clone, D: DimName + Clone, DefaultAllocator: Allocator<T, D>,

fn clone(&self) -> PolyMesh<T, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, D> Debug for PolyMesh<T, D>

where T: Scalar + Debug, D: DimName + Debug, DefaultAllocator: Allocator<T, D>,

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

Formats the value using the given formatter.

impl<'de, T, D> Deserialize<'de> for PolyMesh<T, D>

where T: Scalar, D: DimName, DefaultAllocator: Allocator<T, D>, <DefaultAllocator as Allocator<T, D>>::Buffer: Deserialize<'de>, OPoint<T, D>: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, D> PartialEq for PolyMesh<T, D>

where T: Scalar + PartialEq, D: DimName + PartialEq, DefaultAllocator: Allocator<T, D>,

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

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, D> Serialize for PolyMesh<T, D>

where T: Scalar, D: DimName, DefaultAllocator: Allocator<T, D>, <DefaultAllocator as Allocator<T, D>>::Buffer: Serialize, OPoint<T, D>: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, D> Eq for PolyMesh<T, D>

where T: Scalar + Eq, D: DimName + Eq, DefaultAllocator: Allocator<T, D>,

impl<T, D> StructuralPartialEq for PolyMesh<T, D>

where T: Scalar, D: DimName, DefaultAllocator: Allocator<T, D>,