Inheritance diagram for wmtk::components::triwild::TriWildMesh:

Classes
struct	VertexExtras
	triwild's per-vertex additions to the shared VertexAttributes. More...

Public Member Functions
bool	smoothing_position_is_allowed (const size_t vid, const Vector2d &p) const override
	May vertex `vid` sit at `p`?

void	split_after_vertex (const size_t vid) override

std::pair< size_t, size_t >	feature_retention (double *worst_ratio=nullptr) const
	{feature points still represented within eps, total feature points}.

bool	collapse_breaks_feature (const size_t v1_id, const size_t v2_id) const
	True iff collapsing v1 into v2 would drop or displace a feature point.

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

void	init_mesh (const MatrixXd &V, const std::vector< Vector2r > &V_rational, const MatrixXi &F, const MatrixXi &E, const std::vector< std::string > &tag_names, const MatrixXd &V_env, const MatrixXi &E_env)
	Init mesh from IGL-style matrices.

void	init_surfaces_and_boundaries ()

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

size_t	refine_sizing_around_worst (double max_energy) override
	The old global sizing-field update (KNN R-ball around every low-quality triangle). Superseded by refine_sizing_around_worst, but kept compiled and callable so the two can be compared – tetwild and simwild keep theirs for the same reason.

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

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

void	compute_winding_numbers (const std::vector< MatrixXd > &Vs, const std::vector< MatrixXi > &Es)
	Tag every face with the inputs it lies inside, by winding number.

void	filter_with_input_winding_number ()
	Remove the faces that lie inside no input (needs compute_winding_numbers).

void	filter_with_flood_fill ()
	Remove the flood-fill region that dominates the mesh boundary (needs flood_fill).

int	flood_fill ()

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

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

virtual double	quality_rel (const size_t fid) const
	A face's quality relative to the quality it is required to reach; <= 1 means it meets it.

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
wmtk::AttributeCollection< VertexExtras >	m_vertex_extra

Parameters &	m_tri_params

std::vector< Vector2d >	m_V_envelope

std::vector< Vector2i >	m_E_envelope

double	m_feature_eps = -1

std::vector< Vector2d >	m_feature_points

std::atomic< size_t >	m_feature_rejects = 0
	Collapses refused because they would drop or displace a feature point. Diagnostic.

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
void	write_smoothing_debug_output (const std::string &path) const override

void	collapse_pass_begin () override

void	collapse_pass_end (size_t) override

bool	collapse_before_vertex (size_t v1, size_t v2) override

void	collapse_after_vertex (size_t v1, size_t v2) override

Protected Member Functions inherited from wmtk::TriOptimizerMesh
virtual std::tuple< double, double >	optimization_quality_stats ()

virtual double	optimization_stop_metric () const

virtual bool	optimization_stop_at_float () const

virtual bool	collapse_quality_allowed (size_t v1, size_t, double q, double ring_max) const

virtual bool	split_adjust_position (size_t, const std::vector< Tuple > &)

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)

Additional Inherited Members
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

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

◆ collapse_after_vertex()

void wmtk::components::triwild::TriWildMesh::collapse_after_vertex	(	size_t	v1,
		size_t	v2
	)

inlineoverrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ collapse_before_vertex()

bool wmtk::components::triwild::TriWildMesh::collapse_before_vertex	(	size_t	v1,
		size_t	v2
	)

inlineoverrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ collapse_pass_begin()

void wmtk::components::triwild::TriWildMesh::collapse_pass_begin ( )

inlineoverrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ collapse_pass_end()

void wmtk::components::triwild::TriWildMesh::collapse_pass_end ( size_t )

inlineoverrideprotectedvirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ compute_winding_numbers()

void wmtk::components::triwild::TriWildMesh::compute_winding_numbers	(	const std::vector< MatrixXd > &	Vs,
		const std::vector< MatrixXi > &	Es
	)

Tag every face with the inputs it lies inside, by winding number.

Vs/Es are the per-input meshes as read when the initial mesh was built (2D, x/y only) – they are passed in rather than re-read from disk.

◆ feature_retention()

std::pair< size_t, size_t > wmtk::components::triwild::TriWildMesh::feature_retention ( double * worst_ratio = nullptr ) const

{feature points still represented within eps, total feature points}.

The invariant preserve_feature_points maintains, measured on the finished mesh rather than assumed from the per-operation checks.

◆ init_mesh()

void wmtk::components::triwild::TriWildMesh::init_mesh	(	const MatrixXd &	V,
		const std::vector< Vector2r > &	V_rational,
		const MatrixXi &	F,
		const MatrixXi &	E,
		const std::vector< std::string > &	tag_names,
		const MatrixXd &	V_env,
		const MatrixXi &	E_env
	)

Init mesh from IGL-style matrices.

Parameters

V	Vx2 vertices of the initial mesh
F	Fx3 vertex IDs for all faces
E	Ex2 vertex IDs for all constraint edges
tag_names	Names for each tag.
V_rational	the arrangement's EXACT vertex positions, matching V row for row. V is only their rounding, and two exactly distinct vertices can round to the same double, so V alone cannot tell a genuine degeneracy from a rounding collision. Pass an empty vector when no exact positions exist (unit tests building a mesh from doubles); every vertex is then taken as rounded.
V_env,E_env	the curves the envelope is built around. These are the original input curves, not the arrangement's constrained edges: the optimizer has to stay near what the user gave us, not near the simplified version of it. Same arrangement as tetwild, which hands its optimizer the envelope built on the unsimplified input surface.

◆ refine_sizing_around_worst()

size_t wmtk::components::triwild::TriWildMesh::refine_sizing_around_worst ( double max_energy )

overridevirtual

The old global sizing-field update (KNN R-ball around every low-quality triangle). Superseded by refine_sizing_around_worst, but kept compiled and callable so the two can be compared – tetwild and simwild keep theirs for the same reason.

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

Finds the m_params.stuck_refine_num_worst triangles with the highest energy (0 => all of them above the filter 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.

Returns: the number of vertices refined.

Implements wmtk::TriOptimizerMesh.

◆ smoothing_position_is_allowed()

bool wmtk::components::triwild::TriWildMesh::smoothing_position_is_allowed	(	const size_t	vid,
		const Vector2d &	p
	)		const

overridevirtual

May vertex vid sit at p?

False only when the vertex stands for a feature point and p is more than m_envelope_eps away from it. Smoothing is free to move a feature vertex inside that ball – it is a containment test, not a freeze, so the optimizer keeps the quality it can get near features.

Implements wmtk::TriOptimizerMesh.

◆ split_after_vertex()

void wmtk::components::triwild::TriWildMesh::split_after_vertex ( const size_t vid )

inlineoverridevirtual

Reimplemented from wmtk::TriOptimizerMesh.

◆ write_smoothing_debug_output()

void wmtk::components::triwild::TriWildMesh::write_smoothing_debug_output ( const std::string & path ) const

inlineoverrideprotectedvirtual

Implements wmtk::TriOptimizerMesh.

Member Data Documentation

◆ m_feature_eps

double wmtk::components::triwild::TriWildMesh::m_feature_eps = -1

Radius of the ball a feature-carrying vertex must stay inside.

Presently equal to m_envelope_eps, but deliberately a separate name: the two are different quantities – the envelope bounds how far the CURVE may deviate, this bounds how far a SURVIVOR VERTEX may sit from an anchor – so tying them means a tighter envelope silently tightens feature retention by the same factor. Measured on triwild20k 189017 at eps_rel 1e-4, giving this its own (10x wider) value cut collapse refusals 75270 -> 61666 and delayed the mesh blow-up by two iterations. That was not enough to fix that model on its own – the collapse length gate was the real cause – so the value is left alone here and only the coupling is made visible.

◆ m_feature_points

std::vector<Vector2d> wmtk::components::triwild::TriWildMesh::m_feature_points

Anchor positions of the curve network's 0-dimensional features, indexed by VertexExtras::m_feature_id.

Filled in init_mesh from the arrangement's constrained edges: a vertex whose valence in that edge set is neither 0 nor 2 is a feature – valence 1 is an open polyline's endpoint, valence >= 3 a junction. Reading it off the arrangement rather than the raw input is deliberate: it is the network the optimizer actually starts from, so a junction the simplification was allowed to merge (which it may, with simplify_use_link_condition off) is correctly absent, and no provenance or position-matching plumbing is needed.

A vertex carrying feature f may never end up further than m_envelope_eps from m_feature_points[f]. Since the anchor never moves, no spatial index is required: the feature id is a direct lookup.

◆ m_tri_params

Parameters& wmtk::components::triwild::TriWildMesh::m_tri_params

The base holds only wmtk::OptimizerParameters; this is the same object, typed, for the triwild-only fields (features, high valence, smoothing schedule, box).

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

/home/runner/work/wildmeshing-toolkit/wildmeshing-toolkit/components/triwild/wmtk/components/triwild/TriWildMesh.h
/home/runner/work/wildmeshing-toolkit/wildmeshing-toolkit/components/triwild/wmtk/components/triwild/TriWildMesh.cpp

Classes

Public Member Functions

Public Attributes

Protected Member Functions

Additional Inherited Members

Member Function Documentation

◆ collapse_after_vertex()

◆ collapse_before_vertex()

◆ collapse_pass_begin()

◆ collapse_pass_end()

◆ compute_winding_numbers()

◆ feature_retention()

◆ init_mesh()

◆ refine_sizing_around_worst()

◆ smoothing_position_is_allowed()

◆ split_after_vertex()

◆ write_smoothing_debug_output()

Member Data Documentation

◆ m_feature_eps

◆ m_feature_points

◆ m_tri_params