Struct Mesh 

pub struct Mesh<const D: usize> { /* private fields */ }

Implementations

impl Mesh<3>

pub fn normals(&self) -> TensorRank1Vec2D<3, Reference, Dimensionless>

impl<const D: usize> Mesh<D>

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

pub fn bounding_boxes(&self) -> BoundingBoxes<D>

pub fn centroids(&self) -> Coordinates<D>

pub fn bounding_boxes_and_centroids( &self, ) -> impl Iterator<Item = (BoundingBox<D>, Coordinate<D>)>

pub fn blocks(&self) -> Option<&[usize]>

pub fn connectivities(&self) -> &[Connectivity]

pub fn node_sets(&self) -> &[Vec<usize>]

pub fn node_set_numbers(&self) -> Option<&[usize]>

pub fn set_node_sets(&mut self, node_sets: NodeSets)

pub fn side_sets(&self) -> &[Vec<(usize, usize)>]

pub fn side_set_numbers(&self) -> Option<&[usize]>

pub fn set_side_sets(&mut self, side_sets: SideSets)

pub fn iter(&self) -> impl Iterator<Item = &Connectivity>

pub fn coordinates(&self) -> &Coordinates<D>

pub fn node_element_connectivity(&self) -> &[Vec<usize>]

pub fn node_nodes(&self) -> &Graph

pub fn node_node_connectivity(&self) -> &[Vec<usize>]

pub fn number_of_element_blocks(&self) -> usize

pub fn number_of_face_blocks(&self) -> Option<usize>

pub fn number_of_elements(&self) -> usize

pub fn number_of_faces(&self) -> Option<usize>

pub fn number_of_nodes(&self) -> usize

impl Mesh<3>

pub fn buffer( self, target: &Tessellation, fitting: Fitting, ) -> Result<Self, &'static str>

pub fn buffer_tets( self, target: &Tessellation, fitting: Fitting, ) -> Result<Self, &'static str>

Adds a buffer layer of tetrahedra to a tetrahedral mesh and fits it to the target.

The counterpart of buffer, differing in that each boundary triangle raises a prism split into three tetrahedra rather than one hexahedron, so the result stays a single tetrahedral block.

It also runs no clearance pre-pass. restrict is defined on hexahedral boundary quadrilaterals and has no tetrahedral analogue yet, so a boundary leaving some node no feasible direction is fitted here rather than pruned first.

impl<const D: usize> Mesh<D>

pub fn laplacian( &self, weighting: Weighting, ) -> Result<Coordinates<D>, &'static str>

impl Mesh<2>

pub fn from_pixels<T>(pixels: Pixels<T>, remove: Option<&[T]>) -> Self

where T: Copy + PartialEq + Into<usize>,

impl Mesh<3>

pub fn from_segmentation<T>( segmentation: Segmentation<3, T>, remove: Option<&[T]>, ) -> Self

where T: Copy + PartialEq + Into<usize>,

impl Mesh<3>

pub fn from_voxels<T>(voxels: Voxels<T>, remove: Option<&[T]>) -> Self

where T: Copy + PartialEq + Into<usize>,

impl<const D: usize> Mesh<D>

pub fn smart_laplace_smooth(&mut self, iterations: usize, scale: Scalar)

impl<const D: usize> Mesh<D>

pub fn untangle( &mut self, iterations: usize, margin: Scalar, surface: Option<&Tessellation>, )

impl Mesh<D>

pub fn self_intersections(&self) -> Vec<[usize; 2]>

impl<const D: usize> Mesh<D>

pub fn boundary_edges(&self) -> Vec<[usize; 2]>

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

pub fn non_manifold_edges(&self) -> Vec<[usize; 2]>

pub fn non_manifold_seams(&self) -> Vec<Vec<[usize; 2]>>

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

impl Mesh<D>

pub fn remesh(self, remeshing: Remeshing) -> Result<Self, &'static str>

impl<const D: usize> Mesh<D>

pub fn laplace_smooth( &mut self, iterations: usize, scale: Scalar, weighting: Weighting, preserve_boundary: bool, preserve_interfaces: bool, ) -> Result<(), &'static str>

impl<const D: usize> Mesh<D>

pub fn taubin_smooth( &mut self, iterations: usize, pass_band: Scalar, scale: Scalar, weighting: Weighting, preserve_boundary: bool, preserve_interfaces: bool, ) -> Result<(), &'static str>

impl<const D: usize> Mesh<D>

pub fn smooth(&mut self, smoothing: Smoothing) -> Result<(), &'static str>

Trait Implementations

impl<const D: usize> From<&Mesh<D>> for BoundingVolumeHierarchy<D>

fn from(mesh: &Mesh<D>) -> Self

Converts to this type from the input type.

impl<const D: usize> From<&Mesh<D>> for Vec<Primitive<D>>

fn from(mesh: &Mesh<D>) -> Self

Converts to this type from the input type.

impl<const D: usize> From<(Set<Vec<Connectivity>>, Set<TensorVector<TensorRank1<D, Reference, Length>>>)> for Mesh<D>

fn from( (connectivities, coordinates): (Connectivities, Set<Coordinates<D>>), ) -> Self

Converts to this type from the input type.

impl<const D: usize> From<(Vec<Connectivity>, TensorVector<TensorRank1<D, Reference, Length>>)> for Mesh<D>

fn from( (connectivities, coordinates): (Vec<Connectivity>, Coordinates<D>), ) -> Self

Converts to this type from the input type.

impl<const D: usize> From<Mesh<D>> for (Connectivities, Coordinates<D>)

fn from(mesh: Mesh<D>) -> Self

Converts to this type from the input type.

impl From<Mesh<D>> for Tessellation

fn from(mesh: Mesh<D>) -> Self

Converts to this type from the input type.

impl<T, U, V> From<Orthotree<2, 2, 4, 4, T, U, V>> for Mesh<2>

where T: Cell, U: Slot,

fn from(quadtree: Quadtree<T, U, V>) -> Self

Converts to this type from the input type.

impl<T, U, V> From<Orthotree<3, 4, 6, 8, T, U, V>> for Mesh<3>

where T: Cell, U: Slot,

fn from(octree: Octree<T, U, V>) -> Self

Converts to this type from the input type.

impl From<Tessellation> for Mesh<D>

fn from(tessellation: Tessellation) -> Self

Converts to this type from the input type.

impl<const D: usize> IntoIterator for Mesh<D>

type Item = Connectivity

The type of the elements being iterated over.

type IntoIter = IntoIter<Connectivity>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const D: usize, P> TryFrom<Input<P>> for Mesh<D>

where P: AsRef<Path>,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(input: Input<P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const D: usize> Verdict for Mesh<D>

fn maximum_edge_ratios(&self) -> Vec<Vec<Scalar>>

fn minimum_jacobians(&self) -> Vec<Vec<Scalar>>

fn minimum_scaled_jacobians(&self) -> Vec<Vec<Scalar>>

fn maximum_skews(&self) -> Vec<Vec<Scalar>>

fn volumes(&self) -> Vec<Vec<Scalar>>

impl<const D: usize, P> Write<Output<P>> for Mesh<D>

where P: AsRef<Path>,

type Error = Error

fn write(&self, output: Output<P>) -> Result<(), Self::Error>