|
|
| TopoOffsetTetMesh (Parameters &_m_params, int _num_threads=0) |
| |
| 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 TetMesh from vertex, tet, and tag data
|
| |
|
void | label_input_complex () |
| | label input simplicial complex simplices, as defined in m_params.offset_selection
|
| |
|
bool | empty_input_complex () |
| | check if the input complex is empty. Only valid after calling init_from_image(...). Checks if any vertices (therefore any simplices) are labelled 1, if not returns true
|
| |
|
void | init_input_complex_bvh () |
| | initialize BVH for input complex. Must be called after init_from_image(...)
|
| |
|
void | edge_split_binary_search (const size_t v1, const size_t v2, Vector3d &p_new) const |
| | split edge at point by minimizing m_params.target_distance - d() (where d() is distance to input complex via BVH) along the edge. Uses binary search, so implicitly assumes distance field is monotonic along edge. May give weird results if not monotonic
|
| |
|
size_t | flood_fill () |
| | label connected simplicial complex components (simplices labelled 1 or 2)
|
| |
| 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 > &tets) override |
| |
|
void | marching_tets () |
| | execute simplistic marching tets. All edges with one vertex labelled 0 and the other 1/2 are split. If m_edge_split_mode=BinarySearch, edges are split according to BVH distance field and the offset target distance (m_params.target_distance). If m_edge_split_mode=Midpoint, edges are split at the midpoint
|
| |
|
bool | is_simplicially_embedded () const |
| | check if the input complex (simplices labelled 1) are simplicially embedded w.r.t. the entire mesh
|
| |
|
bool | tet_is_simp_emb (const Tuple &t) const |
| | check if a tet satisfies simpicial embedding criteria w.r.t. input complex (simplices labelled 1)
|
| |
|
void | simplicial_embedding () |
| | make mesh a simplicial embedding of the input complex (simplices labelled 1)
|
| |
|
bool | tag_tet_consistent_topology (size_t t_id, int64_t tag) const |
| | check if removing the tet would change the topology of any label
|
| |
|
bool | offset_tet_consistent_topology (const size_t t_id) const |
| | check if adding a tet to the offset region does not change the topology of the offset. Returns true if topology would not be changed
|
| |
|
bool | tet_is_in_offset_conservative (const size_t t_id, const double threshold_r) const |
| | check if a tet is inside the offset (implicitly defined via BVH distance field to input complex) via conservative sphere subdivision estimation
|
| |
|
void | grow_offset_conservative () |
| | grow offset region conservatively using conservative checks while ensuring consistent topology
|
| |
|
void | set_offset_tet_tags () |
| | update 'tags' data for tets in the offset region (tets labelled 2) based on the given offset tag values in m_params.offset_tag_value
|
| |
| bool | offset_is_manifold () |
| | verify that the closed offset region (simplices labelled 1 or 2) form a manifold region. This should be true for any offset. This function is for verification.
|
| |
|
void | write_input_complex (const std::string &path) |
| |
|
void | write_vtu (const std::string &path) |
| |
|
void | write_msh_groups (const std::string &file) |
| |
|
std::vector< Tuple > | get_face_adjacent_tets (const Tuple &t) const |
| | get tets (as Tuples) that are face-adjacent to the given tet (as Tuple)
|
| |
|
std::vector< size_t > | connected_components_helper (const size_t &v_id) |
| | get all one-ring vertices through input simplices (labelled 1)
|
| |
|
void | reset_connected_components () |
| | reset connected component assignments.
|
| |
| 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