Face

Classes
class	vcg::face::EdgePlane< T >
	Per Face Precomputed Edge/Plane. More...
class	vcg::face::EmptyEdgePlane< T >
class	vcg::face::JumpingPos< FACE_TYPE >
class	vcg::face::Pos< FaceType >
class	vcg::face::VFIterator< FaceType >
Functions
template<class FaceType >
void	vcg::face::AssertAdj (FaceType &f)
template<class FaceType >
int	vcg::face::BorderCount (FaceType const &f)
	Count border edges of the face.
template<class FaceType >
bool	vcg::face::CheckFlipEdge (FaceType &f, int z)
template<class FaceType >
bool	vcg::face::CheckFlipEdgeNormal (FaceType &f, const int z, const float angleRad)
template<class FaceType >
bool	vcg::face::CheckOrientation (FaceType &f, int z)
template<class FaceType >
int	vcg::face::ComplexSize (FaceType &f, const int e)
	Counts the number of incident faces in a complex edge.
template<class FaceType >
int	vcg::face::CountSharedVertex (FaceType *f0, FaceType *f1)
template<class FaceType >
FaceType::ScalarType	vcg::face::DihedralAngleRad (FaceType &f, const int i)
	Compute the signed dihedral angle between the normals of two adjacent faces.
template<class FaceType >
void	vcg::face::EFStarFF (FaceType *fp, int ei, std::vector< FaceType * > &faceVec, std::vector< int > &indVed)
	Compute the set of faces incident onto a given edge using FF adjacency.
template<class FaceType >
void	vcg::face::FFAttach (FaceType *&f, int z1, FaceType *&f2, int z2)
template<class FaceType >
void	vcg::face::FFAttachManifold (FaceType *&f1, int z1, FaceType *&f2, int z2)
template<class FaceType >
bool	vcg::face::FFCorrectness (FaceType &f, const int e)
template<class FaceType >
void	vcg::face::FFDetach (FaceType &f, const int e)
template<class FaceType >
void	vcg::face::FFDetachManifold (FaceType &f, const int e)
template<class MeshType >
void	vcg::face::FFEdgeCollapse (MeshType &m, typename MeshType::FaceType &f, const int z)
template<class FaceType >
static void	vcg::face::FFExtendedStarFF (FaceType *fp, const int num_step, std::vector< FaceType * > &faceVec)
template<class FaceType >
bool	vcg::face::FFLinkCondition (FaceType &f, const int z)
template<class FaceType >
void	vcg::face::FFSetBorder (FaceType *&f1, int z1)
template<class FaceType >
bool	vcg::face::FindSharedEdge (FaceType *f0, FaceType *f1, int &i, int &j)
template<class FaceType >
bool	vcg::face::FindSharedFaces (typename FaceType::VertexType *v0, typename FaceType::VertexType *v1, FaceType *&f0, FaceType *&f1, int &e0, int &e1)
template<class FaceType >
bool	vcg::face::FindSharedVertex (FaceType *f0, FaceType *f1, int &i, int &j)
template<class FaceType >
void	vcg::face::FlipEdge (FaceType &f, const int z)
template<class FaceType >
bool	vcg::face::IsBorder (FaceType const &f, const int j)
template<class FaceType >
bool	vcg::face::IsManifold (FaceType const &f, const int j)
template<class FaceType >
bool	vcg::face::ShareEdgeFF (FaceType *f0, FaceType *f1, int *i0=0, int *i1=0)
template<class FaceType >
void	vcg::face::SwapEdge (FaceType &f, const int z)
template<class FaceType , bool UpdateTopology>
void	vcg::face::SwapEdge (FaceType &f, const int z)
template<class FaceType >
void	vcg::face::VFAppend (FaceType *&f, int z)
	Append a face in VF list of vertex f->V(z)
template<class FaceType >
void	vcg::face::VFDetach (FaceType &f)
template<class FaceType >
void	vcg::face::VFDetach (FaceType &f, int z)
template<class FaceType >
void	vcg::face::VFExtendedStarVF (typename FaceType::VertexType *vp, const int num_step, std::vector< FaceType * > &faceVec)
	Compute the set of faces adjacent to a given vertex using VF adjacency.
template<class FaceType >
void	vcg::face::VFOrderedStarFF (const Pos< FaceType > &startPos, std::vector< Pos< FaceType > > &posVec)
	Compute the ordered set of faces adjacent to a given vertex using FF adiacency.
template<class FaceType >
void	vcg::face::VFOrderedStarFF (const Pos< FaceType > &startPos, std::vector< FaceType * > &faceVec, std::vector< int > &edgeVec)
	Compute the ordered set of faces adjacent to a given vertex using FF adiacency.
template<class FaceType >
void	vcg::face::VFStarVF (typename FaceType::VertexType *vp, std::vector< FaceType * > &faceVec, std::vector< int > &indexes)
	Compute the set of faces adjacent to a given vertex using VF adjacency.
template<class FaceType >
void	vcg::face::VVExtendedStarVF (typename FaceType::VertexType *vp, const int num_step, std::vector< typename FaceType::VertexType * > &vertVec)
	Compute the set of vertices adjacent to a given vertex using VF adjacency.
template<class FaceType >
void	vcg::face::VVOrderedStarFF (Pos< FaceType > &startPos, std::vector< typename FaceType::VertexType * > &vertexVec)
	Compute the ordered set of vertices adjacent to a given vertex using FF adiacency.
template<class FaceType >
void	vcg::face::VVStarVF (typename FaceType::VertexType *vp, std::vector< typename FaceType::VertexType * > &starVec)
	Compute the set of vertices adjacent to a given vertex using VF adjacency.

---

Function Documentation

template<class FaceType >

void vcg::face::AssertAdj

(

FaceType &

f

)

Definition at line 345 of file simplex/face/topology.h.

template<class FaceType >

int vcg::face::BorderCount

(

FaceType const &

f

)

[inline]

Count border edges of the face.

Definition at line 117 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::CheckFlipEdge	(	FaceType &	f,
		int	z
	)

Perform a Topological check to see if the z-th edge of the face f can be flipped. No Geometric test are done. (see CheckFlipEdgeNormal)

Parameters:

f	pointer to the face
z	the edge index

Definition at line 595 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::CheckFlipEdgeNormal	(	FaceType &	f,
		const int	z,
		const float	angleRad
	)

Perform a Geometric Check about the normals of a edge flip. return trues if after the flip the normals does not change more than the given threshold angle; it assumes that the flip is topologically correct.

Parameters:

f	the face
z	the edge index
angleRad	the threshold angle

oldD1 ___________ newD1 |\ | | \ | | \ | | f z\ | | \ | |__________\| newD0 oldD0

Definition at line 563 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::CheckOrientation	(	FaceType &	f,
		int	z
	)

Check if the given face is oriented as the one adjacent to the specified edge.

Parameters:

f	Face to check the orientation
z	Index of the edge

Definition at line 363 of file simplex/face/topology.h.

template<class FaceType >

int vcg::face::ComplexSize	(	FaceType &	f,
		const int	e
	)		[inline]

Counts the number of incident faces in a complex edge.

Definition at line 133 of file simplex/face/topology.h.

template<class FaceType >

int vcg::face::CountSharedVertex	(	FaceType *	f0,
		FaceType *	f1
	)

Count the number of vertices shared between two faces.

Parameters:

f0,f1

the two face to be checked ;

Definition at line 1055 of file simplex/face/topology.h.

template<class FaceType >

FaceType::ScalarType vcg::face::DihedralAngleRad	(	FaceType &	f,
		const int	i
	)		[inline]

Compute the signed dihedral angle between the normals of two adjacent faces.

The angle between the normal is signed according to the concavity/convexity of the dihedral angle: negative if the edge shared between the two faces is concave, positive otherwise. The surface it is assumend to be oriented. It simply use the projection of the opposite vertex onto the plane of the other one. It does not assume anything on face normals.

v0 ___________ vf1 |\ | | f1 | | \ | |f0 i0\ | | \ | |__________\| vf0 v1

Definition at line 83 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::EFStarFF	(	FaceType *	fp,
		int	ei,
		std::vector< FaceType * > &	faceVec,
		std::vector< int > &	indVed
	)

Compute the set of faces incident onto a given edge using FF adjacency.

Parameters:

fp	pointer to the face whose star has to be computed
ei	the index of the edge
faceVec	a std::vector of Face pointer that is filled with the faces incident on that edge.
indexes	a std::vector of integer of the edge position as it is seen from the faces

Definition at line 849 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::FFAttach	(	FaceType *&	f,
		int	z1,
		FaceType *&	f2,
		int	z2
	)

This function attach the face (via the edge z1) to another face (via the edge z2). It's possible to use it also in non-two manifold situation. The function cannot be applicated if the adjacencies among faces aren't define.

Parameters:

z1	Index of the edge
f2	Pointer to the face
z2	The edge of the face f2

Definition at line 291 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::FFAttachManifold	(	FaceType *&	f1,
		int	z1,
		FaceType *&	f2,
		int	z2
	)

This function attach the face (via the edge z1) to another face (via the edge z2). It is not possible to use it also in non-two manifold situation. The function cannot be applicated if the adjacencies among faces aren't define.

Parameters:

z1	Index of the edge
f2	Pointer to the face
z2	The edge of the face f2

Definition at line 322 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::FFCorrectness	(	FaceType &	f,
		const int	e
	)

This function check the FF topology correctness for an edge of a face. It's possible to use it also in non-two manifold situation. The function cannot be applicated if the adjacencies among faces aren't defined.

Parameters:

f	the face to be checked
e	Index of the edge to be checked

Definition at line 166 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::FFDetach	(	FaceType &	f,
		const int	e
	)

This function detach the face from the adjacent face via the edge e. It's possible to use it also in non-two manifold situation. The function cannot be applicated if the adjacencies among faces aren't defined.

Parameters:

f	the face to be detached
e	Index of the edge to be detached

Definition at line 238 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::FFDetachManifold	(	FaceType &	f,
		const int	e
	)

This function detach the face from the adjacent face via the edge e. It's possible to use this function it ONLY in non-two manifold situation. The function cannot be applicated if the adjacencies among faces aren't defined.

Parameters:

f	the face to be detached
e	Index of the edge to be detached

Note:

it updates border flag and faux flags (the detached edge has it border bit flagged and faux bit cleared)

Definition at line 208 of file simplex/face/topology.h.

template<class MeshType >

void vcg::face::FFEdgeCollapse	(	MeshType &	m,
		typename MeshType::FaceType &	f,
		const int	z
	)

Perform a simple edge collapse The edge z is collapsed and the vertex V(z) is collapsed onto the vertex V1(Z) vertex V(z) is deleted and vertex V1(z) survives. It assumes that the mesh is Manifold. Note that it preserves manifoldness only if FFLinkConditions are satisfied If the mesh is not manifold it will crash (there will be faces with deleted vertexes around) f12 surV ___________ |\ | | \ f1 | f01 | \ z1 | f11 | f0 z0\ | | \ | |__________\| f02 delV

Definition at line 493 of file simplex/face/topology.h.

template<class FaceType >

static void vcg::face::FFExtendedStarFF	(	FaceType *	fp,
		const int	num_step,
		std::vector< FaceType * > &	faceVec
	)		[static]

initialize front

then dilate front for each step

Definition at line 877 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::FFLinkCondition	(	FaceType &	f,
		const int	z
	)

Perform a simple edge collapse Basic link conditions

Definition at line 448 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::FFSetBorder	(	FaceType *&	f1,
		int	z1
	)

Definition at line 336 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::FindSharedEdge	(	FaceType *	f0,
		FaceType *	f1,
		int &	i,
		int &	j
	)

find the first shared edge between two faces.

Parameters:

f0,f1	the two face to be checked
i,j	the indexes of the shared edge in the two faces. Meaningful only if there is a shared edge

Definition at line 1090 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::FindSharedFaces	(	typename FaceType::VertexType *	v0,
		typename FaceType::VertexType *	v1,
		FaceType *&	f0,
		FaceType *&	f1,
		int &	e0,
		int &	e1
	)

find the faces that shares the two vertices

Parameters:

v0,v1	the two vertices
f0,f1	the two faces , counterclokwise order

then find the intersection

no pair of faces share the 2 vertices

and finally check if the order is right

Definition at line 1108 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::FindSharedVertex	(	FaceType *	f0,
		FaceType *	f1,
		int &	i,
		int &	j
	)

find the first shared vertex between two faces.

Parameters:

f0,f1	the two face to be checked
i,j	the indexes of the shared vertex in the two faces. Meaningful only if there is one single shared vertex ;

Definition at line 1073 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::FlipEdge	(	FaceType &	f,
		const int	z
	)

Flip the z-th edge of the face f. Check for topological correctness first using CheckFlipFace().

Parameters:

f	pointer to the face
z	the edge index

Note: For edge flip we intend the swap of the diagonal of the rectangle formed by the face f and the face adjacent to the specified edge.

Definition at line 647 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::IsBorder	(	FaceType const &	f,
		const int	j
	)		[inline]

Return a boolean that indicate if the j-th edge of the face is a border.

Parameters:

j	Index of the edge

Returns:

true if j is an edge of border, false otherwise

Definition at line 54 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::IsManifold	(	FaceType const &	f,
		const int	j
	)		[inline]

Return a boolean that indicate if the face is complex.

Parameters:

j	Index of the edge

Returns:

true se la faccia e' manifold, false altrimenti

Definition at line 40 of file simplex/face/topology.h.

template<class FaceType >

bool vcg::face::ShareEdgeFF	(	FaceType *	f0,
		FaceType *	f1,
		int *	i0 = 0,
		int *	i1 = 0
	)

Check if two faces share and edge through the FF topology.

Parameters:

f0,f1	the two face to be checked
i0,i1	the index of the shared edge;

Definition at line 1034 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::SwapEdge	(	FaceType &	f,
		const int	z
	)

This function change the orientation of the face by inverting the index of two vertex.

Parameters:

z	Index of the edge

Definition at line 391 of file simplex/face/topology.h.

template<class FaceType , bool UpdateTopology>

void vcg::face::SwapEdge	(	FaceType &	f,
		const int	z
	)

Definition at line 394 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VFAppend	(	FaceType *&	f,
		int	z
	)

Append a face in VF list of vertex f->V(z)

Definition at line 739 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VFDetach

(

FaceType &

f

)

Definition at line 698 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VFDetach	(	FaceType &	f,
		int	z
	)

Definition at line 709 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VFExtendedStarVF	(	typename FaceType::VertexType *	vp,
		const int	num_step,
		std::vector< FaceType * > &	faceVec
	)

Compute the set of faces adjacent to a given vertex using VF adjacency.

The set is faces is extended of a given number of step

Parameters:

vp	pointer to the vertex whose star has to be computed.
num_step	the number of step to extend the star
faceVec	a std::vector of Face pointer that is filled with the adjacent faces.

initialize front

then dilate front for each step

Definition at line 915 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VFOrderedStarFF	(	const Pos< FaceType > &	startPos,
		std::vector< Pos< FaceType > > &	posVec
	)

Compute the ordered set of faces adjacent to a given vertex using FF adiacency.

Parameters:

startPos	a Pos<FaceType> indicating the vertex whose star has to be computed.
posVec	a std::vector of Pos filled with Pos arranged around the passed vertex.

Definition at line 972 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VFOrderedStarFF	(	const Pos< FaceType > &	startPos,
		std::vector< FaceType * > &	faceVec,
		std::vector< int > &	edgeVec
	)

Compute the ordered set of faces adjacent to a given vertex using FF adiacency.

Parameters:

startPos	a Pos<FaceType> indicating the vertex whose star has to be computed.
faceVec	a std::vector of Face pointer that is filled with the adjacent faces.
edgeVec	a std::vector of indexes filled with the indexes of the corresponding edges shared between the faces.

Definition at line 1012 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VFStarVF	(	typename FaceType::VertexType *	vp,
		std::vector< FaceType * > &	faceVec,
		std::vector< int > &	indexes
	)

Compute the set of faces adjacent to a given vertex using VF adjacency.

Parameters:

vp	pointer to the vertex whose star has to be computed.
faceVec	a std::vector of Face pointer that is filled with the adjacent faces.
indexes	a std::vector of integer of the vertex as it is seen from the faces

Definition at line 824 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VVExtendedStarVF	(	typename FaceType::VertexType *	vp,
		const int	num_step,
		std::vector< typename FaceType::VertexType * > &	vertVec
	)

Compute the set of vertices adjacent to a given vertex using VF adjacency.

The set is faces is extended of a given number of step

Parameters:

vp	pointer to the vertex whose star has to be computed.
num_step	the number of step to extend the star
vertVec	a std::vector of Ve pointer that is filled with the adjacent faces.

initialize front

then dilate front for each step

Definition at line 789 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VVOrderedStarFF	(	Pos< FaceType > &	startPos,
		std::vector< typename FaceType::VertexType * > &	vertexVec
	)

Compute the ordered set of vertices adjacent to a given vertex using FF adiacency.

Parameters:

startPos	a Pos<FaceType> indicating the vertex whose star has to be computed.
vertexVec	a std::vector of VertexPtr filled vertices around the given vertex.

Definition at line 954 of file simplex/face/topology.h.

template<class FaceType >

void vcg::face::VVStarVF	(	typename FaceType::VertexType *	vp,
		std::vector< typename FaceType::VertexType * > &	starVec
	)

Compute the set of vertices adjacent to a given vertex using VF adjacency.

Parameters:

vp	pointer to the vertex whose star has to be computed.
starVec	a std::vector of Vertex pointer that is filled with the adjacent vertices.

Definition at line 763 of file simplex/face/topology.h.