ReadOff< T > Class Template Reference

#include <TAPsReadOff.hpp>

List of all members.

Static Public Member Functions

static bool readFile (const char *fileName, OpenGL::HalfEdgeModel< T > *const prModel)

static bool readFile (const char *fileName, OpenGL::XPolygonalModel< T > *const prModel)

static bool readFile (const char *fileName, OpenGL::PolygonalModel< T > *const prModel)

Static Private Member Functions

static void ProcessFACE_LIST (FILE *inputFile, OpenGL::HalfEdgeModel< T > *const prModel)

static void ProcessFACE_LIST (FILE *inputFile, OpenGL::XPolygonalModel< T > *const prModel)

static void ProcessFACE_LIST (FILE *inputFile, OpenGL::PolygonalModel< T > *const prModel)

static bool ProcessHEADER (FILE *inputFile, OpenGL::MeshModel< T > *const prModel)

static void ProcessVERTEX_LIST (FILE *inputFile, OpenGL::HalfEdgeModel< T > *const prModel)

static void ProcessVERTEX_LIST (FILE *inputFile, OpenGL::XPolygonalModel< T > *const prModel)

static void ProcessVERTEX_LIST (FILE *inputFile, OpenGL::PolygonalModel< T > *const prModel)

Static Private Attributes

static int halfEdgeCounter = 0

static int vertexNo = 0

Friends

class ReadModels< T >

Detailed Description

template<typename T>
class ReadOff< T >

Definition at line 21 of file TAPsReadOff.hpp.

Member Function Documentation

template<typename T>

void ReadOff< T >::ProcessFACE_LIST	(	FILE *	inputFile,
		OpenGL::HalfEdgeModel< T > *const	prModel
	)			`[inline, static, private]`

Definition at line 376 of file TAPsReadOff.cpp.

00378 {
00379     std::cout << "Processing Node MESH_FACE_LIST\n";
00380     //-------------------------------------------------------------------
00381     // Example:
00382     //  *MESH_FACE_LIST {
00383     //      *MESH_FACE    0:    A:    0 B:    2 C:    3 AB:    1 BC:    1 CA:    0   *MESH_SMOOTHING 2  *MESH_MTLID 1
00384     //      *MESH_FACE    1:    A:    3 B:    1 C:    0 AB:    1 BC:    1 CA:    0   *MESH_SMOOTHING 2  *MESH_MTLID 1
00385     //      *MESH_FACE    2:    A:    4 B:    5 C:    7 AB:    1 BC:    1 CA:    0   *MESH_SMOOTHING 3  *MESH_MTLID 0
00386     //      ...
00387     //  }
00388     //-------------------------------------------------------------------
00389     HEFace<T> *heFace;
00390     char node[128];
00391     char N[16], A[4], B[4], C[4];
00392     int  v0, v1, v2;
00393     fgets( line, 128, fileIn );
00394     sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 );
00395     while ( node[0] != '}' ) {
00396         heFace = new HEFace<T>();
00397         prModel->GetFaceList()->Append( heFace );
00398         //----------------------------------------------------------------
00399         // Create and Set all three half-edges
00400         HEHalfEdge<T> *heHalfEdge0 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
00401             HelpCreateHalfEdgeModel<T>::vertexList[v0], 
00402             HelpCreateHalfEdgeModel<T>::vertexList[v1], 
00403             heFace );
00404         HEHalfEdge<T> *heHalfEdge1 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
00405             HelpCreateHalfEdgeModel<T>::vertexList[v1], 
00406             HelpCreateHalfEdgeModel<T>::vertexList[v2], 
00407             heFace, heHalfEdge0 );
00408         HEHalfEdge<T> *heHalfEdge2 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
00409             HelpCreateHalfEdgeModel<T>::vertexList[v2], 
00410             HelpCreateHalfEdgeModel<T>::vertexList[v0], 
00411             heFace, heHalfEdge1, heHalfEdge0 );
00412         halfEdgeCounter += 3;
00413         //----------------------------------------------------------------
00414         // Set incident half-edge of this face
00415         heFace->IncidentHalfEdge( heHalfEdge0 );
00416         //----------------------------------------------------------------
00417         // (CCW) Record v0 to v1, v1 to v2, and v2 to v0 in vertexRingList
00418         HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v1, v0 );   // put v1 in bucket v0
00419         HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v2, v1 );   // put v2 in bucket v1
00420         HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v0, v2 );   // put v0 in bucket v2
00421         //----------------------------------------------------------------
00422         // Record half-edges in halfEdgeRingList
00423         HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge0, v0 );    // put in bucket v0
00424         HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge1, v1 );    // put in bucket v1
00425         HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge2, v2 );    // put in bucket v2
00426         //----------------------------------------------------------------
00427         fgets( line, 128, fileIn );
00428         sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 );
00429     }
00430 }

template<typename T>

void ReadOff< T >::ProcessFACE_LIST	(	FILE *	inputFile,
		OpenGL::XPolygonalModel< T > *const	prModel
	)			`[inline, static, private]`

Definition at line 334 of file TAPsReadOff.cpp.

00336 {
00337 #ifdef  TAPs_DEBUG_MODE
00338     std::cout << "Processing FACE LIST\n";
00339 #endif
00340     //---------------------------------------------------------------
00341     // Example:  number of vertices for this face followed by vertex numbers
00342     //   4 0  1  2  3
00343     //   ...
00344     //   3 10 11 12
00345     //---------------------------------------------------------------
00346     char line[128];
00347     char *delimiters = "\t ";
00348     char *token = NULL;
00349     char *end;
00350     int numberOfVertices;
00351     int vertexNo;
00352     int faceNo = 0;
00353     //---------------------------------------------------------------
00354     prModel->NewFaceListByNoFaces();
00355     do {
00356         do {
00357             fgets( line, 128, inputFile );
00358         } while ( strlen( line ) < 3 || line[0] == '#' );
00359         token = strtok( line, delimiters );     // number of vertices
00360         numberOfVertices = static_cast<int>( strtol( token, &end, 10 ) );
00361         prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices );
00362         // DEBUG
00363         prModel->GetFaceList()[faceNo].ID = faceNo;
00364         for ( int i = 0; i < numberOfVertices; ++i ) {
00365             token = strtok( '\0', delimiters ); // vertex number
00366             vertexNo = static_cast<int>( strtol( token, &end, 10 ) );
00367             prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo );
00368         }
00369         ++faceNo;
00370     } while ( faceNo < prModel->GetNoFaces() );
00371     //---------------------------------------------------------------
00372 }

template<typename T>

void ReadOff< T >::ProcessFACE_LIST	(	FILE *	inputFile,
		OpenGL::PolygonalModel< T > *const	prModel
	)			`[inline, static, private]`

Definition at line 294 of file TAPsReadOff.cpp.

00296 {
00297 #ifdef  TAPs_DEBUG_MODE
00298     std::cout << "Processing FACE LIST\n";
00299 #endif
00300     //---------------------------------------------------------------
00301     // Example:  number of vertices for this face followed by vertex numbers
00302     //   4 0  1  2  3
00303     //   ...
00304     //   3 10 11 12
00305     //---------------------------------------------------------------
00306     char line[128];
00307     char *delimiters = "\t ";
00308     char *token = NULL;
00309     char *end;
00310     int numberOfVertices;
00311     int vertexNo;
00312     int faceNo = 0;
00313     //---------------------------------------------------------------
00314     prModel->NewFaceListByNoFaces();
00315     do {
00316         do {
00317             fgets( line, 128, inputFile );
00318         } while ( strlen( line ) < 3 || line[0] == '#' );
00319         token = strtok( line, delimiters );     // number of vertices
00320         numberOfVertices = static_cast<int>( strtol( token, &end, 10 ) );
00321         prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices );
00322         for ( int i = 0; i < numberOfVertices; ++i ) {
00323             token = strtok( '\0', delimiters ); // vertex number
00324             vertexNo = static_cast<int>( strtol( token, &end, 10 ) );
00325             prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo );
00326         }
00327         ++faceNo;
00328     } while ( faceNo < prModel->GetNoFaces() );
00329     //---------------------------------------------------------------
00330 }

template<typename T>

bool ReadOff< T >::ProcessHEADER	(	FILE *	inputFile,
		OpenGL::MeshModel< T > *const	prModel
	)			`[inline, static, private]`

Definition at line 134 of file TAPsReadOff.cpp.

00136 {
00137     //---------------------------------------------------------------
00138     //m_iNumOfVertices = 0;
00139     //m_iNumOfFaces    = 0;
00140     //---------------------------------------------------------------
00141     char line[256];
00142     char node[128];
00143 //  while ( !feof(fileIn) ) {
00144     do {
00145         fgets( line, 256, inputFile );  // read the first line
00146     } while ( strlen( line ) < 3 || line[0] == '#' );
00147     sscanf( line, "%s", node );
00148     //-------------------------------------------
00149     // Example:
00150     //   OFF
00151     //   9995 20000 0   // #Vertex #Faces #Edges
00152     //-------------------------------------------
00153     // Check for OFF format
00154     if ( strncmp( node, "OFF", strlen("OFF") ) ) {
00155         return false;
00156     }
00157     //-------------------------------------------
00158     char *delimiters = "\t ";
00159     char *token = NULL;
00160     char *end;
00161     //-------------------------------------------
00162     fgets( line, 256, inputFile );  // read the next line
00163     //-------------------------------------------
00164     // Number of Vertices
00165     token = strtok( line, delimiters );
00166     if ( token != NULL ) {
00167         prModel->SetNoVertices( static_cast<int>( strtol( token, &end, 10 ) ) );
00168     }
00169     //-------------------------------------------
00170     // Number of Faces
00171     token = strtok( '\0', delimiters );
00172     if ( token != NULL ) {
00173         prModel->SetNoFaces( static_cast<int>( strtol( token, &end, 10 ) ) );
00174     }
00175     //-------------------------------------------
00176     // Number of Edges
00177     token = strtok( '\0', delimiters );
00178     if ( token != NULL ) {
00179         //prModel->SetNoEdges( static_cast<int>( strtol( token, &end, 10 ) ) );
00180     }
00181     //-------------------------------------------
00182 #ifdef  TAPs_DEBUG_MODE
00183     std::cout << "Number of Vertices: " << prModel->GetNoVertices() << "\n";
00184     std::cout << "Number of Faces:    " << prModel->GetNoFaces() << "\n";
00185     //std::cout << "Number of Edges:    " << prModel->GetNoEdges() << "\n";
00186 #endif
00187     return true;
00188 }

template<typename T>

void ReadOff< T >::ProcessVERTEX_LIST	(	FILE *	inputFile,
		OpenGL::HalfEdgeModel< T > *const	prModel
	)			`[inline, static, private]`

Definition at line 256 of file TAPsReadOff.cpp.

00258 {
00259 #ifdef  TAPs_DEBUG_MODE
00260     std::cout << "Processing VERTEX LIST\n";
00261 #endif
00262     //-------------------------------------------------------------------
00263     // Example:
00264     //  *MESH_VERTEX_LIST {
00265     //      *MESH_VERTEX    0   -10.000000  -5.000000   0.000000
00266     //      *MESH_VERTEX    1   10.000000   -5.000000   0.000000
00267     //      *MESH_VERTEX    2   -10.000000  5.000000    0.000000
00268     //      ...
00269     //  }
00270     //-------------------------------------------------------------------
00271     char node[128];
00272     int n;
00273     float x, y, z;
00274     fgets( line, 128, inputFile );
00275     sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z );
00276     while ( node[0] != '}' ) {
00277         //------------------------------------------------------
00278         // Put created vertex in vertexList for look up later
00279         HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] = new HEVertex<T>( x, y, z );
00280         // Put created vertex in vertexList of the model
00281         prModel->GetVertexList()->Append( HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] );
00282         ++vertexNo; // next vertex#
00283         //std::cout << "Vertex: " << vertexNo << "\n";
00284         //------------------------------------------------------
00285         fgets( line, 128, fileIn );
00286         sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z );
00287     }
00288 }

template<typename T>

void ReadOff< T >::ProcessVERTEX_LIST	(	FILE *	inputFile,
		OpenGL::XPolygonalModel< T > *const	prModel
	)			`[inline, static, private]`

Definition at line 225 of file TAPsReadOff.cpp.

00227 {
00228 #ifdef  TAPs_DEBUG_MODE
00229     std::cout << "Processing VERTEX LIST\n";
00230 #endif
00231     //-------------------------------------------------------------------
00232     // Example: x y z values
00233     //   0 0 0
00234     //   ...
00235     //   0 0 1
00236     //-------------------------------------------------------------------
00237     char vertexStr[128];
00238     int vertexNumber = 0;
00239     float x, y, z;      // since sscanf does not work for T (template)
00240     //-------------------------------------------------------------------
00241     prModel->NewVertexListByNoVertices();
00242     do {
00243         do {
00244             fgets( vertexStr, 128, inputFile );
00245         } while ( strlen( vertexStr ) < 3 || vertexStr[0] == '#' );
00246         sscanf( vertexStr, "%g %g %g", &x, &y, &z );
00247         prModel->GetVertexList()[vertexNumber][0] = x;
00248         prModel->GetVertexList()[vertexNumber][1] = y;
00249         prModel->GetVertexList()[vertexNumber][2] = z;
00250         ++vertexNumber;
00251     } while ( vertexNumber < prModel->GetNoVertices() );
00252 }

template<typename T>

void ReadOff< T >::ProcessVERTEX_LIST	(	FILE *	inputFile,
		OpenGL::PolygonalModel< T > *const	prModel
	)			`[inline, static, private]`

Definition at line 194 of file TAPsReadOff.cpp.

00196 {
00197 #ifdef  TAPs_DEBUG_MODE
00198     std::cout << "Processing VERTEX LIST\n";
00199 #endif
00200     //-------------------------------------------------------------------
00201     // Example: x y z values
00202     //   0 0 0
00203     //   ...
00204     //   0 0 1
00205     //-------------------------------------------------------------------
00206     char vertexStr[128];
00207     int vertexNumber = 0;
00208     float x, y, z;      // since sscanf does not work for T (template)
00209     //-------------------------------------------------------------------
00210     prModel->NewVertexListByNoVertices();
00211     do {
00212         do {
00213             fgets( vertexStr, 128, inputFile );
00214         } while ( strlen( vertexStr ) < 3 || vertexStr[0] == '#' );
00215         sscanf( vertexStr, "%g %g %g", &x, &y, &z );
00216         prModel->GetVertexList()[vertexNumber][0] = x;
00217         prModel->GetVertexList()[vertexNumber][1] = y;
00218         prModel->GetVertexList()[vertexNumber][2] = z;
00219         ++vertexNumber;
00220     } while ( vertexNumber < prModel->GetNoVertices() );
00221 }

template<typename T>

bool ReadOff< T >::readFile	(	const char *	fileName,
		OpenGL::HalfEdgeModel< T > *const	prModel
	)			`[inline, static]`

Definition at line 93 of file TAPsReadOff.cpp.

00095 {
00096     //----------------------------------------------------------------
00097     // Initialization
00098     halfEdgeCounter = 0;
00099     vertexNo = 0;
00100     //----------------------------------------------------------------
00101     // Open the input file
00102     FILE * fileIn = fopen( fileName, "r" );
00103     if ( !fileIn ) {
00104         std::perror( fileName );
00105         return false;
00106     }
00107     //----------------------------------------------------------------
00108 #ifdef  TAPs_DEBUG_MODE
00109     std::cout << "START READING " << fileName << "\n";
00110 #endif
00111     //----------------------------------------------------------------
00112     if ( ProcessHEADER( fileIn, prModel ) == false )    return false;
00113     if ( prModel->GetNoVertices() > 0 )
00114         ProcessVERTEX_LIST( fileIn, prModel );
00115     if ( prModel->GetNoFaces() > 0 )
00116         ProcessFACE_LIST( fileIn, prModel );
00117     //----------------------------------------------------------------
00118     fclose(fileIn);
00119     //----------------------------------------------------------------
00120     HelpCreateHalfEdgeModel<T>::CreateHalfEdgeModel( prModel );
00121     //----------------------------------------------------------------
00122 #ifdef  TAPs_DEBUG_MODE
00123     std::cout << "END READING " << fileName << "\n";
00124     std::cout << "Number of Half-Edges: " << halfEdgeCounter << "\n";
00125 #endif
00126     prModel->GetMaterial()->ApplyMaterial();
00127     return true;
00128 }

template<typename T>

bool ReadOff< T >::readFile	(	const char *	fileName,
		OpenGL::XPolygonalModel< T > *const	prModel
	)			`[inline, static]`

Definition at line 64 of file TAPsReadOff.cpp.

00066 {
00067     //----------------------------------------------------------------
00068     // Open the input file
00069     FILE * fileIn = fopen( fileName, "r" );
00070     if ( !fileIn ) {
00071         std::perror( fileName );
00072         return false;
00073     }
00074     //----------------------------------------------------------------
00075 #ifdef  TAPs_DEBUG_MODE
00076     std::cout << "START READING " << fileName << "\n";
00077 #endif
00078     //----------------------------------------------------------------
00079     if ( ProcessHEADER( fileIn, prModel ) == false )    return false;
00080     if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST( fileIn, prModel );
00081     if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST( fileIn, prModel );
00082     //----------------------------------------------------------------
00083     fclose(fileIn);
00084 #ifdef  TAPs_DEBUG_MODE
00085     std::cout << "END READING " << fileName << "\n";
00086 #endif
00087     prModel->GetMaterial()->ApplyMaterial();
00088     return true;
00089 }

template<typename T>

bool ReadOff< T >::readFile	(	const char *	fileName,
		OpenGL::PolygonalModel< T > *const	prModel
	)			`[inline, static]`

Definition at line 35 of file TAPsReadOff.cpp.

00037 {
00038     //----------------------------------------------------------------
00039     // Open the input file
00040     FILE * fileIn = fopen( fileName, "r" );
00041     if ( !fileIn ) {
00042         std::perror( fileName );
00043         return false;
00044     }
00045     //----------------------------------------------------------------
00046 #ifdef  TAPs_DEBUG_MODE
00047     std::cout << "START READING " << fileName << "\n";
00048 #endif
00049     //----------------------------------------------------------------
00050     if ( ProcessHEADER( fileIn, prModel ) == false )    return false;
00051     if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST( fileIn, prModel );
00052     if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST( fileIn, prModel );
00053     //----------------------------------------------------------------
00054     fclose(fileIn);
00055 #ifdef  TAPs_DEBUG_MODE
00056     std::cout << "END READING " << fileName << "\n";
00057 #endif
00058     prModel->GetMaterial()->ApplyMaterial();
00059     return true;
00060 }

Friends And Related Function Documentation

template<typename T>

friend class ReadModels< T > [friend]

Definition at line 22 of file TAPsReadOff.hpp.

Member Data Documentation

template<typename T>

BEGIN_NAMESPACE_TAPs int ReadOff< T >::halfEdgeCounter = 0 [inline, static, private]

Definition at line 59 of file TAPsReadOff.hpp.

template<typename T>

int ReadOff< T >::vertexNo = 0 [inline, static, private]

Definition at line 58 of file TAPsReadOff.hpp.

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

G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModelFromFile/TAPsReadOff.hpp
G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModelFromFile/TAPsReadOff.cpp


Static Public Member Functions
static bool	readFile (const char fileName, OpenGL::HalfEdgeModel< T > const prModel)
static bool	readFile (const char fileName, OpenGL::XPolygonalModel< T > const prModel)
static bool	readFile (const char fileName, OpenGL::PolygonalModel< T > const prModel)
Static Private Member Functions
static void	ProcessFACE_LIST (FILE inputFile, OpenGL::HalfEdgeModel< T > const prModel)
static void	ProcessFACE_LIST (FILE inputFile, OpenGL::XPolygonalModel< T > const prModel)
static void	ProcessFACE_LIST (FILE inputFile, OpenGL::PolygonalModel< T > const prModel)
static bool	ProcessHEADER (FILE inputFile, OpenGL::MeshModel< T > const prModel)
static void	ProcessVERTEX_LIST (FILE inputFile, OpenGL::HalfEdgeModel< T > const prModel)
static void	ProcessVERTEX_LIST (FILE inputFile, OpenGL::XPolygonalModel< T > const prModel)
static void	ProcessVERTEX_LIST (FILE inputFile, OpenGL::PolygonalModel< T > const prModel)
Static Private Attributes
static int	halfEdgeCounter = 0
static int	vertexNo = 0
Friends
class	ReadModels< T >

ReadOff< T > Class Template Reference

Static Public Member Functions

Static Private Member Functions

Static Private Attributes

Friends

Detailed Description

template<typename T> class ReadOff< T >

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename T>
class ReadOff< T >