geom Namespace Reference

All classes and functions in the computational geometry package are defined in the geom namespace. More...

Classes
class	RegularGrid
	A regular grid in N-D. More...
class	Ball
	A ball in N dimensional space. More...
class	BBox
	An axes-oriented bounding box in the specified dimension. More...
class	Circle3
	A circle in 3-dimensional space. More...
class	CircularArc3
	A circular arc in 3-dimensional space. More...
class	Interval
	An axes-oriented interval in the specified dimension. More...
class	Line_2
	A line in 2-D. More...
class	ParametrizedLine
	A parametrized line in N-D. More...
class	ParametrizedPlane
	A parametrized plane in N-D. More...
class	Plane
	A plane in 3 dimensions. More...
class	Segment
	A segment in N dimensional space. More...
class	SegmentMath
	A segment in N dimensional space designed for doing math operations. More...
class	SemiOpenInterval
	An axes-oriented semi-open interval in N dimensions. More...
class	Triangle
	A class for a triangle in N dimensions. More...
class	IndSimpSet
	Class for a mesh that stores vertices and indexed simplices. More...
class	IndSimpSetIncAdj
	An indexed simplex set that stores vertex-simplex incidences and simplex adjacencies. More...
class	ISS_Interpolate
	Interpolation for an indexed simplex set with fields at the vertices. More...
class	ISS_Distance
	Functor that returns the distance to a mesh. More...
class	ISS_SD_Distance
	Functor that returns the signed distance to an (N-1)-D mesh in N-D space. More...
class	ISS_SD_ClosestPoint
	Functor that returns the closest point to an (N-1)-D mesh in N-D space. More...
class	ISS_SD_ClosestPointDirection
	Functor that returns the closest point along a specified direction to an (N-1)-D mesh in N-D space. More...
class	ISS_SD_CloserPointDirection
	Functor that returns the closest point along a specified direction to an (N-1)-D mesh in N-D space. More...
class	ISS_SD_CloserPoint
	Functor that returns a closer point to an (N-1)-D mesh in N-D space. More...
class	ISS_SimplexQuery
	Simplex queries on an indexed simplex set. More...
class	ISS_VertexField
	Indexed simplex set with fields at the vertices. More...
class	IssiaFaceIterator
	Face iterator in an indexed simplex set (mesh). More...
class	PointsOnManifold< 3, 2, 1, T >
	Feature-based manifold data structure. More...
class	PointsOnManifold< _N, 1, 1, T >
	Feature-based manifold data structure. More...
class	SimplexAdj
	Simplex-simplex adjacencies in an M-D indexed simplex set. More...
class	SimplexIterator
	A simplex iterator for a mesh. More...
class	VertexSimplexInc
	Vertex-simplex incidences in an M-D indexed simplex set. More...
class	ComplexWithFreeVertex
	A local simplicial complex with a free node at the center. More...
class	ComplexContentConstraint
	Functor that evaluates the content constraint for a local simplicial mesh. More...
class	ComplexNorm2
	Functor that evaluates the 2-norm of the quality metric for a local simplicial mesh. More...
class	ComplexNorm2Mod
	Functor that evaluates the 2-norm of the modified quality metric for a local simplicial mesh. More...
class	ComplexWithFreeVertexOnManifoldBase
	A base class for a local simplicial complex with a free node on a manifold. More...
class	ComplexWithFreeVertexOnManifold< QF, N, 1, _Manifold, T >
	A local simplicial complex with a free node on a manifold. More...
class	ComplexWithFreeVertexOnManifold< QF, N, 2, _Manifold, T >
	A local simplicial complex with a free node on a manifold. More...
class	ComplexManifoldNorm2
	Functor that evaluates the 2-norm of the quality metric for a local simplicial mesh. More...
class	ComplexManifoldNorm2Mod
	Functor that evaluates the 2-norm of the modified quality metric for a local simplicial mesh. More...
class	SimplexDeterminant
	Functor for the determinant of the Jacobian matrix. More...
class	SimplexContent
	Functor for the content of a simplex. More...
class	SimplexMinimumEdgeLength
	Functor for the minimum edge length of a simplex. More...
class	SimplexMaximumEdgeLength
	Functor for the minimum edge length of a simplex. More...
class	SimplexAdjJac
	Implements operations for the adjoint Jacobian matrix of a simplex. More...
class	SimplexAdjJacQF
	Quality function of the Jacobian and its adjoint. More...
class	SimplexCondNum
	Implements the condition number quality metric. More...
class	SimplexJacStaticData
	Base class with const data. More...
class	SimplexJac
	Implements operations for the Jacobian matrix of a simplex. More...
class	SimplexJacQF
	Simplex quality functions of the Jacobian matrix. More...
class	SimplexMeanRatio
	Implements the mean ratio quality metric. More...
class	SimplexModCondNum
	Implements the modified condition number quality metric. More...
class	SimplexModDet
	Implements operations for modifying the determinant of the Jacobian. More...
class	SimplexModMeanRatio
	Implements the mean ratio quality metric. More...
class	SimplexWithFreeVertex
	A simplex with a free vertex. More...
class	EdgeIterator
	An iterator on edges in a simplicial mesh. More...
class	EdgeRemoval
	Edge removal in a tetrahedral mesh. More...
class	FaceIterator
	An iterator of faces in a simplicial mesh. More...
class	FaceRemoval
	Edge removal in a tetrahedral mesh. More...
class	IsNotSharpAngle
	Functor that returns true iff the boundary angle is not sharp. More...
class	Node_AllIncCells
	Node in a simplicial mesh that stores iterators to all incident cells. More...
class	Node_OneIncCell
	Vertex in a simplicial mesh that stores one cell incidence. More...
class	Node_VertSelf
	A node in a simplicial mesh that stores a vertex and an iterator to itself. More...
class	Node_VertSelfId
	A node in a simplicial mesh that stores a vertex, an iterator to itself, and an identifier. More...
class	SimpMeshRed
	A simplicial mesh data structure. More...
class	SmrCell
	Cell in a simplicial mesh that stores handles to the adjacent cells. More...
class	SmrNode
	Node in a simplicial mesh that stores iterators to all incident cells. More...
class	StructuredGrid
	Class for a structured grid. More...
class	CellArray
	A cell array in N-D. More...
class	CellArrayBase
	Base class for a cell array in N-D. More...
class	CellArrayStatic
	A static cell array in N-D. More...
class	BinarySearch
	Binary search of records in the final coordinate. More...
class	CellBinarySearch
	A cell array in combined with a binary search in the final coordinate. More...
class	ForwardSearch
	Data structure for performing forward searching on records. More...
class	CellForwardSearch
	A cell array in combined with a forward search in the final coordinate. More...
class	ForwardSearchKey
	Data structure for performing forward searching on the keys of records. More...
class	CellForwardSearchKey
	A cell array in combined with a forward search on keys in the final coordinate. More...
class	Search
	Base class for a search structure in the final coordinate. More...
class	CellSearch
	Base class for a cell array combined with a search structure. More...
class	KDTreeNode
	Abstract base class for nodes in a KDTree. More...
class	KDTreeLeaf
	Class for a leaf in a KDTree. More...
class	KDTreeBranch
	Class for an internal node in a KDTree. More...
class	KDTree
	A kd-tree in N-D. More...
class	OctreeNode
	A node in an octree. More...
class	OctreeBranch
	A branch in an octree. More...
class	OctreeLeaf
	A leaf in an octree. More...
class	Octree
	An octree in 3-D. More...
class	ORQ
	Base class for an orthogonal range query data structure in N-D. More...
class	Placebo
	A placebo for ORQ's in N-D. More...
class	PlaceboCheck
	A placebo for ORQ's in N-D. More...
class	SequentialScan
	The sequential scan algorithm for ORQ's in N-D. More...
class	SortFirst
	A sorted vector of records in N-D. More...
class	SortFirstDynamic
	A sorted vector of records in N-D. More...
class	SortProject
	A sorted vector of records in N-D. More...
class	SortRankProject
	A sorted and ranked vector of grid elements in N-D. More...
struct	IndexAndCell
	An index and cell for holding records. More...
class	SparseCellVector
	A vector of sparse cells. More...
class	SparseCellArray
	A sparse cell array in N-D. More...
class	CyclicIndex
	A class for a cyclic index. More...
class	IndexedEdgePolyhedron
	Class for an indexed edge polyhedron in 3-D. More...
class	ScanConversionPolygon
	Class for a polygon in 2-D. More...
class	ScanConversionPolyhedron
	A class for a polyhedron in 3-D designed for scan conversion. More...
class	DistributedOrthtree
	An orthtree that uses distributed-memory concurrency. More...
class	LevelCoordinatesComposite< 2, _NumberOfLevels >
struct	MergeNull
	Merging functor that does nothing. More...
struct	MergeCopyFirst
	Merging functor that copies the value of the first child. More...
struct	MergeAverage
	Merging functor that averages the values of the children. More...
class	OrthtreeElementNull
	A null element. It holds no data. More...
struct	RefineNull
	Refinement functor that does nothing. More...
struct	CoarsenNull
	Coarsening functor that does nothing. More...
class	OrthtreeMap
	An orthant tree that uses std::map . More...
class	SpatialIndex
	N-D spatial index that uses both interlaced and non-interlaced representations. More...
struct	SplitNull
	Splitting functor that does nothing. More...
struct	SplitCopy
	Splitting functor that copies the value of the parent. More...
class	BBoxTreeTypes
	Define types for a BBoxTree. More...
class	BBoxTreeNode
	Abstract base class for nodes in a BBoxTree. More...
class	BBoxTreeLeaf
	Class for a leaf in a BBoxTree. More...
class	BBoxTreeBranch
	Class for an internal node in a BBoxTree. More...
class	BBoxTree
	A bounding box tree in N-D. More...
Functions
template<int N, int M, typename T >
void	readAscii (std::istream &in, IndSimpSet< N, M, true, T > *mesh)
	Read a mesh in ascii format.
template<int N, int M, typename T >
void	writeAscii (std::ostream &out, const IndSimpSet< N, M, true, T > &mesh)
	Write a mesh in ascii format.
template<typename T >
void	computeClosestPoint (const Circle3< T > &circle, typename Circle3< T >::Point x, typename Circle3< T >::Point *closestPoint)
	Compute the closest point on the circle.
template<typename T >
void	computeClosestPoint (const Circle3< T > &circle, const typename Circle3< T >::Point &source, const typename Circle3< T >::Point &target, typename Circle3< T >::Point *closestPoint, T tolerance=std::sqrt(std::numeric_limits< T >::epsilon()), int maximumSteps=10)
	Compute the closest point on the circle to the edge.
template<typename T >
void	computeClosestPoint (const CircularArc3< T > &circularArc, typename CircularArc3< T >::Point x, typename CircularArc3< T >::Point *closestPoint)
	Compute the closest point on the circular arc.
template<typename T >
void	computeClosestPoint (const Circle3< T > &circle, const CircularArc3< T > &circularArc, typename CircularArc3< T >::Point *closestPoint, T tolerance=std::sqrt(std::numeric_limits< T >::epsilon()), int maximumSteps=10)
	Compute the closest point on the circle to the circular arc.
template<std::size_t N, typename T >
T	computeDistance (const std::tr1::array< T, N > &x, const std::tr1::array< T, N > &y)
	Return the distance between the points x and y.
template<std::size_t N, typename T >
T	computeDistance (const std::tr1::array< std::tr1::array< T, N >, 2 > &x)
	Return the distance between the points x[0] and x[1].
template<std::size_t N, typename T >
T	computeContent (const std::tr1::array< T, N > &x, const std::tr1::array< T, N > &y)
	Return the distance between the points x and y.
template<std::size_t N, typename T >
T	computeContent (const std::tr1::array< std::tr1::array< T, N >, 2 > &x)
	Return the distance between the points x[0] and x[1].
template<std::size_t N, typename T >
void	computeGradientOfDistance (const std::tr1::array< T, N > &x, const std::tr1::array< T, N > &y, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to x) of the distance between the points x and y.
template<std::size_t N, typename T >
void	computeGradientOfDistance (const std::tr1::array< std::tr1::array< T, N >, 2 > &x, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to x[0]) of the distance between the points x[0] and x[1].
template<std::size_t N, typename T >
void	computeGradientOfContent (const std::tr1::array< T, N > &x, const std::tr1::array< T, N > &y, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to x) of the distance between the points x and y.
template<std::size_t N, typename T >
void	computeGradientOfContent (const std::tr1::array< std::tr1::array< T, N >, 2 > &x, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to x[0]) of the distance between the points x[0] and x[1].
template<typename T >
T	computeArea (const std::tr1::array< T, 2 > &a, const std::tr1::array< T, 2 > &b, const std::tr1::array< T, 2 > &c)
	Return the area of the triangle with points a, b and c.
template<typename T >
T	computeArea (const std::tr1::array< std::tr1::array< T, 2 >, 3 > &p)
	Return the area of the triangle with points p[0], p[1] and p[2].
template<typename T >
T	computeArea (const std::tr1::array< T, 3 > &a, const std::tr1::array< T, 3 > &b, const std::tr1::array< T, 3 > &c)
	Return the area of the triangle with points a, b and c.
template<typename T >
T	computeArea (const std::tr1::array< std::tr1::array< T, 3 >, 3 > &p)
	Return the area of the triangle with points p[0], p[1] and p[2].
template<std::size_t N, typename T >
T	computeContent (const std::tr1::array< T, N > &a, const std::tr1::array< T, N > &b, const std::tr1::array< T, N > &c)
	Return the area of the triangle with points a, b and c.
template<std::size_t N, typename T >
T	computeContent (const std::tr1::array< std::tr1::array< T, N >, 3 > &p)
	Return the area of the triangle with points p[0], p[1] and p[2].
template<typename T >
void	computeGradientOfArea (const std::tr1::array< T, 2 > &a, const std::tr1::array< T, 2 > &b, const std::tr1::array< T, 2 > &c, std::tr1::array< T, 2 > *gradient)
	Calculate the gradient (with respect to a) of the area of the triangle with points a, b and c.
template<typename T >
void	computeGradientOfArea (const std::tr1::array< T, 3 > &a, const std::tr1::array< T, 3 > &b, const std::tr1::array< T, 3 > &c, std::tr1::array< T, 3 > *gradient)
	Calculate the gradient (with respect to a) of the area of the triangle with points a, b and c.
template<std::size_t N, typename T >
void	computeGradientOfArea (const std::tr1::array< std::tr1::array< T, N >, 3 > &p, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to a) of the area of the triangle with points p[0], p[1] and p[2].
template<std::size_t N, typename T >
void	computeGradientOfContent (const std::tr1::array< T, N > &a, const std::tr1::array< T, N > &b, const std::tr1::array< T, N > &c, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to a) of the area of the triangle with points a, b and c.
template<std::size_t N, typename T >
void	computeGradientOfContent (const std::tr1::array< std::tr1::array< T, N >, 3 > &p, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to a) of the area of the triangle with points p[0], p[1] and p[2].
template<std::size_t N, typename T >
T	computeVolume (const std::tr1::array< T, N > &a, const std::tr1::array< T, N > &b, const std::tr1::array< T, N > &c, const std::tr1::array< T, N > &d)
	Return the volume of the tetrahedron with points a, b, c and d.
template<std::size_t N, typename T >
T	computeVolume (const std::tr1::array< std::tr1::array< T, N >, 4 > &p)
	Return the volume of the tetrahedron with points p[0], p[1], p[2] and p[3].
template<std::size_t N, typename T >
T	computeContent (const std::tr1::array< T, N > &a, const std::tr1::array< T, N > &b, const std::tr1::array< T, N > &c, const std::tr1::array< T, N > &d)
	Return the volume of the tetrahedron with points a, b, c and d.
template<std::size_t N, typename T >
T	computeContent (const std::tr1::array< std::tr1::array< T, N >, 4 > &p)
	Return the volume of the tetrahedron with points p[0], p[1], p[2] and p[3].
template<typename T >
void	computeGradientOfVolume (const std::tr1::array< T, 3 > &a, const std::tr1::array< T, 3 > &b, const std::tr1::array< T, 3 > &c, const std::tr1::array< T, 3 > &d, std::tr1::array< T, 3 > *gradient)
	Calculate the gradient (with respect to a) of the volume of the tetrahedron with points a, b, c and d.
template<std::size_t N, typename T >
void	computeGradientOfVolume (const std::tr1::array< std::tr1::array< T, N >, 4 > &p, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to a) of the volume of the tetrahedron with points p[0], p[1], p[2] and p[3].
template<std::size_t N, typename T >
void	computeGradientOfContent (const std::tr1::array< T, N > &a, const std::tr1::array< T, N > &b, const std::tr1::array< T, N > &c, const std::tr1::array< T, N > &d, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to a) of the volume of the tetrahedron with points a, b, c and d.
template<std::size_t N, typename T >
void	computeGradientOfContent (const std::tr1::array< std::tr1::array< T, N >, 4 > &p, std::tr1::array< T, N > *gradient)
	Calculate the gradient (with respect to a) of the volume of the tetrahedron with points p[0], p[1], p[2] and p[3].
template<std::size_t N, typename T >
T	computeUpperBoundOnSignedDistance (const BBox< N, T > &box, const typename BBox< N, T >::Point &x)
	Return an upper bound on the signed distance from the point to the objects in the box.
template<std::size_t N, typename T >
T	computeLowerBoundOnSignedDistance (const BBox< N, T > &box, const typename BBox< N, T >::Point &x)
	Return an lower bound on the signed distance from the point to the objects in the box.
template<std::size_t N, typename T >
T	computeUpperBoundOnUnsignedDistance (const BBox< N, T > &box, const typename BBox< N, T >::Point &x)
	Return an upper bound on the signed distance.
template<std::size_t N, typename T >
T	computeLowerBoundOnUnsignedDistance (const BBox< N, T > &box, const typename BBox< N, T >::Point &x)
	Return a lower bound on the signed distance.
template<typename T >
T	computeOrientationDeterminant (const std::tr1::array< T, 2 > &a, const std::tr1::array< T, 2 > &b, const std::tr1::array< T, 2 > &c)
	Compute the orientation determinant.
template<typename T >
T	computeInCircleDeterminant (const std::tr1::array< T, 2 > &a, const std::tr1::array< T, 2 > &b, const std::tr1::array< T, 2 > &c, const std::tr1::array< T, 2 > &d)
	Compute the in-circle determinant.
template<typename T >
bool	isInCircle (const std::tr1::array< T, 2 > &a, const std::tr1::array< T, 2 > &b, const std::tr1::array< T, 2 > &c, const std::tr1::array< T, 2 > &d)
	Return true if d is inside the circle with a, b, and c on its boundary.
template<typename T >
void	computeAnOrthogonalVector (const std::tr1::array< T, 3 > &vector, std::tr1::array< T, 3 > *orthogonal)
	Compute an orthogonal vector.
template<typename T >
int	computeSignOfTurn (const std::tr1::array< T, 2 > &p, const std::tr1::array< T, 2 > &q, const std::tr1::array< T, 2 > &r)
	Positive turn: return 1. No turn: return 0. Negative turn: return -1.
template<typename T >
int	computeApproximateSignOfTurn (const std::tr1::array< T, 2 > &p, const std::tr1::array< T, 2 > &q, const std::tr1::array< T, 2 > &r)
	Positive turn: return 1. No turn: return 0. Negative turn: return -1.
template<typename T >
T	computePseudoAngle (const std::tr1::array< T, 2 > &vec)
	Return the pseudo-angle between vec and the x axis.
template<std::size_t N, typename T >
T	computeAngle (const std::tr1::array< T, N > &a, const std::tr1::array< T, N > &b)
	Return the angle between the two vectors.
template<typename T >
void	rotatePiOver2 (std::tr1::array< T, 2 > *p)
	Rotate the vector + pi / 2.
template<typename T >
void	rotateMinusPiOver2 (std::tr1::array< T, 2 > &p)
	Rotate the vector - pi / 2.
template<typename T , class ISS >
void	applyBoundaryCondition (IndSimpSetIncAdj< 2, 1, T > *mesh, const ISS_SD_ClosestPoint< ISS > &condition, std::size_t n)
	Apply the closest point boundary condition at a vertex.
template<typename T , class ISS >
void	applyBoundaryCondition (IndSimpSetIncAdj< 2, 1, T > *mesh, const ISS_SD_ClosestPointDirection< ISS > &condition, std::size_t n)
	Apply the closest point in the normal direction boundary condition at a vertex.
template<typename T , class ISS >
void	applyBoundaryCondition (IndSimpSetIncAdj< 3, 2, T > *mesh, const ISS_SD_ClosestPoint< ISS > &condition, std::size_t n)
	Apply the closest point boundary condition at a vertex.
template<typename T , class ISS >
void	applyBoundaryCondition (IndSimpSetIncAdj< 3, 2, T > *mesh, const ISS_SD_ClosestPointDirection< ISS > &condition, std::size_t n)
	Apply the closest point in the normal direction boundary condition at a vertex.
template<std::size_t N, typename T , class UnaryFunction >
void	applyBoundaryCondition (IndSimpSetIncAdj< N, N, T > *mesh, const UnaryFunction &condition, std::size_t n)
	Apply the condition at a vertex.
template<std::size_t N, typename T , class ISS >
void	applyBoundaryCondition (IndSimpSetIncAdj< N, N, T > *mesh, const ISS_SD_ClosestPoint< ISS > &condition, std::size_t n)
	Apply the closest point boundary condition at a vertex.
template<std::size_t N, typename T , class ISS >
void	applyBoundaryCondition (IndSimpSetIncAdj< N, N, T > *mesh, const ISS_SD_CloserPoint< ISS > &condition, std::size_t n)
	Apply the closer point boundary condition at a vertex.
template<std::size_t N, typename T , class ISS >
void	applyBoundaryCondition (IndSimpSetIncAdj< N, N, T > *mesh, const ISS_SD_ClosestPointDirection< ISS > &condition, std::size_t n)
	Apply the closest point in the normal direction boundary condition at a vertex.
template<std::size_t N, typename T , class ISS >
void	applyBoundaryCondition (IndSimpSetIncAdj< N, N, T > *mesh, const ISS_SD_CloserPointDirection< ISS > &condition, std::size_t n)
	Apply the closer point in the normal direction boundary condition at a vertex.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter , typename OutputIterator >
void	computeMeanRatio (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, OutputIterator output)
	Calculate the mean ratio function for each simplex in the mesh.
template<std::size_t M, typename T , typename SimpInIter , typename OutputIterator >
void	computeMeanRatio (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, OutputIterator output)
	Calculate the mean ratio function for each simplex in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter , typename OutputIterator >
void	computeModifiedMeanRatio (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, OutputIterator output)
	Calculate the modified mean ratio function for each simplex in the mesh.
template<std::size_t M, typename T , typename SimpInIter , typename OutputIterator >
void	computeModifiedMeanRatio (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, OutputIterator output)
	Calculate the modified mean ratio function for each simplex in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter , typename OutputIterator >
void	computeConditionNumber (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, OutputIterator output)
	Calculate the condition number function for each simplex in the mesh.
template<std::size_t M, typename T , typename SimpInIter , typename OutputIterator >
void	computeConditionNumber (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, OutputIterator output)
	Calculate the condition number function for each simplex in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter , typename OutputIterator >
void	computeModifiedConditionNumber (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, OutputIterator output)
	Calculate the modified condition number function for each simplex in the mesh.
template<std::size_t M, typename T , typename SimpInIter , typename OutputIterator >
void	computeModifiedConditionNumber (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, OutputIterator output)
	Calculate the modified condition number function for each simplex in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter , typename OutputIterator >
void	computeContent (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, OutputIterator output)
	Calculate the content for each simplex in the mesh.
template<std::size_t M, typename T , typename SimpInIter , typename OutputIterator >
void	computeContent (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, OutputIterator output)
	Calculate the content for each simplex in the mesh.
template<typename _T >
IndSimpSetIncAdj< 2, 1, _T > ::Number	computeSignedDistance (const IndSimpSetIncAdj< 2, 1, _T > &mesh, const std::vector< typename IndSimpSetIncAdj< 2, 1, _T >::Number > &squaredHalfLengths, const typename IndSimpSetIncAdj< 2, 1, _T >::Vertex &point, typename IndSimpSetIncAdj< 2, 1, _T >::Vertex *closestPoint)
	Compute the signed distance to the mesh and closest point on the mesh.
template<typename _T >
IndSimpSetIncAdj< 2, 1, _T > ::Number	computeSignedDistance (const IndSimpSetIncAdj< 2, 1, _T > &mesh, const typename IndSimpSetIncAdj< 2, 1, _T >::Vertex &point, typename IndSimpSetIncAdj< 2, 1, _T >::Vertex *closestPoint)
	Compute the signed distance to the mesh and closest point on the mesh.
template<typename _T >
IndSimpSetIncAdj< 2, 1, _T > ::Number	computeSignedDistance (const IndSimpSetIncAdj< 2, 1, _T > &mesh, const typename IndSimpSetIncAdj< 2, 1, _T >::Vertex &point)
	Compute the signed distance to the mesh.
template<typename _T , typename InputIterator , typename NumberOutputIterator , typename PointOutputIterator >
void	computeSignedDistance (const IndSimpSetIncAdj< 2, 1, _T > &mesh, InputIterator pointsBeginning, InputIterator pointsEnd, NumberOutputIterator distances, PointOutputIterator closestPoints)
	Compute the signed distances to the mesh and closest points on the mesh.
template<typename _T , typename InputIterator , typename NumberOutputIterator >
void	computeSignedDistance (const IndSimpSetIncAdj< 2, 1, _T > &mesh, InputIterator pointsBeginning, InputIterator pointsEnd, NumberOutputIterator distances)
	Compute the signed distances to the mesh and closest points on the mesh.
template<typename _T >
IndSimpSetIncAdj< 3, 2, _T > ::Number	computeSignedDistance (const IndSimpSetIncAdj< 3, 2, _T > &mesh, const std::vector< typename IndSimpSetIncAdj< 3, 2, _T >::Number > &squaredLongestEdgeLengths, const typename IndSimpSetIncAdj< 3, 2, _T >::Vertex &point, typename IndSimpSetIncAdj< 3, 2, _T >::Vertex *closestPoint)
	Compute the signed distance to the mesh and closest point on the mesh.
template<typename _T >
IndSimpSetIncAdj< 3, 2, _T > ::Number	computeSignedDistance (const IndSimpSetIncAdj< 3, 2, _T > &mesh, const typename IndSimpSetIncAdj< 3, 2, _T >::Vertex &point, typename IndSimpSetIncAdj< 3, 2, _T >::Vertex *closestPoint)
	Compute the signed distance to the mesh and closest point on the mesh.
template<typename _T >
IndSimpSetIncAdj< 3, 2, _T > ::Number	computeSignedDistance (const IndSimpSetIncAdj< 3, 2, _T > &mesh, const typename IndSimpSetIncAdj< 3, 2, _T >::Vertex &point)
	Compute the signed distance to the mesh.
template<typename _T , typename InputIterator , typename NumberOutputIterator , typename PointOutputIterator >
void	computeSignedDistance (const IndSimpSetIncAdj< 3, 2, _T > &mesh, InputIterator pointsBeginning, InputIterator pointsEnd, NumberOutputIterator distances, PointOutputIterator closestPoints)
	Compute the signed distances to the mesh and closest points on the mesh.
template<typename _T , typename InputIterator , typename NumberOutputIterator >
void	computeSignedDistance (const IndSimpSetIncAdj< 3, 2, _T > &mesh, InputIterator pointsBeginning, InputIterator pointsEnd, NumberOutputIterator distances)
	Compute the signed distances to the mesh and closest points on the mesh.
template<std::size_t N, typename PtForIter , typename PtOutIter , typename IntOutIter , typename T >
void	buildDistinctPoints (PtForIter pointsBeginning, PtForIter pointsEnd, PtOutIter distinctPointsOutput, IntOutIter indicesOutput, const T minDistance)
	From a set of points, generate an indexed set of distinct points.
template<std::size_t N, typename PtForIter , typename PtOutIter , typename IntOutIter >
void	buildDistinctPoints (PtForIter pointsBeginning, PtForIter pointsEnd, PtOutIter distinctPoints, IntOutIter indices)
	From a set of points, generate an indexed set of distinct points.
template<std::size_t N, std::size_t M, typename T >
void	removeDuplicateVertices (IndSimpSet< N, M, T > *x, T minDistance)
	Remove duplicate vertices.
template<std::size_t N, std::size_t M, typename T >
void	removeDuplicateVertices (IndSimpSet< N, M, T > *x)
	Remove duplicate vertices.
template<std::size_t N, std::size_t M, typename VertForIter , typename ISForIter >
void	writeIssAscii (std::ostream &out, VertForIter verticesBeginning, VertForIter verticesEnd, ISForIter indexedSimplicesBeginning, ISForIter indexedSimplicesEnd)
	Write an indexed simplex set in ascii format.
template<std::size_t N, std::size_t M, typename VertForIter , typename ISForIter >
void	writeIssBinary (std::ostream &out, VertForIter verticesBeginning, VertForIter verticesEnd, ISForIter indexedSimplicesBeginning, ISForIter indexedSimplicesEnd)
	Write an indexed simplex set in binary format.
template<std::size_t N, std::size_t M, typename VertForIter , typename ISForIter , typename ContainerIter , typename StringIter >
void	writeIssAndCellDataVtkXml (std::ostream &out, VertForIter verticesBeginning, VertForIter verticesEnd, ISForIter indexedSimplicesBeginning, ISForIter indexedSimplicesEnd, ContainerIter cellDataContainersBeginning, ContainerIter cellDataContainersEnd, StringIter dataNamesBeginning, StringIter dataNamesEnd)
	Write in VTK XML unstructured grid format with a cell field.
template<std::size_t N, std::size_t M, typename VertForIter , typename ISForIter >
void	writeIssVtkXml (std::ostream &out, VertForIter verticesBeginning, VertForIter verticesEnd, ISForIter indexedSimplicesBeginning, ISForIter indexedSimplicesEnd)
	Write in VTK XML unstructured grid format.
template<std::size_t N, std::size_t M, typename VertForIter , typename ISForIter >
void	writeIssVtkLegacy (std::ostream &out, VertForIter verticesBeginning, VertForIter verticesEnd, ISForIter indexedSimplicesBeginning, ISForIter indexedSimplicesEnd, std::string title="")
	Write in legacy VTK unstructured grid format.
template<typename T >
IndSimpSetIncAdj< 2, 1, T >::Vertex	computeVertexNormal (const IndSimpSetIncAdj< 2, 1, T > &mesh, std::size_t n)
	Return the outward normal at the specified vertex.
template<typename T >
void	computeVertexNormal (const IndSimpSetIncAdj< 2, 1, T > &mesh, std::size_t n, typename IndSimpSetIncAdj< 2, 1, T >::Vertex *normal)
	Compute the outward normal at the specified vertex.
template<typename T >
IndSimpSetIncAdj< 2, 2, T >::Vertex	computeVertexNormal (const IndSimpSetIncAdj< 2, 2, T > &mesh, std::size_t n)
	Return the outward normal at the specified boundary vertex.
template<typename T >
void	computeVertexNormal (const IndSimpSetIncAdj< 2, 2, T > &mesh, std::size_t n, typename IndSimpSetIncAdj< 2, 2, T >::Vertex *normal)
	Compute the outward normal at the specified boundary vertex.
template<typename T >
IndSimpSetIncAdj< 3, 2, T >::Vertex	computeVertexNormal (const IndSimpSetIncAdj< 3, 2, T > &mesh, std::size_t n)
	Return the outward normal at the specified vertex.
template<typename T >
void	computeVertexNormal (const IndSimpSetIncAdj< 3, 2, T > &mesh, std::size_t n, typename IndSimpSetIncAdj< 3, 2, T >::Vertex *normal)
	Compute the outward normal at the specified vertex.
template<typename T >
IndSimpSetIncAdj< 3, 3, T >::Vertex	computeVertexNormal (const IndSimpSetIncAdj< 3, 3, T > &mesh, std::size_t n)
	Return the outward normal at the specified boundary vertex.
template<typename T >
void	computeVertexNormal (const IndSimpSetIncAdj< 3, 3, T > &mesh, std::size_t n, typename IndSimpSetIncAdj< 3, 3, T >::Vertex *normal)
	Compute the outward normal at the specified boundary vertex.
template<typename T >
void	computeSimplexNormal (const IndSimpSetIncAdj< 3, 2, T > &mesh, std::size_t simplexIndex, typename IndSimpSetIncAdj< 3, 2, T >::Vertex *simplexNormal)
	Compute the outward normal for the specified simplex (triangle face).
template<typename T >
void	computeSimplexNormals (const IndSimpSetIncAdj< 3, 2, T > &mesh, std::vector< typename IndSimpSetIncAdj< 3, 2, T >::Vertex > *simplexNormals)
	Compute the outward normals for the simplices (triangle faces).
template<typename T >
void	computeSimplexNormals (const IndSimpSetIncAdj< 2, 1, T > &mesh, std::vector< typename IndSimpSetIncAdj< 2, 1, T >::Vertex > *simplexNormals)
	Compute the outward normals for the simplices (line segments).
template<typename T >
void	computeVertexNormals (const IndSimpSetIncAdj< 3, 2, T > &mesh, const std::vector< typename IndSimpSetIncAdj< 3, 2, T >::Vertex > &simplexNormals, std::vector< typename IndSimpSetIncAdj< 3, 2, T >::Vertex > *vertexNormals)
	Compute the outward normals for the vertices.
template<typename T >
void	computeSimplexAndVertexNormals (const IndSimpSetIncAdj< 3, 2, T > &mesh, std::vector< typename IndSimpSetIncAdj< 3, 2, T >::Vertex > *simplexNormals, std::vector< typename IndSimpSetIncAdj< 3, 2, T >::Vertex > *vertexNormals)
	Compute the outward normals for the simplices and vertices.
template<std::size_t N, typename T >
T	computeCosineAngle (const IndSimpSetIncAdj< N, 1, T > &mesh, std::size_t vertexIndex)
	Return the cosine of the interior angle at the specified vertex.
template<typename T >
T	computeCosineAngle (const IndSimpSetIncAdj< 3, 2, T > &mesh, const typename IndSimpSetIncAdj< 3, 2, T >::Face &face)
	Return the cosine of the interior angle at the specified 1-face.
template<typename T >
T	computeCosineBoundaryAngle (const IndSimpSetIncAdj< 3, 2, T > &mesh, std::size_t vertexIndex)
	Return the cosine of the interior angle at the specified boundary vertex.
template<typename T >
T	computeAngle (const IndSimpSetIncAdj< 3, 2, T > &mesh, std::size_t n)
	Return the solid interior angle at the specified vertex.
template<typename T >
T	computeAngle (const IndSimpSetIncAdj< 3, 3, T > &mesh, std::size_t n)
	Return the sum of the incident angles at the specified vertex.
template<typename T >
T	computeAngle (const IndSimpSetIncAdj< 2, 2, T > &mesh, std::size_t n)
	Return the sum of the incident angles at the specified vertex.
template<typename T >
T	computeAngle (const IndSimpSetIncAdj< 1, 1, T > &mesh, std::size_t n)
	Return the sum of the incident angles at the specified vertex.
template<typename T , typename OutputIterator >
void	projectAndGetSimplices (const IndSimpSet< 2, 1, T > &mesh, OutputIterator simplices)
	Project the line segments to 1-D and collect them.
template<typename T , typename OutputIterator >
void	projectAndGetSimplices (const IndSimpSet< 3, 2, T > &mesh, OutputIterator simplices)
	Project the triangle simplices to 2-D and collect them.
template<template< std::size_t, typename > class QF, std::size_t N, typename T >
void	geometricOptimizeInterior (IndSimpSetIncAdj< N, N, T > *mesh, std::size_t numSweeps=1)
	Optimize the position of the interior vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , typename IntForIter >
void	geometricOptimizeInterior (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, std::size_t numSweeps=1)
	Make numSweeps optimization sweeps over the given interior vertices with the quality function given as a template parameter.
template<std::size_t N, typename T >
void	geometricOptimizeInteriorUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, const std::size_t numSweeps=1)
	Optimize the position of the interior vertices.
template<std::size_t N, typename T >
void	geometricOptimizeInteriorUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, const std::size_t numSweeps=1)
	Optimize the position of the interior vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , std::size_t SD>
void	geometricOptimizeBoundary (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, std::size_t numSweeps=1)
	Optimize the position of all boundary vertices.
template<template< std::size_t, typename > class QF, typename T , typename IntForIter , std::size_t SD>
void	geometricOptimizeBoundary (IndSimpSetIncAdj< 2, 2, T > *mesh, IntForIter begin, IntForIter end, PointsOnManifold< 2, 1, SD, T > *boundaryManifold, std::size_t numSweeps=1)
	Make numSweeps optimization sweeps over the given boundary vertices with the quality function given as a template parameter.
template<std::size_t N, typename T , std::size_t SD>
void	geometricOptimizeBoundaryUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, const std::size_t numSweeps=1)
	Optimize the position of all boundary vertices.
template<std::size_t N, typename T , std::size_t SD>
void	geometricOptimizeBoundaryUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, const std::size_t numSweeps=1)
	Optimize the position of all boundary vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , std::size_t SD>
void	geometricOptimize (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<std::size_t N, typename T , std::size_t SD>
void	geometricOptimizeUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<std::size_t N, typename T , std::size_t SD>
void	geometricOptimizeUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , std::size_t SD>
void	geometricOptimizeWithBoundaryCondition (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<std::size_t N, typename T , std::size_t SD>
void	geometricOptimizeWithBoundaryConditionUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<std::size_t N, typename T , std::size_t SD>
void	geometricOptimizeWithBoundaryConditionUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , class BoundaryCondition >
void	geometricOptimizeWithCondition (IndSimpSetIncAdj< N, N, T > *mesh, const BoundaryCondition &condition, std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<std::size_t N, typename T , class BoundaryCondition >
void	geometricOptimizeWithConditionUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, const BoundaryCondition &condition, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<std::size_t N, typename T , class BoundaryCondition >
void	geometricOptimizeWithConditionUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, const BoundaryCondition &condition, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T >
void	geometricOptimize (IndSimpSetIncAdj< N, N, T > *mesh, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<std::size_t N, typename T >
void	geometricOptimizeUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<std::size_t N, typename T >
void	geometricOptimizeUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, const std::size_t numSweeps=1)
	Optimize the position of all vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , typename IntForIter , std::size_t SD>
void	geometricOptimizeWithBoundaryCondition (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, std::size_t numSweeps=1)
	Make numSweeps optimization sweeps over the given vertices with the quality function given as a template parameter.
template<std::size_t N, typename T , typename IntForIter , std::size_t SD>
void	geometricOptimizeWithBoundaryConditionUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, const std::size_t numSweeps=1)
	Optimize the position of a set of vertices.
template<std::size_t N, typename T , typename IntForIter , std::size_t SD>
void	geometricOptimizeWithBoundaryConditionUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, PointsOnManifold< N, N-1, SD, T > *boundaryManifold, const std::size_t numSweeps=1)
	Optimize the position of a set of vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , typename IntForIter , class BoundaryCondition >
void	geometricOptimizeWithCondition (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const BoundaryCondition &condition, std::size_t numSweeps=1)
	Make numSweeps optimization sweeps over the given vertices with the quality function given as a template parameter.
template<std::size_t N, typename T , typename IntForIter , class BoundaryCondition >
void	geometricOptimizeWithConditionUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const BoundaryCondition &condition, std::size_t numSweeps=1)
	Optimize the position of a set of vertices.
template<std::size_t N, typename T , typename IntForIter , class BoundaryCondition >
void	geometricOptimizeWithConditionUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const BoundaryCondition &condition, const std::size_t numSweeps=1)
	Optimize the position of a set of vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , typename IntForIter >
void	geometricOptimize (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const std::size_t numSweeps=1)
	Make numSweeps optimization sweeps over the given vertices with the quality function given as a template parameter.
template<std::size_t N, typename T , typename IntForIter >
void	geometricOptimizeUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const std::size_t numSweeps=1)
	Optimize the position of a set of vertices.
template<std::size_t N, typename T , typename IntForIter >
void	geometricOptimizeUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const std::size_t numSweeps=1)
	Optimize the position of a set of vertices.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , typename IntForIter , class BoundaryCondition >
void	geometricOptimizeWithConditionConstrained (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const BoundaryCondition &condition, const T maxConstraintError, std::size_t numSweeps=1)
	Make numSweeps constrained optimization sweeps over the given vertices with the quality function given as a template parameter.
template<std::size_t N, typename T , typename IntForIter , class BoundaryCondition >
void	geometricOptimizeWithConditionConstrainedUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const BoundaryCondition &condition, const T maxConstraintError, std::size_t numSweeps=1)
	Optimize the position of a set of vertices subject to a constant content constraint.
template<std::size_t N, typename T , typename IntForIter , class BoundaryCondition >
void	geometricOptimizeWithConditionConstrainedUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const BoundaryCondition &condition, const T maxConstraintError, const std::size_t numSweeps=1)
	Optimize the position of a set of vertices subject to a constant content constraint.
template<template< std::size_t, typename > class QF, std::size_t N, typename T , typename IntForIter >
void	geometricOptimizeConstrained (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const T maxConstraintError, const std::size_t numSweeps=1)
	Make numSweeps constrained optimization sweeps over the given vertices with the quality function given as a template parameter.
template<std::size_t N, typename T , typename IntForIter >
void	geometricOptimizeConstrainedUsingMeanRatio (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const T maxConstraintError, const std::size_t numSweeps=1)
	Optimize the position of a set of vertices subject to a constant content constraint.
template<std::size_t N, typename T , typename IntForIter >
void	geometricOptimizeConstrainedUsingConditionNumber (IndSimpSetIncAdj< N, N, T > *mesh, IntForIter begin, IntForIter end, const T maxConstraintError, const std::size_t numSweeps=1)
	Optimize the position of a set of vertices subject to a constant content constraint.
template<std::size_t N, typename T >
T	maximumIncidentEdgeLength (const IndSimpSetIncAdj< N, N, T > &mesh, std::size_t n)
	Return the maximum incident edge length.
template<std::size_t M, typename SimpInIter , typename T >
void	computeEdgeLengthStatistics (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, T *minimumLength, T *maximumLength)
	Compute edge length statistics.
template<std::size_t M, typename VertRAIter , typename ISInIter , typename T >
void	computeEdgeLengthStatistics (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, T *minimumLength, T *maximumLength)
	Compute edge length statistics.
template<std::size_t N, typename T >
void	computeEdgeLengthStatistics (const IndSimpSetIncAdj< N, 2, T > &mesh, T *minimumLength, T *maximumLength, T *meanLength)
	Compute edge length statistics.
template<std::size_t M, typename T , typename SimpInIter >
T	computeMinimumEdgeLength (SimpInIter simplicesBeginning, SimpInIter simplicesEnd)
	Return the minimum edge length.
template<std::size_t M, typename T , typename SimpInIter >
T	computeMaximumEdgeLength (SimpInIter simplicesBeginning, SimpInIter simplicesEnd)
	Return the maximum edge length.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter >
T	computeContent (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd)
	Return the total content of the simplices in the mesh.
template<std::size_t M, typename T , typename SimpInIter >
T	computeContent (SimpInIter simplicesBeginning, SimpInIter simplicesEnd)
	Return the total content of the simplices in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter >
void	computeContentStatistics (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, T *minimumContent, T *maximumContent, T *meanContent)
	Calculate content (hypervolume) statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename SimpInIter >
void	computeContentStatistics (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, T *minimumContent, T *maximumContent, T *meanContent)
	Calculate content (hypervolume) statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter >
void	computeDeterminantStatistics (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, T *minimumDeterminant, T *maximumDeterminant, T *meanDeterminant)
	Calculate determinant statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename SimpInIter >
void	computeDeterminantStatistics (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, T *minimumDeterminant, T *maximumDeterminant, T *meanDeterminant)
	Calculate determinant statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter >
void	computeModifiedMeanRatioStatistics (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, T *minimumModMeanRatio, T *maximumModMeanRatio, T *meanModMeanRatio)
	Calculate modified mean ratio function statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename SimpInIter >
void	computeModifiedMeanRatioStatistics (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, T *minimumModMeanRatio, T *maximumModMeanRatio, T *meanModMeanRatio)
	Calculate modified mean ratio function statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter >
void	computeModifiedConditionNumberStatistics (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, T *minimumModCondNum, T *maximumModCondNum, T *meanModCondNum)
	Calculate modified condition number function statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename SimpInIter >
void	computeModifiedConditionNumberStatistics (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, T *minimumModCondNum, T *maximumModCondNum, T *meanModCondNum)
	Calculate modified condition number function statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename VertRAIter , typename ISInIter >
void	computeQualityStatistics (VertRAIter vertices, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd, T *minimumContent, T *maximumContent, T *meanContent, T *minimumDeterminant, T *maximumDeterminant, T *meanDeterminant, T *minimumModMeanRatio, T *maximumModMeanRatio, T *meanModMeanRatio, T *minimumModCondNum, T *maximumModCondNum, T *meanModCondNum)
	Calculate quality statistics for the simplices in the mesh.
template<std::size_t M, typename T , typename SimpInIter >
void	computeQualityStatistics (SimpInIter simplicesBeginning, SimpInIter simplicesEnd, T *minimumContent, T *maximumContent, T *meanContent, T *minimumDeterminant, T *maximumDeterminant, T *meanDeterminant, T *minimumModMeanRatio, T *maximumModMeanRatio, T *meanModMeanRatio, T *minimumModCondNum, T *maximumModCondNum, T *meanModCondNum)
	Calculate quality statistics for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , typename VertRAIter , typename ISInIter >
void	printQualityStatistics (std::ostream &out, VertRAIter verticesBeginning, VertRAIter verticesEnd, ISInIter indexedSimplicesBeginning, ISInIter indexedSimplicesEnd)
	Print quality statistics for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , typename SimpInIter >
void	printQualityStatistics (std::ostream &out, SimpInIter simplicesBeginning, SimpInIter simplicesEnd)
	Print quality statistics for the simplices in the mesh.
template<typename IntForIter , typename IntOutIter >
void	determineComplementSetOfIndices (const std::size_t upperBound, IntForIter beginning, IntForIter end, IntOutIter indexIterator)
	Make the complement set of indices.
template<std::size_t M>
std::ostream &	operator<< (std::ostream &out, const SimplexAdj< M > &x)
	Write the simplex adjacencies.
template<class ISS >
bool	operator== (const SimplexIterator< ISS > &x, const SimplexIterator< ISS > &y)
	Return true if the iterators have a handle to the same index.
template<class ISS >
bool	operator!= (const SimplexIterator< ISS > &x, const SimplexIterator< ISS > &y)
	Return true if the iterators do not have a handle to the same index.
template<class ISS >
bool	operator< (const SimplexIterator< ISS > &x, const SimplexIterator< ISS > &y)
	Return true if the index of x precedes that of y.
template<class ISS >
bool	operator> (const SimplexIterator< ISS > &x, const SimplexIterator< ISS > &y)
	Return true if the index of x follows that of y.
template<class ISS >
bool	operator<= (const SimplexIterator< ISS > &x, const SimplexIterator< ISS > &y)
	Return true if the index of x precedes or is equal to that of y.
template<class ISS >
bool	operator>= (const SimplexIterator< ISS > &x, const SimplexIterator< ISS > &y)
	Return true if the index of x follows or is equal to that of y.
template<class ISS >
SimplexIterator< ISS > ::difference_type	operator- (const SimplexIterator< ISS > &x, const SimplexIterator< ISS > &y)
	The difference of two iterators.
template<class ISS >
SimplexIterator< ISS >	operator+ (typename SimplexIterator< ISS >::difference_type n, const SimplexIterator< ISS > &i)
	Iterator advance.
template<std::size_t M>
std::ostream &	operator<< (std::ostream &out, const VertexSimplexInc< M > &x)
	Write the vertex-simplex incidences.
template<typename T >
void	decompose (const ads::SquareMatrix< 2, T > &jacobian, ads::SquareMatrix< 2, T > *orientation, ads::SquareMatrix< 2, T > *skew, ads::SquareMatrix< 2, T > *aspectRatio)
	Decompose the jacobian into orientation * skew * aspectRatio.
template<typename T >
void	decompose (const ads::SquareMatrix< 3, T > &jacobian, ads::SquareMatrix< 3, T > *orientation, ads::SquareMatrix< 3, T > *skew, ads::SquareMatrix< 3, T > *aspectRatio)
	Decompose the jacobian into orientation * skew * aspectRatio.
template<std::size_t N, std::size_t M, typename T >
SimplexDeterminant< N, M, T >	simplexDeterminant ()
	Convenience function for constructing a SimplexDeterminant.
template<std::size_t N, std::size_t M, typename T >
SimplexContent< N, M, T >	simplexContent ()
	Convenience function for constructing a SimplexContent.
template<std::size_t N, std::size_t M, typename T >
SimplexMinimumEdgeLength< N, M, T >	simplexMinimumEdgeLength ()
	Convenience function for constructing a SimplexMinimumEdgeLength.
template<std::size_t N, std::size_t M, typename T >
SimplexMaximumEdgeLength< N, M, T >	simplexMaximumEdgeLength ()
	Convenience function for constructing a SimplexMaximumEdgeLength.
template<typename _T , std::size_t _N, typename _Number >
void	computeBBox (const std::tr1::array< _T, _N > &simplex, BBox< _N-1, _Number > *bb)
	Calculate a bounding box around the simplex.
template<typename _T , std::size_t _N>
void	computeCentroid (const std::tr1::array< _T, _N > &simplex, _T *centroid)
	Calculate the centroid of the simplex.
template<typename _T >
_T	computeAngle (const std::tr1::array< std::tr1::array< _T, 3 >, 3+1 > &s, std::size_t a, std::size_t b)
	The dihedral angle between two faces.
template<typename _T >
_T	computeAngle (const std::tr1::array< std::tr1::array< _T, 3 >, 3+1 > &s, std::size_t n)
	The solid angle at a vertex.
template<typename _T >
_T	computeAngle (const std::tr1::array< std::tr1::array< _T, 2 >, 2+1 > &s, std::size_t n)
	The interior angle at a vertex.
template<typename _T >
_T	computeAngle (const std::tr1::array< std::tr1::array< _T, 1 >, 1+1 > &s, std::size_t n)
	The interior angle at a vertex is 1.
template<typename _T >
void	projectToLowerDimension (const std::tr1::array< std::tr1::array< _T, 2 >, 1+1 > &s, std::tr1::array< std::tr1::array< _T, 1 >, 1+1 > *t)
	Project the simplex to a lower dimension.
template<typename _T >
void	projectToLowerDimension (const std::tr1::array< std::tr1::array< _T, 3 >, 1+1 > &s, std::tr1::array< std::tr1::array< _T, 1 >, 1+1 > *t)
	Project the simplex to a lower dimension.
template<typename _T >
void	projectToLowerDimension (const std::tr1::array< std::tr1::array< _T, 3 >, 2+1 > &s, std::tr1::array< std::tr1::array< _T, 2 >, 2+1 > *t)
	Project the simplex to a lower dimension.
template<typename T >
void	project (const std::tr1::array< std::tr1::array< T, 2 >, 1+1 > &s2, const std::tr1::array< T, 2 > &x2, std::tr1::array< std::tr1::array< T, 1 >, 1+1 > *s1, std::tr1::array< T, 1 > *x1)
	Project the simplex and the point in 2-D to 1-D.
template<typename T >
void	project (const std::tr1::array< std::tr1::array< T, 2 >, 1+1 > &s2, const std::tr1::array< T, 2 > &x2, std::tr1::array< std::tr1::array< T, 1 >, 1+1 > *s1, std::tr1::array< T, 1 > *x1, std::tr1::array< T, 1 > *y1)
	Project the simplex and the point in 2-D to 1-D.
template<typename T >
void	project (const std::tr1::array< std::tr1::array< T, 3 >, 2+1 > &s3, const std::tr1::array< T, 3 > &x3, std::tr1::array< std::tr1::array< T, 2 >, 2+1 > *s2, std::tr1::array< T, 2 > *x2)
	Project the simplex and the point in 3-D to 2-D.
template<typename T >
void	project (const std::tr1::array< std::tr1::array< T, 3 >, 2+1 > &s3, const std::tr1::array< T, 3 > &x3, std::tr1::array< std::tr1::array< T, 2 >, 2+1 > *s2, std::tr1::array< T, 2 > *x2, std::tr1::array< T, 1 > *z1)
	Project the simplex and the point in 3-D to 2-D.
void	computeOtherIndices (std::size_t i, std::size_t j, std::size_t *a, std::size_t *b)
	Compute the other indices of the simplex.
std::size_t	computeOtherIndex (std::size_t i, std::size_t j, std::size_t k)
	Compute the other index of the simplex.
template<typename _T , std::size_t _N>
void	reverseOrientation (std::tr1::array< _T, _N > *simplex)
	Reverse the orientation of the simplex.
template<typename _T , std::size_t _N>
void	getFace (const std::tr1::array< _T, _N > &simplex, const std::size_t n, std::tr1::array< _T, _N-1 > *face)
	Get the face obtained by removing the n_th vertex.
template<typename _T , std::size_t _N>
std::tr1::array< _T, _N-1 >	getFace (const std::tr1::array< _T, _N > &simplex, const std::size_t n)
	Return the face obtained by removing the n_th vertex.
template<typename _T >
bool	haveSameOrientation (const std::tr1::array< _T, 0+1 > &x, const std::tr1::array< _T, 0+1 > &y)
	Return true if the two simplices have the same orientation.
template<typename _T >
bool	haveSameOrientation (const std::tr1::array< _T, 1+1 > &x, const std::tr1::array< _T, 1+1 > &y)
	Return true if the two simplices have the same orientation.
template<typename _T >
bool	haveSameOrientation (const std::tr1::array< _T, 2+1 > &x, const std::tr1::array< _T, 2+1 > &y)
	Return true if the two simplices have the same orientation.
template<typename _T , std::size_t _N, std::size_t _M>
bool	hasFace (const std::tr1::array< _T, _N > &simplex, const std::tr1::array< _T, _M > &face, std::size_t *faceIndex)
	Return true if the N-simplex has the specified (N-1)-face.
template<typename _T , std::size_t _N, std::size_t _M>
bool	hasFace (const std::tr1::array< _T, _N > &simplex, const std::tr1::array< _T, _M > &face)
	Return true if the simplex has the given face as a sub-simplex.
template<typename _T >
bool	hasFace (const std::tr1::array< _T, 3+1 > &simplex, const _T &x, const _T &y, const _T &z)
	Return true if the 3-simplex has the face specified by the three vertices.
template<typename _T >
bool	hasFace (const std::tr1::array< _T, 3+1 > &simplex, const _T &x, const _T &y, const _T &z, std::size_t *faceIndex)
	Return true if the 3-simplex has the face specified by the three vertices.
template<typename SMR , typename CellIteratorOutputIterator >
void	getIncidentCells (const typename SMR::CellIterator cell, std::size_t i, std::size_t j, CellIteratorOutputIterator out)
	Get the incident cells of the edge.
template<class CellIterator , class NodeIterator >
std::size_t	getFaceIndex (const CellIterator &cell, const NodeIterator &a, const NodeIterator &b)
	For a 2-simplex cell, a pair of nodes defines a 1-face. Return the index of this 1-face.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	buildIndSimpSetFromSimpMeshRed (const SimpMeshRed< N, M, T, Node, Cell, Cont > &smr, IndSimpSet< N, M, T > *iss)
	Make an indexed simplex set from the mesh.
template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t SD, class MinEdgeLength >
std::size_t	coarsen (SimpMeshRed< 2, 2, T, Node, Cell, Cont > *mesh, const MinEdgeLength &f, T minimumAllowedQuality, T qualityFactor, PointsOnManifold< 2, 1, SD, T > *manifold, std::size_t maxSweeps=0)
	Coarsen the mesh using the minimum edge length function.
template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MinEdgeLength >
std::size_t	coarsen (SimpMeshRed< 2, 2, T, Node, Cell, Cont > *mesh, const MinEdgeLength &f, T minimumAllowedQuality, T qualityFactor, T cornerDeviation=-1, std::size_t maxSweeps=0)
	Coarsen the mesh using the min edge length function.
template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t SD, class MinEdgeLength >
std::size_t	coarsen (SimpMeshRed< 3, 2, T, Node, Cell, Cont > *mesh, const MinEdgeLength &f, T minimumAllowedQuality, T qualityFactor, PointsOnManifold< 3, 2, SD, T > *manifold, std::size_t maxSweeps=0)
	Coarsen the mesh using the min edge length function.
template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MinEdgeLength >
std::size_t	coarsen (SimpMeshRed< 3, 2, T, Node, Cell, Cont > *mesh, const MinEdgeLength &f, T minimumAllowedQuality, T qualityFactor, T maxDihedralAngleDeviation=-1, T maxSolidAngleDeviation=-1, T maxBoundaryAngleDeviation=-1, std::size_t maxSweeps=0)
	Coarsen the mesh using the min edge length function.
template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t SD, class MinEdgeLength >
std::size_t	coarsen (SimpMeshRed< 3, 3, T, Node, Cell, Cont > *mesh, const MinEdgeLength &f, T minimumAllowedQuality, T qualityFactor, PointsOnManifold< 3, 2, SD, T > *manifold, std::size_t maxSweeps=0)
	Coarsen the mesh using the min edge length function.
template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MinEdgeLength >
std::size_t	coarsen (SimpMeshRed< 3, 3, T, Node, Cell, Cont > *mesh, const MinEdgeLength &f, T minimumAllowedQuality, T qualityFactor, T maxDihedralAngleDeviation=-1, T maxSolidAngleDeviation=-1, T maxBoundaryAngleDeviation=-1, std::size_t maxSweeps=0)
	Coarsen the mesh using the min edge length function.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename IntInIter >
std::size_t	coarsen (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, IntInIter begin, IntInIter end)
	Collapse edges to remove the specified cells.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	writeAscii (std::ostream &out, const SimpMeshRed< N, M, T, Node, Cell, Cont > &x)
	Write a mesh as an indexed simplex set in ascii format.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	print (std::ostream &out, const SimpMeshRed< N, M, T, Node, Cell, Cont > &x)
	Print detailed information about the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	writeBinary (std::ostream &out, const SimpMeshRed< N, M, T, Node, Cell, Cont > &x)
	Write a mesh as an indexed simplex set in binary format.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	readAscii (std::istream &in, SimpMeshRed< N, M, T, Node, Cell, Cont > *x)
	Read a mesh as an indexed simplex set in ascii format.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	readBinary (std::istream &in, SimpMeshRed< N, M, T, Node, Cell, Cont > *x)
	Read an indexed simplex set in binary format.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	writeVtkXml (std::ostream &out, const SimpMeshRed< N, M, T, Node, Cell, Cont > &x)
	Write in VTK XML unstructured grid format.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	writeVtkLegacy (std::ostream &out, const SimpMeshRed< N, M, T, Node, Cell, Cont > &x, std::string title="")
	Write in legacy VTK unstructured grid format.
template<class SMR >
SMR::Number	computeIncidentCellsAngle (typename SMR::NodeConstIterator node)
	Return the solid angle accumulated from the incident cells.
template<class SMR >
SMR::Number	computeDihedralAngle (typename SMR::ConstEdge edge)
	Compute the dihedral angle at the specified edge.
template<class SMR >
SMR::Number	computeCosineAngle (typename SMR::FaceConstIterator face)
	Return the cosine of the interior angle at the specified 1-face.
template<class SMR >
void	computeNodeNormal (typename SMR::NodeConstIterator node, typename SMR::Vertex *normal)
	Compute the normal to the surface.
template<class SMR >
SMR::Vertex	computeNodeNormal (typename SMR::NodeConstIterator node)
	Return the normal to the surface.
template<class SMR >
void	computeCellNormal (typename SMR::CellConstIterator cell, typename SMR::Vertex *normal)
	Compute the cell normal.
template<class SMR >
SMR::Vertex	computeCellNormal (typename SMR::CellConstIterator cell)
	Return the normal to the surface.
template<class SMR >
void	computeFaceNormal (typename SMR::CellConstIterator cell, std::size_t i, typename SMR::Vertex *x)
	Compute the face normal.
template<typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename OutputIterator >
void	projectAndGetSimplices (const SimpMeshRed< 2, 1, T, Node, Cell, Cont > &mesh, OutputIterator simplices)
	Project the line segments to 1-D and collect them.
template<typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename OutputIterator >
void	projectAndGetSimplices (const SimpMeshRed< 3, 2, T, Node, Cell, Cont > &mesh, OutputIterator simplices)
	Project the triangle simplices to 2-D and collect them.
template<std::size_t N, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
std::size_t	incidenceOptimize (SimpMeshRed< N, 2, T, Node, Cell, Cont > *mesh, std::size_t norm, std::size_t numSweeps=0)
	Modify the topology to optimize the cell-node incidences.
template<std::size_t N, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
SimpMeshRed< N, 1, T, Node, Cell, Cont >::CellIterator	insertCell (SimpMeshRed< N, 1, T, Node, Cell, Cont > *mesh, const typename SimpMeshRed< N, 1, T, Node, Cell, Cont >::NodeIterator n0, const typename SimpMeshRed< N, 1, T, Node, Cell, Cont >::NodeIterator n1, const typename SimpMeshRed< N, 1, T, Node, Cell, Cont >::CellIterator c0=typename SimpMeshRed< N, 1, T, Node, Cell, Cont >::CellIterator(0), const typename SimpMeshRed< N, 1, T, Node, Cell, Cont >::CellIterator c1=typename SimpMeshRed< N, 1, T, Node, Cell, Cont >::CellIterator(0))
	Insert the specified cell into the 1-D mesh.
template<std::size_t N, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
SimpMeshRed< N, 2, T, Node, Cell, Cont >::CellIterator	insertCell (SimpMeshRed< N, 2, T, Node, Cell, Cont > *mesh, const typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::NodeIterator n0, const typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::NodeIterator n1, const typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::NodeIterator n2, const typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::CellIterator c0=typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::CellIterator(0), const typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::CellIterator c1=typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::CellIterator(0), const typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::CellIterator c2=typename SimpMeshRed< N, 2, T, Node, Cell, Cont >::CellIterator(0))
	Insert the specified cell into the 2-D mesh.
template<std::size_t N, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator	insertCell (SimpMeshRed< N, 3, T, Node, Cell, Cont > *mesh, const typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::NodeIterator n0, const typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::NodeIterator n1, const typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::NodeIterator n2, const typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::NodeIterator n3, const typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator c0=typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator(0), const typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator c1=typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator(0), const typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator c2=typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator(0), const typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator c3=typename SimpMeshRed< N, 3, T, Node, Cell, Cont >::CellIterator(0))
	Insert the specified cell into the 3-D mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	orientPositive (SimpMeshRed< N, M, T, Node, Cell, Cont > *x)
	Orient each simplex so it has non-negative volume.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	eraseUnusedNodes (SimpMeshRed< N, M, T, Node, Cell, Cont > *x)
	Erase the nodes that do not have an incident cells.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	eraseCellsWithLowAdjacencies (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, std::size_t minimumAdjacencies)
	Erase cells until there are none with minimum adjacencies less than specified.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	renumberIdentifiers (SimpMeshRed< N, M, T, Node, Cell, Cont > *x)
	Re-number the node and cell identifiers so they start at 0 and are contiguous.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	countAdjacencies (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, std::tr1::array< std::size_t, M+2 > *counts)
	Calculate the adjacency counts for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
T	computeContent (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh)
	Return the total content of the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	computeContentStatistics (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, T *minContent, T *maxContent, T *meanContent)
	Calculate content (hypervolume) statistics for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	computeEdgeLengthStatistics (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, T *minLength, T *maxLength, T *meanLength)
	Calculate edge length statistics.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	printEdgeLengthStatistics (std::ostream &out, const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh)
	Print edge length statistics.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	computeDeterminantStatistics (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, T *minDeterminant, T *maxDeterminant, T *meanDeterminant)
	Calculate determinant statistics for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	computeModifiedMeanRatioStatistics (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, T *minModifiedMeanRatio, T *maxModifiedMeanRatio, T *meanModifiedMeanRatio)
	Calculate modified mean ratio function statistics for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	computeModifiedConditionNumberStatistics (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, T *minModifiedConditionNumber, T *maxModifiedConditionNumber, T *meanModifiedConditionNumber)
	Calculate modified condition number function statistics for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	computeQualityStatistics (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, T *minContent, T *maxContent, T *meanContent, T *minDeterminant, T *maxDeterminant, T *meanDeterminant, T *minModifiedMeanRatio, T *maxModifiedMeanRatio, T *meanModifiedMeanRatio, T *minModifiedConditionNumber, T *maxModifiedConditionNumber, T *meanModifiedConditionNumber)
	Calculate quality statistics for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	printQualityStatistics (std::ostream &out, const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh)
	Print quality statistics for the simplices in the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD, class MaxEdgeLength >
std::size_t	refine (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, PointsOnManifold< N, MM, SD, T > *manifold, const MaxEdgeLength &f)
	Refine the mesh using the maximum edge length function.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MaxEdgeLength >
std::size_t	refine (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, const MaxEdgeLength &f)
	Refine the mesh using the maximum edge length function.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD, typename IntInputIterator >
std::size_t	refine (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, PointsOnManifold< N, MM, SD, T > *manifold, IntInputIterator begin, IntInputIterator end)
	Refine the mesh by splitting the specified cells.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename IntInputIterator >
std::size_t	refine (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, IntInputIterator begin, IntInputIterator end)
	Refine the mesh by splitting the specified cells.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD, typename IntInputIterator , class MaxEdgeLength >
std::size_t	refine (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, PointsOnManifold< N, MM, SD, T > *manifold, IntInputIterator begin, IntInputIterator end, const MaxEdgeLength &f)
	Refine the specified cells using the maximum edge length function.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename IntInputIterator , class MaxEdgeLength >
std::size_t	refine (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, IntInputIterator begin, IntInputIterator end, const MaxEdgeLength &f)
	Refine the specified cells using the maximum edge length function.
template<typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class ISS >
std::size_t	refineBoundary (SimpMeshRed< 2, 2, T, Node, Cell, Cont > *x, const ISS &boundary, T maxAngle, T minEdgeLength, std::size_t maxSweeps=10)
	Refine the mesh to better fit the boundary.
template<typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class Distance , class ClosestPoint , class MaxAngle , class MinEdgeLength >
std::size_t	refineBoundary (SimpMeshRed< 2, 2, T, Node, Cell, Cont > *x, const Distance &distance, const ClosestPoint &closestPoint, const MaxAngle &maxAngle, const MinEdgeLength &minEdgeLength, std::size_t maxSweeps=10)
	Refine the mesh to better fit the boundary.
template<typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MaxEdgeLength >
std::size_t	refineAdjust (SimpMeshRed< 2, 2, T, Node, Cell, Cont > *mesh, const MaxEdgeLength &f)
	Refine and adjust the mesh using the maximum edge length function.
template<typename NodeInIter , class LSF , typename OutIter >
void	determineNodesOutside (NodeInIter begin, NodeInIter end, const LSF &f, OutIter iter)
	Get the nodes that are outside the object.
template<typename CellInIter , class LSF , typename OutIter >
void	determineCellsOutside (CellInIter begin, CellInIter end, const LSF &f, OutIter iter)
	Get the cells whose centroids are outside the object.
template<typename NodeInIter , typename OutIter >
void	getNodes (NodeInIter begin, NodeInIter end, OutIter iter)
	Get the node iterators for the all of the nodes in the mesh.
template<typename NodeInIter , typename OutIter >
void	determineInteriorNodes (NodeInIter begin, NodeInIter end, OutIter iter)
	Get the node iterators for the interior nodes.
template<typename NodeInIter , typename OutIter >
void	determineBoundaryNodes (NodeInIter begin, NodeInIter end, OutIter iter)
	Get the node iterators for the boundary nodes.
template<typename CellInIter , typename OutIter >
void	determineCellsWithRequiredAdjacencies (CellInIter begin, CellInIter end, std::size_t minimumRequiredAdjacencies, OutIter iter)
	Get the cell iterators with at least the specified number of adjacencies.
template<typename CellInIter , typename OutIter >
void	determineCellsWithLowAdjacencies (CellInIter begin, CellInIter end, const std::size_t minimumRequiredAdjacencies, OutIter iter)
	Get the cell iterators with adjacencies less than specified.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	determineNeighbors (SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIterator node, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIteratorSet *neighbors)
	Get the neighboring nodes of a node.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	determineBoundaryNeighbors (SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIterator node, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIteratorSet *neighbors)
	Get the neighboring boundary nodes of a node.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	determineNeighbors (SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIterator node, std::size_t radius, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIteratorSet *neighbors)
	Get all the nodes within the specified radius of the specified node.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
void	determineFacesOfIncidentCells (SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIterator node, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::FaceSet *faces)
	Get the faces of the incident cells.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename IntInIter >
void	convertIdentifiersToIterators (SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh, IntInIter begin, IntInIter end, typename SimpMeshRed< N, M, T, Node, Cell, Cont >::CellIteratorSet *cells)
	Build a set of cell iterators from a range of cell identifiers.
std::size_t	getNextNodeIndex (const std::size_t i, const std::size_t j)
	Get the next node index.
std::size_t	getPreviousNodeIndex (const std::size_t i, const std::size_t j)
	Get the previous node index.
template<typename SMR >
std::size_t	getNextNodeIndex (const typename SMR::CellConstIterator cell, const typename SMR::NodeConstIterator a, const typename SMR::NodeConstIterator b)
	Get the next node index.
template<typename SMR >
std::size_t	getPreviousNodeIndex (const typename SMR::CellConstIterator cell, const typename SMR::NodeConstIterator a, const typename SMR::NodeConstIterator b)
	Get the previous node index.
template<std::size_t N, std::size_t M, typename T , template< class > class Vertex, template< class > class Cell, template< class, class > class Container>
void	tile (const BBox< N, T > &domain, const T length, SimpMeshRed< N, M, T, Vertex, Cell, Container > *mesh)
	Tile the rectilinear region.
template<std::size_t N, std::size_t M, typename T , template< class > class Vertex, template< class > class Cell, template< class, class > class Container, class LSF >
void	tile (const BBox< N, T > &domain, const T length, const LSF &f, SimpMeshRed< N, M, T, Vertex, Cell, Container > *mesh)
	Tile the object.
template<class _QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t SD>
std::size_t	topologicalOptimize (SimpMeshRed< 3, 3, T, Node, Cell, Cont > *mesh, const PointsOnManifold< 3, 2, SD, T > *manifold, std::multiset< std::pair< std::size_t, std::size_t > > *edgeRemovalOperations=0, std::multiset< std::pair< std::size_t, std::size_t > > *faceRemovalOperations=0, std::size_t maximumSteps=std::numeric_limits< std::size_t >::max())
	Use edge and face removal to optimize the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD>
std::size_t	topologicalOptimizeUsingMeanRatio (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, const PointsOnManifold< N, MM, SD, T > *manifold, std::multiset< std::pair< std::size_t, std::size_t > > *edgeRemovalOperations=0, std::multiset< std::pair< std::size_t, std::size_t > > *faceRemovalOperations=0, const std::size_t maximumSteps=std::numeric_limits< std::size_t >::max())
	Use edge and face removal to optimize the mesh.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD>
std::size_t	topologicalOptimizeUsingConditionNumber (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, const PointsOnManifold< N, MM, SD, T > *manifold, std::multiset< std::pair< std::size_t, std::size_t > > *edgeRemovalOperations=0, std::multiset< std::pair< std::size_t, std::size_t > > *faceRemovalOperations=0, const std::size_t maximumSteps=std::numeric_limits< std::size_t >::max())
	Use edge and face removal to optimize the mesh.
template<class SMR >
bool	doNodesShareACell (typename SMR::NodeConstIterator x, typename SMR::NodeConstIterator y)
	Return true if the nodes are incident to a common cell.
template<typename SMR , typename NodeIterInIter , class UnaryFunction >
void	transformNodes (NodeIterInIter begin, NodeIterInIter end, const UnaryFunction &f)
	Transform each vertex in the range with the specified function.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class UnaryFunction >
void	transform (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, const UnaryFunction &f)
	Transform each vertex in the mesh with the specified function.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class UnaryFunction >
void	transformBoundary (SimpMeshRed< N, M, T, Node, Cell, Cont > *mesh, const UnaryFunction &f)
	Transform each boundary vertex in the mesh with the specified function.
template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>
bool	isValid (const SimpMeshRed< N, M, T, Node, Cell, Cont > &mesh)
	Return true if the mesh is valid.
template<typename Cell >
bool	operator< (const IndexAndCell< Cell > &a, const IndexAndCell< Cell > &b)
	Less than comparison for indices.
template<std::size_t _Dimension, std::size_t _MaximumLevel, typename _Element , bool _AutomaticBalancing, class _Split , class _Merge , class _Refine , class _Coarsen , class _Action , template< std::size_t, std::size_t > class _Key>
_Element	accumulate (const OrthtreeMap< _Dimension, _MaximumLevel, _Element, _AutomaticBalancing, _Split, _Merge, _Refine, _Coarsen, _Action, _Key > &x, _Element initial)
	Compute the sum of the elements.
template<std::size_t _Dimension, std::size_t _MaximumLevel, typename _Element , bool _AutomaticBalancing, class _Split , class _Merge , class _Refine , class _Coarsen , class _Action , template< std::size_t, std::size_t > class _Key, typename _T , typename _BinaryFunction >
_T	accumulate (const OrthtreeMap< _Dimension, _MaximumLevel, _Element, _AutomaticBalancing, _Split, _Merge, _Refine, _Coarsen, _Action, _Key > &x, _T initial, _BinaryFunction f)
	Accumulate the elements using a specified function.
template<std::size_t _Dimension, std::size_t _MaximumLevel, typename _Element , bool _AutomaticBalancing, class _Split , class _Merge , class _Refine , class _Coarsen , class _Action , template< std::size_t, std::size_t > class _Key, typename _Function >
_Function::result_type	accumulateFunction (const OrthtreeMap< _Dimension, _MaximumLevel, _Element, _AutomaticBalancing, _Split, _Merge, _Refine, _Coarsen, _Action, _Key > &x, typename _Function::result_type initial, _Function f)
	Sum the results of a function applied to each node.

---

Detailed Description

All classes and functions in the computational geometry package are defined in the geom namespace.

---

Function Documentation

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>

void geom::buildIndSimpSetFromSimpMeshRed	(	const SimpMeshRed< N, M, T, Node, Cell, Cont > &	smr,
		IndSimpSet< N, M, T > *	iss
	)			[inline]

Make an indexed simplex set from the mesh.

ISSV is the Indexed Simplex Set Vertex type. ISSIS is the Indexed Simplex Set Indexed Simplex type.

Referenced by main().

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename IntInIter >

std::size_t geom::coarsen	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		IntInIter	begin,
		IntInIter	end
	)			[inline]

Collapse edges to remove the specified cells.

Parameters:

	mesh	The simplicial mesh.
	begin	The beginning of a range of cells.
	end	The end of a range of cells.

Returns:

the number of edges collapsed.

template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MinEdgeLength >

std::size_t geom::coarsen	(	SimpMeshRed< 3, 3, T, Node, Cell, Cont > *	mesh,
		const MinEdgeLength &	f,
		T	minimumAllowedQuality,
		T	qualityFactor,
		T	maxDihedralAngleDeviation = -1,
		T	maxSolidAngleDeviation = -1,
		T	maxBoundaryAngleDeviation = -1,
		std::size_t	maxSweeps = 0
	)			[inline]

Coarsen the mesh using the min edge length function.

Parameters:

	mesh	The simplicial mesh.
	f	The minimum edge length functor. The algorithm will try to collapse edges below this threshold.
	minimumAllowedQuality	A collapse is only allowed if the quality of the resulting elements is not less than this value.
	qualityFactor	A collapse is only allowed if the quality of the resulting elements is not less than the initial quality times this value.
	maxDihedralAngleDeviation	The maximum dihedral angle deviation (from straight) for a surface feature. The rest are edge features. If not specified, all interior edges will be set as surface features.
	maxSolidAngleDeviation	Solid angles that deviate more than this value (from ) are corner features. If not specified, this criterion will not be used to identify corners.
	maxBoundaryAngleDeviation	If the angle deviation (from ) between two boundary edges exceeds this value, it will be set as a corner feature. If not specified, this criterion will not be used to identify corners on the boundary.
	maxSweeps	The maximum number of sweeps over the vertices. By default, there is no limit on the number of sweeps.

Returns:

the number of edges collapsed.

template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t SD, class MinEdgeLength >

std::size_t geom::coarsen	(	SimpMeshRed< 3, 3, T, Node, Cell, Cont > *	mesh,
		const MinEdgeLength &	f,
		T	minimumAllowedQuality,
		T	qualityFactor,
		PointsOnManifold< 3, 2, SD, T > *	manifold,
		std::size_t	maxSweeps = 0
	)			[inline]

Coarsen the mesh using the min edge length function.

Parameters:

	mesh	The simplicial mesh.
	f	The minimum edge length functor. The algorithm will try to collapse edges below this threshold.
	minimumAllowedQuality	A collapse is only allowed if the quality of the resulting elements is not less than this value.
	qualityFactor	A collapse is only allowed if the quality of the resulting elements is not less than the initial quality times this value.
	manifold	The manifold data structure.
	maxSweeps	The maximum number of sweeps over the vertices. By default, there is no limit on the number of sweeps.

Returns:

the number of edges collapsed.

Only edges which are a common minimum edge are collapsed. Also, an edge may not be collapsed if its' endpoints are mirror nodes. (Doing so would tangle the mesh.) An interior edge may not be collapsed if both of its incident nodes lay on the boundary. (Doing so would change the topology of the mesh.)

template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MinEdgeLength >

std::size_t geom::coarsen	(	SimpMeshRed< 3, 2, T, Node, Cell, Cont > *	mesh,
		const MinEdgeLength &	f,
		T	minimumAllowedQuality,
		T	qualityFactor,
		T	maxDihedralAngleDeviation = -1,
		T	maxSolidAngleDeviation = -1,
		T	maxBoundaryAngleDeviation = -1,
		std::size_t	maxSweeps = 0
	)			[inline]

Coarsen the mesh using the min edge length function.

Parameters:

	mesh	The simplicial mesh.
	f	The minimum edge length functor. The algorithm will try to collapse edges below this threshold.
	minimumAllowedQuality	A collapse is only allowed if the quality of the resulting elements is not less than this value.
	qualityFactor	A collapse is only allowed if the quality of the resulting elements is not less than the initial quality times this value.
	maxDihedralAngleDeviation	The maximum dihedral angle deviation (from straight) for a surface feature. The rest are edge features. If not specified, all interior edges will be set as surface features.
	maxSolidAngleDeviation	Solid angles that deviate more than this value (from ) are corner features. If not specified, this criterion will not be used to identify corners.
	maxBoundaryAngleDeviation	If the angle deviation (from ) between two boundary edges exceeds this value, it will be set as a corner feature. If not specified, this criterion will not be used to identify corners on the boundary.
	maxSweeps	The maximum number of sweeps over the vertices. By default, there is no limit on the number of sweeps.

Returns:

the number of edges collapsed.

template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t SD, class MinEdgeLength >

std::size_t geom::coarsen	(	SimpMeshRed< 3, 2, T, Node, Cell, Cont > *	mesh,
		const MinEdgeLength &	f,
		T	minimumAllowedQuality,
		T	qualityFactor,
		PointsOnManifold< 3, 2, SD, T > *	manifold,
		std::size_t	maxSweeps = 0
	)			[inline]

Coarsen the mesh using the min edge length function.

Parameters:

	mesh	The simplicial mesh.
	f	The minimum edge length functor. The algorithm will try to collapse edges below this threshold.
	minimumAllowedQuality	A collapse is only allowed if the quality of the resulting elements is not less than this value.
	qualityFactor	A collapse is only allowed if the quality of the resulting elements is not less than the initial quality times this value.
	manifold	The manifold data structure.
	maxSweeps	The maximum number of sweeps over the vertices. By default, there is no limit on the number of sweeps.

Returns:

the number of edges collapsed.

Only edges which are a common minimum edge are collapsed. Also, an edge may not be collapsed if its' endpoints are mirror nodes. (Doing so would tangle the mesh.) An interior edge may not be collapsed if both of its incident nodes lay on the boundary. (Doing so would change the topology of the mesh.)

template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MinEdgeLength >

std::size_t geom::coarsen	(	SimpMeshRed< 2, 2, T, Node, Cell, Cont > *	mesh,
		const MinEdgeLength &	f,
		T	minimumAllowedQuality,
		T	qualityFactor,
		T	cornerDeviation = -1,
		std::size_t	maxSweeps = 0
	)			[inline]

Coarsen the mesh using the min edge length function.

Parameters:

	mesh	The simplicial mesh.
	f	The minimum edge length functor. The algorithm will try to collapse edges below this threshold.
	minimumAllowedQuality	A collapse is only allowed if the quality of the resulting elements is not less than this value.
	qualityFactor	A collapse is only allowed if the quality of the resulting elements is not less than the initial quality times this value.
	cornerDeviation	Any boundary node whose angle deviates from more than this value will be considered a corner feature. If not specified, no vertices will be considered corner features.
	maxSweeps	The maximum number of sweeps over the vertices. By default, there is no limit on the number of sweeps.

Returns:

the number of edges collapsed.

template<class QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t SD, class MinEdgeLength >

std::size_t geom::coarsen	(	SimpMeshRed< 2, 2, T, Node, Cell, Cont > *	mesh,
		const MinEdgeLength &	f,
		T	minimumAllowedQuality,
		T	qualityFactor,
		PointsOnManifold< 2, 1, SD, T > *	manifold,
		std::size_t	maxSweeps = 0
	)			[inline]

Coarsen the mesh using the minimum edge length function.

Parameters:

	mesh	The simplicial mesh.
	f	The minimum edge length functor. The algorithm will try to collapse edges below this threshold.
	minimumAllowedQuality	A collapse is only allowed if the quality of the resulting elements is not less than this value.
	qualityFactor	A collapse is only allowed if the quality of the resulting elements is not less than the initial quality times this value.
	manifold	The manifold data structure.
	maxSweeps	The maximum number of sweeps over the vertices. By default, there is no limit on the number of sweeps.

Returns:

the number of edges collapsed.

Only edges which are a common minimum edge are collapsed. Also, an edge may not be collapsed if its' endpoints are mirror nodes. (Doing so would tangle the mesh.) An interior edge may not be collapsed if both of its incident nodes lay on the boundary. (Doing so would change the topology of the mesh.)

A boundary edge may not be collapsed if both of its nodes are corner features. (Doing so would change the corner features.)

Referenced by geom::OrthtreeMap< _Dimension, _MaximumLevel, _Element, _AutomaticBalancing, _Split, _Merge, _Refine, _Coarsen, _Action, _Key >::coarsen(), and main().

template<class SMR >

SMR::Vertex geom::computeCellNormal

(

typename SMR::CellConstIterator

cell

)

[inline]

Return the normal to the surface.

Note:

The space dimension must be one more than the simplex dimension, N == M + 1.

template<class SMR >

void geom::computeCellNormal	(	typename SMR::CellConstIterator	cell,
		typename SMR::Vertex *	normal
	)			[inline]

Compute the cell normal.

Note:

The space dimension must be one more than the simplex dimension, N == M + 1.

template<class SMR >

SMR::Number geom::computeCosineAngle

(

typename SMR::FaceConstIterator

face

)

[inline]

Return the cosine of the interior angle at the specified 1-face.

Precondition:

The 1-face must have two incident simplices.

template<class SMR >

SMR::Number geom::computeDihedralAngle

(

typename SMR::ConstEdge

edge

)

[inline]

Compute the dihedral angle at the specified edge.

The dihedral angle is accumulated from the incident cells.

template<class SMR >

void geom::computeFaceNormal	(	typename SMR::CellConstIterator	cell,
		std::size_t	i,
		typename SMR::Vertex *	x
	)			[inline]

Compute the face normal.

Note:

The space dimension must be equal to the simplex dimension, N == M.

template<class SMR >

SMR::Number geom::computeIncidentCellsAngle

(

typename SMR::NodeConstIterator

node

)

[inline]

Return the solid angle accumulated from the incident cells.

This function does not check if the node is in the interior or on the boundary. For the sake of efficiency, only call this function for boundary nodes.

template<std::size_t N, typename T >

T geom::computeLowerBoundOnSignedDistance	(	const BBox< N, T > &	box,
		const typename BBox< N, T >::Point &	x
	)			[inline]

Return an lower bound on the signed distance from the point to the objects in the box.

Consider some objects contained in the bounding box: box. (Specifically, the objects form an N-D manifold. The distance from the point x to the manifold is signed; positive outside and negative inside.) This function returns an lower bound on the distance to the objects.

template<class SMR >

SMR::Vertex geom::computeNodeNormal

(

typename SMR::NodeConstIterator

node

)

[inline]

Return the normal to the surface.

Parameters:

node

Must be a boundary node.

template<class SMR >

void geom::computeNodeNormal	(	typename SMR::NodeConstIterator	node,
		typename SMR::Vertex *	normal
	)			[inline]

Compute the normal to the surface.

Parameters:

	node	Must be a boundary node.
	normal	Set to the node normal.

template<std::size_t N, typename T >

T geom::computeUpperBoundOnSignedDistance	(	const BBox< N, T > &	box,
		const typename BBox< N, T >::Point &	x
	)			[inline]

Return an upper bound on the signed distance from the point to the objects in the box.

Consider some objects contained in the bounding box: box. (Specifically, the objects form an N-D manifold. The distance from the point x to the manifold is signed; positive outside and negative inside.) This function returns an upper bound on the distance to the objects.

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename IntInIter >

void geom::convertIdentifiersToIterators	(	SimpMeshRed< N, M, T, Node, Cell, Cont > &	mesh,
		IntInIter	begin,
		IntInIter	end,
		typename SimpMeshRed< N, M, T, Node, Cell, Cont >::CellIteratorSet *	cells
	)			[inline]

Build a set of cell iterators from a range of cell identifiers.

Parameters:

	mesh	The simplicial mesh. It is not modified, but because we are getting cell iterators (not cell const iterators) we pass it by reference (not const reference).
	begin	The beginning of the range of identifiers.
	end	The end of the range of identifiers.
	cells	The set of cell iterators.

The cell identifiers may not be the same as the cell indices. (Cell indices would be in the range [ 0 .. mesh.cells_size()).

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>

void geom::countAdjacencies	(	const SimpMeshRed< N, M, T, Node, Cell, Cont > &	mesh,
		std::tr1::array< std::size_t, M+2 > *	counts
	)			[inline]

Calculate the adjacency counts for the simplices in the mesh.

Each simplex has between 0 and M+1 (inclusive) adjacent simplices.

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>

void geom::determineBoundaryNeighbors	(	SimpMeshRed< N, M, T, Node, Cell, Cont > &	mesh,
		typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIterator	node,
		typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIteratorSet *	neighbors
	)			[inline]

Get the neighboring boundary nodes of a node.

The set of boundary nodes (not including the specified node) that share a cell with the specified node.

template<typename NodeInIter , typename OutIter >

void geom::determineBoundaryNodes	(	NodeInIter	begin,
		NodeInIter	end,
		OutIter	iter
	)			[inline]

Get the node iterators for the boundary nodes.

Parameters:

	begin	is the beginning of a range of node input iterators.
	end	is the end of a range of node input iterators.
	iter	is an output iterator for the node iterators.

Referenced by geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::determineBoundaryNodes().

template<typename CellInIter , class LSF , typename OutIter >

void geom::determineCellsOutside	(	CellInIter	begin,
		CellInIter	end,
		const LSF &	f,
		OutIter	iter
	)			[inline]

Get the cells whose centroids are outside the object.

Parameters:

	begin	is the beginning of a range of cell input iterators.
	end	is the end of a range of cell input iterators.
	f	is the level set function that describes the object. Points inside/outside the object have negative/positive values.
	iter	is an output iterator for the cell const iterators.

This function calls the function of the same name with const iterators as the initial arguments.

Referenced by geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::determineCellsOutside().

template<typename CellInIter , typename OutIter >

void geom::determineCellsWithLowAdjacencies	(	CellInIter	begin,
		CellInIter	end,
		const std::size_t	minimumRequiredAdjacencies,
		OutIter	iter
	)			[inline]

Get the cell iterators with adjacencies less than specified.

Parameters:

	begin	is the beginning of a range of cell input iterators.
	end	is the end of a range of cell input iterators.
	minimumRequiredAdjacencies	This function gets the cells that have fewer adjacencies than minimumRequiredAdjacencies.
	iter	is an output iterator for the cell iterators.

Referenced by geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::determineCellsWithLowAdjacencies().

template<typename CellInIter , typename OutIter >

void geom::determineCellsWithRequiredAdjacencies	(	CellInIter	begin,
		CellInIter	end,
		std::size_t	minimumRequiredAdjacencies,
		OutIter	iter
	)			[inline]

Get the cell iterators with at least the specified number of adjacencies.

Parameters:

	begin	is the beginning of a range of cell input iterators.
	end	is the end of a range of cell input iterators.
	minimumRequiredAdjacencies	The minimum required adjacencies.
	iter	is an output iterator for the cell iterators.

Referenced by geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::determineCellsWithRequiredAdjacencies().

template<typename NodeInIter , typename OutIter >

void geom::determineInteriorNodes	(	NodeInIter	begin,
		NodeInIter	end,
		OutIter	iter
	)			[inline]

Get the node iterators for the interior nodes.

Parameters:

	begin	is the beginning of a range of node input iterators.
	end	is the end of a range of node input iterators.
	iter	is an output iterator for the node iterators.

Referenced by geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::determineInteriorNodes().

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>

void geom::determineNeighbors	(	SimpMeshRed< N, M, T, Node, Cell, Cont > &	mesh,
		typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIterator	node,
		std::size_t	radius,
		typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIteratorSet *	neighbors
	)			[inline]

Get all the nodes within the specified radius of the specified node.

The set includes the specified node.

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>

void geom::determineNeighbors	(	SimpMeshRed< N, M, T, Node, Cell, Cont > &	mesh,
		typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIterator	node,
		typename SimpMeshRed< N, M, T, Node, Cell, Cont >::NodeIteratorSet *	neighbors
	)			[inline]

Get the neighboring nodes of a node.

The set of nodes (not including the specified node) that share a cell with the specified node.

template<typename NodeInIter , class LSF , typename OutIter >

void geom::determineNodesOutside	(	NodeInIter	begin,
		NodeInIter	end,
		const LSF &	f,
		OutIter	iter
	)			[inline]

Get the nodes that are outside the object.

Parameters:

	begin	is the beginning of a range of node input iterators.
	end	is the end of a range of node input iterators.
	f	is the level set function that describes the object. Points inside/outside the object have negative/positive values.
	iter	is an output iterator for the node const iterators.

Referenced by geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::determineNodesOutside().

template<typename _T , std::size_t _N>

std::tr1::array< _T, _N - 1 > geom::getFace	(	const std::tr1::array< _T, _N > &	simplex,
		const std::size_t	n
	)			[inline]

Return the face obtained by removing the n_th vertex.

For the simplex (v[0], ... v[N]) return (-1)^n (v[0], ..., v[n-1], v[n+1], ..., v[N]).

References getFace().

template<typename _T , std::size_t _N>

void geom::getFace	(	const std::tr1::array< _T, _N > &	simplex,
		const std::size_t	n,
		std::tr1::array< _T, _N-1 > *	face
	)			[inline]

Get the face obtained by removing the n_th vertex.

For the simplex (v[0], ... v[N]) the face is (-1)^n (v[0], ..., v[n-1], v[n+1], ..., v[N]).

References reverseOrientation().

Referenced by getFace().

template<typename NodeInIter , typename OutIter >

void geom::getNodes	(	NodeInIter	begin,
		NodeInIter	end,
		OutIter	iter
	)			[inline]

Get the node iterators for the all of the nodes in the mesh.

Parameters:

	begin	is the beginning of a range of node input iterators.
	end	is the end of a range of node input iterators.
	iter	is an output iterator for the node iterators.

Referenced by geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::getNodes().

template<typename _T >

bool geom::hasFace	(	const std::tr1::array< _T, 3+1 > &	simplex,
		const _T &	x,
		const _T &	y,
		const _T &	z,
		std::size_t *	faceIndex
	)			[inline]

Return true if the 3-simplex has the face specified by the three vertices.

Set the face index.

References computeOtherIndex(), and hasFace().

template<typename _T , std::size_t _N, std::size_t _M>

bool geom::hasFace	(	const std::tr1::array< _T, _N > &	simplex,
		const std::tr1::array< _T, _M > &	face
	)			[inline]

Return true if the simplex has the given face as a sub-simplex.

This function does not check the orientation of the face. It returns true if the simplex has each of the vertices in the face.

References hasFace().

template<typename _T , std::size_t _N, std::size_t _M>

bool geom::hasFace	(	const std::tr1::array< _T, _N > &	simplex,
		const std::tr1::array< _T, _M > &	face,
		std::size_t *	faceIndex
	)			[inline]

Return true if the N-simplex has the specified (N-1)-face.

If true, set the face index.

Referenced by hasFace(), and geom::SmrCell< SMR >::hasFace().

template<typename _T >

bool geom::haveSameOrientation	(	const std::tr1::array< _T, 2+1 > &	x,
		const std::tr1::array< _T, 2+1 > &	y
	)			[inline]

Return true if the two simplices have the same orientation.

Precondition:

x and y must have the same vertices.

template<typename _T >

bool geom::haveSameOrientation	(	const std::tr1::array< _T, 1+1 > &	x,
		const std::tr1::array< _T, 1+1 > &	y
	)			[inline]

Return true if the two simplices have the same orientation.

Precondition:

x and y must have the same vertices.

template<typename _T >

bool geom::haveSameOrientation	(	const std::tr1::array< _T, 0+1 > &	x,
		const std::tr1::array< _T, 0+1 > &	y
	)			[inline]

Return true if the two simplices have the same orientation.

Precondition:

x and y must have the same vertices.

template<std::size_t N, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>

std::size_t geom::incidenceOptimize	(	SimpMeshRed< N, 2, T, Node, Cell, Cont > *	mesh,
		std::size_t	norm,
		std::size_t	numSweeps = 0
	)			[inline]

Modify the topology to optimize the cell-node incidences.

Parameters:

	mesh	The simplicial mesh.
	norm	The norm used in incidence optimization. May be 0, 1, or 2.
	numSweeps	The number of sweeps over the faces. By default, the number of sweeps is not limited.

Returns:

the number of edges flipped.

Referenced by main().

template<typename T >

void geom::project	(	const std::tr1::array< std::tr1::array< T, 3 >, 2+1 > &	s3,
		const std::tr1::array< T, 3 > &	x3,
		std::tr1::array< std::tr1::array< T, 2 >, 2+1 > *	s2,
		std::tr1::array< T, 2 > *	x2,
		std::tr1::array< T, 1 > *	z1
	)			[inline]

Project the simplex and the point in 3-D to 2-D.

The first point in the 3-D simplex will be mapped to the origin; the second point will be mapped to the positive x axis. The triangle will have the positive orientation in the 2-D plane. The 3-D point will be mapped to the xy-plane.

Parameters:

	s3	is the 2-simplex in 3-D.
	x3	is the 3-D point.
	s2	is the mapped simplex, a 2-simplex in 2-D.
	x2	is the mapped point, a 2-D point.
	z1	is the normal offset of x3 from s3.

template<typename T >

void geom::project	(	const std::tr1::array< std::tr1::array< T, 3 >, 2+1 > &	s3,
		const std::tr1::array< T, 3 > &	x3,
		std::tr1::array< std::tr1::array< T, 2 >, 2+1 > *	s2,
		std::tr1::array< T, 2 > *	x2
	)			[inline]

Project the simplex and the point in 3-D to 2-D.

The first point in the 3-D simplex will be mapped to the origin; the second point will be mapped to the positive x axis. The triangle will have the positive orientation in the 2-D plane. The 3-D point will be mapped to the xy-plane.

Parameters:

	s3	is the 2-simplex in 3-D.
	x3	is the 3-D point.
	s2	is the mapped simplex, a 2-simplex in 2-D.
	x2	is the mapped point, a 2-D point.

template<typename T >

void geom::project	(	const std::tr1::array< std::tr1::array< T, 2 >, 1+1 > &	s2,
		const std::tr1::array< T, 2 > &	x2,
		std::tr1::array< std::tr1::array< T, 1 >, 1+1 > *	s1,
		std::tr1::array< T, 1 > *	x1,
		std::tr1::array< T, 1 > *	y1
	)			[inline]

Project the simplex and the point in 2-D to 1-D.

The first point in the 2-D simplex will be mapped to the origin; the second point will be mapped to the positive x axis. The 2-D point will be mapped to the x-axis.

Parameters:

	s2	is the 1-simplex in 2-D.
	x2	is the 2-D point.
	s1	is the mapped simplex, a 1-simplex in 1-D.
	x1	is the mapped point, a 1-D point.
	y1	is the normal offset of x2 from s2.

template<typename T >

void geom::project	(	const std::tr1::array< std::tr1::array< T, 2 >, 1+1 > &	s2,
		const std::tr1::array< T, 2 > &	x2,
		std::tr1::array< std::tr1::array< T, 1 >, 1+1 > *	s1,
		std::tr1::array< T, 1 > *	x1
	)			[inline]

Project the simplex and the point in 2-D to 1-D.

The first point in the 2-D simplex will be mapped to the origin; the second point will be mapped to the positive x axis. The 2-D point will be mapped to the x-axis.

Parameters:

	s2	is the 1-simplex in 2-D.
	x2	is the 2-D point.
	s1	is the mapped simplex, a 1-simplex in 1-D.
	x1	is the mapped point, a 1-D point.

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename IntInputIterator , class MaxEdgeLength >

std::size_t geom::refine	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		IntInputIterator	begin,
		IntInputIterator	end,
		const MaxEdgeLength &	f
	)			[inline]

Refine the specified cells using the maximum edge length function.

Parameters:

	mesh	The simplicial mesh.
	begin	The beginning of a range of cell indices.
	end	The end of a range of cell indices.
	f	The maximum edge length functor. The algorithm will split edges above this threshold.

This simply calls the above function with a null pointer for the boundary manifold data structure.

Returns:

the number of edges split.

References M, N, and refine().

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD, typename IntInputIterator , class MaxEdgeLength >

std::size_t geom::refine	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		PointsOnManifold< N, MM, SD, T > *	manifold,
		IntInputIterator	begin,
		IntInputIterator	end,
		const MaxEdgeLength &	f
	)			[inline]

Refine the specified cells using the maximum edge length function.

Parameters:

	mesh	The simplicial mesh.
	manifold	The manifold data structure.
	begin	The beginning of a range of cell indices.
	end	The end of a range of cell indices.
	f	The maximum edge length functor. The algorithm will split edges above this threshold.

This function will refine the cells whose edge lengths exceed the maximum specified edge length.

Returns:

the number of edges split.

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, typename IntInputIterator >

std::size_t geom::refine	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		IntInputIterator	begin,
		IntInputIterator	end
	)			[inline]

Refine the mesh by splitting the specified cells.

Parameters:

	mesh	The simplicial mesh.
	begin	The beginning of a range of cell indices.
	end	The end of a range of cell indices.

This simply calls the above function with a null pointer for the boundary manifold data structure.

Returns:

the number of edges split.

References M, N, and refine().

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD, typename IntInputIterator >

std::size_t geom::refine	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		PointsOnManifold< N, MM, SD, T > *	manifold,
		IntInputIterator	begin,
		IntInputIterator	end
	)			[inline]

Refine the mesh by splitting the specified cells.

Parameters:

	mesh	The simplicial mesh.
	manifold	The boundary manifold data structure. By default it is null.
	begin	The beginning of a range of cell indices.
	end	The end of a range of cell indices.

Returns:

the number of edges split.

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MaxEdgeLength >

std::size_t geom::refine	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		const MaxEdgeLength &	f
	)			[inline]

Refine the mesh using the maximum edge length function.

Parameters:

	mesh	The simplicial mesh.
	f	The maximum edge length functor. The algorithm will split edges above this threshold.

This simply calls the above function with a null pointer for the boundary manifold data structure.

Returns:

the number of edges split.

References M, N, and refine().

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD, class MaxEdgeLength >

std::size_t geom::refine	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		PointsOnManifold< N, MM, SD, T > *	manifold,
		const MaxEdgeLength &	f
	)			[inline]

Refine the mesh using the maximum edge length function.

Parameters:

	mesh	The simplicial mesh.
	manifold	The manifold data structure.
	f	The maximum edge length functor. The algorithm will split edges above this threshold.

Returns:

the number of edges split.

Referenced by main(), refine(), and geom::OrthtreeMap< _Dimension, _MaximumLevel, _Element, _AutomaticBalancing, _Split, _Merge, _Refine, _Coarsen, _Action, _Key >::refine().

template<typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class MaxEdgeLength >

std::size_t geom::refineAdjust	(	SimpMeshRed< 2, 2, T, Node, Cell, Cont > *	mesh,
		const MaxEdgeLength &	f
	)			[inline]

Refine and adjust the mesh using the maximum edge length function.

Parameters:

	mesh	The simplicial mesh.
	f	The maximum edge length functor. The algorithm will split edges above this threshold.

When an edge is split, incidence optimization and Laplacian smoothing is performed to adjust the mesh.

Returns:

the number of edges split.

template<typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class Distance , class ClosestPoint , class MaxAngle , class MinEdgeLength >

std::size_t geom::refineBoundary	(	SimpMeshRed< 2, 2, T, Node, Cell, Cont > *	x,
		const Distance &	distance,
		const ClosestPoint &	closestPoint,
		const MaxAngle &	maxAngle,
		const MinEdgeLength &	minEdgeLength,
		std::size_t	maxSweeps = 10
	)			[inline]

Refine the mesh to better fit the boundary.

Returns:

the number of edges split.

template<typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, class ISS >

std::size_t geom::refineBoundary	(	SimpMeshRed< 2, 2, T, Node, Cell, Cont > *	x,
		const ISS &	boundary,
		T	maxAngle,
		T	minEdgeLength,
		std::size_t	maxSweeps = 10
	)			[inline]

Refine the mesh to better fit the boundary.

Returns:

the number of edges split.

Referenced by main().

template<std::size_t N, std::size_t M, typename T , template< class > class Vertex, template< class > class Cell, template< class, class > class Container, class LSF >

void geom::tile	(	const BBox< N, T > &	domain,
		const T	length,
		const LSF &	f,
		SimpMeshRed< N, M, T, Vertex, Cell, Container > *	mesh
	)			[inline]

Tile the object.

Parameters:

	domain	is the rectilinear domain to tile.
	length	is the maximum tetrahedron edge length.
	f	is the level set description of the object.
	mesh	is the indexed simplex set.

In 2-D, tile the rectangular region with equilateral triangles. In 3-D, tile with a body-centered cubic lattice.

The template parameters can be deduced from the arguments.

References geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::build(), and tile().

template<std::size_t N, std::size_t M, typename T , template< class > class Vertex, template< class > class Cell, template< class, class > class Container>

void geom::tile	(	const BBox< N, T > &	domain,
		const T	length,
		SimpMeshRed< N, M, T, Vertex, Cell, Container > *	mesh
	)			[inline]

Tile the rectilinear region.

Parameters:

	domain	is the rectilinear domain to tile.
	length	is the maximum tetrahedron edge length.
	mesh	is the indexed simplex set.

In 2-D, tile the rectangular region with equilateral triangles. In 3-D, tile with a body-centered cubic lattice.

CONTINUE: draw a picture of the 2-D mesh and 3-D block.

The template parameters can be deduced from the arguments.

References geom::SimpMeshRed< _N, _M, T, _Node, _Cell, Container >::build().

Referenced by main(), tile(), and geom::IndSimpSet< _N, _M, T >::tile().

template<class _QualityMetric , typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t SD>

std::size_t geom::topologicalOptimize	(	SimpMeshRed< 3, 3, T, Node, Cell, Cont > *	mesh,
		const PointsOnManifold< 3, 2, SD, T > *	manifold,
		std::multiset< std::pair< std::size_t, std::size_t > > *	edgeRemovalOperations = 0,
		std::multiset< std::pair< std::size_t, std::size_t > > *	faceRemovalOperations = 0,
		std::size_t	maximumSteps = std::numeric_limits< std::size_t >::max()
	)			[inline]

Use edge and face removal to optimize the mesh.

Parameters:

	mesh	The simplicial mesh.
	manifold	The manifold data structure. We pass this by const reference, because the topological optimization will not change the manifold data structure.
	edgeRemovalOperations	Multi-set to record the edge removal operations.
	faceRemovalOperations	Multi-set to record the face removal operations.
	maximumSteps	The maximum allowed number of steps.

Use the specified metric.

Returns:

The number of edge and face removal operations.

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD>

std::size_t geom::topologicalOptimizeUsingConditionNumber	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		const PointsOnManifold< N, MM, SD, T > *	manifold,
		std::multiset< std::pair< std::size_t, std::size_t > > *	edgeRemovalOperations = 0,
		std::multiset< std::pair< std::size_t, std::size_t > > *	faceRemovalOperations = 0,
		const std::size_t	maximumSteps = std::numeric_limits<std::size_t>::max()
	)			[inline]

Use edge and face removal to optimize the mesh.

Parameters:

	mesh	The simplicial mesh.
	manifold	The manifold data structure.
	edgeRemovalOperations	Multi-set to record the edge removal operations.
	faceRemovalOperations	Multi-set to record the face removal operations.
	maximumSteps	The maximum allowed number of steps.

Use the modified mean ratio metric.

Returns:

The number of edge and face removal operations.

Referenced by main().

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont, std::size_t MM, std::size_t SD>

std::size_t geom::topologicalOptimizeUsingMeanRatio	(	SimpMeshRed< N, M, T, Node, Cell, Cont > *	mesh,
		const PointsOnManifold< N, MM, SD, T > *	manifold,
		std::multiset< std::pair< std::size_t, std::size_t > > *	edgeRemovalOperations = 0,
		std::multiset< std::pair< std::size_t, std::size_t > > *	faceRemovalOperations = 0,
		const std::size_t	maximumSteps = std::numeric_limits<std::size_t>::max()
	)			[inline]

Use edge and face removal to optimize the mesh.

Parameters:

	mesh	The simplicial mesh.
	manifold	The manifold data structure.
	edgeRemovalOperations	Multi-set to record the edge removal operations.
	faceRemovalOperations	Multi-set to record the face removal operations.
	maximumSteps	The maximum allowed number of steps.

Use the modified mean ratio metric.

Returns:

The number of edge and face removal operations.

Referenced by main().

template<typename SMR , typename NodeIterInIter , class UnaryFunction >

void geom::transformNodes	(	NodeIterInIter	begin,
		NodeIterInIter	end,
		const UnaryFunction &	f
	)			[inline]

Transform each vertex in the range with the specified function.

The first template argument must be specified explicitly.

template<std::size_t N, std::size_t M, typename T , template< class > class Node, template< class > class Cell, template< class, class > class Cont>

void geom::writeAscii	(	std::ostream &	out,
		const SimpMeshRed< N, M, T, Node, Cell, Cont > &	x
	)			[inline]

Write a mesh as an indexed simplex set in ascii format.

First the space dimension and the simplex dimension are written. Then the vertex coordinates are written, followed by the tuples of vertex indices that comprise the simplices. The file format is:

  space_dimension simplex_dimension
  num_vertices
  vertex_0_coord_0 vertex_0_coord_1 ... vertex_0_coord_N-1
  vertex_1_coord_0 vertex_1_coord_1 ... vertex_1_coord_N-1
  ...
  num_simplices
  simplex_0_index_0 simplex_0_index_1 ... simplex_0_index_M
  simplex_1_index_0 simplex_1_index_1 ... simplex_1_index_M
  ...