|
|
| ManExtractMesh (Parameters &_m_params, int _num_threads=0) |
| |
| bool | split_edge_before (const Tuple &t) override |
| | User specified preparations and desideratas for an edge split before changing the connectivity.
|
| |
| bool | split_edge_after (const Tuple &t) override |
| | This function computes the attributes for the added simplices. User specified modifications and desideratas for after an edge split.
|
| |
| bool | split_face_before (const Tuple &t) override |
| | User specified preparations and desideratas for a face split before changing the connectivity.
|
| |
| bool | split_face_after (const Tuple &t) override |
| | Compute the attributes for the added simplices.
|
| |
| bool | split_tet_before (const Tuple &t) override |
| | User specified preparations and desideratas for a tet split before changing the connectivity.
|
| |
| bool | split_tet_after (const Tuple &t) override |
| | Compute the attributes for the added simplices.
|
| |
| bool | invariants (const std::vector< Tuple > &t) override |
| |
|
void | init_from_image (const MatrixXd &V, const MatrixXi &T, const MatrixSi &T_tags, const MatrixXd &V_env, const MatrixXi &F_env, const std::vector< std::string > &tag_names) |
| | initialize mesh from vertices, faces, and tag matrices
|
| |
|
void | label_surface_simplices (bool need_to_clear) |
| | set on_surf boolean for all simplices
|
| |
|
std::pair< size_t, size_t > | label_non_manifold () |
| | label nonmanifold simplices (edges and verts). Corresponding attributes have label set to 1
|
| |
|
bool | edge_is_manifold (const Tuple &t) const |
| | check if an edge is manifold, ie if all 'inside' tets adjacent to the edge form single face-reachable connected component
|
| |
|
void | edge_dfs_helper (std::set< size_t > &visited_tids, const Tuple &t) const |
| | dfs helper for edge manifold check
|
| |
|
bool | vertex_is_manifold (const Tuple &t) const |
| | check if a vertex is manifold. A vertex is manifold if all 'inside' and all 'outside' tets adjacent to the vertex form single face-reachable connected components, respectively. For vertices on the boundary of the mesh, external space is considered an 'outside' polyhedra that is face connected to all tets on the mesh boundary.
|
| |
|
void | vertex_dfs_helper (std::set< size_t > &visited_tids, const Tuple &t, const bool include, const std::vector< simplex::Face > &b_out_faces) const |
| | dfs helper for vertex manifold check
|
| |
|
bool | is_boundary_vertex (size_t vid) const |
| | check if a vertex is on the boundary of the mesh
|
| |
|
std::vector< simplex::Face > | get_boundary_faces_for_out_tets (size_t vid) const |
| | collect faces on the boundary of the mesh that belong to an 'outside' tet.
|
| |
|
bool | is_simplicially_embedded () const |
| | check if input complex (simplices labeled 1) are simplicially embedded by the background mesh
|
| |
|
bool | tet_is_simp_emb (const Tuple &t) const |
| | check if a tet meets simplicial embedding criteria (i.e., contains zero/one vertex, one edge, one face, or entire tet in input complex)
|
| |
|
void | simplicial_embedding () |
| | make the background mesh a simplicial embedding via tet/face/edge splits. Since the input complex is just edges and vertices, tets will never be split.
|
| |
|
void | perform_offset () |
| | perform offset via "marching tets". All edges between input complex and background are split (ie, edges with one vertex labeled 0 and the other vertex labeled 1)
|
| |
|
void | set_offset_tags () |
| | update tet tags based off offset label and union/subtract mode. if union mode, all tets with label 2 are given in_tag, for subtraction mode replace_tag
|
| |
|
void | extract_surface_mesh (MatrixXd &V, MatrixXi &F) |
| | extract tri mesh separating 'inside' tets from 'outside' tets. Resulting mesh is guaranteed to be manifold.
|
| |
|
void | write_input_complex (const std::string &path) |
| | write input complex (non manifold components) to vtu file
|
| |
|
void | write_surface (const std::string &path) |
| | write surface (boundary of in_tag)
|
| |
|
void | write_vtu (const std::string &path) |
| | write tet mesh to vtu file
|
| |
|
void | write_msh_groups (const std::string &path) |
| | write tet mesh to msh file with physical groups format
|
| |
| size_t | vert_capacity () const |
| | get the current largest global vid
|
| |
| size_t | tet_capacity () const |
| | get the current largest global tid
|
| |
|
size_t | vertex_size () const |
| | get the number of unremoved verticies
|
| |
|
size_t | tet_size () const |
| | get the number of unremoved tets
|
| |
| void | init (size_t n_vertices, const std::vector< std::array< size_t, 4 > > &tets) |
| |
|
void | init_with_isolated_vertices (size_t n_vertices, const std::vector< std::array< size_t, 4 > > &tets) |
| |
| void | init (const MatrixXi &T) |
| | Generate the connectivity of the mesh from an IGL-style T matrix.
|
| |
| bool | split_edge (const Tuple &t, std::vector< Tuple > &new_tets) |
| |
| virtual bool | collapse_edge (const Tuple &t, std::vector< Tuple > &new_tets) |
| |
| bool | link_condition (const Tuple &t) |
| |
| bool | collapse_edge_conn (const Tuple &loc0, std::vector< Tuple > &new_edges, size_t &v1_id, Tuple &new_loc, std::map< size_t, wmtk::TetMesh::VertexConnectivity > &rollback_vert_conn, std::vector< size_t > &n1_t_ids_copy, std::vector< size_t > &new_tet_id, std::vector< TetrahedronConnectivity > &old_tets) |
| |
| bool | collapse_edge_check_topology (const std::vector< size_t > &new_tet_id) |
| | Check topology after collapse connectivity change. This is a sanity check and should not be necessary.
|
| |
| void | collapse_edge_rollback (size_t &v1_id, std::map< size_t, wmtk::TetMesh::VertexConnectivity > &rollback_vert_conn, std::vector< size_t > &n1_t_ids, std::vector< size_t > &new_tet_id, std::vector< TetrahedronConnectivity > &old_tets) |
| |
| bool | swap_edge_56 (const Tuple &t, std::vector< Tuple > &new_tets) |
| |
| bool | swap_edge_44 (const Tuple &t, std::vector< Tuple > &new_tets) |
| |
| bool | swap_edge (const Tuple &t, std::vector< Tuple > &new_tets) |
| | 3-2 edge swap
|
| |
| bool | swap_face (const Tuple &t, std::vector< Tuple > &new_tets) |
| | 2-3 face swap
|
| |
| bool | smooth_vertex (const Tuple &t) |
| |
| bool | split_tet (const Tuple &t, std::vector< Tuple > &new_tets) |
| | Split a tet in 4 tets.
|
| |
| bool | split_face (const Tuple &t, std::vector< Tuple > &new_tets) |
| | Split a face in 3 faces.
|
| |
| void | triangle_insertion (const std::vector< Tuple > &intersected_tets, const std::vector< Tuple > &intersected_edges, std::vector< size_t > &new_edge_vids, std::vector< size_t > &new_center_vids, std::vector< std::array< size_t, 4 > > ¢er_split_tets) |
| | Insert a triangle into a tetmesh, with known intersection information.
|
| |
| bool | insert_point (const Tuple &t, std::vector< Tuple > &new_tets) |
| | Insert a point into a tetmesh inside a tet. In general position, this split a tet into 4. In face position, split two tets. In edge position, In point position, do nothing.
|
| |
|
virtual bool | insert_point_before (const Tuple &t) |
| |
|
virtual bool | insert_point_after (std::vector< Tuple > &new_tets) |
| |
|
void | consolidate_mesh () |
| | cleans up the deleted vertices or tetrahedra, fixes the corresponding indices, and reset the version number. WARNING: it invalidates all tuples!
|
| |
| std::vector< Tuple > | get_edges () const |
| |
| std::vector< Tuple > | get_faces () const |
| |
| std::vector< Tuple > | get_vertices () const |
| |
| std::vector< Tuple > | get_tets () const |
| |
| virtual void | for_each_face (const std::function< void(const TetMesh::Tuple &)> &) |
| | looping through all the unique edges and perform the given function
|
| |
| Tuple | tuple_from_edge (size_t tid, int local_eid) const |
| | get a Tuple from global tetra index and local edge index (from 0-5).
|
| |
| Tuple | tuple_from_edge (const std::array< size_t, 2 > &vids) const |
| | get a Tuple from global vids of the 2 end of an edge
|
| |
| Tuple | tuple_from_face (size_t tid, int local_fid) const |
| | get a Tuple from global tetra index and local face index (from 0-3).
|
| |
| std::tuple< Tuple, size_t > | tuple_from_face (const std::array< size_t, 3 > &vids) const |
| | get a Tuple and the global face index from global vertex index of the face.
|
| |
|
std::tuple< Tuple, size_t > | tuple_from_face (const simplex::Face &f) const |
| |
| Tuple | tuple_from_vertex (size_t vid) const |
| | get a Tuple from global vertex index
|
| |
| Tuple | tuple_from_tet (size_t tid) const |
| | get a Tuple from global tetra index
|
| |
|
Tuple | tuple_from_vids (size_t vid0, size_t vid1, size_t vid2, size_t vid3) const |
| | Get a Tuple from global vertex IDs.
|
| |
|
simplex::Tet | simplex_from_tet (const Tuple &t) const |
| |
|
simplex::Tet | simplex_from_tet (const size_t tid) const |
| |
|
simplex::Edge | simplex_from_edge (const Tuple &t) const |
| |
|
Tuple | switch_vertex (const Tuple &t) const |
| | wrapper function from Tuple::switch_vertex
|
| |
|
Tuple | switch_edge (const Tuple &t) const |
| | wrapper function from Tuple::switch_edge
|
| |
|
Tuple | switch_face (const Tuple &t) const |
| | wrapper function from Tuple::switch_face
|
| |
|
std::optional< Tuple > | switch_tetrahedron (const Tuple &t) const |
| | wrapper function from Tuple::switch_tetrahedron
|
| |
| std::vector< Tuple > | get_one_ring_tets_for_vertex (const Tuple &t) const |
| | Get the one ring tets for a vertex.
|
| |
| std::vector< size_t > | get_one_ring_tids_for_vertex (const Tuple &t) const |
| | Get the one ring tids for vertex.
|
| |
|
std::vector< size_t > | get_one_ring_tids_for_vertex (const size_t vid) const |
| |
| std::vector< Tuple > | get_one_ring_vertices_for_vertex (const Tuple &t) const |
| | Get the one ring vertices for a vertex.
|
| |
| std::vector< size_t > | get_one_ring_vids_for_vertex (size_t vid, std::vector< size_t > &cache) |
| | Get the one ring vids for vertex.
|
| |
| std::vector< size_t > | get_one_ring_vids_for_vertex (size_t vid) const |
| | Get the one ring vids for vertex.
|
| |
|
std::vector< size_t > | get_one_ring_vids_for_vertex_adj (size_t vid) const |
| | Duplicate of the function TetMesh::get_one_ring_vids_for_vertex.
|
| |
|
std::vector< size_t > | get_one_ring_vids_for_vertex_adj (size_t vid, std::vector< size_t > &cache) |
| | Duplicate of the function TetMesh::get_one_ring_vids_for_vertex.
|
| |
| std::vector< Tuple > | get_incident_tets_for_edge (const Tuple &t) const |
| | Get the incident tets for edge.
|
| |
|
std::vector< Tuple > | get_incident_tets_for_edge (const size_t vid0, const size_t vid1) const |
| |
|
std::vector< size_t > | get_incident_tids_for_edge (const Tuple &t) const |
| |
|
std::vector< size_t > | get_incident_tids_for_edge (const size_t vid0, const size_t vid1) const |
| |
| std::vector< Tuple > | get_one_ring_tets_for_edge (const Tuple &t) const |
| | Get the one ring tets for edge.
|
| |
| std::vector< std::array< size_t, 3 > > | vertex_adjacent_boundary_faces (const Tuple &t) const |
| |
| std::array< Tuple, 4 > | oriented_tet_vertices (const Tuple &t) const |
| |
| std::array< size_t, 4 > | oriented_tet_vids (const Tuple &t) const |
| |
|
std::array< size_t, 4 > | oriented_tet_vids (const size_t tid) const |
| |
| std::array< Tuple, 3 > | get_face_vertices (const Tuple &t) const |
| | Get the 3 vertices of a face represented by Tuple.
|
| |
|
std::array< size_t, 3 > | get_face_vids (const Tuple &t) const |
| |
| std::array< Tuple, 6 > | tet_edges (const Tuple &t) const |
| | get the 6 edges of a tet represented by Tuples
|
| |
| void | check_tuple_validity (const Tuple &t) const |
| |
| bool | check_mesh_connectivity_validity () const |
| | checks the validity of the connectivity of the mesh. Including the validity of each Tuple
|
| |
| void | remove_tets_by_ids (const std::vector< size_t > &tids) |
| | remove the tetrahedrons in the mesh that have given tet ids
|
| |
|
void | start_protect_attributes () |
| |
|
void | release_protect_attributes () |
| |
|
void | rollback_protected_attributes () |
| |
|
int | release_vertex_mutex_in_stack () |
| |
| bool | try_set_vertex_mutex_two_ring (const Tuple &v, int threadid) |
| | try lock the two-ring neighboring traingles' incident vertices
|
| |
| bool | try_set_vertex_mutex_two_ring_vid (const Tuple &v, int threadid) |
| | try lock the two-ring neighboring traingles' incident vertices using vids
|
| |
| bool | try_set_vertex_mutex_two_ring_vid (size_t v, int threadid) |
| | a duplicate of ConcurrentTetMesh::try_set_vertex_mutex_two_ring_vid that gets vids using the vid of the input Tuple
|
| |
| bool | try_set_edge_mutex_two_ring (const Tuple &e, int threadid=0) |
| | try lock the two-ring neighboring triangles' incident vertices for the two ends of an edge
|
| |
| bool | try_set_face_mutex_two_ring (const Tuple &f, int threadid=0) |
| | try lock the two-ring neighboring triangles' incident vertices for the 3 vertices of a face
|
| |
| bool | try_set_face_mutex_two_ring (const Tuple &v1, const Tuple &v2, const Tuple &v3, int threadid=0) |
| | locking the two-ring neighboring triangles' incident vertices given the 3 vertex Tuples of the face
|
| |
| bool | try_set_face_mutex_two_ring (size_t v1, size_t v2, size_t v3, int threadid=0) |
| | a duplicate of ConcurrentTetMesh::try_set_face_mutex_two_ring usign the vids of the 3 vertices of a face
|
| |
| bool | try_set_vertex_mutex_one_ring (const Tuple &v, int threadid=0) |
| | try lock the one-ring neighboring traingles' incident vertices
|
| |
|
void | for_each_edge (const std::function< void(const TetMesh::Tuple &)> &) |
| | perform the given function for each edge
|
| |
|
void | for_each_vertex (const std::function< void(const TetMesh::Tuple &)> &) |
| | perform the given function for each vertex
|
| |
|
void | for_each_tetra (const std::function< void(const TetMesh::Tuple &)> &) |
| | perform the given function for each tet
|
| |
| virtual bool | vertex_is_on_surface (const size_t vid) const |
| | Is a vertex part of the substructure.
|
| |
| virtual bool | face_is_on_surface (const size_t fid) const |
| | Is a face part of the substructure.
|
| |
| simplex::SimplexCollection | get_surface_faces_for_vertex (const size_t vid) const |
| | Get all faces on the surface that are incident to vid.
|
| |
| simplex::SimplexCollection | get_surface_faces_for_edge (const std::array< size_t, 2 > &vids) const |
| | Get all faces on the surface that are incident to the edge.
|
| |
| size_t | get_num_surface_faces_for_edge (const std::array< size_t, 2 > &vids) const |
| | Get the number of surface faces incident to the edge.
|
| |
| size_t | compute_vertex_order (const size_t vid) const |
| | Compute the vertex order for a single vertex.
|
| |
| virtual size_t | get_order_of_vertex (const size_t vid) const |
| | Get the order of a vertex.
|
| |
| size_t | get_order_of_edge (const std::array< size_t, 2 > &vids) const |
| | Compute the order of an edge.
|
| |
| bool | substructure_link_condition (const Tuple &e_tuple) const |
| | Link condition that also considers substructures.
|
| |
Public Types inherited from wmtk::TetMesh