FACET Class Reference

#include <wrlfacet.h>

Public Member Functions
	FACET ()
void	Init ()
bool	HasMinPoints ()
bool	HasColors ()
void	AddVertex (WRLVEC3F &aVertex, int aIndex)
	Add the vertex and its associated index to the internal list of polygon vertices. More...
void	AddColor (const SGCOLOR &aColor)
	Add the given RGB color to the internal list. More...
float	CalcFaceNormal ()
	Calculate the normal to the facet assuming a CCW orientation and perform the calculation of the angle weighted vertex normals. More...
void	Renormalize (float aMaxValue)
void	CalcVertexNormal (int aIndex, std::list< FACET * > &aFacetList, float aCreaseAngle)
	Calculate the weighted normal for the given vertex. More...
bool	GetWeightedNormal (int aIndex, WRLVEC3F &aNorm)
	Retrieve the angle weighted normal for the given vertex index. More...
bool	GetFaceNormal (WRLVEC3F &aNorm)
	Retrieve the normal for this facet. More...
bool	GetData (std::vector< WRLVEC3F > &aVertexList, std::vector< WRLVEC3F > &aNormalsList, std::vector< SGCOLOR > &aColorsList, WRL1_ORDER aVertexOrder)
	Package the internal data as triangles with corresponding per-vertex normals. More...
int	GetMaxIndex ()
void	CollectVertices (std::vector< std::list< FACET * > > &aFacetList)
	Add a pointer to this object at each position within aFacetList referenced by the internal vertex indices. More...

Private Attributes
std::vector< WRLVEC3F >	vertices
std::vector< SGCOLOR >	colors
std::vector< int >	indices
WRLVEC3F	face_normal
std::vector< WRLVEC3F >	norms
std::vector< WRLVEC3F >	vnweight
int	maxIdx

Detailed Description

Definition at line 42 of file wrlfacet.h.

Constructor & Destructor Documentation

FACET()

FACET::FACET

(

)

Definition at line 149 of file wrlfacet.cpp.

{
 face_normal.x = 0.0;
 face_normal.y = 0.0;
 face_normal.z = 0.0;
 maxIdx = 0;
}

References face_normal, and maxIdx.

Member Function Documentation

AddColor()

void FACET::AddColor

(

const SGCOLOR &

aColor

)

Add the given RGB color to the internal list.

For per-face coloring only a single color needs to be specified. For a per-vertex coloring the color must be specified for each vertex.

Definition at line 204 of file wrlfacet.cpp.

{
 colors.push_back( aColor );

 return;
}

References colors.

Referenced by WRL1FACESET::TranslateToSG(), and WRL2FACESET::TranslateToSG().

AddVertex()

void FACET::AddVertex	(	WRLVEC3F &	aVertex,
		int	aIndex
	)

Add the vertex and its associated index to the internal list of polygon vertices.

Definition at line 191 of file wrlfacet.cpp.

{
 if( aIndex < 0 )
 return;

 vertices.push_back( aVertex );
 indices.push_back( aIndex );

 if( aIndex > maxIdx )
 maxIdx = aIndex;
}

References indices, maxIdx, and vertices.

Referenced by WRL1FACESET::TranslateToSG(), X3DIFACESET::TranslateToSG(), and WRL2FACESET::TranslateToSG().

CalcFaceNormal()

float FACET::CalcFaceNormal

(

)

Calculate the normal to the facet assuming a CCW orientation and perform the calculation of the angle weighted vertex normals.

Returns

is the max. magnitude of any component of the normal or zero if there is a fault or the normal has already been calculated.

Definition at line 212 of file wrlfacet.cpp.

{
 // note: this calculation assumes that the face is a convex polygon;
 // concave polygons may be supported in the future via functions which
 // split the polygon into triangles

 if( vertices.size() < 3 )
 return 0.0;

 // check if the values were already calculated
 if( vertices.size() == vnweight.size() )
 return 0.0;

 WRLVEC3F lCPts[3];

 std::vector< WRLVEC3F >::iterator sV = vertices.begin();
 std::vector< WRLVEC3F >::iterator eV = vertices.end();

 lCPts[0] = vertices.back();
 lCPts[1] = *sV;
 ++sV;
 lCPts[2] = *sV;
 ++sV;

 face_normal = VCalcTriNorm( lCPts[1], lCPts[0], lCPts[2] );

 vnweight.clear();
 WRLVEC3F wnorm = face_normal;

 // calculate area:
 size_t nv = vertices.size();
 float a1 = 0.0;
 glm::vec3 sum( 0.0, 0.0, 0.0 );
 size_t j = 0;

 for( size_t i = 1; i < nv; ++i, ++j )
 sum += glm::cross( vertices[j], vertices[i] );

 a1 = fabs( glm::dot( face_normal, sum ) );
 float a2 = acosf( VCalcCosAngle( lCPts[1], lCPts[0], lCPts[2] ) );

 wnorm.x *= a1 * a2;
 wnorm.y *= a1 * a2;
 wnorm.z *= a1 * a2;
 vnweight.push_back( wnorm );

 float maxV = fabs( wnorm.x );
 float tV = fabs( wnorm.y );

 if( tV > maxV )
 maxV = tV;

 tV = fabs( wnorm.z );

 if( tV > maxV )
 maxV = tV;

 while( sV != eV )
 {
 lCPts[0] = lCPts[1];
 lCPts[1] = lCPts[2];
 lCPts[2] = *sV;
 ++sV;

 wnorm = face_normal;
 a2 = acosf( VCalcCosAngle( lCPts[1], lCPts[0], lCPts[2] ) );
 wnorm.x *= a1 * a2;
 wnorm.y *= a1 * a2;
 wnorm.z *= a1 * a2;
 vnweight.push_back( wnorm );

 tV = fabs( wnorm.x );

 if( tV > maxV )
 maxV = tV;

 tV = fabs( wnorm.y );

 if( tV > maxV )
 maxV = tV;

 tV = fabs( wnorm.z );

 if( tV > maxV )
 maxV = tV;
 }

 lCPts[0] = lCPts[1];
 lCPts[1] = lCPts[2];
 lCPts[2] = vertices.front();

 wnorm = face_normal;
 a2 = acosf( VCalcCosAngle( lCPts[1], lCPts[0], lCPts[2] ) );
 wnorm.x *= a1 * a2;
 wnorm.y *= a1 * a2;
 wnorm.z *= a1 * a2;
 vnweight.push_back( wnorm );

 tV = fabs( wnorm.x );

 if( tV > maxV )
 maxV = tV;

 tV = fabs( wnorm.y );

 if( tV > maxV )
 maxV = tV;

 tV = fabs( wnorm.z );

 if( tV > maxV )
 maxV = tV;

 return maxV;
}

References face_normal, VCalcCosAngle(), VCalcTriNorm(), vertices, and vnweight.

CalcVertexNormal()

void FACET::CalcVertexNormal	(	int	aIndex,
		std::list< FACET * > &	aFacetList,
		float	aCreaseAngle
	)

Calculate the weighted normal for the given vertex.

Parameters

aIndex	is the VRML file's Vertex Index for the vertex to be processed.
aFacetList	is the list of all faces which share this vertex.

Definition at line 329 of file wrlfacet.cpp.

{
 if( vertices.size() < 3 )
 return;

 if( vnweight.size() != vertices.size() )
 return;

 if( norms.size() != vertices.size() )
 norms.resize( vertices.size() );

 std::vector< int >::iterator sI = indices.begin();
 std::vector< int >::iterator eI = indices.end();
 int idx = 0;

 WRLVEC3F fp[2]; // vectors to calculate facet angle
 fp[0].x = 0.0;
 fp[0].y = 0.0;
 fp[0].z = 0.0;

  while( sI != eI )
 {
 if( *sI == aIndex )
 {
 // first set the default (weighted) normal value
 norms[idx] = vnweight[idx];

 // iterate over adjacent facets
 std::list< FACET* >::iterator sF = aFacetList.begin();
 std::list< FACET* >::iterator eF = aFacetList.end();

 while( sF != eF )
 {
 if( this == *sF )
 {
 ++sF;
 continue;
 }

 // check the crease angle limit
 (*sF)->GetFaceNormal( fp[1] );

 float thrs = VCalcCosAngle( fp[0], face_normal, fp[1] );

 if( aCreaseLimit <= thrs && (*sF)->GetWeightedNormal( aIndex, fp[1] ) )
 {
 norms[idx].x += fp[1].x;
 norms[idx].y += fp[1].y;
 norms[idx].z += fp[1].z;
 }

 ++sF;
 }

 // normalize the vector
 float dn = sqrtf( norms[idx].x * norms[idx].x
 + norms[idx].y * norms[idx].y
 + norms[idx].z * norms[idx].z );

 if( dn > LOWER_LIMIT )
 {
 norms[idx].x /= dn;
 norms[idx].y /= dn;
 norms[idx].z /= dn;
 }

 // if the normals is an invalid normal this test will pass
 if( fabs( norms[idx].x ) < 0.5
 && fabs( norms[idx].y ) < 0.5
 && fabs( norms[idx].z ) < 0.5 )
 {
 norms[idx] = face_normal;
 }

 return;
 }

 ++idx;
 ++sI;
 }
}

References face_normal, indices, LOWER_LIMIT, norms, VCalcCosAngle(), vertices, and vnweight.

CollectVertices()

void FACET::CollectVertices

(

std::vector< std::list< FACET * > > &

aFacetList

)

Add a pointer to this object at each position within aFacetList referenced by the internal vertex indices.

Definition at line 642 of file wrlfacet.cpp.

{
 // check if this facet may contribute anything at all
 if( vertices.size() < 3 )
 return;

 // note: in principle this should never be invoked
 if( (maxIdx + 1) >= (int)aFacetList.size() )
 aFacetList.resize( static_cast<std::size_t>( maxIdx ) + 1 );

 std::vector< int >::iterator sI = indices.begin();
 std::vector< int >::iterator eI = indices.end();

 while( sI != eI )
 {
 aFacetList[*sI].push_back( this );
 ++sI;
 }
}

References indices, maxIdx, and vertices.

GetData()

bool FACET::GetData	(	std::vector< WRLVEC3F > &	aVertexList,
		std::vector< WRLVEC3F > &	aNormalsList,
		std::vector< SGCOLOR > &	aColorsList,
		WRL1_ORDER	aVertexOrder
	)

Package the internal data as triangles with corresponding per-vertex normals.

Parameters

aVertexList	is the list of vertices to add to.
aNormalsList	is the list of per-vertex normals to add to.
aColorsList	is the list of per-vertex colors (if any) to add to.
aVertexOrder	informs the function of the vertex winding order.

Definition at line 462 of file wrlfacet.cpp.

{
 // if no normals are calculated we simply return
 if( norms.empty() )
 return false;

 // the output must always be triangle sets in order to conform to the
 // requirements of the SG* classes
 int idx[3];

 idx[0] = 0;
 idx[1] = 1;
 idx[2] = 2;
 WRLVEC3F tnorm;

 if( aVertexOrder != WRL1_ORDER::ORD_CLOCKWISE )
 {
 aVertexList.push_back( vertices[idx[0]] );
 aVertexList.push_back( vertices[idx[1]] );
 aVertexList.push_back( vertices[idx[2]] );

 aNormalsList.push_back( norms[idx[0]] );
 aNormalsList.push_back( norms[idx[1]] );
 aNormalsList.push_back( norms[idx[2]] );
 }

 if( aVertexOrder != WRL1_ORDER::ORD_CCW )
 {
 aVertexList.push_back( vertices[idx[0]] );
 aVertexList.push_back( vertices[idx[2]] );
 aVertexList.push_back( vertices[idx[1]] );

 tnorm = norms[idx[0]];
 tnorm.x = -tnorm.x;
 tnorm.y = -tnorm.y;
 tnorm.z = -tnorm.z;
 aNormalsList.push_back( tnorm );

 tnorm = norms[idx[2]];
 tnorm.x = -tnorm.x;
 tnorm.y = -tnorm.y;
 tnorm.z = -tnorm.z;
 aNormalsList.push_back( tnorm );

 tnorm = norms[idx[1]];
 tnorm.x = -tnorm.x;
 tnorm.y = -tnorm.y;
 tnorm.z = -tnorm.z;
 aNormalsList.push_back( tnorm );
 }

 bool hasColor = false;
 bool perVC = false; // per-vertex colors?

 if( !colors.empty() )
 {
 hasColor = true;

 if( colors.size() >= vertices.size() )
 perVC = true;

 if( perVC )
 {
 if( aVertexOrder != WRL1_ORDER::ORD_CLOCKWISE )
 {
 aColorsList.push_back( colors[idx[0]] );
 aColorsList.push_back( colors[idx[1]] );
 aColorsList.push_back( colors[idx[2]] );
 }

 if( aVertexOrder != WRL1_ORDER::ORD_CCW )
 {
 aColorsList.push_back( colors[idx[0]] );
 aColorsList.push_back( colors[idx[2]] );
 aColorsList.push_back( colors[idx[1]] );
 }
 }
 else
 {
 if( aVertexOrder != WRL1_ORDER::ORD_CLOCKWISE )
 {
 aColorsList.push_back( colors[0] );
 aColorsList.push_back( colors[0] );
 aColorsList.push_back( colors[0] );
 }

 if( aVertexOrder != WRL1_ORDER::ORD_CCW )
 {
  aColorsList.push_back( colors[0] );
 aColorsList.push_back( colors[0] );
 aColorsList.push_back( colors[0] );
 }
 }
 }

 int lim = (int) vertices.size() - 1;

 while( idx[2] < lim )
 {
 idx[1] = idx[2];
 ++idx[2];

 if( aVertexOrder != WRL1_ORDER::ORD_CLOCKWISE )
 {
 aVertexList.push_back( vertices[idx[0]] );
 aVertexList.push_back( vertices[idx[1]] );
 aVertexList.push_back( vertices[idx[2]] );

 aNormalsList.push_back( norms[idx[0]] );
 aNormalsList.push_back( norms[idx[1]] );
 aNormalsList.push_back( norms[idx[2]] );
 }

 if( aVertexOrder != WRL1_ORDER::ORD_CCW )
 {
 aVertexList.push_back( vertices[idx[0]] );
 aVertexList.push_back( vertices[idx[2]] );
 aVertexList.push_back( vertices[idx[1]] );

 tnorm = norms[idx[0]];
 tnorm.x = -tnorm.x;
 tnorm.y = -tnorm.y;
 tnorm.z = -tnorm.z;
 aNormalsList.push_back( tnorm );

 tnorm = norms[idx[2]];
 tnorm.x = -tnorm.x;
 tnorm.y = -tnorm.y;
 tnorm.z = -tnorm.z;
 aNormalsList.push_back( tnorm );

 tnorm = norms[idx[1]];
 tnorm.x = -tnorm.x;
 tnorm.y = -tnorm.y;
 tnorm.z = -tnorm.z;
 aNormalsList.push_back( tnorm );
 }

 if( hasColor )
 {
 if( perVC )
 {
 if( aVertexOrder != WRL1_ORDER::ORD_CLOCKWISE )
 {
 aColorsList.push_back( colors[idx[0]] );
 aColorsList.push_back( colors[idx[1]] );
 aColorsList.push_back( colors[idx[2]] );
 }

 if( aVertexOrder != WRL1_ORDER::ORD_CCW )
 {
 aColorsList.push_back( colors[idx[0]] );
 aColorsList.push_back( colors[idx[2]] );
 aColorsList.push_back( colors[idx[1]] );
 }
 }
 else
 {
 if( aVertexOrder != WRL1_ORDER::ORD_CLOCKWISE )
 {
 aColorsList.push_back( colors[0] );
 aColorsList.push_back( colors[0] );
 aColorsList.push_back( colors[0] );
 }

 if( aVertexOrder != WRL1_ORDER::ORD_CCW )
 {
 aColorsList.push_back( colors[0] );
 aColorsList.push_back( colors[0] );
 aColorsList.push_back( colors[0] );
 }
 }
 }
 }

 return true;
}

References colors, norms, ORD_CCW, ORD_CLOCKWISE, and vertices.

GetFaceNormal()

bool FACET::GetFaceNormal

(

WRLVEC3F &

aNorm

)

Retrieve the normal for this facet.

Parameters

aNorm

will hold the result.

Definition at line 445 of file wrlfacet.cpp.

{
 aNorm.x = 0.0;
 aNorm.y = 0.0;
 aNorm.z = 0.0;

 if( vertices.size() < 3 )
 return false;

 if( vnweight.size() != vertices.size() )
 return false;

 aNorm = face_normal;
 return true;
}

References face_normal, vertices, and vnweight.

GetMaxIndex()

int FACET::GetMaxIndex ( )

inline

Definition at line 109 of file wrlfacet.h.

 {
 return maxIdx;
 }

References maxIdx.

GetWeightedNormal()

bool FACET::GetWeightedNormal	(	int	aIndex,
		WRLVEC3F &	aNorm
	)

Retrieve the angle weighted normal for the given vertex index.

Parameters

aIndex	is the VRML file's Vertex Index for the vertex to be processed.
aNorm	will hold the result.

Definition at line 412 of file wrlfacet.cpp.

{
 // the default weighted normal shall have no effect even if accidentally included
 aNorm.x = 0.0;
 aNorm.y = 0.0;
 aNorm.z = 0.0;

 if( vertices.size() < 3 )
 return false;

 if( vnweight.size() != vertices.size() )
 return false;

 std::vector< int >::iterator sI = indices.begin();
 std::vector< int >::iterator eI = indices.end();
 int idx = 0;

 while( sI != eI )
 {
 if( *sI == aIndex )
 {
 aNorm = vnweight[idx];
 return true;
 }

 ++idx;
 ++sI;
 }

 return false;
}

References indices, vertices, and vnweight.

HasColors()

bool FACET::HasColors

(

void

)

Definition at line 182 of file wrlfacet.cpp.

{
 if( colors.empty() )
 return false;

 return true;
}

References colors.

Referenced by WRL1FACESET::TranslateToSG().

HasMinPoints()

bool FACET::HasMinPoints

(

)

Definition at line 173 of file wrlfacet.cpp.

{
 if( vertices.size() < 3 )
 return false;

 return true;
}

References vertices.

Referenced by WRL1FACESET::TranslateToSG(), X3DIFACESET::TranslateToSG(), and WRL2FACESET::TranslateToSG().

Init()

void FACET::Init

(

)

Definition at line 158 of file wrlfacet.cpp.

{
 vertices.clear();
 colors.clear();
 indices.clear();
 norms.clear();
 vnweight.clear();

 face_normal.x = 0.0;
 face_normal.y = 0.0;
 face_normal.z = 0.0;
 maxIdx = 0;
}

References colors, face_normal, indices, maxIdx, norms, vertices, and vnweight.

Referenced by WRL1FACESET::TranslateToSG(), X3DIFACESET::TranslateToSG(), and WRL2FACESET::TranslateToSG().

Renormalize()

void FACET::Renormalize

(

float

aMaxValue

)

Definition at line 663 of file wrlfacet.cpp.

{
 if( vnweight.empty() || aMaxValue < LOWER_LIMIT )
 return;

 size_t vs = vnweight.size();

 for( size_t i = 0; i < vs; ++i )
 {
 vnweight[i].x /= aMaxValue;
 vnweight[i].y /= aMaxValue;
 vnweight[i].z /= aMaxValue;
 }
}

References LOWER_LIMIT, and vnweight.

Member Data Documentation

colors

std::vector< SGCOLOR > FACET::colors

private

Definition at line 122 of file wrlfacet.h.

Referenced by AddColor(), GetData(), HasColors(), and Init().

face_normal

WRLVEC3F FACET::face_normal

private

Definition at line 125 of file wrlfacet.h.

Referenced by CalcFaceNormal(), CalcVertexNormal(), FACET(), GetFaceNormal(), and Init().

indices

std::vector< int > FACET::indices

private

Definition at line 123 of file wrlfacet.h.

Referenced by AddVertex(), CalcVertexNormal(), CollectVertices(), GetWeightedNormal(), and Init().

maxIdx

int FACET::maxIdx

private

Definition at line 129 of file wrlfacet.h.

Referenced by AddVertex(), CollectVertices(), FACET(), GetMaxIndex(), and Init().

norms

std::vector< WRLVEC3F > FACET::norms

private

Definition at line 126 of file wrlfacet.h.

Referenced by CalcVertexNormal(), GetData(), and Init().

vertices

std::vector< WRLVEC3F > FACET::vertices

private

Definition at line 121 of file wrlfacet.h.

Referenced by AddVertex(), CalcFaceNormal(), CalcVertexNormal(), CollectVertices(), GetData(), GetFaceNormal(), GetWeightedNormal(), HasMinPoints(), and Init().

vnweight

std::vector< WRLVEC3F > FACET::vnweight

private

Definition at line 127 of file wrlfacet.h.

Referenced by CalcFaceNormal(), CalcVertexNormal(), GetFaceNormal(), GetWeightedNormal(), Init(), and Renormalize().

---

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

• wrlfacet.h
• wrlfacet.cpp