manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add File I/O

This commit is contained in:
Paolo Cignoni 2006-11-16 11:24:44 +00:00
parent 48669a758a
commit b9eebf7d98
5 changed files with 1268 additions and 1093 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
wrap/io_trimesh/export_dxf.h
View File

@ -20,15 +20,9 @@
* for more details. * * for more details. *
* * * *
****************************************************************************/ ****************************************************************************/
#ifndef __VCGLIB_EXPORT_DXF #ifndef __VCGLIB_EXPORT_DXF
#define __VCGLIB_EXPORT_DXF #define __VCGLIB_EXPORT_DXF
namespace vcg { namespace vcg {
namespace tri { namespace tri {
namespace io { namespace io {
@ -43,8 +37,9 @@ public:
*/ */
static int Save(SaveMeshType &m, const char * filename) static int Save(SaveMeshType &m, const char * filename)
{ {
FILE * o = fopen(filename,"w"); FILE * o = fopen(filename,"w");
if(o==NULL) return false; if(o==NULL) return 1;
fprintf(o,"0\n"); fprintf(o,"0\n");
fprintf(o,"SECTION\n"); fprintf(o,"SECTION\n");
fprintf(o,"2\n"); fprintf(o,"2\n");
@ -83,7 +78,6 @@ public:
fprintf(o,"EOF\n"); fprintf(o,"EOF\n");
fclose(o); fclose(o);
return 0; return 0;
} }
static const char *ErrorMsg(int error) static const char *ErrorMsg(int error)
@ -107,6 +101,4 @@ public:
} // end Namespace io } // end Namespace io
} // end Namespace vcg } // end Namespace vcg
#endif #endif

154
wrap/io_trimesh/export_smf.h
View File

@ -1,57 +1,97 @@
/**************************************************************************** /****************************************************************************
* VCGLib o o * * VCGLib o o *
* Visual and Computer Graphics Library o o * * Visual and Computer Graphics Library o o *
* _ O _ * * _ O _ *
* Copyright(C) 2004 \/)\/ * * Copyright(C) 2004 \/)\/ *
* Visual Computing Lab /\/| * * Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | * * ISTI - Italian National Research Council | *
* \ * * \ *
* All rights reserved. * * All rights reserved. *
* * * *
* This program is free software; you can redistribute it and/or modify * * This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * * the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. * * (at your option) any later version. *
* * * *
* This program is distributed in the hope that it will be useful, * * This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of * * but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. * * for more details. *
* * * *
****************************************************************************/ ****************************************************************************/
/****************************************************************************
History
/** Function to save to Smf format file. $Log: not supported by cvs2svn $
@param filename Name of the new Smf file ****************************************************************************/
*/
void Save_Smf(const char * filename) #ifndef __VCGLIB_EXPORT_SMF
{ #define __VCGLIB_EXPORT_SMF
FILE *fp;
fp = fopen(filename,"wb"); #include <stdio.h>
fprintf(fp,"#SMF \n" );
namespace vcg {
face_iterator fi; namespace tri {
vertex_iterator vi; namespace io {
map<vertex_pointer,int> index;
int ind; template <class SaveMeshType>
class ExporterSMF
for(ind=1,vi=vert.begin(); vi!=vert.end(); ++vi,++ind) {
{ public:
fprintf(fp,"v " ); typedef typename SaveMeshType::VertexPointer VertexPointer;
fprintf(fp,"%f%s",(*vi).P()[0]," " ); typedef typename SaveMeshType::ScalarType ScalarType;
fprintf(fp,"%f%s",(*vi).P()[1]," " ); typedef typename SaveMeshType::VertexType VertexType;
fprintf(fp,"%f%s",(*vi).P()[2],"\n"); typedef typename SaveMeshType::FaceType FaceType;
index[&*vi] = ind; typedef typename SaveMeshType::VertexIterator VertexIterator;
} typedef typename SaveMeshType::FaceIterator FaceIterator;
for (fi=face.begin(); fi!=face.end(); ++fi) static int Save(SaveMeshType &m, const char * filename, const int &mask, CallBackPos *cb=0)
{ {
fprintf(fp,"%s","f "); VertexIterator vi;
for (int j = 0; j < 3; j++) FaceIterator fi;
fprintf(fp,"%i%s",index[(*fi).V(j)]," "); FILE *fp;
fprintf(fp,"%s","\n"); fp = fopen(filename,"wb");
} fprintf(fp,"#SMF \n" );
fclose(fp); std::map<VertexPointer,int> index;
} int ind;
for(ind=1,vi=m.vert.begin(); vi!=m.vert.end(); ++vi,++ind)
{
fprintf(fp,"v " );
fprintf(fp,"%f%s",(*vi).P()[0]," " );
fprintf(fp,"%f%s",(*vi).P()[1]," " );
fprintf(fp,"%f%s",(*vi).P()[2],"\n");
index[&*vi] = ind;
}
for (fi=m.face.begin(); fi!=m.face.end(); ++fi)
{
fprintf(fp,"%s","f ");
for (int j = 0; j < 3; j++)
fprintf(fp,"%i%s",index[(*fi).V(j)]," ");
fprintf(fp,"%s","\n");
}
fclose(fp);
return 0;
}
static const char *ErrorMsg(int error)
{
static std::vector<std::string> smf_error_msg;
if(smf_error_msg.empty())
{
smf_error_msg.resize(2 );
smf_error_msg[0]="No errors";
smf_error_msg[1]="Can't open file";
}
if(error>1 || error<0) return "Unknown error";
else return smf_error_msg[error].c_str();
}
}; // end class
} // end Namespace tri
} // end Namespace io
} // end Namespace vcg
#endif

605
wrap/io_trimesh/export_vrml.h
View File

@ -1,305 +1,300 @@
/**************************************************************************** #ifndef __VCGLIB_EXPORT_WRL
* VCGLib o o * #define __VCGLIB_EXPORT_WRL
* Visual and Computer Graphics Library o o *
* _ O _ * #include <stdio.h>
* Copyright(C) 2004 \/)\/ * #include <wrap/io_trimesh/io_mask.h>
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | * #include "io_material.h"
* \ *
* All rights reserved. * namespace vcg {
* * namespace tri {
* This program is free software; you can redistribute it and/or modify * namespace io {
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * template <class SaveMeshType>
* (at your option) any later version. * class ExporterWRL
* * {
* This program is distributed in the hope that it will be useful, * public:
* but WITHOUT ANY WARRANTY; without even the implied warranty of * typedef typename SaveMeshType::VertexPointer VertexPointer;
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * typedef typename SaveMeshType::ScalarType ScalarType;
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * typedef typename SaveMeshType::VertexType VertexType;
* for more details. * typedef typename SaveMeshType::FaceType FaceType;
* * typedef typename SaveMeshType::VertexIterator VertexIterator;
****************************************************************************/ typedef typename SaveMeshType::FaceIterator FaceIterator;
static int Save(SaveMeshType &m, const char * filename, const int &mask, CallBackPos *cb=0)
{
/** Function to save in Inventor format file. FILE *fp;
@param filename Name of the new inventor file fp = fopen(filename,"wb");
*/ if(fp==NULL)
bool Save_VRML2(const char * filename, int savemask = SM_ALL ) return 1;
{
FILE *fp; // Header
fprintf(fp,
fp = fopen(filename,"wb"); "#VRML V2.0 utf8\n"
if(fp==0) "\n"
return false; "# Generated by VCGLIB, (C)Copyright 1999-2001 VCG, IEI-CNR\n"
"\n"
// Header "NavigationInfo {\n"
fprintf(fp, " type [ \"EXAMINE\", \"ANY\" ]\n"
"#VRML V2.0 utf8\n" "}\n"
"\n" );
"# Generated by VCGLIB, (C)Copyright 1999-2001 VCG, IEI-CNR\n"
"\n" // Tranche principale
"NavigationInfo {\n" double ss = 8.0/m.bbox.Diag();
" type [ \"EXAMINE\", \"ANY\" ]\n" m.bbox.Diag();
"}\n"
); fprintf(fp,
"Transform {\n"
// Trans principale " scale %g %g %g\n"
double ss = 8.0/bbox.Diag(); " translation %g %g %g\n"
" children\n"
fprintf(fp, " [\n"
"Transform {\n" ,ss
" scale %g %g %g\n" ,ss
" translation %g %g %g\n" ,ss
" children\n" , -m.bbox.Center()[0]*ss
" [\n" , -m.bbox.Center()[1]*ss
,ss ,-3-m.bbox.Center()[2]*ss
,ss );
,ss
, -bbox.Center()[0]*ss // Start Shape
, -bbox.Center()[1]*ss fprintf(fp,
,-3-bbox.Center()[2]*ss " Shape\n"
); " {\n"
" geometry IndexedFaceSet\n"
// Start Shape " {\n"
fprintf(fp, " creaseAngle .5\n"
" Shape\n" " solid FALSE\n"
" {\n" " coord Coordinate\n"
" geometry IndexedFaceSet\n" " {\n"
" {\n" " point\n"
" creaseAngle .5\n" " ["
" solid FALSE\n" );
" coord Coordinate\n" FaceIterator fi;
" {\n" VertexIterator vi;
" point\n" std::map<VertexPointer,int> index;
" [" int ind;
);
// Vertici
for(ind=0,vi=m.vert.begin(); vi!=m.vert.end(); ++vi, ++ind)
face_iterator fi; {
vertex_iterator vi; if(ind%4==0)
map<vertex_pointer,int> index; fprintf(fp,
int ind; "\n "
// Vertici );
for(ind=0,vi=vert.begin(); vi!=vert.end(); ++vi,++ind) fprintf(fp,
{ "%g %g %g, "
if(ind%4==0) ,(*vi).P()[0]
fprintf(fp,"\n "); ,(*vi).P()[1]
,(*vi).P()[2]
fprintf(fp,"%g %g %g, " );
,(*vi).P()[0] index[&*vi] = ind;
,(*vi).P()[1]
,(*vi).P()[2] }
); fprintf(fp,"\n"
index[&*vi] = ind; " ]\n"
} " }\n"
);
fprintf(fp,
"\n"
" ]\n" if( m.HasPerVertexColor() && (mask & vcg::tri::io::Mask::IOM_VERTCOLOR))
" }\n" {
); fprintf(fp,
" color Color\n"
if( ( savemask & SM_VERTCOLOR ) && (vertex_type::OBJ_TYPE & vertex_type::OBJ_TYPE_C) ) " {\n"
{ " color\n"
fprintf(fp, " ["
" color Color\n" );
" {\n" for(ind=0,vi=m.vert.begin();vi!=m.vert.end();++vi,++ind)
" color\n" {
" [" float r = float(vi->C()[0])/255;
); float g = float(vi->C()[1])/255;
float b = float(vi->C()[2])/255;
for(ind=0,vi=vert.begin();vi!=vert.end();++vi,++ind)
{ if(ind%4==0)
fprintf(fp,"\n ");
float r = float(vi->C()[0])/255; fprintf(fp,"%g %g %g,",r,g,b);
float g = float(vi->C()[1])/255; }
float b = float(vi->C()[2])/255; fprintf(fp,
"\n"
if(ind%4==0) " ]\n"
fprintf(fp,"\n "); " }\n"
" colorIndex\n"
fprintf(fp, " ["
"%g %g %g," );
,r,g,b
); for(ind=0,fi=m.face.begin(); fi!=m.face.end(); ++fi,++ind)
} {
if(ind%4==0)
fprintf(fp, fprintf(fp,"\n ");
"\n" for (int j = 0; j < 3; j++)
" ]\n" fprintf(fp,"%i,",index[(*fi).V(j)]);
" }\n" fprintf(fp,"-1,");
" colorIndex\n" }
" [" fprintf(fp,
); "\n"
" ]\n"
for(ind=0,fi=face.begin(); fi!=face.end(); ++fi,++ind) );
{ }
if(ind%4==0) else if( m.HasPerWedgeColor() && (mask & vcg::tri::io::Mask::IOM_WEDGCOLOR ))
fprintf(fp,"\n "); {
for (int j = 0; j < 3; j++) fprintf(fp,
fprintf(fp,"%i,",index[(*fi).V(j)]); " color Color\n"
fprintf(fp,"-1,"); " {\n"
} " color\n"
" [" );
fprintf(fp, for(ind=0,fi=m.face.begin();fi!=m.face.end();++fi,++ind)
"\n" {
" ]\n" for(int z=0;z<3;++z)
); {
} float r = float(fi->WC(z)[0])/255;
else if( ( savemask & SM_WEDGCOLOR ) && (face_type::OBJ_TYPE & face_type::OBJ_TYPE_WC) ) float g = float(fi->WC(z)[1])/255;
{ float b = float(fi->WC(z)[2])/255;
fprintf(fp, if(ind%4==0)
" color Color\n" fprintf(fp,"\n ");
" {\n" fprintf(fp,"%g %g %g,",r,g,b);
" color\n" }
" [" }
); fprintf(fp,
"\n"
for(ind=0,fi=face.begin();fi!=face.end();++fi,++ind) " ]\n"
{ " }\n"
for(int z=0;z<3;++z) " colorIndex\n"
{ " [" );
float r = float(fi->WC(z)[0])/255; int nn = 0;
float g = float(fi->WC(z)[1])/255; for(ind=0,fi=m.face.begin(); fi!=m.face.end(); ++fi,++ind)
float b = float(fi->WC(z)[2])/255; {
if(ind%4==0)
if(ind%4==0) fprintf(fp,"\n ");
fprintf(fp,"\n "); for (int j = 0; j < 3; j++)
{
fprintf(fp, fprintf(fp,"%i,",nn);
"%g %g %g," ++nn;
,r,g,b }
); fprintf(fp,"-1,");
} }
} fprintf(fp,
"\n"
fprintf(fp, " ]\n"
"\n" );
" ]\n" }
" }\n" else if (HasPerWedgeTexture(m) &&(mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD))
" colorIndex\n" {
" [" fprintf(fp,
); "\n"
" texCoord TextureCoordinate\n"
int nn = 0; " {\n"
for(ind=0,fi=face.begin(); fi!=face.end(); ++fi,++ind) " point\n"
{ " [\n"
if(ind%4==0) );
fprintf(fp,"\n "); for(ind=0,fi=m.face.begin(); fi!=m.face.end(); ++fi,++ind)
for (int j = 0; j < 3; j++) {
{ if(ind%4==0)
fprintf(fp,"%i,",nn); fprintf(fp,"\n ");
++nn; for (int j = 0; j < 3; j++)
} {
fprintf(fp,"-1,"); fprintf(fp,"%g %g, ",fi->WT(j).u(),fi->WT(j).v());
} }
}
fprintf(fp, fprintf(fp,
"\n" "\n"
" ]\n" " ]\n"
); " }\n"
} " texCoordIndex\n"
else if( ( savemask & SM_WEDGTEXCOORD ) && (face_type::OBJ_TYPE & face_type::OBJ_TYPE_WT) ) " [\n"
{ );
fprintf(fp, int nn = 0;
"\n" for(ind=0,fi=m.face.begin(); fi!=m.face.end(); ++fi,++ind)
" texCoord TextureCoordinate\n" {
" {\n" if(ind%4==0)
" point\n" fprintf(fp,"\n ");
" [\n" for (int j = 0; j < 3; j++)
); {
fprintf(fp,"%d,",nn);
for(ind=0,fi=face.begin(); fi!=face.end(); ++fi,++ind) ++nn;
{ }
if(ind%4==0) fprintf(fp,"-1,");
fprintf(fp,"\n "); }
for (int j = 0; j < 3; j++) fprintf(fp,
{ "\n"
fprintf(fp,"%g %g, " " ]\n"
,fi->WT(j).u() );
,fi->WT(j).v() }
); fprintf(fp,
} " coordIndex\n"
} " ["
);
fprintf(fp, // Facce
"\n" for(ind=0,fi=m.face.begin(); fi!=m.face.end(); ++fi,++ind)
" ]\n" {
" }\n" if(ind%6==0)
" texCoordIndex\n" {
" [\n" fprintf(fp,"\n ");
); }
for (int j = 0; j < 3; j++)
int nn = 0; fprintf(fp,"%i,",index[(*fi).V(j)]);
for(ind=0,fi=face.begin(); fi!=face.end(); ++fi,++ind) fprintf(fp,"-1,");
{ }
if(ind%4==0) fprintf(fp,
fprintf(fp,"\n "); "\n"
for (int j = 0; j < 3; j++) " ]\n"
{ " }\n"
fprintf(fp,"%d,",nn); " appearance Appearance\n"
++nn; " {\n"
} " material Material\n"
fprintf(fp,"-1,"); " {\n"
} " ambientIntensity 0.2\n"
" diffuseColor 0.9 0.9 0.9\n"
fprintf(fp, " specularColor .1 .1 .1\n"
"\n" " shininess .5\n"
" ]\n" " }\n"
); );
} if(m.textures.size())
{
fprintf(fp,
fprintf(fp, " texture ImageTexture { url \" %s \" }\n"
" coordIndex\n" ,m.textures[0].c_str()
" [" );
); }
// Facce fprintf(fp,
for(ind=0,fi=face.begin(); fi!=face.end(); ++fi,++ind) " }\n"
{ " }\n"
if(ind%6==0) " ]\n"
{ "}\n"
fprintf(fp,"\n "); );
} fclose(fp);
return 0;
for (int j = 0; j < 3; j++) }
fprintf(fp,"%i,",index[(*fi).V(j)]); static int GetExportMaskCapability()
fprintf(fp,"-1,"); {
} int capability = 0;
fprintf(fp, //vert
"\n" capability |= MeshModel::IOM_VERTCOLOR;
" ]\n"
" }\n" //wedg
" appearance Appearance\n" capability |= MeshModel::IOM_WEDGTEXCOORD;
" {\n" capability |= MeshModel::IOM_WEDGCOLOR;
" material Material\n"
" {\n" return capability;
" ambientIntensity 0.2\n" }
" diffuseColor 0.9 0.9 0.9\n"
" specularColor .1 .1 .1\n" static const char *ErrorMsg(int error)
" shininess .5\n" {
" }\n" static std::vector<std::string> wrl_error_msg;
); if(wrl_error_msg.empty())
{
if(textures.size()) wrl_error_msg.resize(2 );
{ wrl_error_msg[0]="No errors";
fprintf(fp, wrl_error_msg[1]="Can't open file";
" texture ImageTexture { url \"%s\" }\n" }
,textures[0] if(error>1 || error<0) return "Unknown error";
); else return wrl_error_msg[error].c_str();
} }
fprintf(fp, }; // end class
" }\n" } // end Namespace io
" }\n" } // end Namespace tri
" ]\n" } // end Namespace vcg
"}\n"
); #endif
fclose(fp);
return true;
}

1455
wrap/io_trimesh/import_ptx.h
View File

File diff suppressed because it is too large Load Diff

135
wrap/io_trimesh/import_smf.h
View File

@ -1,24 +1,129 @@
/**************************************************************************** * VCGLib o o * * Visual and Computer Graphics Library o o * * _ O _ * /****************************************************************************
* Copyright(C) 2004 \/)\/ * * Visual Computing Lab /\/| * * ISTI - Italian National Research Council | * * \ * * All rights reserved. * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * VCGLib o o *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * * for more details. * * * ****************************************************************************/ * Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
/**************************************************************************** /****************************************************************************
History History
$Log: not supported by cvs2svn $ $Log: not supported by cvs2svn $
****************************************************************************/ #ifndef __VCGLIB_IMPORTERSMF ****************************************************************************/
#define __VCGLIB_IMPORTERSMF #include <map>
#ifndef __VCGLIB_IMPORTER_SMF
#define __VCGLIB_IMPORTER_SMF
#include <stdio.h>
#include <vcg/space/point3.h>
namespace vcg { namespace vcg {
namespace tri { namespace tri {
namespace io { namespace io {
template<class OpenMeshType>
class ImporterSMF
{
public:
typedef typename OpenMeshType::VertexPointer VertexPointer;
typedef typename OpenMeshType::ScalarType ScalarType;
typedef typename OpenMeshType::VertexType VertexType;
typedef typename OpenMeshType::FaceType FaceType;
typedef typename OpenMeshType::VertexIterator VertexIterator;
typedef typename OpenMeshType::FaceIterator FaceIterator;
// if it is binary there are 80 char of comment, the number fn of faces and then exactly fn*4*3 bytes.
enum {SMF_LABEL_SIZE=80};
class SMFFacet
{
public:
vcg::Point3f n;
vcg::Point3f v[3];
};
enum SMFError {
E_NOERROR, // 0
// Errori di open
E_CANTOPEN, // 1
E_UNESPECTEDEOF // 2
};
static const char *ErrorMsg(int error)
{
static const char * smf_error_msg[] =
{
"No errors",
"Can't open file",
"Premature End of file",
};
if(error>2 || error<0) return "Unknown error";
else return smf_error_msg[error];
};
static int Open(OpenMeshType &m, const char * filename )
{
VertexType v;
FaceType f;
FILE *fp;
float x,y,z;
bool one = true;
std::map<int,VertexPointer> mv;
fp = fopen(filename,"r");
if(!fp) return -1;
char buf[1024];
while( fgets(buf,1024,fp) )
{
char *vf, *comm_pt;
if((comm_pt = strstr(buf,"#")) != NULL)
*comm_pt = '\0';
if( (vf = strstr(buf,"v")) != NULL )
{
sscanf(vf+1,"%f %f %f", &x, &y, &z);
v.P()[0] = x;
v.P()[1] = y;
v.P()[2] = z;
m.vert.push_back(v);
}
else if( (vf = strstr(buf,"f")) != NULL)
{
if(one)
{
VertexIterator vi;
int ind;
for(ind=1,vi=m.vert.begin(); vi!=m.vert.end(); ++vi,++ind)
mv[ind]=&*vi;
one = false;
}
int v1,v2,v3;
sscanf(vf+1,"%d %d %d", &v1, &v2, &v3);
f.V(0) = mv[v1];
f.V(1) = mv[v2];
f.V(2) = mv[v3];
m.face.push_back(f);
}
}
m.vn = m.vert.size();
m.fn = m.face.size();
return 0;
}
};
}// end of io
}// end of tri
}// end of vcg
#endif
template <class MESHTYPE>
int Load_Smf( MESHTYPE & m, const char * filename ) { typedef typename MESHTYPE::VertexPointer VertexPointer;
typedef typename MESHTYPE::VertexType VertexType;
typedef typename MESHTYPE::FaceType FaceType;
typedef typename MESHTYPE::VertexIterator VertexIterator;
typedef typename MESHTYPE::FaceIterator FaceIterator;
char buf[1024];
FILE *fp; float x,y,z; bool one = true; std::map<int,VertexPointer> mv; fp = fopen(filename,"r"); if(!fp) return -1; VertexType v; v.Supervisor_Flags() = 0; FaceType f; f.Supervisor_Flags() = 0;
while( fgets(buf,1024,fp) ) { char *vf, *comm_pt; if((comm_pt = strstr(buf,"#")) != NULL) *comm_pt = '\0'; if( (vf = strstr(buf,"v")) != NULL ) { sscanf(vf+1,"%f %f %f", &x, &y, &z); v.P()[0] = x; v.P()[1] = y; v.P()[2] = z; m.vert.push_back(v); } else if( (vf = strstr(buf,"f")) != NULL) { if(one) { VertexIterator vi; int ind; for(ind=1,vi=m.vert.begin(); vi!=m.vert.end(); ++vi,++ind) mv[ind]=&*vi; one = false; } int v1,v2,v3; sscanf(vf+1,"%d %d %d", &v1, &v2, &v3); f.V(0) = mv[v1]; f.V(1) = mv[v2]; f.V(2) = mv[v3]; m.face.push_back(f); } } m.vn = m.vert.size(); m.fn = m.face.size(); return 0; } };// end of io };// end of tri };// end of vcg #endif