#include <TAPsReadPly.hpp>
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) |
Private Types | |
| enum | PlyEnum { FORMAT_ASCII = 1, FORMAT_BINARY_LITTLE_ENDDIAN, FORMAT_BINARY_BIG_ENDDIAN, ELEMENT_VERTEX, ELEMENT_FACE, ELEMENT_EDGE, LIST_VERTEX_INDICES, INT_8, UINT_8, INT_16, UINT_16, INT_32, UINT_32, FLOAT_32, FLOAT_64, X, Y, Z, CONFIDENCE, INTENSITY, VERTEX1, VERTEX2, RED, GREEN, BLUE, UNDEFINED } |
Static Private Member Functions | |
| static void | Clear () |
| static void | ConvertBigEnddianToLittleEnddian (unsigned char dataType, unsigned char *prData) |
| static void | ProcessELEMENT (char *line, OpenGL::MeshModel< T > *const prModel) |
| static void | ProcessFACE_LIST_ASCII (FILE *inputFile, OpenGL::HalfEdgeModel< T > *const prModel) |
| static void | ProcessFACE_LIST_ASCII (FILE *inputFile, OpenGL::XPolygonalModel< T > *const prModel) |
| static void | ProcessFACE_LIST_ASCII (FILE *inputFile, OpenGL::PolygonalModel< T > *const prModel) |
| static void | ProcessFACE_LIST_BINARY_BIG_ENDDIAN (FILE *inputFile, OpenGL::HalfEdgeModel< T > *const prModel) |
| static void | ProcessFACE_LIST_BINARY_BIG_ENDDIAN (FILE *inputFile, OpenGL::XPolygonalModel< T > *const prModel) |
| static void | ProcessFACE_LIST_BINARY_BIG_ENDDIAN (FILE *inputFile, OpenGL::PolygonalModel< T > *const prModel) |
| static void | ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN (FILE *inputFile, OpenGL::HalfEdgeModel< T > *const prModel) |
| static void | ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN (FILE *inputFile, OpenGL::XPolygonalModel< T > *const prModel) |
| static void | ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN (FILE *inputFile, OpenGL::PolygonalModel< T > *const prModel) |
| static bool | ProcessFORMAT (char *line) |
| static bool | ProcessHEADER (FILE *inputFile, OpenGL::MeshModel< T > *const prModel) |
| static void | ProcessPROPERTY (char *line) |
| static void | ProcessVERTEX_LIST_ASCII (FILE *inputFile, OpenGL::HalfEdgeModel< T > *const prModel) |
| static void | ProcessVERTEX_LIST_ASCII (FILE *inputFile, OpenGL::XPolygonalModel< T > *const prModel) |
| static void | ProcessVERTEX_LIST_ASCII (FILE *inputFile, OpenGL::PolygonalModel< T > *const prModel) |
| static void | ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN (FILE *inputFile, OpenGL::HalfEdgeModel< T > *const prModel) |
| static void | ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN (FILE *inputFile, OpenGL::XPolygonalModel< T > *const prModel) |
| static void | ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN (FILE *inputFile, OpenGL::PolygonalModel< T > *const prModel) |
| static void | ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN (FILE *inputFile, OpenGL::HalfEdgeModel< T > *const prModel) |
| static void | ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN (FILE *inputFile, OpenGL::XPolygonalModel< T > *const prModel) |
| static void | ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN (FILE *inputFile, OpenGL::PolygonalModel< T > *const prModel) |
Static Private Attributes | |
| static int | halfEdgeCounter = 0 |
| static unsigned char | m_eCurrentListType = UNDEFINED |
| static unsigned char | m_eFormat = UNDEFINED |
| static float | m_fFormatVersion = 0.0f |
| static std::vector< unsigned char > | m_veEdgeListAttrib |
| static std::vector< unsigned char > | m_veEdgeListType |
| static std::vector< unsigned char > | m_veFaceListAttrib |
| static std::vector< unsigned char > | m_veFaceListType |
| static std::vector< unsigned char > | m_veVertexListAttrib |
| static std::vector< unsigned char > | m_veVertexListType |
| static int | vertexNo = 0 |
Friends | |
| class | ReadModels< T > |
Definition at line 21 of file TAPsReadPly.hpp.
enum ReadPly::PlyEnum [private] |
Definition at line 85 of file TAPsReadPly.hpp.
00085 { 00086 //----------------------------------------------- 00087 // Format 00088 //----------------------------------------------- 00089 FORMAT_ASCII = 1, 00090 FORMAT_BINARY_LITTLE_ENDDIAN, // PC 00091 FORMAT_BINARY_BIG_ENDDIAN, // UNIX 00092 //----------------------------------------------- 00093 // Element 00094 //----------------------------------------------- 00095 ELEMENT_VERTEX, // = 4 00096 ELEMENT_FACE, 00097 ELEMENT_EDGE, 00098 //----------------------------------------------- 00099 // List 00100 //----------------------------------------------- 00101 LIST_VERTEX_INDICES, // = 7 00102 //----------------------------------------------- 00103 // Name Type Number of Bytes 00104 //----------------------------------------------- 00105 // int8 character 1 00106 // uint8 unsigned character 1 00107 // int16 short integer 2 00108 // uint16 unsigned short integer 2 00109 // int32 integer 4 00110 // uint32 unsigned integer 4 00111 // float32 single-precision float 4 00112 // float64 double-precision float 8 00113 //----------------------------------------------- 00114 // Alias name: 00115 // uchar --> uint8 00116 // int --> int32 00117 // float --> float32 00118 // double --> float64 00119 //----------------------------------------------- 00120 INT_8, // = 8 00121 UINT_8, 00122 INT_16, 00123 UINT_16, 00124 INT_32, 00125 UINT_32, 00126 FLOAT_32, 00127 FLOAT_64, 00128 //----------------------------------------------- 00129 // Examples of User Defined 00130 //----------------------------------------------- 00131 // element material 6 00132 // property ambient_red uint8 { ambient color } 00133 // property ambient_green uint8 00134 // property ambient_blue uint8 00135 // property ambient_coeff float32 00136 // property diffuse_red uint8 { diffuse color } 00137 // property diffuse_green uint8 00138 // property diffuse_blue uint8 00139 // property diffuse_coeff float32 00140 // property specular_red uint8 { specular color } 00141 // property specular_green uint8 00142 // property specular_blue uint8 00143 // property specular_coeff float32 00144 // property specular_power float32 { Phong power } 00145 //----------------------------------------------- 00146 // Attribute 00147 X, Y, Z, // = 16, 17, 18 00148 CONFIDENCE, 00149 INTENSITY, 00150 VERTEX1, VERTEX2, // for edge list 00151 RED, GREEN, BLUE, 00152 //----------------------------------------------- 00153 UNDEFINED // = 26 00154 };
| void ReadPly< T >::Clear | ( | ) | [inline, static, private] |
Definition at line 186 of file TAPsReadPly.cpp.
00187 { 00188 m_eFormat = UNDEFINED; 00189 m_fFormatVersion = 0.0; 00190 m_eCurrentListType = UNDEFINED; 00191 //----------------------------------------------------- 00192 m_veVertexListType.clear(); 00193 m_veVertexListAttrib.clear(); 00194 m_veFaceListType.clear(); 00195 m_veFaceListAttrib.clear(); 00196 m_veEdgeListType.clear(); 00197 m_veEdgeListAttrib.clear(); 00198 //----------------------------------------------------- 00199 halfEdgeCounter = 0; 00200 vertexNo = 0; 00201 HelpCreateHalfEdgeModel<T>::vertexList = NULL; 00202 HelpCreateHalfEdgeModel<T>::vertexRingList = NULL; 00203 HelpCreateHalfEdgeModel<T>::halfEdgeRingList = NULL; 00204 HelpCreateHalfEdgeModel<T>::boundaryHalfEdgePtr = NULL; 00205 }
| void ReadPly< T >::ConvertBigEnddianToLittleEnddian | ( | unsigned char | dataType, | |
| unsigned char * | prData | |||
| ) | [inline, static, private] |
Definition at line 1964 of file TAPsReadPly.cpp.
01966 { 01967 unsigned char temp; 01968 switch ( dataType ) { 01969 case INT_16: 01970 case UINT_16: 01971 temp = prData[0]; 01972 prData[0] = prData[1]; 01973 prData[1] = temp; 01974 break; 01975 case INT_32: 01976 case UINT_32: 01977 case FLOAT_32: 01978 temp = prData[0]; 01979 prData[0] = prData[3]; 01980 prData[3] = temp; 01981 temp = prData[1]; 01982 prData[1] = prData[2]; 01983 prData[2] = temp; 01984 break; 01985 case FLOAT_64: 01986 temp = prData[0]; 01987 prData[0] = prData[7]; 01988 prData[7] = temp; 01989 temp = prData[1]; 01990 prData[1] = prData[6]; 01991 prData[6] = temp; 01992 temp = prData[2]; 01993 prData[2] = prData[5]; 01994 prData[5] = temp; 01995 temp = prData[3]; 01996 prData[3] = prData[4]; 01997 prData[4] = temp; 01998 break; 01999 } 02000 }
| void ReadPly< T >::ProcessELEMENT | ( | char * | line, | |
| OpenGL::MeshModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 341 of file TAPsReadPly.cpp.
00343 { 00344 //--------------------------------------------------------------- 00345 char *delimiters = "\t "; 00346 char *token = NULL; 00347 char *end; 00348 //--------------------------------------------------------------- 00349 token = strtok( line, delimiters ); // "element" 00350 token = strtok( '\0', delimiters ); // type of element 00351 if ( !strncmp( token, "vertex", strlen("vertex") ) ) { 00352 token = strtok( '\0', delimiters ); // # of vertices 00353 prModel->SetNoVertices( static_cast<int>( strtol( token, &end, 10 ) ) ); 00354 m_eCurrentListType = ELEMENT_VERTEX; 00355 } 00356 else if ( !strncmp( token, "face", strlen("face") ) ) { 00357 token = strtok( '\0', delimiters ); // # of faces 00358 prModel->SetNoFaces( static_cast<int>( strtol( token, &end, 10 ) ) ); 00359 m_eCurrentListType = ELEMENT_FACE; 00360 } 00361 else if ( !strncmp( token, "edge", strlen("edge") ) ) { 00362 token = strtok( '\0', delimiters ); // # of faces 00363 // prModel doesn't support edge list 00364 //prModel->SetNoFaces( static_cast<int>( strtol( token, &end, 10 ) ) ); 00365 m_eCurrentListType = ELEMENT_EDGE; 00366 } 00367 }
| void ReadPly< T >::ProcessFACE_LIST_ASCII | ( | FILE * | inputFile, | |
| OpenGL::HalfEdgeModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 686 of file TAPsReadPly.cpp.
00688 { 00689 std::cout << "Processing Node MESH_FACE_LIST\n"; 00690 //------------------------------------------------------------------- 00691 // Example: 00692 // *MESH_FACE_LIST { 00693 // *MESH_FACE 0: A: 0 B: 2 C: 3 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1 00694 // *MESH_FACE 1: A: 3 B: 1 C: 0 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1 00695 // *MESH_FACE 2: A: 4 B: 5 C: 7 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 3 *MESH_MTLID 0 00696 // ... 00697 // } 00698 //------------------------------------------------------------------- 00699 HEFace<T> *heFace; 00700 char node[128]; 00701 char N[16], A[4], B[4], C[4]; 00702 int v0, v1, v2; 00703 fgets( line, 128, fileIn ); 00704 sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 ); 00705 while ( node[0] != '}' ) { 00706 heFace = new HEFace<T>(); 00707 prModel->GetFaceList()->Append( heFace ); 00708 //---------------------------------------------------------------- 00709 // Create and Set all three half-edges 00710 HEHalfEdge<T> *heHalfEdge0 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 00711 HelpCreateHalfEdgeModel<T>::vertexList[v0], 00712 HelpCreateHalfEdgeModel<T>::vertexList[v1], 00713 heFace ); 00714 HEHalfEdge<T> *heHalfEdge1 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 00715 HelpCreateHalfEdgeModel<T>::vertexList[v1], 00716 HelpCreateHalfEdgeModel<T>::vertexList[v2], 00717 heFace, heHalfEdge0 ); 00718 HEHalfEdge<T> *heHalfEdge2 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 00719 HelpCreateHalfEdgeModel<T>::vertexList[v2], 00720 HelpCreateHalfEdgeModel<T>::vertexList[v0], 00721 heFace, heHalfEdge1, heHalfEdge0 ); 00722 halfEdgeCounter += 3; 00723 //---------------------------------------------------------------- 00724 // Set incident half-edge of this face 00725 heFace->IncidentHalfEdge( heHalfEdge0 ); 00726 //---------------------------------------------------------------- 00727 // (CCW) Record v0 to v1, v1 to v2, and v2 to v0 in vertexRingList 00728 HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v1, v0 ); // put v1 in bucket v0 00729 HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v2, v1 ); // put v2 in bucket v1 00730 HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v0, v2 ); // put v0 in bucket v2 00731 //---------------------------------------------------------------- 00732 // Record half-edges in halfEdgeRingList 00733 HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge0, v0 ); // put in bucket v0 00734 HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge1, v1 ); // put in bucket v1 00735 HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge2, v2 ); // put in bucket v2 00736 //---------------------------------------------------------------- 00737 fgets( line, 128, fileIn ); 00738 sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 ); 00739 } 00740 }
| void ReadPly< T >::ProcessFACE_LIST_ASCII | ( | FILE * | inputFile, | |
| OpenGL::XPolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 646 of file TAPsReadPly.cpp.
00648 { 00649 #ifdef TAPs_DEBUG_MODE 00650 std::cout << "Processing FACE LIST\n"; 00651 #endif 00652 //--------------------------------------------------------------- 00653 // Example: number of vertices for this face followed by vertex numbers 00654 // 4 0 1 2 3 00655 // ... 00656 // 3 10 11 12 00657 //--------------------------------------------------------------- 00658 char line[128]; 00659 char *delimiters = "\t "; 00660 char *token = NULL; 00661 char *end; 00662 int numberOfVertices; 00663 int vertexNo; 00664 int faceNo = 0; 00665 //--------------------------------------------------------------- 00666 prModel->NewFaceListByNoFaces(); 00667 do { 00668 do { 00669 fgets( line, 128, inputFile ); 00670 } while ( strlen( line ) < 3 || line[0] == '#' ); 00671 token = strtok( line, delimiters ); // number of vertices 00672 numberOfVertices = static_cast<int>( strtol( token, &end, 10 ) ); 00673 prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices ); 00674 for ( int i = 0; i < numberOfVertices; ++i ) { 00675 token = strtok( '\0', delimiters ); // vertex number 00676 vertexNo = static_cast<int>( strtol( token, &end, 10 ) ); 00677 prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo ); 00678 } 00679 ++faceNo; 00680 } while ( faceNo < prModel->GetNoFaces() ); 00681 //--------------------------------------------------------------- 00682 }
| void ReadPly< T >::ProcessFACE_LIST_ASCII | ( | FILE * | inputFile, | |
| OpenGL::PolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 606 of file TAPsReadPly.cpp.
00608 { 00609 #ifdef TAPs_DEBUG_MODE 00610 std::cout << "Processing FACE LIST\n"; 00611 #endif 00612 //--------------------------------------------------------------- 00613 // Example: number of vertices for this face followed by vertex numbers 00614 // 4 0 1 2 3 00615 // ... 00616 // 3 10 11 12 00617 //--------------------------------------------------------------- 00618 char line[128]; 00619 char *delimiters = "\t "; 00620 char *token = NULL; 00621 char *end; 00622 int numberOfVertices; 00623 int vertexNo; 00624 int faceNo = 0; 00625 //--------------------------------------------------------------- 00626 prModel->NewFaceListByNoFaces(); 00627 do { 00628 do { 00629 fgets( line, 128, inputFile ); 00630 } while ( strlen( line ) < 3 || line[0] == '#' ); 00631 token = strtok( line, delimiters ); // number of vertices 00632 numberOfVertices = static_cast<int>( strtol( token, &end, 10 ) ); 00633 prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices ); 00634 for ( int i = 0; i < numberOfVertices; ++i ) { 00635 token = strtok( '\0', delimiters ); // vertex number 00636 vertexNo = static_cast<int>( strtol( token, &end, 10 ) ); 00637 prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo ); 00638 } 00639 ++faceNo; 00640 } while ( faceNo < prModel->GetNoFaces() ); 00641 //--------------------------------------------------------------- 00642 }
| void ReadPly< T >::ProcessFACE_LIST_BINARY_BIG_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::HalfEdgeModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 1348 of file TAPsReadPly.cpp.
01350 { 01351 #ifdef TAPs_DEBUG_MODE 01352 std::cout << "Processing FACE LIST\n"; 01353 #endif 01354 }
| void ReadPly< T >::ProcessFACE_LIST_BINARY_BIG_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::XPolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 1152 of file TAPsReadPly.cpp.
01154 { 01155 #ifdef TAPs_DEBUG_MODE 01156 std::cout << "Processing FACE LIST\n"; 01157 #endif 01158 //--------------------------------------------------------------- 01159 // Example: number of vertices for this face followed by vertex numbers 01160 // 4 0 1 2 3 01161 // ... 01162 // 3 10 11 12 01163 //--------------------------------------------------------------- 01164 prModel->NewFaceListByNoFaces(); 01165 if ( prModel->GetNoFaces() == 0 ) return; 01166 //--------------------------------------------------------------- 01167 int readingSizeBefore = 0; 01168 int readingSizeAfter = 0; 01169 int numberOfVerticesSize = 0; 01170 int vertexIndexSize = 0; 01171 int faceNo = 0; 01172 int vertexNo = 0; 01173 int numberOfVertices = 0; 01174 int index = -1; 01175 unsigned char prBuffer[256]; 01176 //--------------------------------------------------------------- 01177 for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) { 01178 if ( m_veFaceListAttrib[i] == LIST_VERTEX_INDICES ) { 01179 index = i; 01180 //--------------------------------------------- 01181 // Set data type for number of vertices 01182 switch ( m_veFaceListType[i] ) { 01183 case INT_8: 01184 case UINT_8: 01185 numberOfVerticesSize = 1; 01186 break; 01187 case INT_16: 01188 case UINT_16: 01189 numberOfVerticesSize = 2; 01190 break; 01191 case INT_32: 01192 case UINT_32: 01193 case FLOAT_32: 01194 numberOfVerticesSize = 4; 01195 break; 01196 case FLOAT_64: 01197 numberOfVerticesSize = 8; 01198 break; 01199 } 01200 //--------------------------------------------- 01201 // Set data type for the list of vertex indices 01202 switch ( m_veFaceListType[++i] ) { 01203 case INT_8: 01204 case UINT_8: 01205 vertexIndexSize = 1; 01206 break; 01207 case INT_16: 01208 case UINT_16: 01209 vertexIndexSize = 2; 01210 break; 01211 case INT_32: 01212 case UINT_32: 01213 case FLOAT_32: 01214 vertexIndexSize = 4; 01215 break; 01216 case FLOAT_64: 01217 vertexIndexSize = 8; 01218 break; 01219 } 01220 } 01221 else { 01222 //--------------------------------------------- 01223 // Set data type for this attribute 01224 switch ( m_veFaceListType[i] ) { 01225 case INT_8: 01226 case UINT_8: 01227 if ( index == -1 ) readingSizeBefore += 1; 01228 else readingSizeAfter += 1; 01229 break; 01230 case INT_16: 01231 case UINT_16: 01232 if ( index == -1 ) readingSizeBefore += 2; 01233 else readingSizeAfter += 2; 01234 break; 01235 case INT_32: 01236 case UINT_32: 01237 case FLOAT_32: 01238 if ( index == -1 ) readingSizeBefore += 4; 01239 else readingSizeAfter += 4; 01240 break; 01241 case FLOAT_64: 01242 if ( index == -1 ) readingSizeBefore += 8; 01243 else readingSizeAfter += 8; 01244 break; 01245 } 01246 } 01247 } 01248 //--------------------------------------------------------------- 01249 // Set Faces 01250 do { 01251 //------------------------------------------------- 01252 // Get some attributes before face info 01253 fread( prBuffer, readingSizeBefore, 1, inputFile ); 01254 //------------------------------------------------- 01255 // Get number of vertices for each face 01256 fread( prBuffer, numberOfVerticesSize, 1, inputFile ); 01257 ConvertBigEnddianToLittleEnddian( m_veFaceListType[index], prBuffer ); 01258 switch ( m_veFaceListType[index] ) { 01259 case INT_8: 01260 numberOfVertices = *((char *)(prBuffer)); 01261 break; 01262 case UINT_8: 01263 numberOfVertices = *((unsigned char *)(prBuffer)); 01264 break; 01265 case INT_16: 01266 numberOfVertices = *((short int *)(prBuffer)); 01267 break; 01268 case UINT_16: 01269 numberOfVertices = *((unsigned short int *)(prBuffer)); 01270 break; 01271 case INT_32: 01272 numberOfVertices = *((long int *)(prBuffer)); 01273 break; 01274 case UINT_32: 01275 numberOfVertices = *((unsigned long int *)(prBuffer)); 01276 break; 01277 case FLOAT_32: 01278 numberOfVertices = *((float *)(prBuffer)); 01279 break; 01280 case FLOAT_64: 01281 numberOfVertices = *((double *)(prBuffer)); 01282 break; 01283 } 01284 //------------------------------------------------- 01285 #ifdef TAPs_DEBUG_MODE_DETAIL_4 01286 if ( numberOfVertices <= 0 ) { 01287 std::cerr << "ERROR: This face has " 01288 << numberOfVertices << " of vertices!" << std::endl; 01289 } 01290 #endif 01291 prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices ); 01292 //------------------------------------------------- 01293 // Get the list of vertex indices for each face 01294 fread( prBuffer, vertexIndexSize, numberOfVertices, inputFile ); 01295 int index2 = 0; 01296 for ( int i = 0; i < numberOfVertices; ++i ) { 01297 if ( vertexIndexSize > 1 ) { 01298 ConvertBigEnddianToLittleEnddian( m_veFaceListType[index+1], &(prBuffer[index2]) ); 01299 } 01300 switch ( m_veFaceListType[index+1] ) { 01301 case INT_8: 01302 vertexNo = *((char *)( &(prBuffer[index2]) )); 01303 break; 01304 case UINT_8: 01305 vertexNo = *((unsigned char *)( &(prBuffer[index2]) )); 01306 break; 01307 case INT_16: 01308 vertexNo = *((short int *)( &(prBuffer[index2]) )); 01309 break; 01310 case UINT_16: 01311 vertexNo = *((unsigned short int *)( &(prBuffer[index2]) )); 01312 break; 01313 case INT_32: 01314 vertexNo = *((long int *)( &(prBuffer[index2]) )); 01315 break; 01316 case UINT_32: 01317 vertexNo = *((unsigned long int *)( &(prBuffer[index2]) )); 01318 break; 01319 case FLOAT_32: 01320 vertexNo = *((float *)( &(prBuffer[index2]) )); 01321 break; 01322 case FLOAT_64: 01323 vertexNo = *((double *)( &(prBuffer[index2]) )); 01324 break; 01325 } 01326 prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo ); 01327 index2 += vertexIndexSize; 01328 } 01329 //------------------------------------------------- 01330 // Get some attributes after face info 01331 fread( prBuffer, readingSizeAfter, 1, inputFile ); 01332 //------------------------------------------------- 01333 #ifdef TAPs_DEBUG_MODE_DETAIL_3 01334 std::cout << "Face# " << faceNo << " has " << numberOfVertices << " vertices --> "; 01335 for ( int i = 0; i < numberOfVertices; ++i ) { 01336 std::cout << "\t" << vertexNo; 01337 } 01338 std::cout << "\n"; 01339 #endif 01340 //------------------------------------------------- 01341 ++faceNo; 01342 //------------------------------------------------- 01343 } while ( faceNo < prModel->GetNoFaces() ); 01344 }
| void ReadPly< T >::ProcessFACE_LIST_BINARY_BIG_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::PolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 956 of file TAPsReadPly.cpp.
00958 { 00959 #ifdef TAPs_DEBUG_MODE 00960 std::cout << "Processing FACE LIST\n"; 00961 #endif 00962 //--------------------------------------------------------------- 00963 // Example: number of vertices for this face followed by vertex numbers 00964 // 4 0 1 2 3 00965 // ... 00966 // 3 10 11 12 00967 //--------------------------------------------------------------- 00968 prModel->NewFaceListByNoFaces(); 00969 if ( prModel->GetNoFaces() == 0 ) return; 00970 //--------------------------------------------------------------- 00971 int readingSizeBefore = 0; 00972 int readingSizeAfter = 0; 00973 int numberOfVerticesSize = 0; 00974 int vertexIndexSize = 0; 00975 int faceNo = 0; 00976 int vertexNo = 0; 00977 int numberOfVertices = 0; 00978 int index = -1; 00979 unsigned char prBuffer[256]; 00980 //--------------------------------------------------------------- 00981 for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) { 00982 if ( m_veFaceListAttrib[i] == LIST_VERTEX_INDICES ) { 00983 index = i; 00984 //--------------------------------------------- 00985 // Set data type for number of vertices 00986 switch ( m_veFaceListType[i] ) { 00987 case INT_8: 00988 case UINT_8: 00989 numberOfVerticesSize = 1; 00990 break; 00991 case INT_16: 00992 case UINT_16: 00993 numberOfVerticesSize = 2; 00994 break; 00995 case INT_32: 00996 case UINT_32: 00997 case FLOAT_32: 00998 numberOfVerticesSize = 4; 00999 break; 01000 case FLOAT_64: 01001 numberOfVerticesSize = 8; 01002 break; 01003 } 01004 //--------------------------------------------- 01005 // Set data type for the list of vertex indices 01006 switch ( m_veFaceListType[++i] ) { 01007 case INT_8: 01008 case UINT_8: 01009 vertexIndexSize = 1; 01010 break; 01011 case INT_16: 01012 case UINT_16: 01013 vertexIndexSize = 2; 01014 break; 01015 case INT_32: 01016 case UINT_32: 01017 case FLOAT_32: 01018 vertexIndexSize = 4; 01019 break; 01020 case FLOAT_64: 01021 vertexIndexSize = 8; 01022 break; 01023 } 01024 } 01025 else { 01026 //--------------------------------------------- 01027 // Set data type for this attribute 01028 switch ( m_veFaceListType[i] ) { 01029 case INT_8: 01030 case UINT_8: 01031 if ( index == -1 ) readingSizeBefore += 1; 01032 else readingSizeAfter += 1; 01033 break; 01034 case INT_16: 01035 case UINT_16: 01036 if ( index == -1 ) readingSizeBefore += 2; 01037 else readingSizeAfter += 2; 01038 break; 01039 case INT_32: 01040 case UINT_32: 01041 case FLOAT_32: 01042 if ( index == -1 ) readingSizeBefore += 4; 01043 else readingSizeAfter += 4; 01044 break; 01045 case FLOAT_64: 01046 if ( index == -1 ) readingSizeBefore += 8; 01047 else readingSizeAfter += 8; 01048 break; 01049 } 01050 } 01051 } 01052 //--------------------------------------------------------------- 01053 // Set Faces 01054 do { 01055 //------------------------------------------------- 01056 // Get some attributes before face info 01057 fread( prBuffer, readingSizeBefore, 1, inputFile ); 01058 //------------------------------------------------- 01059 // Get number of vertices for each face 01060 fread( prBuffer, numberOfVerticesSize, 1, inputFile ); 01061 ConvertBigEnddianToLittleEnddian( m_veFaceListType[index], prBuffer ); 01062 switch ( m_veFaceListType[index] ) { 01063 case INT_8: 01064 numberOfVertices = *((char *)(prBuffer)); 01065 break; 01066 case UINT_8: 01067 numberOfVertices = *((unsigned char *)(prBuffer)); 01068 break; 01069 case INT_16: 01070 numberOfVertices = *((short int *)(prBuffer)); 01071 break; 01072 case UINT_16: 01073 numberOfVertices = *((unsigned short int *)(prBuffer)); 01074 break; 01075 case INT_32: 01076 numberOfVertices = *((long int *)(prBuffer)); 01077 break; 01078 case UINT_32: 01079 numberOfVertices = *((unsigned long int *)(prBuffer)); 01080 break; 01081 case FLOAT_32: 01082 numberOfVertices = *((float *)(prBuffer)); 01083 break; 01084 case FLOAT_64: 01085 numberOfVertices = *((double *)(prBuffer)); 01086 break; 01087 } 01088 //------------------------------------------------- 01089 #ifdef TAPs_DEBUG_MODE_DETAIL_4 01090 if ( numberOfVertices <= 0 ) { 01091 std::cerr << "ERROR: This face has " 01092 << numberOfVertices << " of vertices!" << std::endl; 01093 } 01094 #endif 01095 prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices ); 01096 //------------------------------------------------- 01097 // Get the list of vertex indices for each face 01098 fread( prBuffer, vertexIndexSize, numberOfVertices, inputFile ); 01099 int index2 = 0; 01100 for ( int i = 0; i < numberOfVertices; ++i ) { 01101 if ( vertexIndexSize > 1 ) { 01102 ConvertBigEnddianToLittleEnddian( m_veFaceListType[index+1], &(prBuffer[index2]) ); 01103 } 01104 switch ( m_veFaceListType[index+1] ) { 01105 case INT_8: 01106 vertexNo = *((char *)( &(prBuffer[index2]) )); 01107 break; 01108 case UINT_8: 01109 vertexNo = *((unsigned char *)( &(prBuffer[index2]) )); 01110 break; 01111 case INT_16: 01112 vertexNo = *((short int *)( &(prBuffer[index2]) )); 01113 break; 01114 case UINT_16: 01115 vertexNo = *((unsigned short int *)( &(prBuffer[index2]) )); 01116 break; 01117 case INT_32: 01118 vertexNo = *((long int *)( &(prBuffer[index2]) )); 01119 break; 01120 case UINT_32: 01121 vertexNo = *((unsigned long int *)( &(prBuffer[index2]) )); 01122 break; 01123 case FLOAT_32: 01124 vertexNo = *((float *)( &(prBuffer[index2]) )); 01125 break; 01126 case FLOAT_64: 01127 vertexNo = *((double *)( &(prBuffer[index2]) )); 01128 break; 01129 } 01130 prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo ); 01131 index2 += vertexIndexSize; 01132 } 01133 //------------------------------------------------- 01134 // Get some attributes after face info 01135 fread( prBuffer, readingSizeAfter, 1, inputFile ); 01136 //------------------------------------------------- 01137 #ifdef TAPs_DEBUG_MODE_DETAIL_3 01138 std::cout << "Face# " << faceNo << " has " << numberOfVertices << " vertices --> "; 01139 for ( int i = 0; i < numberOfVertices; ++i ) { 01140 std::cout << "\t" << vertexNo; 01141 } 01142 std::cout << "\n"; 01143 #endif 01144 //------------------------------------------------- 01145 ++faceNo; 01146 //------------------------------------------------- 01147 } while ( faceNo < prModel->GetNoFaces() ); 01148 }
| void ReadPly< T >::ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::HalfEdgeModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 1952 of file TAPsReadPly.cpp.
01954 { 01955 #ifdef TAPs_DEBUG_MODE 01956 std::cout << "Processing FACE LIST\n"; 01957 #endif 01958 }
| void ReadPly< T >::ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::XPolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 1760 of file TAPsReadPly.cpp.
01762 { 01763 #ifdef TAPs_DEBUG_MODE 01764 std::cout << "Processing FACE LIST\n"; 01765 #endif 01766 //--------------------------------------------------------------- 01767 // Example: number of vertices for this face followed by vertex numbers 01768 // 4 0 1 2 3 01769 // ... 01770 // 3 10 11 12 01771 //--------------------------------------------------------------- 01772 prModel->NewFaceListByNoFaces(); 01773 if ( prModel->GetNoFaces() == 0 ) return; 01774 //--------------------------------------------------------------- 01775 int readingSizeBefore = 0; 01776 int readingSizeAfter = 0; 01777 int numberOfVerticesSize = 0; 01778 int vertexIndexSize = 0; 01779 int faceNo = 0; 01780 int vertexNo = 0; 01781 int numberOfVertices = 0; 01782 int index = -1; 01783 unsigned char prBuffer[256]; 01784 //--------------------------------------------------------------- 01785 for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) { 01786 if ( m_veFaceListAttrib[i] == LIST_VERTEX_INDICES ) { 01787 index = i; 01788 //--------------------------------------------- 01789 // Set data type for number of vertices 01790 switch ( m_veFaceListType[i] ) { 01791 case INT_8: 01792 case UINT_8: 01793 numberOfVerticesSize = 1; 01794 break; 01795 case INT_16: 01796 case UINT_16: 01797 numberOfVerticesSize = 2; 01798 break; 01799 case INT_32: 01800 case UINT_32: 01801 case FLOAT_32: 01802 numberOfVerticesSize = 4; 01803 break; 01804 case FLOAT_64: 01805 numberOfVerticesSize = 8; 01806 break; 01807 } 01808 //--------------------------------------------- 01809 // Set data type for the list of vertex indices 01810 switch ( m_veFaceListType[++i] ) { 01811 case INT_8: 01812 case UINT_8: 01813 vertexIndexSize = 1; 01814 break; 01815 case INT_16: 01816 case UINT_16: 01817 vertexIndexSize = 2; 01818 break; 01819 case INT_32: 01820 case UINT_32: 01821 case FLOAT_32: 01822 vertexIndexSize = 4; 01823 break; 01824 case FLOAT_64: 01825 vertexIndexSize = 8; 01826 break; 01827 } 01828 } 01829 else { 01830 //--------------------------------------------- 01831 // Set data type for this attribute 01832 switch ( m_veFaceListType[i] ) { 01833 case INT_8: 01834 case UINT_8: 01835 if ( index == -1 ) readingSizeBefore += 1; 01836 else readingSizeAfter += 1; 01837 break; 01838 case INT_16: 01839 case UINT_16: 01840 if ( index == -1 ) readingSizeBefore += 2; 01841 else readingSizeAfter += 2; 01842 break; 01843 case INT_32: 01844 case UINT_32: 01845 case FLOAT_32: 01846 if ( index == -1 ) readingSizeBefore += 4; 01847 else readingSizeAfter += 4; 01848 break; 01849 case FLOAT_64: 01850 if ( index == -1 ) readingSizeBefore += 8; 01851 else readingSizeAfter += 8; 01852 break; 01853 } 01854 } 01855 } 01856 //--------------------------------------------------------------- 01857 // Set Faces 01858 do { 01859 //------------------------------------------------- 01860 // Get some attributes before face info 01861 fread( prBuffer, readingSizeBefore, 1, inputFile ); 01862 //------------------------------------------------- 01863 // Get number of vertices for each face 01864 fread( prBuffer, numberOfVerticesSize, 1, inputFile ); 01865 switch ( m_veFaceListType[index] ) { 01866 case INT_8: 01867 numberOfVertices = *((char *)(prBuffer)); 01868 break; 01869 case UINT_8: 01870 numberOfVertices = *((unsigned char *)(prBuffer)); 01871 break; 01872 case INT_16: 01873 numberOfVertices = *((short int *)(prBuffer)); 01874 break; 01875 case UINT_16: 01876 numberOfVertices = *((unsigned short int *)(prBuffer)); 01877 break; 01878 case INT_32: 01879 numberOfVertices = *((long int *)(prBuffer)); 01880 break; 01881 case UINT_32: 01882 numberOfVertices = *((unsigned long int *)(prBuffer)); 01883 break; 01884 case FLOAT_32: 01885 numberOfVertices = *((float *)(prBuffer)); 01886 break; 01887 case FLOAT_64: 01888 numberOfVertices = *((double *)(prBuffer)); 01889 break; 01890 } 01891 //------------------------------------------------- 01892 #ifdef TAPs_DEBUG_MODE_DETAIL_4 01893 if ( numberOfVertices <= 0 ) { 01894 std::cerr << "ERROR: This face has " 01895 << numberOfVertices << " of vertices!" << std::endl; 01896 } 01897 #endif 01898 prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices ); 01899 //------------------------------------------------- 01900 // Get the list of vertex indices for each face 01901 fread( prBuffer, vertexIndexSize, numberOfVertices, inputFile ); 01902 int index2 = 0; 01903 for ( int i = 0; i < numberOfVertices; ++i ) { 01904 switch ( m_veFaceListType[index+1] ) { 01905 case INT_8: 01906 vertexNo = *((char *)( &(prBuffer[index2]) )); 01907 break; 01908 case UINT_8: 01909 vertexNo = *((unsigned char *)( &(prBuffer[index2]) )); 01910 break; 01911 case INT_16: 01912 vertexNo = *((short int *)( &(prBuffer[index2]) )); 01913 break; 01914 case UINT_16: 01915 vertexNo = *((unsigned short int *)( &(prBuffer[index2]) )); 01916 break; 01917 case INT_32: 01918 vertexNo = *((long int *)( &(prBuffer[index2]) )); 01919 break; 01920 case UINT_32: 01921 vertexNo = *((unsigned long int *)( &(prBuffer[index2]) )); 01922 break; 01923 case FLOAT_32: 01924 vertexNo = *((float *)( &(prBuffer[index2]) )); 01925 break; 01926 case FLOAT_64: 01927 vertexNo = *((double *)( &(prBuffer[index2]) )); 01928 break; 01929 } 01930 prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo ); 01931 index2 += vertexIndexSize; 01932 } 01933 //------------------------------------------------- 01934 // Get some attributes after face info 01935 fread( prBuffer, readingSizeAfter, 1, inputFile ); 01936 //------------------------------------------------- 01937 #ifdef TAPs_DEBUG_MODE_DETAIL_3 01938 std::cout << "Face# " << faceNo << " has " << numberOfVertices << " vertices --> "; 01939 for ( int i = 0; i < numberOfVertices; ++i ) { 01940 std::cout << "\t" << vertexNo; 01941 } 01942 std::cout << "\n"; 01943 #endif 01944 //------------------------------------------------- 01945 ++faceNo; 01946 //------------------------------------------------- 01947 } while ( faceNo < prModel->GetNoFaces() ); 01948 }
| void ReadPly< T >::ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::PolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 1568 of file TAPsReadPly.cpp.
01570 { 01571 #ifdef TAPs_DEBUG_MODE 01572 std::cout << "Processing FACE LIST\n"; 01573 #endif 01574 //--------------------------------------------------------------- 01575 // Example: number of vertices for this face followed by vertex numbers 01576 // 4 0 1 2 3 01577 // ... 01578 // 3 10 11 12 01579 //--------------------------------------------------------------- 01580 prModel->NewFaceListByNoFaces(); 01581 if ( prModel->GetNoFaces() == 0 ) return; 01582 //--------------------------------------------------------------- 01583 int readingSizeBefore = 0; 01584 int readingSizeAfter = 0; 01585 int numberOfVerticesSize = 0; 01586 int vertexIndexSize = 0; 01587 int faceNo = 0; 01588 int vertexNo = 0; 01589 int numberOfVertices = 0; 01590 int index = -1; 01591 unsigned char prBuffer[256]; 01592 //--------------------------------------------------------------- 01593 for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) { 01594 if ( m_veFaceListAttrib[i] == LIST_VERTEX_INDICES ) { 01595 index = i; 01596 //--------------------------------------------- 01597 // Set data type for number of vertices 01598 switch ( m_veFaceListType[i] ) { 01599 case INT_8: 01600 case UINT_8: 01601 numberOfVerticesSize = 1; 01602 break; 01603 case INT_16: 01604 case UINT_16: 01605 numberOfVerticesSize = 2; 01606 break; 01607 case INT_32: 01608 case UINT_32: 01609 case FLOAT_32: 01610 numberOfVerticesSize = 4; 01611 break; 01612 case FLOAT_64: 01613 numberOfVerticesSize = 8; 01614 break; 01615 } 01616 //--------------------------------------------- 01617 // Set data type for the list of vertex indices 01618 switch ( m_veFaceListType[++i] ) { 01619 case INT_8: 01620 case UINT_8: 01621 vertexIndexSize = 1; 01622 break; 01623 case INT_16: 01624 case UINT_16: 01625 vertexIndexSize = 2; 01626 break; 01627 case INT_32: 01628 case UINT_32: 01629 case FLOAT_32: 01630 vertexIndexSize = 4; 01631 break; 01632 case FLOAT_64: 01633 vertexIndexSize = 8; 01634 break; 01635 } 01636 } 01637 else { 01638 //--------------------------------------------- 01639 // Set data type for this attribute 01640 switch ( m_veFaceListType[i] ) { 01641 case INT_8: 01642 case UINT_8: 01643 if ( index == -1 ) readingSizeBefore += 1; 01644 else readingSizeAfter += 1; 01645 break; 01646 case INT_16: 01647 case UINT_16: 01648 if ( index == -1 ) readingSizeBefore += 2; 01649 else readingSizeAfter += 2; 01650 break; 01651 case INT_32: 01652 case UINT_32: 01653 case FLOAT_32: 01654 if ( index == -1 ) readingSizeBefore += 4; 01655 else readingSizeAfter += 4; 01656 break; 01657 case FLOAT_64: 01658 if ( index == -1 ) readingSizeBefore += 8; 01659 else readingSizeAfter += 8; 01660 break; 01661 } 01662 } 01663 } 01664 //--------------------------------------------------------------- 01665 // Set Faces 01666 do { 01667 //------------------------------------------------- 01668 // Get some attributes before face info 01669 fread( prBuffer, readingSizeBefore, 1, inputFile ); 01670 //------------------------------------------------- 01671 // Get number of vertices for each face 01672 fread( prBuffer, numberOfVerticesSize, 1, inputFile ); 01673 switch ( m_veFaceListType[index] ) { 01674 case INT_8: 01675 numberOfVertices = *((char *)(prBuffer)); 01676 break; 01677 case UINT_8: 01678 numberOfVertices = *((unsigned char *)(prBuffer)); 01679 break; 01680 case INT_16: 01681 numberOfVertices = *((short int *)(prBuffer)); 01682 break; 01683 case UINT_16: 01684 numberOfVertices = *((unsigned short int *)(prBuffer)); 01685 break; 01686 case INT_32: 01687 numberOfVertices = *((long int *)(prBuffer)); 01688 break; 01689 case UINT_32: 01690 numberOfVertices = *((unsigned long int *)(prBuffer)); 01691 break; 01692 case FLOAT_32: 01693 numberOfVertices = *((float *)(prBuffer)); 01694 break; 01695 case FLOAT_64: 01696 numberOfVertices = *((double *)(prBuffer)); 01697 break; 01698 } 01699 //------------------------------------------------- 01700 #ifdef TAPs_DEBUG_MODE_DETAIL_4 01701 if ( numberOfVertices <= 0 ) { 01702 std::cerr << "ERROR: This face has " 01703 << numberOfVertices << " of vertices!" << std::endl; 01704 } 01705 #endif 01706 prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices ); 01707 //------------------------------------------------- 01708 // Get the list of vertex indices for each face 01709 fread( prBuffer, vertexIndexSize, numberOfVertices, inputFile ); 01710 int index2 = 0; 01711 for ( int i = 0; i < numberOfVertices; ++i ) { 01712 switch ( m_veFaceListType[index+1] ) { 01713 case INT_8: 01714 vertexNo = *((char *)( &(prBuffer[index2]) )); 01715 break; 01716 case UINT_8: 01717 vertexNo = *((unsigned char *)( &(prBuffer[index2]) )); 01718 break; 01719 case INT_16: 01720 vertexNo = *((short int *)( &(prBuffer[index2]) )); 01721 break; 01722 case UINT_16: 01723 vertexNo = *((unsigned short int *)( &(prBuffer[index2]) )); 01724 break; 01725 case INT_32: 01726 vertexNo = *((long int *)( &(prBuffer[index2]) )); 01727 break; 01728 case UINT_32: 01729 vertexNo = *((unsigned long int *)( &(prBuffer[index2]) )); 01730 break; 01731 case FLOAT_32: 01732 vertexNo = *((float *)( &(prBuffer[index2]) )); 01733 break; 01734 case FLOAT_64: 01735 vertexNo = *((double *)( &(prBuffer[index2]) )); 01736 break; 01737 } 01738 prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo ); 01739 index2 += vertexIndexSize; 01740 } 01741 //------------------------------------------------- 01742 // Get some attributes after face info 01743 fread( prBuffer, readingSizeAfter, 1, inputFile ); 01744 //------------------------------------------------- 01745 #ifdef TAPs_DEBUG_MODE_DETAIL_3 01746 std::cout << "Face# " << faceNo << " has " << numberOfVertices << " vertices --> "; 01747 for ( int i = 0; i < numberOfVertices; ++i ) { 01748 std::cout << "\t" << vertexNo; 01749 } 01750 std::cout << "\n"; 01751 #endif 01752 //------------------------------------------------- 01753 ++faceNo; 01754 //------------------------------------------------- 01755 } while ( faceNo < prModel->GetNoFaces() ); 01756 }
| bool ReadPly< T >::ProcessFORMAT | ( | char * | line | ) | [inline, static, private] |
Definition at line 289 of file TAPsReadPly.cpp.
00290 { 00291 //--------------------------------------------------------------- 00292 char *delimiters = "\t "; 00293 char *token = NULL; 00294 char *end; 00295 // Example on using string token 00296 // token = strtok( line, delimiters ); // start 00297 // token = strtok( '\0', delimiters ); // next 00298 // token = strtok( NULL, delimiters ); // next 00299 // while ( token != NULL ) { ... } // not reach the end yet 00300 // numberOfVertices = static_cast<int>( strtol( token, &end, 10 ) ); 00301 //--------------------------------------------------------------- 00302 token = strtok( line, delimiters ); // "format" 00303 token = strtok( '\0', delimiters ); // format type 00304 if ( !strncmp( token, "ascii", strlen("ascii") ) ) { 00305 m_eFormat = FORMAT_ASCII; 00306 #ifdef TAPs_DEBUG_MODE_DETAIL_1 00307 std::cout << "Format: ASCII\n"; 00308 #endif 00309 } 00310 else if ( !strncmp( token, "binary_big_endian", strlen("binary_big_endian") ) ) { 00311 m_eFormat = FORMAT_BINARY_BIG_ENDDIAN; 00312 #ifdef TAPs_DEBUG_MODE_DETAIL_1 00313 std::cout << "Format: Binary Big Enddian\n"; 00314 #endif 00315 } 00316 else if ( !strncmp( token, "binary_little_endian", strlen("binary_little_endian") ) ) { 00317 m_eFormat = FORMAT_BINARY_LITTLE_ENDDIAN; 00318 #ifdef TAPs_DEBUG_MODE_DETAIL_1 00319 std::cout << "Format: Binary Little Enddian\n"; 00320 #endif 00321 } 00322 else { 00323 #ifdef TAPs_DEBUG_MODE 00324 std::cout << "Ply \"" << token << "\" format is unrecognizable!" << std::endl; 00325 return false; 00326 #endif 00327 } 00328 //--------------------------------------------------------------- 00329 token = strtok( '\0', delimiters ); // format version 00330 if ( token != NULL ) { 00331 m_fFormatVersion = static_cast<int>( strtol( token, &end, 10 ) ); 00332 } 00333 //--------------------------------------------------------------- 00334 return true; 00335 }
| bool ReadPly< T >::ProcessHEADER | ( | FILE * | inputFile, | |
| OpenGL::MeshModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 211 of file TAPsReadPly.cpp.
00213 { 00214 //--------------------------------------------------------------- 00215 //m_iNumOfVertices = 0; 00216 //m_iNumOfFaces = 0; 00217 //--------------------------------------------------------------- 00218 char line[256]; 00219 char node[128]; 00220 // while ( !feof(fileIn) ) { 00221 do { 00222 fgets( line, 256, inputFile ); // read the first line 00223 } while ( strlen( line ) < 3 || line[0] == '#' ); 00224 sscanf( line, "%s", node ); 00225 //------------------------------------------- 00226 // Check for ply format 00227 if ( strncmp( node, "ply", strlen("ply") ) ) { 00228 return false; 00229 } 00230 //------------------------------------------- 00231 bool bKeepRunning = true; 00232 while ( bKeepRunning ) { 00233 do { 00234 fgets( line, 256, inputFile ); // read the next line 00235 } while ( strlen( line ) < 3 || line[0] == '#' ); 00236 sscanf( line, "%s", node ); 00237 if ( !strncmp( node, "property", strlen("property") ) ) { 00238 ProcessPROPERTY( line ); 00239 } 00240 else if ( !strncmp( node, "element", strlen("element") ) ) { 00241 ProcessELEMENT( line, prModel ); 00242 } 00243 else if ( !strncmp( node, "end_header", strlen("end_header") ) ) { 00244 bKeepRunning = false; 00245 } 00246 else if ( !strncmp( node, "format", strlen("format") ) ) { 00247 if ( !ProcessFORMAT( line ) ) { 00248 return false; 00249 } 00250 } 00251 } 00252 #ifdef TAPs_DEBUG_MODE 00253 std::cout << "Number of Vertices: " << prModel->GetNoVertices() << "\n"; 00254 std::cout << "Number of Faces: " << prModel->GetNoFaces() << "\n"; 00255 #endif 00256 #ifdef TAPs_DEBUG_MODE_DETAIL_1 00257 std::cout << "\nVertex Prop:\n"; 00258 for ( int i = 0; i < static_cast<int>( m_veVertexListType.size() ); ++i ) { 00259 std::cout << "\t" << static_cast<int>( m_veVertexListType[i] ); 00260 } 00261 std::cout << "\n"; 00262 for ( int i = 0; i < static_cast<int>( m_veVertexListAttrib.size() ); ++i ) { 00263 std::cout << "\t" << static_cast<int>( m_veVertexListAttrib[i] ); 00264 } 00265 std::cout << "\nFace Prop:\n"; 00266 for ( int i = 0; i < static_cast<int>( m_veFaceListType.size() ); ++i ) { 00267 std::cout << "\t" << static_cast<int>( m_veFaceListType[i] ); 00268 } 00269 std::cout << "\n"; 00270 for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) { 00271 std::cout << "\t" << static_cast<int>( m_veFaceListAttrib[i] ); 00272 } 00273 std::cout << "\nEdge Prop:\n"; 00274 for ( int i = 0; i < static_cast<int>( m_veEdgeListType.size() ); ++i ) { 00275 std::cout << "\t" << static_cast<int>( m_veEdgeListType[i] ); 00276 } 00277 std::cout << "\n"; 00278 for ( int i = 0; i < static_cast<int>( m_veEdgeListAttrib.size() ); ++i ) { 00279 std::cout << "\t" << static_cast<int>( m_veEdgeListAttrib[i] ); 00280 } 00281 #endif 00282 return true; 00283 }
| void ReadPly< T >::ProcessPROPERTY | ( | char * | line | ) | [inline, static, private] |
Definition at line 373 of file TAPsReadPly.cpp.
00374 { 00375 int bListForFace = 0; // for face 00376 unsigned char dataType_0 = UNDEFINED; // for face 00377 unsigned char dataType = UNDEFINED; 00378 unsigned char attribute = UNDEFINED; 00379 //--------------------------------------------------------------- 00380 char *delimiters = "\t\n "; 00381 char *token = NULL; 00382 //char *end; 00383 //--------------------------------------------------------------- 00384 token = strtok( line, delimiters ); // "property" 00385 //--------------------------------------------------------------- 00386 token = strtok( '\0', delimiters ); 00387 do { 00388 //std::cout << "\t" << token; 00389 //------------------------------------------------- 00390 // Data Type 00391 if ( !strcmp( token, "int8" ) ) { 00392 dataType = INT_8; 00393 } 00394 else if ( !strcmp( token, "uint8" ) 00395 || !strcmp( token, "uchar" ) ) { 00396 dataType = UINT_8; 00397 } 00398 else if ( !strcmp( token, "int16" ) ) { 00399 dataType = INT_16; 00400 } 00401 else if ( !strcmp( token, "uint16" ) ) { 00402 dataType = UINT_16; 00403 } 00404 else if ( !strcmp( token, "int32" ) 00405 || !strcmp( token, "int" ) ) { 00406 dataType = INT_32; 00407 } 00408 else if ( !strcmp( token, "uint32" ) ) { 00409 dataType = UINT_32; 00410 } 00411 else if ( !strcmp( token, "float32" ) 00412 || !strcmp( token, "float" ) ) { 00413 dataType = FLOAT_32; 00414 } 00415 else if ( !strcmp( token, "float64" ) 00416 || !strcmp( token, "double" ) ) { 00417 dataType = FLOAT_64; 00418 } 00419 //------------------------------------------------- 00420 // Attribute 00421 else if ( !strcmp( token, "x" ) ) { 00422 attribute = X; 00423 } 00424 else if ( !strcmp( token, "y" ) ) { 00425 attribute = Y; 00426 } 00427 else if ( !strcmp( token, "z" ) ) { 00428 attribute = Z; 00429 } 00430 else if ( !strcmp( token, "red" ) ) { 00431 attribute = RED; 00432 } 00433 else if ( !strcmp( token, "green" ) ) { 00434 attribute = GREEN; 00435 } 00436 else if ( !strcmp( token, "blue" ) ) { 00437 attribute = BLUE; 00438 } 00439 else if ( !strcmp( token, "confidence" ) ) { 00440 attribute = CONFIDENCE; 00441 } 00442 else if ( !strcmp( token, "intensity" ) ) { 00443 attribute = INTENSITY; 00444 } 00445 else if ( !strcmp( token, "vertex1" ) ) { 00446 attribute = VERTEX1; 00447 } 00448 else if ( !strcmp( token, "vertex2" ) ) { 00449 attribute = VERTEX2; 00450 } 00451 //------------------------------------------------- 00452 // List 00453 else if ( !strcmp( token, "list" ) ) { 00454 if ( m_eCurrentListType == ELEMENT_FACE ) { 00455 bListForFace = 2; 00456 } 00457 token = strtok( '\0', delimiters ); 00458 continue; 00459 } 00460 else if ( !strcmp( token, "vertex_indices" ) ) { 00461 attribute = LIST_VERTEX_INDICES; 00462 } 00463 //------------------------------------------------- 00464 // For Face List 00465 if ( bListForFace == 2 ) { 00466 dataType_0 = dataType; 00467 bListForFace = 1; 00468 } 00469 //------------------------------------------------- 00470 token = strtok( '\0', delimiters ); 00471 } while ( token != NULL ); 00472 //--------------------------------------------------------------- 00473 if ( m_eCurrentListType == ELEMENT_VERTEX ) { 00474 m_veVertexListType.push_back( dataType ); 00475 m_veVertexListAttrib.push_back( attribute ); 00476 } 00477 // Since an element can be declared after "element face #ofFaces", 00478 // this element belongs to face element. 00479 // For face element "property list dataType_0 dataType vertex_indices", 00480 // they are put back into m_veFaceListType and Attrib by 00481 // the ProcessPROPERTY fn 00482 else if ( m_eCurrentListType == ELEMENT_FACE ) { 00483 if ( bListForFace == 1 ) { 00484 m_veFaceListType.push_back( dataType_0 ); 00485 m_veFaceListType.push_back( dataType ); 00486 m_veFaceListAttrib.push_back( attribute ); 00487 m_veFaceListAttrib.push_back( 0 ); 00488 // push 0 for dummy value 00489 } 00490 else { 00491 m_veFaceListType.push_back( dataType ); 00492 m_veFaceListAttrib.push_back( attribute ); 00493 } 00494 bListForFace = 0; 00495 } 00496 else if ( m_eCurrentListType == ELEMENT_EDGE ) { 00497 m_veEdgeListType.push_back( dataType ); 00498 m_veEdgeListAttrib.push_back( attribute ); 00499 } 00500 }
| void ReadPly< T >::ProcessVERTEX_LIST_ASCII | ( | FILE * | inputFile, | |
| OpenGL::HalfEdgeModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 568 of file TAPsReadPly.cpp.
00570 { 00571 #ifdef TAPs_DEBUG_MODE 00572 std::cout << "Processing VERTEX LIST\n"; 00573 #endif 00574 //------------------------------------------------------------------- 00575 // Example: 00576 // *MESH_VERTEX_LIST { 00577 // *MESH_VERTEX 0 -10.000000 -5.000000 0.000000 00578 // *MESH_VERTEX 1 10.000000 -5.000000 0.000000 00579 // *MESH_VERTEX 2 -10.000000 5.000000 0.000000 00580 // ... 00581 // } 00582 //------------------------------------------------------------------- 00583 char node[128]; 00584 int n; 00585 float x, y, z; 00586 fgets( line, 128, inputFile ); 00587 sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z ); 00588 while ( node[0] != '}' ) { 00589 //------------------------------------------------------ 00590 // Put created vertex in vertexList for look up later 00591 HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] = new HEVertex<T>( x, y, z ); 00592 // Put created vertex in vertexList of the model 00593 prModel->GetVertexList()->Append( HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] ); 00594 ++vertexNo; // next vertex# 00595 //std::cout << "Vertex: " << vertexNo << "\n"; 00596 //------------------------------------------------------ 00597 fgets( line, 128, fileIn ); 00598 sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z ); 00599 } 00600 }
| void ReadPly< T >::ProcessVERTEX_LIST_ASCII | ( | FILE * | inputFile, | |
| OpenGL::XPolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 537 of file TAPsReadPly.cpp.
00539 { 00540 #ifdef TAPs_DEBUG_MODE 00541 std::cout << "Processing VERTEX LIST\n"; 00542 #endif 00543 //------------------------------------------------------------------- 00544 // Example: x y z values 00545 // 0 0 0 00546 // ... 00547 // 0 0 1 00548 //------------------------------------------------------------------- 00549 char vertexStr[128]; 00550 int vertexNumber = 0; 00551 float x, y, z; // since sscanf does not work for T (template) 00552 //------------------------------------------------------------------- 00553 prModel->NewVertexListByNoVertices(); 00554 do { 00555 do { 00556 fgets( vertexStr, 128, inputFile ); 00557 } while ( strlen( vertexStr ) < 3 || vertexStr[0] == '#' ); 00558 sscanf( vertexStr, "%g %g %g", &x, &y, &z ); 00559 prModel->GetVertexList()[vertexNumber][0] = x; 00560 prModel->GetVertexList()[vertexNumber][1] = y; 00561 prModel->GetVertexList()[vertexNumber][2] = z; 00562 ++vertexNumber; 00563 } while ( vertexNumber < prModel->GetNoVertices() ); 00564 }
| void ReadPly< T >::ProcessVERTEX_LIST_ASCII | ( | FILE * | inputFile, | |
| OpenGL::PolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 506 of file TAPsReadPly.cpp.
00508 { 00509 #ifdef TAPs_DEBUG_MODE 00510 std::cout << "Processing VERTEX LIST\n"; 00511 #endif 00512 //------------------------------------------------------------------- 00513 // Example: x y z values 00514 // 0 0 0 00515 // ... 00516 // 0 0 1 00517 //------------------------------------------------------------------- 00518 char vertexStr[128]; 00519 int vertexNumber = 0; 00520 float x, y, z; // since sscanf does not work for T (template) 00521 //------------------------------------------------------------------- 00522 prModel->NewVertexListByNoVertices(); 00523 do { 00524 do { 00525 fgets( vertexStr, 128, inputFile ); 00526 } while ( strlen( vertexStr ) < 3 || vertexStr[0] == '#' ); 00527 sscanf( vertexStr, "%g %g %g", &x, &y, &z ); 00528 prModel->GetVertexList()[vertexNumber][0] = x; 00529 prModel->GetVertexList()[vertexNumber][1] = y; 00530 prModel->GetVertexList()[vertexNumber][2] = z; 00531 ++vertexNumber; 00532 } while ( vertexNumber < prModel->GetNoVertices() ); 00533 }
| void ReadPly< T >::ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::HalfEdgeModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 944 of file TAPsReadPly.cpp.
00946 { 00947 #ifdef TAPs_DEBUG_MODE 00948 std::cout << "Processing VERTEX LIST\n"; 00949 #endif 00950 }
| void ReadPly< T >::ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::XPolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 845 of file TAPsReadPly.cpp.
00847 { 00848 #ifdef TAPs_DEBUG_MODE 00849 std::cout << "Processing VERTEX LIST\n"; 00850 #endif 00851 //------------------------------------------------------------------- 00852 // Example: x y z and other values 00853 // 0 0 0 ... 00854 // ... 00855 // 0 0 1 ... 00856 //--------------------------------------------------------------- 00857 int readingSize = 0; 00858 //--------------------------------------------------------------- 00859 for ( int i = 0; i < static_cast<int>(m_veVertexListType.size()); ++i ) { 00860 if ( m_veVertexListType[i] == INT_8 ) readingSize += 1; 00861 else if ( m_veVertexListType[i] == UINT_8 ) readingSize += 1; 00862 else if ( m_veVertexListType[i] == INT_16 ) readingSize += 2; 00863 else if ( m_veVertexListType[i] == UINT_16 ) readingSize += 2; 00864 else if ( m_veVertexListType[i] == INT_32 ) readingSize += 4; 00865 else if ( m_veVertexListType[i] == UINT_32 ) readingSize += 4; 00866 else if ( m_veVertexListType[i] == FLOAT_32 ) readingSize += 4; 00867 else if ( m_veVertexListType[i] == FLOAT_64 ) readingSize += 8; 00868 } 00869 //--------------------------------------------------------------- 00870 prModel->NewVertexListByNoVertices(); 00871 int vertexNumber = 0; 00872 int index, dim; 00873 unsigned char * prBuffer = new unsigned char[ readingSize ]; 00874 //--------------------------------------------------------------- 00875 do { 00876 fread( prBuffer, readingSize, 1, inputFile ); 00877 index = 0; 00878 //------------------------------------------------- 00879 for ( int i = 0; i < static_cast<int>(m_veVertexListAttrib.size()); ++i ) { 00880 //----------------------------------- 00881 if ( ( m_veVertexListAttrib[i] == X ) 00882 || ( m_veVertexListAttrib[i] == Y ) 00883 || ( m_veVertexListAttrib[i] == Z ) ) { 00884 //--------------------- 00885 if ( m_veVertexListAttrib[i] == X ) dim = 0; 00886 else if ( m_veVertexListAttrib[i] == Y ) dim = 1; 00887 else dim = 2; 00888 //else if ( m_veVertexListAttrib[i] == Z ) dim = 2; 00889 //--------------------- 00890 ConvertBigEnddianToLittleEnddian( m_veVertexListType[i], &(prBuffer[index]) ); 00891 if ( m_veVertexListType[i] == INT_8 ) { 00892 prModel->GetVertexList()[vertexNumber][dim] = *((char *)( &( prBuffer[index] ) )); 00893 } 00894 else if ( m_veVertexListType[i] == UINT_8 ) { 00895 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned char *)( &( prBuffer[index] ) )); 00896 } 00897 else if ( m_veVertexListType[i] == INT_16 ) { 00898 prModel->GetVertexList()[vertexNumber][dim] = *((short int *)( &( prBuffer[index] ) )); 00899 } 00900 else if ( m_veVertexListType[i] == UINT_16 ) { 00901 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned short int *)( &( prBuffer[index] ) )); 00902 } 00903 else if ( m_veVertexListType[i] == INT_32 ) { 00904 prModel->GetVertexList()[vertexNumber][dim] = *((long int *)( &( prBuffer[index] ) )); 00905 } 00906 else if ( m_veVertexListType[i] == UINT_32 ) { 00907 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned long int *)( &( prBuffer[index] ) )); 00908 } 00909 else if ( m_veVertexListType[i] == FLOAT_32 ) { 00910 prModel->GetVertexList()[vertexNumber][dim] = *((float *)( &( prBuffer[index] ) )); 00911 } 00912 else if ( m_veVertexListType[i] == FLOAT_64 ) { 00913 prModel->GetVertexList()[vertexNumber][dim] = *((double *)( &( prBuffer[index] ) )); 00914 } 00915 } 00916 //----------------------------------- 00917 if ( m_veVertexListType[i] == INT_8 ) index += 1; 00918 else if ( m_veVertexListType[i] == UINT_8 ) index += 1; 00919 else if ( m_veVertexListType[i] == INT_16 ) index += 2; 00920 else if ( m_veVertexListType[i] == UINT_16 ) index += 2; 00921 else if ( m_veVertexListType[i] == INT_32 ) index += 4; 00922 else if ( m_veVertexListType[i] == UINT_32 ) index += 4; 00923 else if ( m_veVertexListType[i] == FLOAT_32 ) index += 4; 00924 else if ( m_veVertexListType[i] == FLOAT_64 ) index += 8; 00925 //----------------------------------- 00926 } 00927 //------------------------------------------------- 00928 #ifdef TAPs_DEBUG_MODE_DETAIL_3 00929 std::cout << "Vertex# " << vertexNumber << " --> "; 00930 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][0]; 00931 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][1]; 00932 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][2]; 00933 std::cout << "\n"; 00934 #endif 00935 //------------------------------------------------- 00936 ++vertexNumber; 00937 } while ( vertexNumber < prModel->GetNoVertices() ); 00938 //--------------------------------------------------------------- 00939 delete [] prBuffer; 00940 }
| void ReadPly< T >::ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::PolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 746 of file TAPsReadPly.cpp.
00748 { 00749 #ifdef TAPs_DEBUG_MODE 00750 std::cout << "Processing VERTEX LIST\n"; 00751 #endif 00752 //------------------------------------------------------------------- 00753 // Example: x y z and other values 00754 // 0 0 0 ... 00755 // ... 00756 // 0 0 1 ... 00757 //--------------------------------------------------------------- 00758 int readingSize = 0; 00759 //--------------------------------------------------------------- 00760 for ( int i = 0; i < static_cast<int>(m_veVertexListType.size()); ++i ) { 00761 if ( m_veVertexListType[i] == INT_8 ) readingSize += 1; 00762 else if ( m_veVertexListType[i] == UINT_8 ) readingSize += 1; 00763 else if ( m_veVertexListType[i] == INT_16 ) readingSize += 2; 00764 else if ( m_veVertexListType[i] == UINT_16 ) readingSize += 2; 00765 else if ( m_veVertexListType[i] == INT_32 ) readingSize += 4; 00766 else if ( m_veVertexListType[i] == UINT_32 ) readingSize += 4; 00767 else if ( m_veVertexListType[i] == FLOAT_32 ) readingSize += 4; 00768 else if ( m_veVertexListType[i] == FLOAT_64 ) readingSize += 8; 00769 } 00770 //--------------------------------------------------------------- 00771 prModel->NewVertexListByNoVertices(); 00772 int vertexNumber = 0; 00773 int index, dim; 00774 unsigned char * prBuffer = new unsigned char[ readingSize ]; 00775 //--------------------------------------------------------------- 00776 do { 00777 fread( prBuffer, readingSize, 1, inputFile ); 00778 index = 0; 00779 //------------------------------------------------- 00780 for ( int i = 0; i < static_cast<int>(m_veVertexListAttrib.size()); ++i ) { 00781 //----------------------------------- 00782 if ( ( m_veVertexListAttrib[i] == X ) 00783 || ( m_veVertexListAttrib[i] == Y ) 00784 || ( m_veVertexListAttrib[i] == Z ) ) { 00785 //--------------------- 00786 if ( m_veVertexListAttrib[i] == X ) dim = 0; 00787 else if ( m_veVertexListAttrib[i] == Y ) dim = 1; 00788 else dim = 2; 00789 //else if ( m_veVertexListAttrib[i] == Z ) dim = 2; 00790 //--------------------- 00791 ConvertBigEnddianToLittleEnddian( m_veVertexListType[i], &(prBuffer[index]) ); 00792 if ( m_veVertexListType[i] == INT_8 ) { 00793 prModel->GetVertexList()[vertexNumber][dim] = *((char *)( &( prBuffer[index] ) )); 00794 } 00795 else if ( m_veVertexListType[i] == UINT_8 ) { 00796 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned char *)( &( prBuffer[index] ) )); 00797 } 00798 else if ( m_veVertexListType[i] == INT_16 ) { 00799 prModel->GetVertexList()[vertexNumber][dim] = *((short int *)( &( prBuffer[index] ) )); 00800 } 00801 else if ( m_veVertexListType[i] == UINT_16 ) { 00802 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned short int *)( &( prBuffer[index] ) )); 00803 } 00804 else if ( m_veVertexListType[i] == INT_32 ) { 00805 prModel->GetVertexList()[vertexNumber][dim] = *((long int *)( &( prBuffer[index] ) )); 00806 } 00807 else if ( m_veVertexListType[i] == UINT_32 ) { 00808 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned long int *)( &( prBuffer[index] ) )); 00809 } 00810 else if ( m_veVertexListType[i] == FLOAT_32 ) { 00811 prModel->GetVertexList()[vertexNumber][dim] = *((float *)( &( prBuffer[index] ) )); 00812 } 00813 else if ( m_veVertexListType[i] == FLOAT_64 ) { 00814 prModel->GetVertexList()[vertexNumber][dim] = *((double *)( &( prBuffer[index] ) )); 00815 } 00816 } 00817 //----------------------------------- 00818 if ( m_veVertexListType[i] == INT_8 ) index += 1; 00819 else if ( m_veVertexListType[i] == UINT_8 ) index += 1; 00820 else if ( m_veVertexListType[i] == INT_16 ) index += 2; 00821 else if ( m_veVertexListType[i] == UINT_16 ) index += 2; 00822 else if ( m_veVertexListType[i] == INT_32 ) index += 4; 00823 else if ( m_veVertexListType[i] == UINT_32 ) index += 4; 00824 else if ( m_veVertexListType[i] == FLOAT_32 ) index += 4; 00825 else if ( m_veVertexListType[i] == FLOAT_64 ) index += 8; 00826 //----------------------------------- 00827 } 00828 //------------------------------------------------- 00829 #ifdef TAPs_DEBUG_MODE_DETAIL_3 00830 std::cout << "Vertex# " << vertexNumber << " --> "; 00831 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][0]; 00832 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][1]; 00833 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][2]; 00834 std::cout << "\n"; 00835 #endif 00836 //------------------------------------------------- 00837 ++vertexNumber; 00838 } while ( vertexNumber < prModel->GetNoVertices() ); 00839 //--------------------------------------------------------------- 00840 delete [] prBuffer; 00841 }
| void ReadPly< T >::ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::HalfEdgeModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 1556 of file TAPsReadPly.cpp.
01558 { 01559 #ifdef TAPs_DEBUG_MODE 01560 std::cout << "Processing VERTEX LIST\n"; 01561 #endif 01562 }
| void ReadPly< T >::ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::XPolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 1458 of file TAPsReadPly.cpp.
01460 { 01461 #ifdef TAPs_DEBUG_MODE 01462 std::cout << "Processing VERTEX LIST\n"; 01463 #endif 01464 //------------------------------------------------------------------- 01465 // Example: x y z and other values 01466 // 0 0 0 ... 01467 // ... 01468 // 0 0 1 ... 01469 //--------------------------------------------------------------- 01470 int readingSize = 0; 01471 //--------------------------------------------------------------- 01472 for ( int i = 0; i < static_cast<int>(m_veVertexListType.size()); ++i ) { 01473 if ( m_veVertexListType[i] == INT_8 ) readingSize += 1; 01474 else if ( m_veVertexListType[i] == UINT_8 ) readingSize += 1; 01475 else if ( m_veVertexListType[i] == INT_16 ) readingSize += 2; 01476 else if ( m_veVertexListType[i] == UINT_16 ) readingSize += 2; 01477 else if ( m_veVertexListType[i] == INT_32 ) readingSize += 4; 01478 else if ( m_veVertexListType[i] == UINT_32 ) readingSize += 4; 01479 else if ( m_veVertexListType[i] == FLOAT_32 ) readingSize += 4; 01480 else if ( m_veVertexListType[i] == FLOAT_64 ) readingSize += 8; 01481 } 01482 //--------------------------------------------------------------- 01483 prModel->NewVertexListByNoVertices(); 01484 int vertexNumber = 0; 01485 int index, dim; 01486 unsigned char * prBuffer = new unsigned char[ readingSize ]; 01487 //--------------------------------------------------------------- 01488 do { 01489 fread( prBuffer, readingSize, 1, inputFile ); 01490 index = 0; 01491 //------------------------------------------------- 01492 for ( int i = 0; i < static_cast<int>(m_veVertexListAttrib.size()); ++i ) { 01493 //----------------------------------- 01494 if ( ( m_veVertexListAttrib[i] == X ) 01495 || ( m_veVertexListAttrib[i] == Y ) 01496 || ( m_veVertexListAttrib[i] == Z ) ) { 01497 //--------------------- 01498 if ( m_veVertexListAttrib[i] == X ) dim = 0; 01499 else if ( m_veVertexListAttrib[i] == Y ) dim = 1; 01500 else dim = 2; 01501 //else if ( m_veVertexListAttrib[i] == Z ) dim = 2; 01502 //--------------------- 01503 if ( m_veVertexListType[i] == INT_8 ) { 01504 prModel->GetVertexList()[vertexNumber][dim] = *((char *)( &( prBuffer[index] ) )); 01505 } 01506 else if ( m_veVertexListType[i] == UINT_8 ) { 01507 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned char *)( &( prBuffer[index] ) )); 01508 } 01509 else if ( m_veVertexListType[i] == INT_16 ) { 01510 prModel->GetVertexList()[vertexNumber][dim] = *((short int *)( &( prBuffer[index] ) )); 01511 } 01512 else if ( m_veVertexListType[i] == UINT_16 ) { 01513 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned short int *)( &( prBuffer[index] ) )); 01514 } 01515 else if ( m_veVertexListType[i] == INT_32 ) { 01516 prModel->GetVertexList()[vertexNumber][dim] = *((long int *)( &( prBuffer[index] ) )); 01517 } 01518 else if ( m_veVertexListType[i] == UINT_32 ) { 01519 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned long int *)( &( prBuffer[index] ) )); 01520 } 01521 else if ( m_veVertexListType[i] == FLOAT_32 ) { 01522 prModel->GetVertexList()[vertexNumber][dim] = *((float *)( &( prBuffer[index] ) )); 01523 } 01524 else if ( m_veVertexListType[i] == FLOAT_64 ) { 01525 prModel->GetVertexList()[vertexNumber][dim] = *((double *)( &( prBuffer[index] ) )); 01526 } 01527 } 01528 //----------------------------------- 01529 if ( m_veVertexListType[i] == INT_8 ) index += 1; 01530 else if ( m_veVertexListType[i] == UINT_8 ) index += 1; 01531 else if ( m_veVertexListType[i] == INT_16 ) index += 2; 01532 else if ( m_veVertexListType[i] == UINT_16 ) index += 2; 01533 else if ( m_veVertexListType[i] == INT_32 ) index += 4; 01534 else if ( m_veVertexListType[i] == UINT_32 ) index += 4; 01535 else if ( m_veVertexListType[i] == FLOAT_32 ) index += 4; 01536 else if ( m_veVertexListType[i] == FLOAT_64 ) index += 8; 01537 //----------------------------------- 01538 } 01539 //------------------------------------------------- 01540 #ifdef TAPs_DEBUG_MODE_DETAIL_3 01541 std::cout << "Vertex# " << vertexNumber << " --> "; 01542 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][0]; 01543 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][1]; 01544 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][2]; 01545 std::cout << "\n"; 01546 #endif 01547 //------------------------------------------------- 01548 ++vertexNumber; 01549 } while ( vertexNumber < prModel->GetNoVertices() ); 01550 //--------------------------------------------------------------- 01551 delete [] prBuffer; 01552 }
| void ReadPly< T >::ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN | ( | FILE * | inputFile, | |
| OpenGL::PolygonalModel< T > *const | prModel | |||
| ) | [inline, static, private] |
Definition at line 1360 of file TAPsReadPly.cpp.
01362 { 01363 #ifdef TAPs_DEBUG_MODE 01364 std::cout << "Processing VERTEX LIST\n"; 01365 #endif 01366 //------------------------------------------------------------------- 01367 // Example: x y z and other values 01368 // 0 0 0 ... 01369 // ... 01370 // 0 0 1 ... 01371 //--------------------------------------------------------------- 01372 int readingSize = 0; 01373 //--------------------------------------------------------------- 01374 for ( int i = 0; i < static_cast<int>(m_veVertexListType.size()); ++i ) { 01375 if ( m_veVertexListType[i] == INT_8 ) readingSize += 1; 01376 else if ( m_veVertexListType[i] == UINT_8 ) readingSize += 1; 01377 else if ( m_veVertexListType[i] == INT_16 ) readingSize += 2; 01378 else if ( m_veVertexListType[i] == UINT_16 ) readingSize += 2; 01379 else if ( m_veVertexListType[i] == INT_32 ) readingSize += 4; 01380 else if ( m_veVertexListType[i] == UINT_32 ) readingSize += 4; 01381 else if ( m_veVertexListType[i] == FLOAT_32 ) readingSize += 4; 01382 else if ( m_veVertexListType[i] == FLOAT_64 ) readingSize += 8; 01383 } 01384 //--------------------------------------------------------------- 01385 prModel->NewVertexListByNoVertices(); 01386 int vertexNumber = 0; 01387 int index, dim; 01388 unsigned char * prBuffer = new unsigned char[ readingSize ]; 01389 //--------------------------------------------------------------- 01390 do { 01391 fread( prBuffer, readingSize, 1, inputFile ); 01392 index = 0; 01393 //------------------------------------------------- 01394 for ( int i = 0; i < static_cast<int>(m_veVertexListAttrib.size()); ++i ) { 01395 //----------------------------------- 01396 if ( ( m_veVertexListAttrib[i] == X ) 01397 || ( m_veVertexListAttrib[i] == Y ) 01398 || ( m_veVertexListAttrib[i] == Z ) ) { 01399 //--------------------- 01400 if ( m_veVertexListAttrib[i] == X ) dim = 0; 01401 else if ( m_veVertexListAttrib[i] == Y ) dim = 1; 01402 else dim = 2; 01403 //else if ( m_veVertexListAttrib[i] == Z ) dim = 2; 01404 //--------------------- 01405 if ( m_veVertexListType[i] == INT_8 ) { 01406 prModel->GetVertexList()[vertexNumber][dim] = *((char *)( &( prBuffer[index] ) )); 01407 } 01408 else if ( m_veVertexListType[i] == UINT_8 ) { 01409 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned char *)( &( prBuffer[index] ) )); 01410 } 01411 else if ( m_veVertexListType[i] == INT_16 ) { 01412 prModel->GetVertexList()[vertexNumber][dim] = *((short int *)( &( prBuffer[index] ) )); 01413 } 01414 else if ( m_veVertexListType[i] == UINT_16 ) { 01415 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned short int *)( &( prBuffer[index] ) )); 01416 } 01417 else if ( m_veVertexListType[i] == INT_32 ) { 01418 prModel->GetVertexList()[vertexNumber][dim] = *((long int *)( &( prBuffer[index] ) )); 01419 } 01420 else if ( m_veVertexListType[i] == UINT_32 ) { 01421 prModel->GetVertexList()[vertexNumber][dim] = *((unsigned long int *)( &( prBuffer[index] ) )); 01422 } 01423 else if ( m_veVertexListType[i] == FLOAT_32 ) { 01424 prModel->GetVertexList()[vertexNumber][dim] = *((float *)( &( prBuffer[index] ) )); 01425 } 01426 else if ( m_veVertexListType[i] == FLOAT_64 ) { 01427 prModel->GetVertexList()[vertexNumber][dim] = *((double *)( &( prBuffer[index] ) )); 01428 } 01429 } 01430 //----------------------------------- 01431 if ( m_veVertexListType[i] == INT_8 ) index += 1; 01432 else if ( m_veVertexListType[i] == UINT_8 ) index += 1; 01433 else if ( m_veVertexListType[i] == INT_16 ) index += 2; 01434 else if ( m_veVertexListType[i] == UINT_16 ) index += 2; 01435 else if ( m_veVertexListType[i] == INT_32 ) index += 4; 01436 else if ( m_veVertexListType[i] == UINT_32 ) index += 4; 01437 else if ( m_veVertexListType[i] == FLOAT_32 ) index += 4; 01438 else if ( m_veVertexListType[i] == FLOAT_64 ) index += 8; 01439 //----------------------------------- 01440 } 01441 //------------------------------------------------- 01442 #ifdef TAPs_DEBUG_MODE_DETAIL_3 01443 std::cout << "Vertex# " << vertexNumber << " --> "; 01444 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][0]; 01445 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][1]; 01446 std::cout << "\t" << prModel->GetVertexList()[vertexNumber][2]; 01447 std::cout << "\n"; 01448 #endif 01449 //------------------------------------------------- 01450 ++vertexNumber; 01451 } while ( vertexNumber < prModel->GetNoVertices() ); 01452 //--------------------------------------------------------------- 01453 delete [] prBuffer; 01454 }
| bool ReadPly< T >::readFile | ( | const char * | fileName, | |
| OpenGL::HalfEdgeModel< T > *const | prModel | |||
| ) | [inline, static] |
Definition at line 136 of file TAPsReadPly.cpp.
00138 { 00139 Clear(); 00140 //---------------------------------------------------------------- 00141 // Initialization 00142 halfEdgeCounter = 0; 00143 vertexNo = 0; 00144 //---------------------------------------------------------------- 00145 // Open the input file 00146 FILE * fileIn = fopen( fileName, "rb" ); 00147 if ( !fileIn ) { 00148 std::perror( fileName ); 00149 return false; 00150 } 00151 //---------------------------------------------------------------- 00152 #ifdef TAPs_DEBUG_MODE 00153 std::cout << "START READING " << fileName << "\n"; 00154 #endif 00155 //---------------------------------------------------------------- 00156 if ( ProcessHEADER( fileIn, prModel ) == false ) return false; 00157 if ( FORMAT_ASCII == m_eFormat ) { 00158 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_ASCII( fileIn, prModel ); 00159 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_ASCII( fileIn, prModel ); 00160 } 00161 else if ( FORMAT_BINARY_BIG_ENDDIAN == m_eFormat ) { 00162 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel ); 00163 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel ); 00164 } 00165 else if ( FORMAT_BINARY_LITTLE_ENDDIAN == m_eFormat ) { 00166 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel ); 00167 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel ); 00168 } 00169 //---------------------------------------------------------------- 00170 fclose(fileIn); 00171 //---------------------------------------------------------------- 00172 HelpCreateHalfEdgeModel<T>::CreateHalfEdgeModel( prModel ); 00173 //---------------------------------------------------------------- 00174 #ifdef TAPs_DEBUG_MODE 00175 std::cout << "END READING " << fileName << "\n"; 00176 std::cout << "Number of Half-Edges: " << halfEdgeCounter << "\n"; 00177 #endif 00178 prModel->GetMaterial()->ApplyMaterial(); 00179 return true; 00180 }
| bool ReadPly< T >::readFile | ( | const char * | fileName, | |
| OpenGL::XPolygonalModel< T > *const | prModel | |||
| ) | [inline, static] |
Definition at line 96 of file TAPsReadPly.cpp.
00098 { 00099 Clear(); 00100 //---------------------------------------------------------------- 00101 // Open the input file 00102 FILE * fileIn = fopen( fileName, "rb" ); 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 ( FORMAT_ASCII == m_eFormat ) { 00114 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_ASCII( fileIn, prModel ); 00115 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_ASCII( fileIn, prModel ); 00116 } 00117 else if ( FORMAT_BINARY_BIG_ENDDIAN == m_eFormat ) { 00118 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel ); 00119 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel ); 00120 } 00121 else if ( FORMAT_BINARY_LITTLE_ENDDIAN == m_eFormat ) { 00122 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel ); 00123 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel ); 00124 } 00125 //---------------------------------------------------------------- 00126 fclose(fileIn); 00127 #ifdef TAPs_DEBUG_MODE 00128 std::cout << "END READING " << fileName << "\n"; 00129 #endif 00130 prModel->GetMaterial()->ApplyMaterial(); 00131 return true; 00132 }
| bool ReadPly< T >::readFile | ( | const char * | fileName, | |
| OpenGL::PolygonalModel< T > *const | prModel | |||
| ) | [inline, static] |
Definition at line 56 of file TAPsReadPly.cpp.
00058 { 00059 Clear(); 00060 //---------------------------------------------------------------- 00061 // Open the input file 00062 FILE * fileIn = fopen( fileName, "rb" ); 00063 if ( !fileIn ) { 00064 std::perror( fileName ); 00065 return false; 00066 } 00067 //---------------------------------------------------------------- 00068 #ifdef TAPs_DEBUG_MODE 00069 std::cout << "START READING " << fileName << "\n"; 00070 #endif 00071 //---------------------------------------------------------------- 00072 if ( ProcessHEADER( fileIn, prModel ) == false ) return false; 00073 if ( FORMAT_ASCII == m_eFormat ) { 00074 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_ASCII( fileIn, prModel ); 00075 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_ASCII( fileIn, prModel ); 00076 } 00077 else if ( FORMAT_BINARY_BIG_ENDDIAN == m_eFormat ) { 00078 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel ); 00079 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel ); 00080 } 00081 else if ( FORMAT_BINARY_LITTLE_ENDDIAN == m_eFormat ) { 00082 if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel ); 00083 if ( prModel->GetNoFaces() > 0 ) ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel ); 00084 } 00085 //---------------------------------------------------------------- 00086 fclose(fileIn); 00087 #ifdef TAPs_DEBUG_MODE 00088 std::cout << "END READING " << fileName << "\n"; 00089 #endif 00090 prModel->GetMaterial()->ApplyMaterial(); 00091 return true; 00092 }
friend class ReadModels< T > [friend] |
Definition at line 22 of file TAPsReadPly.hpp.
int ReadPly< T >::halfEdgeCounter = 0 [inline, static, private] |
Definition at line 173 of file TAPsReadPly.hpp.
unsigned char ReadPly< T >::m_eCurrentListType = UNDEFINED [inline, static, private] |
Definition at line 158 of file TAPsReadPly.hpp.
BEGIN_NAMESPACE_TAPs unsigned char ReadPly< T >::m_eFormat = UNDEFINED [inline, static, private] |
Definition at line 156 of file TAPsReadPly.hpp.
float ReadPly< T >::m_fFormatVersion = 0.0f [inline, static, private] |
Definition at line 157 of file TAPsReadPly.hpp.
std::vector< unsigned char > ReadPly< T >::m_veEdgeListAttrib [inline, static, private] |
Definition at line 170 of file TAPsReadPly.hpp.
std::vector< unsigned char > ReadPly< T >::m_veEdgeListType [inline, static, private] |
Definition at line 169 of file TAPsReadPly.hpp.
std::vector< unsigned char > ReadPly< T >::m_veFaceListAttrib [inline, static, private] |
Definition at line 166 of file TAPsReadPly.hpp.
std::vector< unsigned char > ReadPly< T >::m_veFaceListType [inline, static, private] |
Definition at line 165 of file TAPsReadPly.hpp.
std::vector< unsigned char > ReadPly< T >::m_veVertexListAttrib [inline, static, private] |
Definition at line 162 of file TAPsReadPly.hpp.
std::vector< unsigned char > ReadPly< T >::m_veVertexListType [inline, static, private] |
Definition at line 161 of file TAPsReadPly.hpp.
Definition at line 172 of file TAPsReadPly.hpp.
1.5.6