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

added a missing const (otherwise clang would not compile)

This commit is contained in:
Paolo Cignoni 2013-09-23 16:23:45 +00:00
parent ce4b264dfd
commit eeccd23f71
1 changed files with 93 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
wrap/io_trimesh/import_vmi.h
View File

@ -8,7 +8,7 @@
* \ * * \ *
* 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. *
@ -28,7 +28,7 @@
Revision 1.1 2007/02/14 01:20:37 ganovelli Revision 1.1 2007/02/14 01:20:37 ganovelli
working draft of VCG Mesh Image importer and exporter. Does not consider optional attributes. The mesh atributes are only vn and fn (no bbox, texture coordiantes) working draft of VCG Mesh Image importer and exporter. Does not consider optional attributes. The mesh atributes are only vn and fn (no bbox, texture coordiantes)
****************************************************************************/ ****************************************************************************/
@ -44,7 +44,7 @@
passed to the function Save(SaveMeshType m) passed to the function Save(SaveMeshType m)
NOTE: THIS IS NOT A FILE FORMAT. IT IS ONLY USEFUL FOR DUMPING MESH IMAGES FOR DEBUG PURPOSE. NOTE: THIS IS NOT A FILE FORMAT. IT IS ONLY USEFUL FOR DUMPING MESH IMAGES FOR DEBUG PURPOSE.
Example of use: say you are running a time consuming mesh processing and you want to save intermediate Example of use: say you are running a time consuming mesh processing and you want to save intermediate
state, but no file format support all the attributes you need in your vertex/face type. state, but no file format support all the attributes you need in your vertex/face type.
NOTE2: At the present if you add members to your TriMesh these will NOT be saved. More precisely, this file and NOTE2: At the present if you add members to your TriMesh these will NOT be saved. More precisely, this file and
import_vmi must be updated to reflect changes in vcg/complex/trimesh/base.h import_vmi must be updated to reflect changes in vcg/complex/trimesh/base.h
@ -84,7 +84,7 @@ namespace io {
else else
T::template AddAttrib<0>(m,name,s,data); T::template AddAttrib<0>(m,name,s,data);
break; break;
case 2: case 2:
if(s == sizeof(A)){ if(s == sizeof(A)){
typename MeshType::template PerMeshAttributeHandle<A> h = vcg::tri::Allocator<MeshType>:: template AddPerMeshAttribute<A>(m,name); typename MeshType::template PerMeshAttributeHandle<A> h = vcg::tri::Allocator<MeshType>:: template AddPerMeshAttribute<A>(m,name);
memcpy(&h(), (void*) ((A*)data),sizeof(A)); // we don't want the type conversion memcpy(&h(), (void*) ((A*)data),sizeof(A)); // we don't want the type conversion
@ -131,9 +131,9 @@ namespace io {
assert(new_pa.second); assert(new_pa.second);
} }
else else
T::template AddAttrib<0>(m,name,s,data); T::template AddAttrib<0>(m,name,s,data);
break; break;
case 1: case 1:
if(s == sizeof(A)){ if(s == sizeof(A)){
typename MeshType::template PerVertexAttributeHandle<A> h = vcg::tri::Allocator<MeshType>::template AddPerVertexAttribute<A>(m,name); typename MeshType::template PerVertexAttributeHandle<A> h = vcg::tri::Allocator<MeshType>::template AddPerVertexAttribute<A>(m,name);
for(unsigned int i = 0; i < m.vert.size(); ++i) for(unsigned int i = 0; i < m.vert.size(); ++i)
@ -158,7 +158,7 @@ namespace io {
assert(new_pa.second); assert(new_pa.second);
} }
else else
T::template AddAttrib<1>(m,name,s,data); T::template AddAttrib<1>(m,name,s,data);
break; break;
case 2: case 2:
if(s == sizeof(A)){ if(s == sizeof(A)){
@ -172,7 +172,7 @@ namespace io {
typename MeshType::template PerMeshAttributeHandle<A> h = vcg::tri::Allocator<MeshType>::template AddPerMeshAttribute<A>(m,name); typename MeshType::template PerMeshAttributeHandle<A> h = vcg::tri::Allocator<MeshType>::template AddPerMeshAttribute<A>(m,name);
char * dest = & ((char*)(&h()))[0]; char * dest = & ((char*)(&h()))[0];
memcpy( (void *)dest , (void*)((A*)data),s); // we don't want the type conversion memcpy( (void *)dest , (void*)((A*)data),s); // we don't want the type conversion
typename MeshType::PointerToAttribute pa; typename MeshType::PointerToAttribute pa;
pa._name = std::string(name); pa._name = std::string(name);
HWIte res = m.mesh_attr.find(pa); HWIte res = m.mesh_attr.find(pa);
@ -183,7 +183,7 @@ namespace io {
assert(new_pa.second); assert(new_pa.second);
} }
else else
T::template AddAttrib<2>(m,name,s,data); T::template AddAttrib<2>(m,name,s,data);
break; break;
default: assert(0);break; default: assert(0);break;
} }
@ -195,9 +195,9 @@ namespace io {
*/ */
template <class MeshType> struct K { template <class MeshType> struct K {
template <int VoF> template <int VoF>
static void AddAttrib(MeshType &/*m*/, const char * /*name*/, unsigned int /*s*/, void * /*data*/){ static void AddAttrib(MeshType &/*m*/, const char * /*name*/, unsigned int /*s*/, void * /*data*/){
// if yohu got this your attribute is larger than 1048576. Honestly... // if yohu got this your attribute is larger than 1048576. Honestly...
assert(0); assert(0);
} }
}; };
@ -215,20 +215,20 @@ namespace io {
template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7,class B8,class B9,class B10,class B11> struct K11 : public DerK< MeshType, B11, K10<MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B11 > > {}; template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7,class B8,class B9,class B10,class B11> struct K11 : public DerK< MeshType, B11, K10<MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B11 > > {};
template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7,class B8,class B9,class B10,class B11,class B12>struct K12 : public DerK< MeshType, B12, K11<MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B11, B12 > > {}; template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7,class B8,class B9,class B10,class B11,class B12>struct K12 : public DerK< MeshType, B12, K11<MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B11, B12 > > {};
template <class MeshType, class A0, template <class MeshType, class A0,
class B0 = DummyType<1048576>, class B0 = DummyType<1048576>,
class B1 = DummyType<2048>, class B1 = DummyType<2048>,
class B2 = DummyType<1024>, class B2 = DummyType<1024>,
class B3 = DummyType<512>, class B3 = DummyType<512>,
class B4 = DummyType<256>, class B4 = DummyType<256>,
class B5 = DummyType<128>, class B5 = DummyType<128>,
class B6 = DummyType<64>, class B6 = DummyType<64>,
class B7 = DummyType<32>, class B7 = DummyType<32>,
class B8 = DummyType<16>, class B8 = DummyType<16>,
class B9 = DummyType<8>, class B9 = DummyType<8>,
class B10 = DummyType<4>, class B10 = DummyType<4>,
class B11 = DummyType<2>, class B11 = DummyType<2>,
class B12 = DummyType<1> class B12 = DummyType<1>
> struct C0 : public DerK< MeshType, A0, K12<MeshType, B0, B1, B2, B3, B4,B5,B6,B7,B8,B9,B10,B11,B12> > {}; > struct C0 : public DerK< MeshType, A0, K12<MeshType, B0, B1, B2, B3, B4,B5,B6,B7,B8,B9,B10,B11,B12> > {};
template <class MeshType, class A0, class A1> struct C1 : public Der< MeshType, A1, C0<MeshType, A0> > {}; template <class MeshType, class A0, class A1> struct C1 : public Der< MeshType, A1, C0<MeshType, A0> > {};
@ -238,29 +238,29 @@ namespace io {
template <class OpenMeshType,class A0 = long, class A1 = double, class A2 = int,class A3 = short, class A4 = char > template <class OpenMeshType,class A0 = long, class A1 = double, class A2 = int,class A3 = short, class A4 = char >
class ImporterVMI: public AttrAll<OpenMeshType,A0,A1,A2,A3,A4> class ImporterVMI: public AttrAll<OpenMeshType,A0,A1,A2,A3,A4>
{ {
static void ReadString(std::string & out){ static void ReadString(std::string & out){
unsigned int l; Read(&l,4,1); unsigned int l; Read(&l,4,1);
char * buf = new char[l+1]; char * buf = new char[l+1];
Read(buf,1,l);buf[l]='\0'; Read(buf,1,l);buf[l]='\0';
out = std::string(buf); out = std::string(buf);
delete [] buf; delete [] buf;
} }
static void ReadInt( unsigned int & i){ Read(&i,1,4);} static void ReadInt( unsigned int & i){ Read(&i,1,4);}
static void ReadFloat( float & v){ Read(&v,1,sizeof(float));} static void ReadFloat( float & v){ Read(&v,1,sizeof(float));}
static int LoadVertexOcfMask( ){ static int LoadVertexOcfMask( ){
int mask =0; int mask =0;
std::string s; std::string s;
// vertex quality // vertex quality
ReadString( s); ReadString( s);
if( s == std::string("HAS_VERTEX_QUALITY_OCF")) mask |= Mask::IOM_VERTQUALITY; if( s == std::string("HAS_VERTEX_QUALITY_OCF")) mask |= Mask::IOM_VERTQUALITY;
// vertex color // vertex color
ReadString( s); ReadString( s);
@ -268,33 +268,33 @@ namespace io {
// vertex normal // vertex normal
ReadString( s); ReadString( s);
if( s == std::string("HAS_VERTEX_NORMAL_OCF")) mask |= Mask::IOM_VERTNORMAL; if( s == std::string("HAS_VERTEX_NORMAL_OCF")) mask |= Mask::IOM_VERTNORMAL;
// vertex mark // vertex mark
ReadString( s); ReadString( s);
//if( s == std::string("HAS_VERTEX_MARK_OCF")) mask |= //if( s == std::string("HAS_VERTEX_MARK_OCF")) mask |=
// vertex texcoord // vertex texcoord
ReadString( s); ReadString( s);
if( s == std::string("HAS_VERTEX_TEXCOORD_OCF")) mask |= Mask::IOM_VERTTEXCOORD; if( s == std::string("HAS_VERTEX_TEXCOORD_OCF")) mask |= Mask::IOM_VERTTEXCOORD;
// vertex-face adjacency // vertex-face adjacency
ReadString( s); ReadString( s);
//if( s == std::string("HAS_VERTEX_VFADJACENCY_OCF")) mask |= //if( s == std::string("HAS_VERTEX_VFADJACENCY_OCF")) mask |=
// vertex curvature // vertex curvature
ReadString( s); ReadString( s);
//if( s == std::string("HAS_VERTEX_CURVATURE_OCF")) mask |= //if( s == std::string("HAS_VERTEX_CURVATURE_OCF")) mask |=
//// vertex curvature dir //// vertex curvature dir
ReadString( s); ReadString( s);
//if( s == std::string("HAS_VERTEX_CURVATUREDIR_OCF")) mask |= //if( s == std::string("HAS_VERTEX_CURVATUREDIR_OCF")) mask |=
// vertex radius // vertex radius
ReadString( s); ReadString( s);
if( s == std::string("HAS_VERTEX_RADIUS_OCF")) mask |= Mask::IOM_VERTRADIUS; if( s == std::string("HAS_VERTEX_RADIUS_OCF")) mask |= Mask::IOM_VERTRADIUS;
return mask; return mask;
} }
template <typename MeshType, typename CONT> template <typename MeshType, typename CONT>
@ -309,7 +309,7 @@ namespace io {
template <typename MeshType> template <typename MeshType>
struct struct
LoadVertexOcf<MeshType,vertex::vector_ocf<typename OpenMeshType::VertexType> >{ LoadVertexOcf<MeshType,vertex::vector_ocf<typename OpenMeshType::VertexType> >{
typedef typename OpenMeshType::VertexType VertexType; typedef typename OpenMeshType::VertexType VertexType;
LoadVertexOcf( FILE * f, vertex::vector_ocf<typename OpenMeshType::VertexType> & vert){ LoadVertexOcf( FILE * f, vertex::vector_ocf<typename OpenMeshType::VertexType> & vert){
std::string s; std::string s;
@ -385,15 +385,15 @@ namespace io {
// do nothing, it is a std::vector // do nothing, it is a std::vector
} }
}; };
static int LoadFaceOcfMask( ){ static int LoadFaceOcfMask( ){
int mask=0; int mask=0;
std::string s; std::string s;
// face quality // face quality
ReadString( s); ReadString( s);
if( s == std::string("HAS_FACE_QUALITY_OCF")) mask |= Mask::IOM_FACEQUALITY; if( s == std::string("HAS_FACE_QUALITY_OCF")) mask |= Mask::IOM_FACEQUALITY;
// face color // face color
ReadString( s); ReadString( s);
@ -401,11 +401,11 @@ namespace io {
// face normal // face normal
ReadString( s); ReadString( s);
if( s == std::string("HAS_FACE_NORMAL_OCF")) mask |= Mask::IOM_FACENORMAL; if( s == std::string("HAS_FACE_NORMAL_OCF")) mask |= Mask::IOM_FACENORMAL;
//// face mark //// face mark
ReadString( s); ReadString( s);
//if( s == std::string("HAS_FACE_MARK_OCF")) mask |= //if( s == std::string("HAS_FACE_MARK_OCF")) mask |=
// face wedgetexcoord // face wedgetexcoord
ReadString( s); ReadString( s);
@ -418,23 +418,23 @@ namespace io {
// vertex-face adjacency // vertex-face adjacency
ReadString( s); ReadString( s);
//if( s == std::string("HAS_FACE_VFADJACENCY_OCF")) mask |= //if( s == std::string("HAS_FACE_VFADJACENCY_OCF")) mask |=
// face WedgeColor // face WedgeColor
ReadString( s); ReadString( s);
if( s == std::string("HAS_FACE_WEDGECOLOR_OCF")) mask |= Mask::IOM_WEDGCOLOR; if( s == std::string("HAS_FACE_WEDGECOLOR_OCF")) mask |= Mask::IOM_WEDGCOLOR;
// face WedgeNormal // face WedgeNormal
ReadString( s); ReadString( s);
if( s == std::string("HAS_FACE_WEDGENORMAL_OCF")) mask |= Mask::IOM_WEDGNORMAL; if( s == std::string("HAS_FACE_WEDGENORMAL_OCF")) mask |= Mask::IOM_WEDGNORMAL;
return mask; return mask;
} }
/* partial specialization for vector_ocf */ /* partial specialization for vector_ocf */
template <typename MeshType> template <typename MeshType>
struct LoadFaceOcf< MeshType, face::vector_ocf<typename OpenMeshType::FaceType> >{ struct LoadFaceOcf< MeshType, face::vector_ocf<typename OpenMeshType::FaceType> >{
typedef typename OpenMeshType::FaceType FaceType; typedef typename OpenMeshType::FaceType FaceType;
LoadFaceOcf( face::vector_ocf<FaceType> & face){ LoadFaceOcf( face::vector_ocf<FaceType> & face){
std::string s; std::string s;
@ -530,7 +530,7 @@ namespace io {
static FILE *& F(){static FILE * f; return f;} static FILE *& F(){static FILE * f; return f;}
static void * Malloc(unsigned int n){ return (n)?malloc(n):0;} static void * Malloc(unsigned int n){ return (n)?malloc(n):0;}
static void Free(void * ptr){ if(ptr) free (ptr);} static void Free(void * ptr){ if(ptr) free (ptr);}
@ -544,7 +544,7 @@ namespace io {
typedef typename OpenMeshType::VertexType VertexType; typedef typename OpenMeshType::VertexType VertexType;
public: public:
enum VMIErrorCodes { enum VMIErrorCodes {
VMI_NO_ERROR = 0, VMI_NO_ERROR = 0,
VMI_INCOMPATIBLE_VERTEX_TYPE, VMI_INCOMPATIBLE_VERTEX_TYPE,
VMI_INCOMPATIBLE_FACE_TYPE, VMI_INCOMPATIBLE_FACE_TYPE,
@ -576,9 +576,9 @@ namespace io {
as a vcg::Box3f, even if the scalar type is not float. The bounding box of the mesh will as a vcg::Box3f, even if the scalar type is not float. The bounding box of the mesh will
be set properly on loading. be set properly on loading.
*/ */
static bool GetHeader( std::vector<std::string>& fnameV, static bool GetHeader( std::vector<std::string>& fnameV,
std::vector<std::string>& fnameF, std::vector<std::string>& fnameF,
unsigned int & vertSize, unsigned int & vertSize,
unsigned int &faceSize, unsigned int &faceSize,
vcg::Box3f & bbox, vcg::Box3f & bbox,
int & mask){ int & mask){
@ -587,14 +587,14 @@ namespace io {
ReadString( name); ReadInt( nameFsize); ReadString( name); ReadInt( nameFsize);
for(i=0; i < nameFsize; ++i) for(i=0; i < nameFsize; ++i)
{ReadString( name);fnameF.push_back( name );mask |= FaceMaskBitFromString(name);} {ReadString( name);fnameF.push_back( name );mask |= FaceMaskBitFromString(name);}
mask |= LoadFaceOcfMask(); mask |= LoadFaceOcfMask();
ReadString( name); ReadInt( faceSize); ReadString( name); ReadInt( faceSize);
ReadString( name); ReadInt( nameVsize); ReadString( name); ReadInt( nameVsize);
for(i=0; i < nameVsize; ++i) for(i=0; i < nameVsize; ++i)
{ReadString( name) ;fnameV.push_back( name);mask |= VertexMaskBitFromString(name);} {ReadString( name) ;fnameV.push_back( name);mask |= VertexMaskBitFromString(name);}
mask |= LoadVertexOcfMask(); mask |= LoadVertexOcfMask();
@ -612,15 +612,15 @@ namespace io {
} }
static bool GetHeader(const char * filename,std::vector<std::string>& nameV, std::vector<std::string>& nameF, unsigned int & vertSize, unsigned int &faceSize,vcg::Box3f & bbox,int & mask){ static bool GetHeader(const char * filename,std::vector<std::string>& nameV, std::vector<std::string>& nameF, unsigned int & vertSize, unsigned int &faceSize,vcg::Box3f & bbox,int & mask){
F() = fopen(filename,"rb"); F() = fopen(filename,"rb");
bool res = GetHeader(nameV, nameF, vertSize, faceSize,bbox,mask); bool res = GetHeader(nameV, nameF, vertSize, faceSize,bbox,mask);
fclose(F()); fclose(F());
return res; return res;
} }
public: public:
static char * & In_mem(){static char * in_mem; return in_mem;} static const char * & In_mem(){static const char * in_mem; return in_mem;}
static unsigned int & In_mode(){static unsigned int in_mode = 0; return in_mode;} static unsigned int & In_mode(){static unsigned int in_mode = 0; return in_mode;}
@ -639,10 +639,10 @@ namespace io {
} }
static bool LoadMask(const char * f, int & mask){ static bool LoadMask(const char * f, int & mask){
std::vector<std::string> nameV; std::vector<std::string> nameV;
std::vector<std::string> nameF; std::vector<std::string> nameF;
unsigned int vertSize, faceSize; unsigned int vertSize, faceSize;
vcg::Box3f bbox; vcg::Box3f bbox;
F() = fopen(f,"rb"); F() = fopen(f,"rb");
In_mode() = 1; In_mode() = 1;
@ -681,36 +681,36 @@ namespace io {
static int Deserialize(OpenMeshType &m, int & mask) static int Deserialize(OpenMeshType &m, int & mask)
{ {
typedef typename OpenMeshType::VertexType VertexType; typedef typename OpenMeshType::VertexType VertexType;
typedef typename OpenMeshType::FaceType FaceType; typedef typename OpenMeshType::FaceType FaceType;
typename OpenMeshType::FaceIterator fi; typename OpenMeshType::FaceIterator fi;
typename OpenMeshType::VertexIterator vi; typename OpenMeshType::VertexIterator vi;
std::vector<std::string> nameF,nameV,fnameF,fnameV; std::vector<std::string> nameF,nameV,fnameF,fnameV;
unsigned int vertSize,faceSize; unsigned int vertSize,faceSize;
/* read the header */ /* read the header */
vcg::Box3f lbbox; vcg::Box3f lbbox;
GetHeader(fnameV, fnameF, vertSize, faceSize,lbbox,mask); GetHeader(fnameV, fnameF, vertSize, faceSize,lbbox,mask);
m.bbox.Import(lbbox); m.bbox.Import(lbbox);
/* read the mesh type */ /* read the mesh type */
OpenMeshType::FaceType::Name(nameF); OpenMeshType::FaceType::Name(nameF);
OpenMeshType::VertexType::Name(nameV); OpenMeshType::VertexType::Name(nameV);
/* check if the type is the very same, otherwise return */ /* check if the type is the very same, otherwise return */
if(fnameV != nameV) return VMI_INCOMPATIBLE_VERTEX_TYPE; if(fnameV != nameV) return VMI_INCOMPATIBLE_VERTEX_TYPE;
if(fnameF != nameF) return VMI_INCOMPATIBLE_FACE_TYPE; if(fnameF != nameF) return VMI_INCOMPATIBLE_FACE_TYPE;
void * offsetV = 0,*offsetF = 0; void * offsetV = 0,*offsetF = 0;
if(vertSize!=0) if(vertSize!=0)
/* read the address of the first vertex */ /* read the address of the first vertex */
Read(&offsetV,sizeof( void *),1 ); Read(&offsetV,sizeof( void *),1 );
if(faceSize!=0) if(faceSize!=0)
/* read the address of the first face */ /* read the address of the first face */
Read(&offsetF,sizeof( void *),1 ); Read(&offsetF,sizeof( void *),1 );
/* read the object mesh */ /* read the object mesh */
Read(&m.shot,sizeof(Shot<typename OpenMeshType::ScalarType>),1 ); Read(&m.shot,sizeof(Shot<typename OpenMeshType::ScalarType>),1 );
Read(&m.vn,sizeof(int),1 ); Read(&m.vn,sizeof(int),1 );
Read(&m.fn,sizeof(int),1 ); Read(&m.fn,sizeof(int),1 );
@ -723,10 +723,10 @@ namespace io {
m.vert.resize(vertSize); m.vert.resize(vertSize);
size_t read = 0; size_t read = 0;
/* load the vertices */ /* load the vertices */
if(vertSize>0){ if(vertSize>0){
read=Read((void*)& m.vert[0],sizeof(VertexType),vertSize ); read=Read((void*)& m.vert[0],sizeof(VertexType),vertSize );
LoadVertexOcf<OpenMeshType,VertContainer>(F(),m.vert); LoadVertexOcf<OpenMeshType,VertContainer>(F(),m.vert);
} }
@ -734,34 +734,34 @@ namespace io {
m.face.resize(faceSize); m.face.resize(faceSize);
if(faceSize>0){ if(faceSize>0){
/* load the faces */ /* load the faces */
read = Read((void*)& m.face[0],sizeof(FaceType),faceSize ); read = Read((void*)& m.face[0],sizeof(FaceType),faceSize );
LoadFaceOcf<OpenMeshType,FaceContainer>(m.face); LoadFaceOcf<OpenMeshType,FaceContainer>(m.face);
} }
/* load the per vertex attributes */ /* load the per vertex attributes */
std::string _string,_trash; std::string _string,_trash;
unsigned int n,sz; unsigned int n,sz;
ReadString( _trash); ReadInt( n); ReadString( _trash); ReadInt( n);
for(size_t ia = 0 ; ia < n; ++ia){ for(size_t ia = 0 ; ia < n; ++ia){
ReadString(_trash); ReadString(_string); ReadString(_trash); ReadString(_string);
ReadString(_trash); ReadInt(sz); ReadString(_trash); ReadInt(sz);
void * data = Malloc(sz*m.vert.size()); void * data = Malloc(sz*m.vert.size());
Read(data,sz,m.vert.size()); Read(data,sz,m.vert.size());
AttrAll<OpenMeshType,A0,A1,A2,A3,A4>::template AddAttrib<0>(m,_string.c_str(),sz,data); AttrAll<OpenMeshType,A0,A1,A2,A3,A4>::template AddAttrib<0>(m,_string.c_str(),sz,data);
Free(data); Free(data);
} }
/* load the per face attributes */ /* load the per face attributes */
ReadString(_trash); ReadInt( n); ReadString(_trash); ReadInt( n);
for(size_t ia = 0 ; ia < n; ++ia){ for(size_t ia = 0 ; ia < n; ++ia){
ReadString(_trash); ReadString( _string); ReadString(_trash); ReadString( _string);
ReadString(_trash); ReadInt( sz); ReadString(_trash); ReadInt( sz);
void * data = Malloc(sz*m.face.size()); void * data = Malloc(sz*m.face.size());
Read(data,sz,m.face.size() ); Read(data,sz,m.face.size() );
AttrAll<OpenMeshType,A0,A1,A2,A3,A4>::template AddAttrib<1>(m,_string.c_str(),sz,data); AttrAll<OpenMeshType,A0,A1,A2,A3,A4>::template AddAttrib<1>(m,_string.c_str(),sz,data);
Free(data); Free(data);
} }
@ -772,7 +772,7 @@ namespace io {
ReadString( _trash); ReadString( _string); ReadString( _trash); ReadString( _string);
ReadString( _trash); ReadInt( sz); ReadString( _trash); ReadInt( sz);
void * data = Malloc(sz); void * data = Malloc(sz);
Read(data,1,sz ); Read(data,1,sz );
AttrAll<OpenMeshType,A0,A1,A2,A3,A4>::template AddAttrib<2>(m,_string.c_str(),sz,data); AttrAll<OpenMeshType,A0,A1,A2,A3,A4>::template AddAttrib<2>(m,_string.c_str(),sz,data);
Free(data); Free(data);
} }
@ -785,14 +785,14 @@ namespace io {
(*vi).VFp() = (*vi).VFp()-(FaceType*)offsetF+ &m.face[0]; (*vi).VFp() = (*vi).VFp()-(FaceType*)offsetF+ &m.face[0];
} }
if(FaceVectorHasFVAdjacency(m.face)) if(FaceVectorHasFVAdjacency(m.face))
for(fi = m.face.begin(); fi != m.face.end(); ++fi){ for(fi = m.face.begin(); fi != m.face.end(); ++fi){
(*fi).V(0) = (*fi).V(0)-(VertexType*)offsetV+ &m.vert[0]; (*fi).V(0) = (*fi).V(0)-(VertexType*)offsetV+ &m.vert[0];
(*fi).V(1) = (*fi).V(1)-(VertexType*)offsetV+ &m.vert[0]; (*fi).V(1) = (*fi).V(1)-(VertexType*)offsetV+ &m.vert[0];
(*fi).V(2) = (*fi).V(2)-(VertexType*)offsetV+ &m.vert[0]; (*fi).V(2) = (*fi).V(2)-(VertexType*)offsetV+ &m.vert[0];
} }
if(FaceVectorHasFFAdjacency(m.face)) if(FaceVectorHasFFAdjacency(m.face))
for(fi = m.face.begin(); fi != m.face.end(); ++fi){ for(fi = m.face.begin(); fi != m.face.end(); ++fi){
(*fi).FFp(0) = (*fi).FFp(0)-(FaceType*)offsetF+ &m.face[0]; (*fi).FFp(0) = (*fi).FFp(0)-(FaceType*)offsetF+ &m.face[0];
(*fi).FFp(1) = (*fi).FFp(1)-(FaceType*)offsetF+ &m.face[0]; (*fi).FFp(1) = (*fi).FFp(1)-(FaceType*)offsetF+ &m.face[0];
@ -801,8 +801,8 @@ namespace io {
} }
return VMI_NO_ERROR; // zero is the standard (!) code of success return VMI_NO_ERROR; // zero is the standard (!) code of success
} }
}; // end class }; // end class