vcg::tri Namespace Reference

Namespaces
	io

Classes
class	Allocator
	Class to safely add and delete elements in a mesh. More...
class	Append
	Class to safely duplicate and append (portion of) meshes. More...
class	UpdateBounding
	This class is used to compute or update the bounding box of a mesh.. More...
class	UpdateColor
	Generation and processing of per-vertex and per-face colors according to various strategy. More...
class	UpdateComponentEP
	This class is used to compute or update the precomputed data used to efficiently compute point-face distances. More...
class	UpdateCurvature
	Management, updating and computation of per-vertex and per-face normals. More...
class	UpdateCurvatureFitting
	Computation of per-vertex directions and values of curvature. More...
class	Fitmaps
class	UpdateFlags
	Management, updating and computation of per-vertex and per-face flags (like border flags). More...
class	UpdateHalfEdges
	This class is used to build edge based data structure from indexed data structure and viceversa. More...
struct	UpdateIndexed
class	HalfEdgeTopology
	Class containing functions to modify the topology of a halfedge based mesh. More...
class	UpdateNormal
	Management, updating and computation of per-vertex, per-face, and per-wedge normals. More...
class	UpdatePosition
	This class is used to update vertex position according to a transformation matrix. More...
class	UpdateQuality
	Generation of per-vertex and per-face qualities. More...
class	SelectionStack
	A stack for saving and restoring selection. More...
class	UpdateSelection
	Management, updating and conditional computation of selections (per-vertex, per-edge, and per-face). More...
class	UpdateTexture
	This class is used to update/generate texcoord position according to various critera. More...
class	UpdateTopology
	Generation of per-vertex and per-face topological information. More...
class	Inertia
	Methods for computing Polyhedral Mass properties (like inertia tensor, volume, etc) More...
class	TrivialSampler
	A basic sampler class that show the required interface used by the SurfaceSampling class. More...
class	TrivialPointerSampler
class	MeshSampler
class	HausdorffSampler
class	RedetailSampler
class	SurfaceSampling
	Main Class of the Sampling framework. More...
class	EdgeConnectedComponentIterator
class	ConnectedComponentIterator
class	Clean
	Class of static functions to clean//restore meshs. More...
class	Split
struct	BaseInterpolator
struct	MidPoint
struct	MidPointArc
struct	MidPointArcNaive
class	EdgeLen
class	RefinedFaceData
struct	MidPointButterfly
struct	MidPointButterfly2
class	QualityMidPointFunctor
class	QualityEdgePredicate
struct	MidPointSphere
class	EdgeSplSphere
struct	CenterPointBarycenter
class	TriSplit
	Triangle split Simple templated function for splitting a triangle with a internal point. It can be templated on a CenterPoint class that is used to generate the position of the internal point. More...
struct	_SphUsedTypes
class	_SphVertex
class	_SphFace
class	_SphMesh
struct	EuclideanDistance
class	IsotropicDistance
struct	BasicCrossFunctor
class	AnisotropicDistance
class	Geodesic
	class for computing approximate geodesic distances on a mesh More...

Functions
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::VertexType &v)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::FaceType &f)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::EdgeType &e)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::HEdgeType &h)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::TetraType &t)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::VertexType *vp)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::FaceType *fp)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::EdgeType *e)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::HEdgeType *h)
template<class MeshType >
size_t	Index (const MeshType &m, const typename MeshType::TetraType *t)
template<class MeshType >
bool	IsValidPointer (MeshType &m, const typename MeshType::VertexType *vp)
template<class MeshType >
bool	IsValidPointer (MeshType &m, const typename MeshType::EdgeType *ep)
template<class MeshType >
bool	IsValidPointer (MeshType &m, const typename MeshType::FaceType *fp)
template<class MeshType >
bool	IsValidPointer (MeshType &m, const typename MeshType::HEdgeType *hp)
template<class MeshType >
bool	IsValidPointer (MeshType &m, const typename MeshType::TetraType *tp)
template<class MeshType , class ATTR_CONT >
void	ReorderAttribute (ATTR_CONT &c, std::vector< size_t > &newVertIndex, MeshType &)
template<class MeshType , class ATTR_CONT >
void	ResizeAttribute (ATTR_CONT &c, size_t sz, MeshType &)
template<class MeshType , typename Callable >
void	ForEachFacePos (const MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachFacePos (MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachFace (const MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachFace (MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachVertex (const MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachVertex (MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachHEdge (const MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachHEdge (MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachEdge (const MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachEdge (MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachTetra (const MeshType &m, Callable action)
template<class MeshType , typename Callable >
void	ForEachTetra (MeshType &m, Callable action)
template<class MeshType >
MeshType::ScalarType	ComputePoissonDiskRadius (MeshType &origMesh, int sampleNum)
template<class MeshType >
void	MontecarloSampling (MeshType &m, MeshType &mm, int sampleNum)
template<class MeshType >
void	MontecarloSampling (MeshType &m, std::vector< Point3f > &montercarloSamples, int sampleNum)
template<class MeshType >
void	PoissonSampling (MeshType &m, std::vector< typename MeshType::CoordType > &poissonSamples, int sampleNum, typename MeshType::ScalarType &radius, typename MeshType::ScalarType radiusVariance=1, typename MeshType::ScalarType PruningByNumberTolerance=0.04f, unsigned int randSeed=0)
template<class MeshType >
void	PoissonPruning (MeshType &m, std::vector< typename MeshType::VertexPointer > &poissonSamples, float radius, unsigned int randSeed=0)
	Low level wrapper for Poisson Disk Pruning. More...
template<class MeshType >
void	PoissonPruning (MeshType &m, std::vector< typename MeshType::CoordType > &poissonSamples, float radius, unsigned int randSeed=0)
	Low level wrapper for Poisson Disk Pruning. More...
template<class MeshType >
void	PoissonPruningExact (MeshType &m, std::vector< typename MeshType::VertexPointer > &poissonSamples, typename MeshType::ScalarType &radius, int sampleNum, float tolerance=0.04, int maxIter=20, unsigned int randSeed=0)
	Very simple wrapping for the Exact Poisson Disk Pruning. More...
template<class MESH_TYPE , class MIDPOINT , class EDGEPRED >
bool	RefineE (MESH_TYPE &m, MIDPOINT &mid, EDGEPRED &ep, bool RefineSelected=false, CallBackPos *cb=0)
template<class MESH_TYPE , class MIDPOINT >
bool	Refine (MESH_TYPE &m, MIDPOINT mid, typename MESH_TYPE::ScalarType thr=0, bool RefineSelected=false, CallBackPos *cb=0)
template<class MeshType >
void	TrivialMidPointRefine (MeshType &m)
template<class MESH_TYPE , class EDGEPRED >
bool	RefineMidpoint (MESH_TYPE &m, EDGEPRED &ep, bool RefineSelected=false, CallBackPos *cb=0)
template<class TetraMeshType >
void	Tetrahedron (TetraMeshType &in)
template<class DodMeshType >
void	Dodecahedron (DodMeshType &in)
template<class OctMeshType >
void	Octahedron (OctMeshType &in)
template<class IcoMeshType >
void	Icosahedron (IcoMeshType &in)
template<class MeshType >
void	Hexahedron (MeshType &in)
template<class MeshType >
void	Square (MeshType &in)
template<class MeshType >
void	SphericalCap (MeshType &in, float angleRad, const int subdiv=3)
template<class MeshType >
void	Sphere (MeshType &in, const int subdiv=3)
template<class MeshType >
void	Sphere (MeshType &m, const typename MeshType::CoordType &position, typename MeshType::ScalarType radius=0, const int subdiv=3)
template<class MeshType >
void	Cone (MeshType &in, const typename MeshType::ScalarType r1, const typename MeshType::ScalarType r2, const typename MeshType::ScalarType h, const int SubDiv=36)
	r1 = raggio 1, r2 = raggio2, h = altezza (asse y)
template<class MeshType >
void	OrientedCone (MeshType &m, const typename MeshType::CoordType origin, const typename MeshType::CoordType end, const typename MeshType::ScalarType r1, const typename MeshType::ScalarType r2, const int SubDiv=36)
template<class MeshType >
void	Box (MeshType &in, const typename MeshType::BoxType &bb)
template<class MeshType >
void	Torus (MeshType &m, float hRingRadius, float vRingRadius, int hRingDiv=24, int vRingDiv=12)
template<class MeshType >
void	SuperToroid (MeshType &m, float hRingRadius, float vRingRadius, float vSquareness, float hSquareness, int hRingDiv=24, int vRingDiv=12)
template<class MeshType >
void	SuperEllipsoid (MeshType &m, float rFeature, float sFeature, float tFeature, int hRingDiv=24, int vRingDiv=12)
template<class MeshType , class InCoordType , class InFaceIndexType >
void	BuildMeshFromCoordVectorIndexVector (MeshType &in, const std::vector< InCoordType > &v, const std::vector< InFaceIndexType > &f)
template<class MeshType , class V >
void	BuildMeshFromCoordVector (MeshType &in, const V &v)
template<class TriMeshType , class EdgeMeshType >
void	BuildFromFaceEdgeSel (TriMeshType &in, EdgeMeshType &out)
template<class MeshType >
void	Grid (MeshType &in, int w, int h, float wl, float hl, float *data=0)
template<class MeshType >
void	FaceGrid (MeshType &in, int w, int h)
template<class MeshType >
void	SparseFaceGrid (MeshType &in, const std::vector< int > &grid, int w, int h)
template<class MeshType >
void	Annulus (MeshType &m, float externalRadius, float internalRadius, int slices)
template<class MeshType >
void	OrientedAnnulus (MeshType &m, Point3f center, Point3f norm, float externalRadius, float internalRadius, int slices)
template<class MeshType >
void	Disk (MeshType &m, int slices)
template<class MeshType >
void	OrientedDisk (MeshType &m, int slices, typename MeshType::CoordType center, typename MeshType::CoordType norm, float radius)
template<class MeshType >
void	OrientedEllipticPrism (MeshType &m, const typename MeshType::CoordType origin, const typename MeshType::CoordType end, float radius, float xScale, float yScale, bool capped, int slices=32, int stacks=4)
template<class MeshType >
void	OrientedCylinder (MeshType &m, const typename MeshType::CoordType origin, const typename MeshType::CoordType end, float radius, bool capped, int slices=32, int stacks=4)
template<class MeshType >
void	Cylinder (int slices, int stacks, MeshType &m, bool capped=false)
template<class MeshType >
void	BuildPrismFaceShell (MeshType &mIn, MeshType &mOut, float height=0, float inset=0, bool smoothFlag=false)
template<class MeshType >
void	BuildCylinderEdgeShell (MeshType &mIn, MeshType &mOut, float radius=0, int slices=16, int stacks=1)
template<class MeshType >
void	BuildSphereVertexShell (MeshType &mIn, MeshType &mOut, float radius=0, int recDiv=2)
template<class MeshType >
void	BuildCylinderVertexShell (MeshType &mIn, MeshType &mOut, float radius=0, float height=0, int slices=16, int stacks=1)
template<class MeshType >
void	GenerateCameraMesh (MeshType &in)
template<class MeshType >
void	OrientedRect (MeshType &square, float width, float height, Point3f c, Point3f dir=Point3f(0, 0, 0), float angleDeg=0, Point3f preRotTra=Point3f(0, 0, 0))
template<class MeshType >
void	OrientedSquare (MeshType &square, float width, Point3f c, Point3f dir=Point3f(0, 0, 0), float angleDeg=0, Point3f preRotTra=Point3f(0, 0, 0))

Variables
const Split	SplitTab [8]

Detailed Description

Everything about triangular meshes lie in this namespace

Function Documentation

BuildMeshFromCoordVectorIndexVector()

template<class MeshType , class InCoordType , class InFaceIndexType >

void vcg::tri::BuildMeshFromCoordVectorIndexVector	(	MeshType &	in,
		const std::vector< InCoordType > &	v,
		const std::vector< InFaceIndexType > &	f
	)

This function build a mesh starting from a vector of generic coords (InCoordType) and indexes (InFaceIndexType) InCoordsType needs to have a [] access method for accessing the three coordinates and similarly the InFaceIndexType requires [] access method for accessing the three indexes

Dodecahedron()

template<class DodMeshType >

void vcg::tri::Dodecahedron

(

DodMeshType &

in

)

builds a Dodecahedron, (each pentagonal face is composed by 5 triangles)

PoissonPruning() [1/2]

template<class MeshType >

void vcg::tri::PoissonPruning	(	MeshType &	m,
		std::vector< typename MeshType::CoordType > &	poissonSamples,
		float	radius,
		unsigned int	randSeed = 0
	)

Low level wrapper for Poisson Disk Pruning.

This function simply takes a mesh containing a point cloud to be pruned and a radius It returns a vector of CoordType listing the "surviving" points.

PoissonPruning() [2/2]

template<class MeshType >

void vcg::tri::PoissonPruning	(	MeshType &	m,
		std::vector< typename MeshType::VertexPointer > &	poissonSamples,
		float	radius,
		unsigned int	randSeed = 0
	)

Low level wrapper for Poisson Disk Pruning.

This function simply takes a mesh and a radius and returns a vector of vertex pointers listing the "surviving" points.

PoissonPruningExact()

template<class MeshType >

void vcg::tri::PoissonPruningExact	(	MeshType &	m,
		std::vector< typename MeshType::VertexPointer > &	poissonSamples,
		typename MeshType::ScalarType &	radius,
		int	sampleNum,
		float	tolerance = 0.04,
		int	maxIter = 20,
		unsigned int	randSeed = 0
	)

Very simple wrapping for the Exact Poisson Disk Pruning.

This function simply takes a mesh and an expected number of points and returns vector of points. It performs multiple attempts with varius radii to correctly get the expected number of samples. It is obviously much slower than the other versions...

Parameters

poissonSamples	the mesh that has to be pruned
radius	the vector that will contain the chosen set of points

SuperEllipsoid()

template<class MeshType >

void vcg::tri::SuperEllipsoid	(	MeshType &	m,
		float	rFeature,
		float	sFeature,
		float	tFeature,
		int	hRingDiv = 24,
		int	vRingDiv = 12
	)

Generate a SuperEllipsoid eg a solid whose horizontal sections are super-ellipses (Lamé curves) with the same exponent r, and whose vertical sections through the center are super-ellipses with the same exponent t.

SuperToroid()

template<class MeshType >

void vcg::tri::SuperToroid	(	MeshType &	m,
		float	hRingRadius,
		float	vRingRadius,
		float	vSquareness,
		float	hSquareness,
		int	hRingDiv = 24,
		int	vRingDiv = 12
	)

SuperToroid

Generate a a supertoroid, e.g. a member of a family of doughnut-like surfaces (technically, a topological torus) whose shape is defined by mathematical formulas similar to those that define the superquadrics.

Tetrahedron()

template<class TetraMeshType >

void vcg::tri::Tetrahedron

(

TetraMeshType &

in

)

A set of functions that builds meshes that represent surfaces of platonic solids, and other simple shapes.

The 1st parameter is usually the mesh that will be filled with the solid.

Variable Documentation

SplitTab

const Split vcg::tri::SplitTab[8]

Initial value:

={
 
    {1, {{0,1,2},{0,0,0},{0,0,0},{0,0,0}}, {{0,0},{0,0}},  {{0,1,2},{0,0,0},{0,0,0},{0,0,0}} },
    {2, {{0,3,2},{3,1,2},{0,0,0},{0,0,0}}, {{0,0},{0,0}},  {{0,3,2},{0,1,3},{0,0,0},{0,0,0}} },
    {2, {{0,1,4},{0,4,2},{0,0,0},{0,0,0}}, {{0,0},{0,0}},  {{0,1,3},{3,1,2},{0,0,0},{0,0,0}} },
    {3, {{3,1,4},{0,3,2},{4,2,3},{0,0,0}}, {{0,4},{3,2}},  {{0,1,3},{0,3,2},{1,3,3},{0,0,0}} },
    {2, {{0,1,5},{5,1,2},{0,0,0},{0,0,0}}, {{0,0},{0,0}},  {{0,3,2},{3,1,2},{0,0,0},{0,0,0}} },
    {3, {{0,3,5},{3,1,5},{2,5,1},{0,0,0}}, {{3,2},{5,1}},  {{0,3,2},{0,3,3},{2,3,1},{0,0,0}} },
    {3, {{2,5,4},{0,1,5},{4,5,1},{0,0,0}}, {{0,4},{5,1}},  {{2,3,1},{0,3,2},{3,3,1},{0,0,0}} },
    
    {4, {{3,4,5},{0,3,5},{3,1,4},{5,4,2}}, {{0,0},{0,0}},  {{3,3,3},{0,3,2},{0,1,3},{3,1,2}} },
}