$darkmode
VCG Library
Namespaces | Classes | Functions | Variables
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
poissonSamplesthe mesh that has to be pruned
radiusthe 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}} },
}