|
|
| QSlimMesh (std::vector< Eigen::Vector3d > _m_vertex_positions, int num_threads=1) |
| |
|
void | set_freeze (TriMesh::Tuple &v) |
| |
|
void | create_mesh (size_t n_vertices, const std::vector< std::array< size_t, 3 > > &tris, const std::vector< size_t > &frozen_verts=std::vector< size_t >(), double eps=0) |
| |
|
void | initiate_quadrics_for_face () |
| |
|
void | initiate_quadrics_for_vertices () |
| |
|
void | partition_mesh () |
| |
|
void | partition_mesh_morton () |
| |
|
size_t | get_partition_id (const Tuple &loc) const |
| |
| bool | collapse_edge_before (const Tuple &t) override |
| | User specified preparations and desideratas for an edge collapse including the link check as collapse prerequisite.
|
| |
| bool | collapse_edge_after (const Tuple &t) override |
| | User specified modifications and desideratas after an edge collapse.
|
| |
|
bool | collapse_qslim (int target_vertex_count) |
| |
|
bool | write_triangle_mesh (std::string path) |
| |
| bool | invariants (const std::vector< Tuple > &new_tris) override |
| | User specified invariants that can't be violated.
|
| |
|
double | compute_cost_for_e (const TriMesh::Tuple &v_tuple) |
| |
|
Quadrics | compute_quadric_for_face (const TriMesh::Tuple &f_tuple) |
| |
|
void | update_quadrics (const TriMesh::Tuple &v_tuple) |
| |
| void | init (size_t n_vertices, const std::vector< std::array< size_t, 3 > > &tris) |
| |
| void | init (const MatrixXi &F) |
| | Generate the connectivity of the mesh from an IGL-style F matrix.
|
| |
| std::vector< Tuple > | get_vertices () const |
| |
| std::vector< Tuple > | get_edges () const |
| |
| std::vector< Tuple > | get_faces () const |
| |
| Tuple | tuple_from_edge (size_t vid1, size_t vid2, size_t fid) const |
| |
|
Tuple | tuple_from_vids (size_t vid0, size_t vid1, size_t vid2) const |
| |
|
simplex::Vertex | simplex_from_vertex (const Tuple &t) const |
| |
|
simplex::Edge | simplex_from_edge (const Tuple &t) const |
| |
|
simplex::Face | simplex_from_face (const Tuple &t) const |
| |
|
simplex::Face | simplex_from_face (const size_t fid) const |
| |
|
Tuple | tuple_from_simplex (const simplex::Face &s) const |
| |
|
simplex::SimplexCollection | simplex_incident_triangles (const simplex::Vertex &v) const |
| |
|
simplex::SimplexCollection | simplex_incident_triangles (const simplex::Edge &e) const |
| |
|
simplex::SimplexCollection | simplex_link_vertices (const simplex::Vertex &v) const |
| |
|
simplex::SimplexCollection | simplex_link_vertices (const simplex::Edge &e) const |
| |
|
simplex::SimplexCollection | simplex_link_edges (const simplex::Vertex &v) const |
| |
|
void | set_preallocation_factor (double factor) |
| | Preallocation factor: init/consolidate reserve capacity = max(floor, ceil(factor * live_count)) so operations can grab fresh slots without resizing the storage. When a pass exhausts the reserved capacity the affected operations fail (retried later after a consolidate). Values < 1 are clamped to 1.
|
| |
|
double | preallocation_factor () const |
| |
|
long | request_tri_slots (size_t n) |
| |
|
long | request_vert_slots (size_t n) |
| |
| virtual bool | split_edge_before (const Tuple &t) |
| | User specified preparations and desideratas for an edge split.
|
| |
| virtual bool | split_edge_after (const Tuple &t) |
| | User specified modifications and desideratas after an edge split.
|
| |
| virtual bool | swap_edge_after (const Tuple &t) |
| | User specified modifications and desideras after an edge swap.
|
| |
| virtual bool | swap_edge_before (const Tuple &t) |
| | User specified preparations and desideratas for an edge swap including 1.can't swap on boundary edge. 2. when swap edge between v1, v2, there can't exist edges between the two opposite vertices v3, v4.
|
| |
| virtual bool | smooth_before (const Tuple &t) |
| | User specified preparations and desideratas for an edge smooth.
|
| |
| virtual bool | smooth_after (const Tuple &t) |
| | User specified modifications and desideras after an edge smooth.
|
| |
| virtual bool | split_face_before (const Tuple &t) |
| | User specified preparations and desideratas for a face split.
|
| |
| virtual bool | split_face_after (const Tuple &t) |
| | User specified modifications and desideratas after a face split.
|
| |
| size_t | tri_capacity () const |
| | get the current largest global fid
|
| |
| size_t | vert_capacity () const |
| | get the current largest global vid
|
| |
| void | consolidate_mesh () |
| | removing the elements that are removed
|
| |
| void | remove_tris_by_ids (const std::vector< size_t > &fids) |
| | Mark the given triangles, and any vertex left without an incident triangle, as removed.
|
| |
|
Tuple | switch_vertex (const Tuple &t) const |
| | a duplicate of Tuple::switch_vertex funciton
|
| |
|
Tuple | switch_edge (const Tuple &t) const |
| | a duplicate of Tuple::switch_edge funciton
|
| |
| std::optional< Tuple > | switch_face (const Tuple &t) const |
| | a duplicate of Tuple::switch_face funciton
|
| |
| bool | check_link_condition (const Tuple &t) const |
| | prerequisite for collapse
|
| |
| void | set_use_link_condition (bool use_it) |
| | Should collapse_edge_before enforce the link condition?
|
| |
|
bool | use_link_condition () const |
| |
| bool | check_mesh_connectivity_validity () const |
| | verify the connectivity validity of the mesh
|
| |
|
bool | check_edge_manifold () const |
| | verify the edge manifoldness of the mesh
|
| |
| size_t | edge_valence (const TriMesh::Tuple &t) const |
| | Number of triangles incident to the edge the Tuple points at.
|
| |
| bool | is_boundary_edge (const TriMesh::Tuple &t) const |
| | Does exactly one triangle share this edge?
|
| |
| bool | is_manifold_edge (const TriMesh::Tuple &t) const |
| | Do exactly two triangles share this edge?
|
| |
| size_t | vertex_component_count (const size_t vid) const |
| | Number of edge-connected components in the fan of a vertex.
|
| |
|
size_t | vertex_component_count (const TriMesh::Tuple &t) const |
| |
|
bool | is_manifold_vertex (const size_t vid) const |
| |
| std::optional< Tuple > | switch_component (const TriMesh::Tuple &t) const |
| | Jump to the next edge-connected component of the fan of the Tuple's vertex.
|
| |
| bool | is_boundary_vertex (const TriMesh::Tuple &t) const |
| | check if the vertex that's represented by a Tuple is at the boundary of the mesh
|
| |
| bool | split_edge (const Tuple &t, std::vector< Tuple > &new_t) |
| |
| virtual bool | collapse_edge (const Tuple &t, std::vector< Tuple > &new_t) |
| |
| void | collapse_edge_conn (const Tuple &loc0, std::vector< Tuple > &new_tris, Tuple &return_t, size_t &new_vid, std::vector< std::pair< size_t, TriangleConnectivity > > &old_tris, std::vector< std::pair< size_t, VertexConnectivity > > &old_vertices, std::vector< std::pair< size_t, size_t > > &same_edge_vid_fid, std::vector< size_t > &n12_intersect_fids) |
| |
| void | collapse_edge_rollback (size_t &new_vid, std::vector< std::pair< size_t, TriangleConnectivity > > &old_tris, std::vector< std::pair< size_t, VertexConnectivity > > &old_vertices, std::vector< std::pair< size_t, size_t > > &same_edge_vid_fid, std::vector< size_t > &n12_intersect_fids) |
| |
| bool | swap_edge (const Tuple &t, std::vector< Tuple > &new_t) |
| |
| bool | smooth_vertex (const Tuple &t) |
| |
| bool | split_face (const Tuple &t, std::vector< Tuple > &new_t) |
| | Split a face in 3 faces.
|
| |
| size_t | get_valence_for_vertex (const Tuple &t) const |
| | Count the number of the one ring tris for a vertex.
|
| |
| size_t | vertex_valence (const size_t vid) const |
| | Number of triangles incident to a vertex, by id.
|
| |
| std::vector< Tuple > | get_one_ring_tris_for_vertex (const Tuple &t) const |
| | Get the one ring tris for a vertex.
|
| |
|
const std::vector< size_t > & | get_one_ring_fids_for_vertex (const Tuple &t) const |
| |
|
const std::vector< size_t > & | get_one_ring_fids_for_vertex (const size_t vid) const |
| |
| std::vector< size_t > | get_one_ring_vids_for_vertex_duplicate (const size_t &t) const |
| | Get the vids of the incident one ring tris for a vertex.
|
| |
|
void | get_one_ring_vids_for_vertex_duplicate (const size_t &t, std::vector< size_t > &one_ring) const |
| |
|
std::vector< size_t > | get_incident_fids_for_edge (const Tuple &t) const |
| |
|
std::vector< size_t > | get_incident_fids_for_edge (const size_t vid0, const size_t vid1) const |
| |
| std::vector< Tuple > | get_one_ring_edges_for_vertex (const Tuple &t) const |
| | Get all edges that are incident to the vertex of Tuple t.
|
| |
|
std::vector< Tuple > | get_one_ring_edges_for_vertex (const size_t vid) const |
| |
| std::array< Tuple, 3 > | oriented_tri_vertices (const Tuple &t) const |
| | Get the incident vertices for a triangle.
|
| |
| std::array< size_t, 3 > | oriented_tri_vids (const Tuple &t) const |
| | Get the incident vertices for a triangle.
|
| |
|
std::array< size_t, 3 > | oriented_tri_vids (const size_t i) const |
| |
|
std::array< Tuple, 2 > | get_edge_vertices (const Tuple &t) const |
| |
|
std::array< size_t, 2 > | get_edge_vids (const Tuple &t) const |
| |
| Tuple | tuple_from_tri (size_t fid) const |
| |
| Tuple | tuple_from_vertex (size_t vid) const |
| |
| Tuple | tuple_from_edge (size_t fid, size_t local_eid) const |
| |
|
std::tuple< Tuple, size_t > | tuple_from_edge (const std::array< size_t, 2 > &vids) const |
| |
| std::optional< std::tuple< Tuple, size_t > > | try_tuple_from_edge (const std::array< size_t, 2 > &vids) const |
| | tuple_from_edge for callers where a missing edge is an answer, not a bug.
|
| |
|
void | start_protect_attributes () |
| | Start the phase where the attributes that will be modified can be recorded.
|
| |
|
void | release_protect_attributes () |
| | End the modification phase.
|
| |
|
void | rollback_protected_attributes () |
| | rollback the attributes that are modified if any condition failed
|
| |
|
int | release_vertex_mutex_in_stack () |
| |
| int | release_vertex_mutex_to (size_t mark) |
| | Release the mutexes taken since the release stack held mark entries.
|
| |
| bool | try_set_vertex_mutex_n_ring (const Tuple &v, int threadid, int n) |
| | Lock every vertex within graph distance n of v, the seed included.
|
| |
|
bool | try_set_vertex_mutex_n_ring (size_t vid, int threadid, int n) |
| |
|
bool | try_set_edge_mutex_n_ring (const Tuple &e, int threadid, int n) |
| | try_set_vertex_mutex_n_ring seeded from both ends of an edge.
|
| |
| bool | try_set_face_mutex_one_ring (const Tuple &f, int threadid) |
| | try lock the one-ring neighboring triangles' incident vertices.
|
| |
|
void | for_each_face (const std::function< void(const Tuple &)> &) |
| | perform the given function for each face
|
| |
|
void | for_each_edge (const std::function< void(const Tuple &)> &) |
| | perform the given function for each edge
|
| |
|
void | for_each_vertex (const std::function< void(const Tuple &)> &) |
| | perform the given function for each vertex
|
| |
| virtual bool | vertex_is_on_surface (const size_t vid) const |
| | Is a vertex part of the substructure.
|
| |
| virtual bool | edge_is_on_surface (const std::array< size_t, 2 > &vids) const |
| | Is an edge part of the substructure.
|
| |
| simplex::SimplexCollection | get_surface_edges_for_vertex (const size_t vid) const |
| | Get all edges on the surface that are incident to vid.
|
| |
| size_t | get_order_of_edge (const std::array< size_t, 2 > &vids) const |
| | Compute the order of an edge.
|
| |
| size_t | get_order_of_vertex (const size_t vid) const |
| | Get the order of a vertex.
|
| |
| bool | substructure_link_condition (const Tuple &e_tuple) const |
| | Link condition that also considers substructures.
|
| |
|
bool | try_set_vertex_mutex_two_ring (const Tuple &v, int threadid) |
| | Lock v's one-ring and, partially, its two-ring. See the note above.
|
| |
|
bool | try_set_edge_mutex_two_ring (const Tuple &e, int threadid) |
| | Lock the edge's one-ring and, partially, its two-ring. See the note above.
|
| |
|
bool | try_set_vertex_mutex_one_ring (const Tuple &v, int threadid) |
| | Lock v and its one-ring. Complete, unlike the two-ring pair.
|
| |
|
size_t | cell_capacity () const |
| |
|
Tuple | tuple_from_cell (size_t cid) const |
| |
Public Member Functions inherited from wmtk::TriMesh