Inheritance diagram for wmtk::components::simwild::tri::SimWildMeshTri:

Public Types
using	ExprPtr = expression_parser::ExpressionPtr

Public Types inherited from wmtk::TriOptimizerMesh
using	EdgeAttributes = wmtk::SurfaceTagAttributes

using	VertAttCol = AttributeCollection< VertexAttributes >

using	EdgeAttCol = AttributeCollection< EdgeAttributes >

using	FaceAttCol = AttributeCollection< FaceAttributes >

Public Types inherited from wmtk::TriMesh
template<typename T >
using	vector = std::vector< T >

using	VertexMutex = wmtk::threading::VertexMutex

Public Member Functions
bool	smoothing_position_is_allowed (const size_t, const Vector2d &) const override

	SimWildMeshTri (Parameters &_m_params, double envelope_eps, int _num_threads=0)

void	init_from_image (const MatrixXd &V, const MatrixXi &T, const MatrixSi &T_tags, const std::vector< std::string > &tag_names)
	Init from meshes image.

void	init_from_image (const MatrixXr &V, const MatrixXi &T, const MatrixSi &T_tags, const std::vector< std::string > &tag_names)
	Same, from EXACT input positions.

void	init_surfaces_and_boundaries ()

void	init_envelope (const MatrixXd &V, const MatrixXi &F)

CellTag	string_set_to_cell_tag (const std::set< std::string > &str_set)

void	set_sizing_field (const nlohmann::json &sizing_field_json)

void	set_quality_field (const nlohmann::json &quality_field_json)

double	target_quality (const size_t tid) const

double	target_quality (const Tuple &t) const

double	quality_rel (const size_t tid) const override

double	quality_rel (const Tuple &t) const

bool	check_mesh_quality (double &max_rel_quality, const bool verbose=false) const

std::vector< size_t >	active_vertices () const override

size_t	refine_sizing_around_worst (double max_metric=0.) override
	Escape a stuck max energy by refining the sizing field around the worst elements.

void	write_msh (std::string file, const bool write_envelope=true)

void	write_vtu (const std::string &path) const

void	write_vtu_with_energies (const std::string &path) const

std::vector< Vector2d >	get_surface_assembles (const Tuple &t) const
	A vector containing the vertex position and all positions of the surface neighbors.

std::shared_ptr< polysolve::nonlinear::Problem >	get_envelope_energy (const Tuple &t) const

std::vector< std::array< double, 6 > >	get_amips_assembles (const Tuple &t) const

std::shared_ptr< polysolve::nonlinear::Problem >	get_amips_energy (const Tuple &t) const

void	log_total_surface_energy ()

double	triangle_area (const size_t fid) const

std::vector< ConnectedComponent >	compute_connected_components (const CellTag &tag_in) const
	Find all connected components that contain the `tag_in` tags.

std::vector< ConnectedComponent >	compute_connected_components (const ExprPtr &expr) const

std::vector< ConnectedComponent >	find_holes (const std::vector< CellTag > &tag_in) const
	Find all regions that do not contain the tags from `tag_in`.

void	compute_tag_boundary (const CellTag &tag, MatrixXd &V, MatrixXi &E) const
	Compute the boundary of a tag.

void	keep_largest_connected_component (const std::vector< CellTag > &lcc_tags, const size_t n_lcc=1)
	Keep only the largest connected component for each of the distinct tag_0 values, and engulf all other components.

void	fill_holes_topo (const std::vector< CellTag > &fill_holes_tags, double threshold=std::numeric_limits< double >::infinity())

void	seal_connected_components (const std::vector< CellTag > &tag_sets, const std::vector< ConnectedComponent > &components)

void	tight_seal_topo (const std::vector< std::vector< CellTag > > &tight_seal_tag_sets, double threshold=std::numeric_limits< double >::infinity())

void	resolve_overlaps (const std::vector< std::array< ExprPtr, 2 > > &intersecting_tags)

void	replace_tags (const std::vector< CellTag > &tags_in, const std::vector< CellTag > &tags_out)

void	tag_priority (const std::vector< int64_t > &tags_order)

Public Member Functions inherited from wmtk::TriOptimizerMesh
	TriOptimizerMesh (OptimizerParameters &params)

size_t	get_partition_id (const Tuple &loc) const

void	partition_mesh ()

void	partition_mesh_morton ()

double	get_length2 (const Tuple &l) const

bool	is_inverted (const std::array< size_t, 3 > &vs) const
	Orientation check, exact for the coordinates the vertices actually carry.

bool	is_inverted (const Tuple &loc) const

bool	is_inverted (const size_t fid) const

bool	is_inverted_f (const Tuple &loc) const
	Inversion check using only the double positions.

bool	is_inverted_f (const size_t fid) const

double	get_quality (const std::array< size_t, 3 > &vs) const

double	get_quality (const Tuple &loc) const

double	get_quality (const size_t fid) const

std::tuple< double, double >	get_max_avg_energy ()

void	mesh_improvement (int max_its=80)

std::tuple< double, double >	local_operations (const std::array< int, 4 > &ops, bool collapse_limit_length=true)

bool	is_force_split_edge (const size_t v1, const size_t v2) const

void	split_all_edges ()

bool	split_edge_before (const Tuple &t) override
	User specified preparations and desideratas for an edge split.

bool	split_edge_after (const Tuple &loc) override
	User specified modifications and desideratas after an edge split.

void	collapse_all_edges (bool is_limit_length=true)

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.

size_t	coarsen_mesh ()
	Coarsen the mesh without letting the max energy rise.

bool	coarsen_collapse_edge (const Tuple &e, std::vector< Tuple > &new_tris)
	One collapse under the coarsening rules, outside a coarsening pass.

size_t	swap_all_edges ()
	Run TriWild's quality-improving interior edge-flip pass.

double	swap_weight (const Tuple &t) const

bool	swap_edge_before (const Tuple &t) override
	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.

bool	swap_edge_after (const Tuple &t) override
	User specified modifications and desideras after an edge swap.

void	smooth_all_vertices (size_t n_iters=1)
	Run TriWild's vertex-smoothing pass.

bool	smooth_before (const Tuple &t) override
	User specified preparations and desideratas for an edge smooth.

bool	smooth_after (const Tuple &t) override
	User specified modifications and desideras after an edge smooth.

Vector2d	smoothing_position (size_t vid) const

void	set_smoothing_position (size_t vid, const Vector2d &p)

double	active_quality_threshold () const

bool	round (const Tuple &v)
	Round a vertex position to floating point, if that inverts no incident face.

bool	is_edge_on_surface (const Tuple &loc) const

bool	is_edge_on_surface (const std::array< size_t, 2 > &vids) const

bool	is_edge_on_bbox (const Tuple &loc) const

bool	is_edge_on_bbox (const std::array< size_t, 2 > &vids) const

bool	vertex_is_on_surface (const size_t vid) const override
	Is a vertex part of the substructure.

bool	edge_is_on_surface (const std::array< size_t, 2 > &vids) const override
	Is an edge part of the substructure.

virtual std::shared_ptr< SampleEnvelope >	surface_envelope_for_edge (const std::array< size_t, 2 > &vids) const
	Envelope the tracked-surface segment `vids` must stay inside.

bool	surface_segment_is_outside (const size_t a, const size_t b) const

std::vector< std::array< size_t, 2 > >	get_edges_by_condition (std::function< bool(const EdgeAttributes &)> cond) const

void	gradation_smooth_sizing (double grade, const std::vector< size_t > &seeds)
	Monotone (only-decreasing) gradation smoothing of the sizing field.

Public Member Functions inherited from wmtk::TriMesh
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	invariants (const std::vector< Tuple > &)
	User specified invariants that can't be violated.

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

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::RationalPositions
size_t	round_all_vertices ()
	Try to round every un-rounded vertex; returns the number reclaimed.

bool	round_and_check_all_rounded ()
	Run the sweep, then report whether the mesh is now fully rounded.

Public Attributes
Parameters &	m_sim_params

std::vector< Vector2d >	m_V_envelope

std::vector< Vector2i >	m_E_envelope

std::vector< std::tuple< ExprPtr, double > >	m_sizing_field

std::vector< std::tuple< ExprPtr, double > >	m_quality_field

bool	m_collapse_check_link_condition = false

bool	m_collapse_check_topology = false

bool	m_collapse_check_manifold = false

Public Attributes inherited from wmtk::TriOptimizerMesh
VertAttCol	m_vertex_attribute

EdgeAttCol	m_edge_attribute

FaceAttCol	m_face_attribute

AttributeContainerGroup	m_vertex_attr_group
	What p_vertex_attrs points at, so a derived class can register more.

AttributeContainerGroup	m_edge_attr_group
	What p_edge_attrs points at, so a derived class can register more.

AttributeContainerGroup	m_face_attr_group
	What p_face_attrs points at, so a derived class can register more.

OptimizerParameters &	m_params

std::shared_ptr< SampleEnvelope >	m_envelope

double	m_envelope_eps = -1

double	m_s_amips = -1

double	m_s_envelope = -1

wmtk::threading::enumerable_thread_specific< std::unique_ptr< polysolve::nonlinear::Solver > >	m_solver

optimization::SmoothRejectCounters	m_smooth_rejects
	Why smoothing attempts were refused, reported once per pass.

bool	m_collapse_limit_length = true

int	m_debug_print_counter = 0

size_t	m_tags_count = 0

std::map< int64_t, std::string >	m_tag_id_to_name

std::map< std::string, int64_t >	m_tag_name_to_id

int	m_iterations_used = 0
	Shared TriWild/SimWild outer optimization schedule.

std::set< simplex::Edge >	m_force_split_edges

size_t	m_force_split_count = 0

std::unique_ptr< std::atomic< int >[]>	m_high_valence_claim

size_t	m_high_valence_claim_size = 0

std::atomic< size_t >	m_high_valence_rejects = 0

CoarsenStats	m_coarsen_stats

Public Attributes inherited from wmtk::TriMesh
AbstractAttributeContainer *	p_vertex_attrs = nullptr

AbstractAttributeContainer *	p_edge_attrs = nullptr

AbstractAttributeContainer *	p_face_attrs = nullptr

wmtk::threading::enumerable_thread_specific< std::vector< size_t > >	mutex_release_stack

int	NUM_THREADS = 0

Protected Member Functions
std::tuple< double, double >	optimization_quality_stats () override

double	optimization_stop_metric () const override

bool	optimization_stop_at_float () const override

void	write_smoothing_debug_output (const std::string &path) const override

bool	collapse_quality_allowed (size_t v1, size_t fid, double q, double ring_max) const override

void	collapse_after_vertex (size_t v1, size_t v2) override

bool	split_adjust_position (size_t v_new, const std::vector< Tuple > &children) override

void	split_after_vertex (size_t v_new) override

Protected Member Functions inherited from wmtk::TriOptimizerMesh
virtual void	collapse_pass_begin ()

virtual void	collapse_pass_end (size_t)

virtual bool	collapse_before_vertex (size_t, size_t)

std::vector< size_t >	all_vertex_ids () const override
	Every live vertex, in the mesh's own iteration order.

bool	vertex_is_rounded (const size_t vid) const override
	Whether this vertex's double position is currently trusted.

bool	round_vertex (const size_t vid) override

Protected Member Functions inherited from wmtk::TriMesh
void	vertex_fan_components (size_t vid, std::vector< size_t > &component_of, std::vector< size_t > &representatives) const

void	resize_mutex (size_t v)

Private Attributes
std::function< double(const Vector2d &)>	m_voronoi_split_fn = nullptr

size_t	m_last_split_vertex = 0

Additional Inherited Members
Static Public Attributes inherited from wmtk::TriOptimizerMesh
static constexpr double	MAX_ENERGY = 1e50
	The sentinel get_quality returns for a face AMIPS2D cannot score.

Static Public Attributes inherited from wmtk::TriMesh
static constexpr int	EDGES_PER_CELL = 3

Protected Attributes inherited from wmtk::TriOptimizerMesh
wmtk::threading::enumerable_thread_specific< SplitInfoCache >	split_cache

wmtk::threading::enumerable_thread_specific< CollapseInfoCache >	collapse_cache

bool	m_coarsen_mode = false
	Set for the duration of coarsen_mesh(); read-only while a pass is running.

Protected Attributes inherited from wmtk::RationalPositions
std::atomic< bool >	m_all_rounded = false
	True when every vertex is known to be rounded.

Member Function Documentation

◆ active_vertices()

std::vector< size_t > wmtk::components::simwild::tri::SimWildMeshTri::active_vertices ( ) const

overridevirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ collapse_after_vertex()

void wmtk::components::simwild::tri::SimWildMeshTri::collapse_after_vertex	(	size_t	v1,
		size_t	v2
	)

overrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ collapse_quality_allowed()

bool wmtk::components::simwild::tri::SimWildMeshTri::collapse_quality_allowed	(	size_t	v1,
		size_t	fid,
		double	q,
		double	ring_max
	)		const

overrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ compute_tag_boundary()

void wmtk::components::simwild::tri::SimWildMeshTri::compute_tag_boundary	(	const CellTag &	tag,
		MatrixXd &	V,
		MatrixXi &	E
	)		const

Compute the boundary of a tag.

Parameters

tag	A set of tags that must be present in a triangle for being considered as tagged.
V	Vertices of the tag boundary.
E	Edges of the tag boundary.

◆ find_holes()

std::vector< ConnectedComponent > wmtk::components::simwild::tri::SimWildMeshTri::find_holes ( const std::vector< CellTag > & tag_in ) const

Find all regions that do not contain the tags from tag_in.

The tag_in vector represents a list of tag intersections. Example: tag_in = {{1,2},{3}} A face will be considered as a hole if its tags neither include {1,2} or {3}. The following would be holes: {} {1,4} The following would be NOT holes: {1,2,4} <- contains 1 and 2 {3} <- contains 3 {1,3} <- contains 3

The returned vector also contains "holes" that touch the boundary. They should be ommitted in hole filling.

◆ get_surface_assembles()

std::vector< Vector2d > wmtk::components::simwild::tri::SimWildMeshTri::get_surface_assembles ( const Tuple & t ) const

A vector containing the vertex position and all positions of the surface neighbors.

Returns an empty vector if vertex is not on the surface.

◆ init_from_image() [1/2]

void wmtk::components::simwild::tri::SimWildMeshTri::init_from_image	(	const MatrixXd &	V,
		const MatrixXi &	T,
		const MatrixSi &	T_tags,
		const std::vector< std::string > &	tag_names
	)

Init from meshes image.

Parameters

V	Vx3 vertices of the tet mesh
T	Tx4 vertex IDs for all faces
T_tags	Tx1 image data represented by the individual faces
tag_names	Names for each tag in T_tags. The size must be the same as the number of columns in T_tags.

◆ init_from_image() [2/2]

void wmtk::components::simwild::tri::SimWildMeshTri::init_from_image	(	const MatrixXr &	V,
		const MatrixXi &	T,
		const MatrixSi &	T_tags,
		const std::vector< std::string > &	tag_names
	)

Same, from EXACT input positions.

Taken when the 2D arrangement produced a vertex with no double representation – a crossing between two input segments generally has none. Rounds what it can and leaves the rest rational; the optimization loop reclaims them.

◆ keep_largest_connected_component()

void wmtk::components::simwild::tri::SimWildMeshTri::keep_largest_connected_component	(	const std::vector< CellTag > &	lcc_tags,
		const size_t	n_lcc = `1`
	)

Keep only the largest connected component for each of the distinct tag_0 values, and engulf all other components.

Parameters

lcc_tags
n_lcc	The number of largest components that should be kept.

◆ log_total_surface_energy()

void wmtk::components::simwild::tri::SimWildMeshTri::log_total_surface_energy ( )

For debugging purposes.

◆ optimization_quality_stats()

std::tuple< double, double > wmtk::components::simwild::tri::SimWildMeshTri::optimization_quality_stats ( )

overrideprotectedvirtual

Quality metric used by the driver. TriWild uses absolute AMIPS; SimWild overrides this with quality normalized by each face's tag-dependent target.

Reimplemented from wmtk::TriOptimizerMesh.

◆ optimization_stop_at_float()

bool wmtk::components::simwild::tri::SimWildMeshTri::optimization_stop_at_float ( ) const

inlineoverrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ optimization_stop_metric()

double wmtk::components::simwild::tri::SimWildMeshTri::optimization_stop_metric ( ) const

inlineoverrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ quality_rel()

double wmtk::components::simwild::tri::SimWildMeshTri::quality_rel ( const size_t tid ) const

overridevirtual

SimWild's target is per tag, so this normalizes each face by its own before the shared optimizer compares one face against another. See TriOptimizerMesh::quality_rel.

Reimplemented from wmtk::TriOptimizerMesh.

◆ refine_sizing_around_worst()

size_t wmtk::components::simwild::tri::SimWildMeshTri::refine_sizing_around_worst ( double max_metric = 0. )

overridevirtual

Escape a stuck max energy by refining the sizing field around the worst elements.

Finds the m_params.stuck_refine_num_worst tets with the highest energy, gathers all vertices within m_params.stuck_refine_rings graph rings of them, and multiplies each such vertex's m_sizing_scalar by m_params.stuck_refine_factor (clamped at m_params.stuck_refine_min_scalar). Then runs gradation_smooth_sizing so the refined region blends smoothly into the surrounding resolution. Replaces the old global adjust_sizing_field mechanism. Returns the number of vertices refined.

Implements wmtk::TriOptimizerMesh.

◆ smoothing_position_is_allowed()

bool wmtk::components::simwild::tri::SimWildMeshTri::smoothing_position_is_allowed	(	const size_t	,
		const Vector2d &
	)		const

inlineoverridevirtual

No 0-dimensional features here, so smoothing is never positionally constrained beyond the envelope. See TriWildMesh::smoothing_position_is_allowed for the case that is.

Implements wmtk::TriOptimizerMesh.

◆ split_adjust_position()

bool wmtk::components::simwild::tri::SimWildMeshTri::split_adjust_position	(	size_t	v_new,
		const std::vector< Tuple > &	children
	)

overrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ split_after_vertex()

void wmtk::components::simwild::tri::SimWildMeshTri::split_after_vertex ( size_t v_new )

inlineoverrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ write_smoothing_debug_output()

void wmtk::components::simwild::tri::SimWildMeshTri::write_smoothing_debug_output ( const std::string & path ) const

inlineoverrideprotectedvirtual

Implements wmtk::TriOptimizerMesh.

Member Data Documentation

◆ m_sim_params

Parameters& wmtk::components::simwild::tri::SimWildMeshTri::m_sim_params

The base holds only wmtk::OptimizerParameters; this is the same object, typed, for the simwild-only fields (tags, the operation name, the raw input box).

The documentation for this class was generated from the following files:

/home/runner/work/wildmeshing-toolkit/wildmeshing-toolkit/components/simwild/wmtk/components/simwild/SimWildMeshTri.hpp
/home/runner/work/wildmeshing-toolkit/wildmeshing-toolkit/components/simwild/wmtk/components/simwild/AnnotationsTri.cpp
/home/runner/work/wildmeshing-toolkit/wildmeshing-toolkit/components/simwild/wmtk/components/simwild/SimWildMeshTri.cpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Private Attributes

Additional Inherited Members

Member Function Documentation

◆ active_vertices()

◆ collapse_after_vertex()

◆ collapse_quality_allowed()

◆ compute_tag_boundary()

◆ find_holes()

◆ get_surface_assembles()

◆ init_from_image() [1/2]

◆ init_from_image() [2/2]

◆ keep_largest_connected_component()

◆ log_total_surface_energy()

◆ optimization_quality_stats()

◆ optimization_stop_at_float()

◆ optimization_stop_metric()

◆ quality_rel()

◆ refine_sizing_around_worst()

◆ smoothing_position_is_allowed()

◆ split_adjust_position()

◆ split_after_vertex()

◆ write_smoothing_debug_output()

Member Data Documentation

◆ m_sim_params