#include <cdt.hpp>

Collaboration diagram for meshkit::BasicConstrainedDelaunay< Storage >:

Classes
struct	QualityOptions
	Options for refineQuality(). More...

struct	QualityReport

struct	Triangle

Public Types
enum	Origin : std::uint32_t { Domain = 1 , Hole = 2 , Line = 4 , Patch = 8 , Node = 16 , Breakline = 32 , Region = 64 , Lattice = 128 , Size = 256 , Angle = 512 , Terrain = 1024 , SegmentSplit = 2048 }

using	Point = typename Storage::Point

using	Box = typename Storage::Box

using	String = typename Storage::String

using	PointInput = typename Storage::PointInput

template<class T >
using	Vector = typename Storage::template Vector< T >

template<class K , class V >
using	Hash = typename Storage::template Hash< K, V >

template<class K , class V >
using	MultiHash = typename Storage::template MultiHash< K, V >

template<class K >
using	Set = typename Storage::template Set< K >

Public Member Functions
bool	build (const PointInput &points, Vector< int > *vertexOfPoint=nullptr, const std::function< bool()> &cancelled={}, const std::function< void(std::uint64_t)> &progress={})
	Reset and incrementally triangulate distinct finite points inside a constructed super triangle.

bool	insertConstraint (int a, int b)
	Recover/mark a straight constraint, recursively splitting at exactly collinear existing vertices.

int	insertPoint (const Point &p)
	Insert one finite point in a live triangle, splitting a triangle/edge and restoring Delaunay edges.

bool	removeVertex (int v)
	Transactionally remove a free post-build interior vertex and retriangulate its local cavity.

bool	isVertexActive (int v) const
	Test whether an in-range vertex has a nonnegative incident-triangle hint.

void	removeExterior ()
	Mark super-touching faces and every unconstrained reachable neighbor dead. Requires successfully built constrained topology; insert closed boundaries first or all connected faces can be removed. Leaves vertex/triangle slots, adjacency and incidence hints allocated; does not compact arrays or clear every active hint. Allocates flood stack, mutates alive flags only, no error return, cancellation, source IO or concurrent queries during mutation.

void	removeSuperTriangles ()
	Mark only live faces touching one of the three super vertices dead. Leaves the unconstrained real-point hull and all storage/adjacency/incidence hints in place; no flood across neighbors or compaction. Requires successful build, exclusive mutation, no allocation/IO.

int	removeRegionLeftOf (int a, int b)
	Delete live constraint-bounded faces topologically seeded to a directed edge's left.

int	inputVertexCount () const
	Return the unique-input count recorded as the super-vertex base at successful build.

int	removeRegionAt (const Point &p)
	Mark the live constraint-bounded component containing a finite seed point dead.

QualityReport	refineQuality (const QualityOptions &opt)
	Mutate live constrained triangulation by bounded size/angle/terrain refinement and optional coarsening.

void	setFixedConstraint (int a, int b)
	Mark every recovered subedge of a requested constraint chain unsplittable for refinement.

bool	smallAngleExempt (int t) const
	Test the shortest edge of a triangle for equal-radius input-corner shell exemption.

bool	touchesFixed (int t) const
	Test whether any triangle vertex participates in a marked fixed constrained edge.

void	enableProvenance ()
	Enable/reset optional origin bits for all currently stored vertices. Fills owned origin array with zero, discarding prior diagnostic bits; call after build. Allocates parallel storage, no geometry/topology mutation, source IO or concurrent access allowed.

void	addVertexOrigin (int v, std::uint32_t origin)
	OR diagnostic provenance flags into an enabled in-range origin slot.

const Vector< std::uint32_t > &	vertexOrigins () const
	Borrow diagnostic origin storage from this triangulation.

const Vector< Point > &	vertices () const
	Borrow all stored XY positions including super, inactive and newly inserted vertices.

const Vector< Triangle > &	triangles () const
	Borrow all triangle slots with alive flags, adjacency and opposite-edge constraints.

const Vector< double > &	terrainElevations () const
	Borrow the most recent refinement's cached per-vertex elevation samples.

int	liveTriangleCount () const
	Count slots whose alive flag is true, including super faces if still alive.

int	locate (const Point &p) const
	Locate a finite point and require its found triangle to be alive.

bool	isConstrained (int a, int b) const
	Check whether a direct edge between two stored vertices is marked constrained.

Vector< int >	constrainedChain (int a, int b) const
	Follow direct, origin-associated or collinear constrained edges from one endpoint to another.

bool	isSuperVertex (int v) const
	Test whether an integer falls in the recorded three-super-vertex interval.

String	errorMsg () const
	Copy the last explicitly recorded build/constraint diagnostic.

Static Public Member Functions
static double	orientExact (const Point &a, const Point &b, const Point &c)
	Return adaptive-exact orientation sign after thread-safe one-time predicate initialization.

Member Typedef Documentation

◆ Box

template<class Storage >

using meshkit::BasicConstrainedDelaunay< Storage >::Box = typename Storage::Box

◆ Hash

template<class Storage >

template<class K , class V >

using meshkit::BasicConstrainedDelaunay< Storage >::Hash = typename Storage::template Hash<K, V>

◆ MultiHash

template<class Storage >

template<class K , class V >

using meshkit::BasicConstrainedDelaunay< Storage >::MultiHash = typename Storage::template MultiHash<K, V>

◆ Point

template<class Storage >

using meshkit::BasicConstrainedDelaunay< Storage >::Point = typename Storage::Point

◆ PointInput

template<class Storage >

using meshkit::BasicConstrainedDelaunay< Storage >::PointInput = typename Storage::PointInput

◆ Set

template<class Storage >

template<class K >

using meshkit::BasicConstrainedDelaunay< Storage >::Set = typename Storage::template Set<K>

◆ String

template<class Storage >

using meshkit::BasicConstrainedDelaunay< Storage >::String = typename Storage::String

◆ Vector

template<class Storage >

template<class T >

using meshkit::BasicConstrainedDelaunay< Storage >::Vector = typename Storage::template Vector<T>

Member Enumeration Documentation

◆ Origin

template<class Storage >

enum meshkit::BasicConstrainedDelaunay::Origin : std::uint32_t

Enumerator
Domain
Hole
Line
Patch
Node
Breakline
Region
Lattice
Size
Angle
Terrain
SegmentSplit

Member Function Documentation

◆ addVertexOrigin()

template<class Storage >

void meshkit::BasicConstrainedDelaunay< Storage >::addVertexOrigin	(	int	v,
		std::uint32_t	origin
	)

inline

OR diagnostic provenance flags into an enabled in-range origin slot.

Parameters

[in]	v	Arbitrary vertex-origin index, bounds checked; no-op if origins disabled/out of range.
[in]	origin	Bit mask to accumulate, no enum-mask validation; overlapping roles allowed. No geometry mutation or allocation, no retained arguments; caller excludes concurrent origin updates.

◆ build()

template<class Storage >

bool meshkit::BasicConstrainedDelaunay< Storage >::build	(	const PointInput &	points,
		Vector< int > *	vertexOfPoint = `nullptr`,
		const std::function< bool()> &	cancelled = `{}`,
		const std::function< void(std::uint64_t)> &	progress = `{}`
	)

Reset and incrementally triangulate distinct finite points inside a constructed super triangle.

Parameters

[in]	points	Borrowed finite Cartesian coordinates, unchanged; coordinate extents/super-triangle expansion and int counts must remain representable. Exact numeric coordinate duplicates coalesce, including +/-0 normalization; no tolerance merging.
[out]	vertexOfPoint	Optional borrowed mapping resized to input count. Each processed input maps to first-occurrence unique vertex ID; early failure may retain partial mapping. Not retained.

Returns: True after all points inserted, false for nonfinite input, <3 distinct points or failed location, with errorMsg diagnostic. Existing state is cleared/replaced before validation; failure is not transactional and may leave partial arrays. This implementation does not explicitly reject all collinear sets: callers requiring nondegenerate real faces must inspect/read out the hull. Unique input IDs are first-occurrence order, then three super vertices; Morton insertion changes triangle slots, not input vertex IDs. Predicate initialization uses call_once. Optional cancellation and insertion-progress callbacks run between bounded input/sort/insertion batches. No workspace budget, IO or external handles; exclude concurrent access and rebuild after failure.

Triangulate points. vertexOfPoint receives, per input point, its vertex id (duplicates share one). Rejects fewer than 3 distinct points; collinear output needs caller inspection.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ constrainedChain()

template<class Storage >

auto meshkit::BasicConstrainedDelaunay< Storage >::constrainedChain	(	int	a,
		int	b
	)		const

Follow direct, origin-associated or collinear constrained edges from one endpoint to another.

Parameters

[in]	a	Valid stored starting vertex, unchecked; consistent incident topology required.
[in]	b	Valid stored ending vertex, unchecked; same predicate-safe frame.

Returns: Owned ordered vertex IDs including endpoints, {a} when equal, empty if no route found within one-million step guard. Prefers direct destination, then origin metadata, then nearest forward collinear neighbor. Not a generic graph shortest path; no alive-only filtering/geometry mutation/IO.

The vertices from a to b along the constrained edges that realise the input constraint (a, b) — {a, b} when it is one edge, more when vertices lying on the segment or refinement split it. Empty when no such chain.

Here is the call graph for this function:

◆ enableProvenance()

template<class Storage >

void meshkit::BasicConstrainedDelaunay< Storage >::enableProvenance ( )

inline

Enable/reset optional origin bits for all currently stored vertices. Fills owned origin array with zero, discarding prior diagnostic bits; call after build. Allocates parallel storage, no geometry/topology mutation, source IO or concurrent access allowed.

◆ errorMsg()

template<class Storage >

String meshkit::BasicConstrainedDelaunay< Storage >::errorMsg ( ) const

inline

Copy the last explicitly recorded build/constraint diagnostic.

Returns: Owned/implicitly shared text, empty after a successful fresh build with no later diagnostic. Other operations may fail without setting it; successful constraint calls do not clear old errors. No topology mutation, IO or ownership transfer of internal storage.

Here is the caller graph for this function:

◆ inputVertexCount()

template<class Storage >

int meshkit::BasicConstrainedDelaunay< Storage >::inputVertexCount ( ) const

inline

Return the unique-input count recorded as the super-vertex base at successful build.

Returns: Stored count; meaningful only after successful build. Early failed rebuild can leave previous base while other arrays were cleared. No allocation/mutation; not total stored or active vertex count.

◆ insertConstraint()

template<class Storage >

bool meshkit::BasicConstrainedDelaunay< Storage >::insertConstraint	(	int	a,
		int	b
	)

Recover/mark a straight constraint, recursively splitting at exactly collinear existing vertices.

Parameters

[in]	a	Stored nonsuper endpoint index; negative/out-of-range rejected unless a==b early no-op.
[in]	b	Stored nonsuper endpoint, same frame; active consistent built topology required.

Returns: True when recovered or a==b, false on invalid indices/crossed existing constraint/stall/lost topology. Failure can leave prior flips/recursive pieces applied; no rollback. errorMsg is set only for selected failures and is not cleared on success. Constraint origin metadata tracks overlapping input pieces. Allocates queues/maps, mutates topology and invalidates borrowed array references; no new intersection vertex is invented, IO, retained arguments or concurrent mutation allowed.

Force the edge between two vertex ids into the triangulation and mark it constrained. Returns false when the edge cannot be recovered (it would cross another constraint).

Here is the call graph for this function:

◆ insertPoint()

template<class Storage >

int meshkit::BasicConstrainedDelaunay< Storage >::insertPoint ( const Point & p )

Insert one finite point in a live triangle, splitting a triangle/edge and restoring Delaunay edges.

Parameters

[in] p Borrowed finite XY query, unchanged; current consistent built topology required.

Returns: Stable new vertex ID, existing coincident located-triangle vertex ID, or -1 outside live triangles. Coincidence uses Point equality, not build's exact bit-key policy. No errorMsg assignment, full finite audit, budget/cancellation or rollback guarantee. Mutates arrays/topology/optional origins; does not independently update full constraint-origin metadata for arbitrary constrained-edge insertion. Caller uses dedicated segment split path where provenance is required. No IO or retained point.

Insert a new vertex at p (inside the current hull). Returns its id, or -1 when the point is outside every live triangle.

Here is the call graph for this function:

◆ isConstrained()

template<class Storage >

bool meshkit::BasicConstrainedDelaunay< Storage >::isConstrained	(	int	a,
		int	b
	)		const

Check whether a direct edge between two stored vertices is marked constrained.

Parameters

[in]	a	Valid stored vertex index, unchecked.
[in]	b	Valid stored vertex index, unchecked; active consistent incidence expected.

Returns: True for direct constrained edge in either direction, false otherwise. A subdivided chain does not count as one direct edge. Does not require returned triangle alive. No allocation/mutation.

True when the (min,max) vertex pair is a constrained edge.

◆ isSuperVertex()

template<class Storage >

bool meshkit::BasicConstrainedDelaunay< Storage >::isSuperVertex ( int v ) const

inline

Test whether an integer falls in the recorded three-super-vertex interval.

Parameters

[in] v Arbitrary candidate integer, range compared without storage indexing.

Returns: True iff m_superBase<=v<m_superBase+3; meaningful after successful build only. No allocation/mutation.

◆ isVertexActive()

template<class Storage >

bool meshkit::BasicConstrainedDelaunay< Storage >::isVertexActive ( int v ) const

inline

Test whether an in-range vertex has a nonnegative incident-triangle hint.

Parameters

[in] v Arbitrary integer index, bounds checked.

Returns: True for a retained incidence hint. Region deletion marks triangles dead without clearing all hints, so this does not alone prove incidence to a LIVE triangle after region operations. Read-only constant time, no allocation or state mutation.

Here is the call graph for this function:

◆ liveTriangleCount()

template<class Storage >

int meshkit::BasicConstrainedDelaunay< Storage >::liveTriangleCount ( ) const

Count slots whose alive flag is true, including super faces if still alive.

Returns: Nonnegative live-slot count maintained in constant time; not necessarily exported triangle count. No allocation/mutation, requires no concurrent edits.

◆ locate()

template<class Storage >

int meshkit::BasicConstrainedDelaunay< Storage >::locate ( const Point & p ) const

Locate a finite point and require its found triangle to be alive.

Parameters

[in] p Borrowed predicate-safe XY query, unchanged; on-edge ownership may select either neighbor.

Returns: Triangle slot or -1 for no found live face. Walk may traverse dead slots before testing final alive flag; not a nearest-face search. No allocation, cached hint update, topology mutation or input retention.

Index of the live triangle containing p (on an edge counts), -1 = none.

◆ orientExact()

template<class Storage >

double meshkit::BasicConstrainedDelaunay< Storage >::orientExact	(	const Point &	a,
		const Point &	b,
		const Point &	c
	)

static

Return adaptive-exact orientation sign after thread-safe one-time predicate initialization.

Parameters

[in]	a	Borrowed finite line origin, unchanged.
[in]	b	Borrowed finite line endpoint in same Cartesian XY frame, unchanged.
[in]	c	Borrowed finite query, unchanged.

Returns: Positive for left/CCW, negative for right, exact zero for collinearity within predicate numeric prerequisites. Magnitude is determinant-like, not normalized distance. Caller avoids extreme overflow/underflow inputs; no geometry conversion, source mutation or retained references.

Exact orientation of c against the line a->b: positive left, negative right, exactly zero when collinear.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refineQuality()

template<class Storage >

auto meshkit::BasicConstrainedDelaunay< Storage >::refineQuality ( const QualityOptions & opt )

Mutate live constrained triangulation by bounded size/angle/terrain refinement and optional coarsening.

Parameters

[in] opt Borrowed settings and synchronous callbacks, not retained after return. Call only after successful build, constraint insertion and dead-region removal. hAt receives XY and returns positive target edge length in XY units, <=0/NaN disables local size bound. minAngleDeg clamps to [0,60] degrees, finite intended; minEdge/terrainMinSpacing use XY units. Terrain activates only with terrainError, terrainElevationAt and positive terrainTolerance; elevations/residual/tolerance share one Z unit. terrainError receives borrowed three-point/height arrays and writable witness point, must initialize a finite useful witness for positive finite error; NaN means unknown coverage. terrainElevationAt results cache per vertex, unavailable samples become NaN. terrainErrorBound must certify nonnegative maximum residual INCLUDING coverage for coarsening; absent skips terrain coarsening. protectedLocation/protectedVertices gate coarsening, not all insertions/smoothing. Callbacks must not throw, reenter/mutate this object or race shared state; temporary pointers expire after each invocation. cancelled is polled periodically, not before every operation or smoothing step.

Returns: Report with inserted/split/reason counts, caps/cancellation, optional final terrain diagnostics and coarsening statistics. Capped/cancelled run RETAINS completed topology edits, no rollback. Caps are checked after insertions and count live slot growth; slight cell-limit overshoot is possible. Coarsening can still run after a cap unless cancelled, with per-vertex attempts clamped [1,10]. Unsplittable edges, small-angle exemptions, min spacing, numeric limits and resource caps can leave unresolved angle/size/terrain targets; report is not a quality-success certificate. terrainFinalCheck false leaves final residual counters zero without verification. Smoothing moves only free stars and runs before terrain placements when enabled; topology observer is removed on return. Allocates queues/grids/heights/cavity scratch and can grow arrays; exclude all concurrent mutation/queries. No engine/GDAL ownership, file access or unit conversion performed by kernel itself.

Delaunay refinement to the size and angle bounds (see the file comment). Call after the constraints are inserted and the exterior, holes and any other removed regions are dead; only live triangles are refined and new vertices never enter a dead region.

Here is the call graph for this function:

◆ removeExterior()

template<class Storage >

void meshkit::BasicConstrainedDelaunay< Storage >::removeExterior ( )

Mark super-touching faces and every unconstrained reachable neighbor dead. Requires successfully built constrained topology; insert closed boundaries first or all connected faces can be removed. Leaves vertex/triangle slots, adjacency and incidence hints allocated; does not compact arrays or clear every active hint. Allocates flood stack, mutates alive flags only, no error return, cancellation, source IO or concurrent queries during mutation.

Drop every triangle reachable from the super-triangle without crossing a constrained edge (the exterior of a constrained boundary).

◆ removeRegionAt()

template<class Storage >

int meshkit::BasicConstrainedDelaunay< Storage >::removeRegionAt ( const Point & p )

Mark the live constraint-bounded component containing a finite seed point dead.

Parameters

[in] p Borrowed XY seed, unchanged; on shared edge locate chooses a face, so use strict interior seed when ownership matters. Requires consistent built topology and predicate-safe coordinates.

Returns: Number newly dead, zero when no live containing face. Leaves coordinates/slots/adjacency/ incidence hints intact. Allocates flood stack, no geometry move, compaction, rollback, cancellation or IO. Returns how many triangles it removed.

◆ removeRegionLeftOf()

template<class Storage >

int meshkit::BasicConstrainedDelaunay< Storage >::removeRegionLeftOf	(	int	a,
		int	b
	)

Delete live constraint-bounded faces topologically seeded to a directed edge's left.

Parameters

[in]	a	Valid stored endpoint index, unchecked by edge lookup; stable built topology required.
[in]	b	Valid distinct endpoint index; orientation a-to-b defines left in XY frame.

Returns: Number newly marked dead, zero if no directly constrained edge pair or eligible left face. Current early isConstrained(a,b) test requires a direct edge, so a purely subdivided chain alone may return zero. Flood never crosses constraints; leaves slots/hints allocated. Allocates stacks/fans, mutates alive flags, no rollback/cancellation/IO or retained input references.

Drop the region (constraint-bounded component) containing p.

◆ removeSuperTriangles()

template<class Storage >

void meshkit::BasicConstrainedDelaunay< Storage >::removeSuperTriangles ( )

Mark only live faces touching one of the three super vertices dead. Leaves the unconstrained real-point hull and all storage/adjacency/incidence hints in place; no flood across neighbors or compaction. Requires successful build, exclusive mutation, no allocation/IO.

Drop only the triangles touching a super-triangle vertex, leaving the convex hull of the input (unconstrained use).

Here is the caller graph for this function:

◆ removeVertex()

template<class Storage >

bool meshkit::BasicConstrainedDelaunay< Storage >::removeVertex ( int v )

Transactionally remove a free post-build interior vertex and retriangulate its local cavity.

Parameters

[in] v Vertex index; invalid/inactive/input/super/segment vertices rejected by preparation.

Returns: True after local replacement committed, false with mesh unchanged for unsupported star, constraints/dead neighbors/failed ear clipping/legalization. Stars limited to 3..128 faces. No quality, size or terrain certification here: coarsening caller applies those gates before commit. Vertex ID storage remains stable/unreferenced rather than erasing coordinates. Allocates scratch arrays, no IO.

Remove a free, interior vertex inserted after build(). Transactional: failure leaves the mesh untouched. Input and constraint vertices are protected. Vertex ids stay stable; removed vertices become unreferenced.

◆ setFixedConstraint()

template<class Storage >

void meshkit::BasicConstrainedDelaunay< Storage >::setFixedConstraint	(	int	a,
		int	b
	)

Mark every recovered subedge of a requested constraint chain unsplittable for refinement.

Parameters

[in]	a	Valid stored endpoint index, unchecked.
[in]	b	Valid stored endpoint index, unchecked; corresponding constraint should already exist. Absent chain is no-op. Allocates chain/set storage, does not insert missing constraints or make arbitrary external insertPoint calls respect this flag. No IO or retained arguments.

Mark the input segment (a, b), already inserted with insertConstraint(), as unsplittable: refineQuality() never puts a vertex on it (a structured patch edge that must keep its stations).

Here is the call graph for this function:

◆ smallAngleExempt()

template<class Storage >

bool meshkit::BasicConstrainedDelaunay< Storage >::smallAngleExempt ( int t ) const

Test the shortest edge of a triangle for equal-radius input-corner shell exemption.

Parameters

[in] t Valid live triangle slot, unchecked.

Returns: True when its shortest edge endpoints belong to different input pieces sharing a corner and squared radii agree within roughly 0.1%. Does not itself compare triangle angle against a bound. Read-only, no allocation beyond helper metadata reads, no source mutation.

True when live triangle t is below the angle bound only because of a small input angle (Shewchuk's exemption: its shortest edge joins two segment vertices equidistant from the input vertex their segments share). For reporting and tests.

Here is the call graph for this function:

◆ terrainElevations()

template<class Storage >

const Vector< double > & meshkit::BasicConstrainedDelaunay< Storage >::terrainElevations ( ) const

inline

Borrow the most recent refinement's cached per-vertex elevation samples.

Returns: Const reference, empty after build/before sampling, possibly shorter than vertices or holding NaN/unqueried infinity sentinels. Values use callback Z units; not a complete terrain-coverage proof. Lifetime bounded by owner/no mutation, no ownership transfer or allocation.

◆ touchesFixed()

template<class Storage >

bool meshkit::BasicConstrainedDelaunay< Storage >::touchesFixed ( int t ) const

Test whether any triangle vertex participates in a marked fixed constrained edge.

Parameters

[in] t Valid live triangle slot, unchecked; consistent incidence topology required.

Returns: True for fixed-edge participation through any vertex star, false with no fixed set/hit. This includes nearby triangle edges not themselves fixed. Allocates local fans, no topology mutation.

True when a vertex of live triangle t lies on a fixed segment (see setFixedConstraint). For reporting and tests.

Here is the call graph for this function:

◆ triangles()

template<class Storage >

const Vector< Triangle > & meshkit::BasicConstrainedDelaunay< Storage >::triangles ( ) const

inline

Borrow all triangle slots with alive flags, adjacency and opposite-edge constraints.

Returns: Const reference including dead exterior/hole/removed slots; consumers filter alive and super vertices as needed. Mutation can rewrite/reallocate slots; lifetime bounded by owner/current immutable state. No ownership transfer, allocation or thread synchronization.

Here is the caller graph for this function:

◆ vertexOrigins()

template<class Storage >

const Vector< std::uint32_t > & meshkit::BasicConstrainedDelaunay< Storage >::vertexOrigins ( ) const

inline

Borrow diagnostic origin storage from this triangulation.

Returns: Const reference, empty when disabled/reset by build. Values index stored vertices; unused trailing diagnostic entries can remain after coincident insertion. No guarantee of causal cell-count explanation. Reference/elements valid only while owner lives and no mutating operation invalidates storage; concurrent access requires immutable owner. No ownership transfer or allocation.

◆ vertices()

template<class Storage >

const Vector< Point > & meshkit::BasicConstrainedDelaunay< Storage >::vertices ( ) const

inline

Borrow all stored XY positions including super, inactive and newly inserted vertices.

Returns: Const owned-array reference; IDs are indices, not a compact active-only list. Valid while owner lives, invalidated by rebuilding/insertion/reallocation; smoothing changes positions. No ownership transfer, allocation or source mutation. Caller excludes concurrent mutable access.

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

/home/runner/work/openswmm.gui/openswmm.gui/libraries/meshkit/include/meshkit/cdt.hpp
/home/runner/work/openswmm.gui/openswmm.gui/libraries/meshkit/src/native/cdt_impl.hpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Member Typedef Documentation

◆ Box

◆ Hash

◆ MultiHash

◆ Point

◆ PointInput

◆ Set

◆ String

◆ Vector

Member Enumeration Documentation

◆ Origin

Member Function Documentation

◆ addVertexOrigin()

◆ build()

◆ constrainedChain()

◆ enableProvenance()

◆ errorMsg()

◆ inputVertexCount()

◆ insertConstraint()

◆ insertPoint()

◆ isConstrained()

◆ isSuperVertex()

◆ isVertexActive()

◆ liveTriangleCount()

◆ locate()

◆ orientExact()

◆ refineQuality()

◆ removeExterior()

◆ removeRegionAt()

◆ removeRegionLeftOf()

◆ removeSuperTriangles()

◆ removeVertex()

◆ setFixedConstraint()

◆ smallAngleExempt()

◆ terrainElevations()

◆ touchesFixed()

◆ triangles()

◆ vertexOrigins()

◆ vertices()