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

harmless gcc warning

This commit is contained in:
Paolo Cignoni 2013-12-12 20:52:52 +00:00
parent d44d6e6f41
commit 88c8bcb293
1 changed files with 354 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

708
wrap/io_trimesh/import_vmi.h
View File

@ -38,15 +38,15 @@
#include <wrap/io_trimesh/io_mask.h> #include <wrap/io_trimesh/io_mask.h>
#include <wrap/callback.h> #include <wrap/callback.h>
/* /*
VMI VCG Mesh Image. VMI VCG Mesh Image.
The vmi image file consists of a header containing the description of the vertex and face type, The vmi image file consists of a header containing the description of the vertex and face type,
the length of vectors containing vertices of faces and the memory image of the object mesh as it is when the length of vectors containing vertices of faces and the memory image of the object mesh as it is when
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
*/ */
@ -54,193 +54,193 @@ namespace vcg {
namespace tri { namespace tri {
namespace io { namespace io {
template <int N> struct DummyType{ char placeholder[N]; }; template <int N> struct DummyType{ char placeholder[N]; };
/* ------------------------- derivation chain for the vertex attribute ---------------------------*/ /* ------------------------- derivation chain for the vertex attribute ---------------------------*/
/** this class is for testing only the equality with the type optionally provided by the user when calling Open /** this class is for testing only the equality with the type optionally provided by the user when calling Open
*/ */
template <class MeshType, class A, class T> template <class MeshType, class A, class T>
struct Der:public T{ struct Der:public T{
typedef typename std::set<typename MeshType::PointerToAttribute >::iterator HWIte; typedef typename std::set<typename MeshType::PointerToAttribute >::iterator HWIte;
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){
switch(VoF) switch(VoF)
{ {
case 0: if(s == sizeof(A)){ case 0: 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)
memcpy(&h[i], (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion memcpy(&h[i], (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion
} }
else else
T::template AddAttrib<0>(m,name,s,data); T::template AddAttrib<0>(m,name,s,data);
break; break;
case 1: if(s == sizeof(A)){ case 1: if(s == sizeof(A)){
typename MeshType::template PerFaceAttributeHandle<A> h = vcg::tri::Allocator<MeshType>:: template AddPerFaceAttribute<A>(m,name); typename MeshType::template PerFaceAttributeHandle<A> h = vcg::tri::Allocator<MeshType>:: template AddPerFaceAttribute<A>(m,name);
for(unsigned int i = 0; i < m.face.size(); ++i) for(unsigned int i = 0; i < m.face.size(); ++i)
memcpy(&h[i], (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion memcpy(&h[i], (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion
} }
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
} }
else else
T::template AddAttrib<2>(m,name,s,data); T::template AddAttrib<2>(m,name,s,data);
break; break;
default:break; default:break;
} }
} }
}; };
/** this class is for testing the list of increasing size types until one is larger than the size of the unknown type /** this class is for testing the list of increasing size types until one is larger than the size of the unknown type
*/ */
template <class MeshType, class A, class T> template <class MeshType, class A, class T>
struct DerK:public T{ struct DerK:public T{
typedef typename std::set<typename MeshType::PointerToAttribute >::iterator HWIte; typedef typename std::set<typename MeshType::PointerToAttribute >::iterator HWIte;
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){
switch(VoF){ switch(VoF){
case 0: case 0:
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)
memcpy((void*) &(h[i]), (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion memcpy((void*) &(h[i]), (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion
} }
else else
if(s < sizeof(A)){ if(s < sizeof(A)){
// padding // padding
int padd = sizeof(A) - s; int padd = sizeof(A) - s;
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){
char * dest = &((char*)(&h[i]))[0]; char * dest = &((char*)(&h[i]))[0];
memcpy( (void *)dest , (void*) &((A*)data)[i],s); // we don't want the type conversion memcpy( (void *)dest , (void*) &((A*)data)[i],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.vert_attr.find(pa); HWIte res = m.vert_attr.find(pa);
pa = *res; pa = *res;
m.vert_attr.erase(res); m.vert_attr.erase(res);
pa._padding = padd; pa._padding = padd;
std::pair<HWIte,bool > new_pa = m.vert_attr.insert(pa); std::pair<HWIte,bool > new_pa = m.vert_attr.insert(pa);
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)
memcpy((void*) &(h[i]), (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion memcpy((void*) &(h[i]), (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion
} }
else else
if(s < sizeof(A)){ if(s < sizeof(A)){
// padding // padding
int padd = sizeof(A) - s; int padd = sizeof(A) - s;
typename MeshType::template PerFaceAttributeHandle<A> h = vcg::tri::Allocator<MeshType>::template AddPerFaceAttribute<A>(m,name); typename MeshType::template PerFaceAttributeHandle<A> h = vcg::tri::Allocator<MeshType>::template AddPerFaceAttribute<A>(m,name);
for(unsigned int i = 0; i < m.face.size(); ++i){ for(unsigned int i = 0; i < m.face.size(); ++i){
char * dest = &((char*)(&h[i]))[0]; char * dest = &((char*)(&h[i]))[0];
memcpy( (void *)dest , (void*) &((A*)data)[i],s); // we don't want the type conversion memcpy( (void *)dest , (void*) &((A*)data)[i],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.face_attr.find(pa); HWIte res = m.face_attr.find(pa);
pa = *res; pa = *res;
m.face_attr.erase(res); m.face_attr.erase(res);
pa._padding = padd; pa._padding = padd;
std::pair<HWIte,bool > new_pa = m.face_attr.insert(pa); std::pair<HWIte,bool > new_pa = m.face_attr.insert(pa);
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)){
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((void*)&h(), (void*)((A*)data),sizeof(A)); // we don't want the type conversion memcpy((void*)&h(), (void*)((A*)data),sizeof(A)); // we don't want the type conversion
} }
else else
if(s < sizeof(A)){ if(s < sizeof(A)){
// padding // padding
int padd = sizeof(A) - s; int padd = sizeof(A) - s;
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);
pa = *res; pa = *res;
m.mesh_attr.erase(res); m.mesh_attr.erase(res);
pa._padding = padd; pa._padding = padd;
std::pair<HWIte,bool > new_pa = m.mesh_attr.insert(pa); std::pair<HWIte,bool > new_pa = m.mesh_attr.insert(pa);
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;
} }
} }
}; };
/** /**
This is the templated derivation chain This is the templated derivation chain
*/ */
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);
} }
}; };
template <class MeshType, class B0 > struct K0 : public DerK< MeshType, B0, K<MeshType> > {}; template <class MeshType, class B0 > struct K0 : public DerK< MeshType, B0, K<MeshType> > {};
template <class MeshType, class B0, class B1 > struct K1 : public DerK< MeshType, B1, K0<MeshType, B0> > {}; template <class MeshType, class B0, class B1 > struct K1 : public DerK< MeshType, B1, K0<MeshType, B0> > {};
template <class MeshType, class B0, class B1, class B2 > struct K2 : public DerK< MeshType, B2, K1<MeshType, B0, B1> > {}; template <class MeshType, class B0, class B1, class B2 > struct K2 : public DerK< MeshType, B2, K1<MeshType, B0, B1> > {};
template <class MeshType, class B0, class B1, class B2,class B3> struct K3 : public DerK< MeshType, B3, K2<MeshType, B0, B1, B2> > {}; template <class MeshType, class B0, class B1, class B2,class B3> struct K3 : public DerK< MeshType, B3, K2<MeshType, B0, B1, B2> > {};
template <class MeshType, class B0, class B1, class B2,class B3,class B4> struct K4 : public DerK< MeshType, B4, K3<MeshType, B0, B1, B2, B3> > {}; template <class MeshType, class B0, class B1, class B2,class B3,class B4> struct K4 : public DerK< MeshType, B4, K3<MeshType, B0, B1, B2, B3> > {};
template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5> struct K5 : public DerK< MeshType, B5, K4<MeshType, B0, B1, B2, B3, B4> > {}; template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5> struct K5 : public DerK< MeshType, B5, K4<MeshType, B0, B1, B2, B3, B4> > {};
template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6> struct K6 : public DerK< MeshType, B6, K5<MeshType, B0, B1, B2, B3, B4, B5> > {}; template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6> struct K6 : public DerK< MeshType, B6, K5<MeshType, B0, B1, B2, B3, B4, B5> > {};
template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7> struct K7 : public DerK< MeshType, B7, K6<MeshType, B0, B1, B2, B3, B4, B5, B6> > {}; template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7> struct K7 : public DerK< MeshType, B7, K6<MeshType, B0, B1, B2, B3, B4, B5, B6> > {};
template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7,class B8> struct K8 : public DerK< MeshType, B8, K7<MeshType, B0, B1, B2, B3, B4, B5, B6, B7> > {}; template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7,class B8> struct K8 : public DerK< MeshType, B8, K7<MeshType, B0, B1, B2, B3, B4, B5, B6, B7> > {};
template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7,class B8,class B9> struct K9 : public DerK< MeshType, B9, K8<MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8> > {}; template <class MeshType, class B0, class B1, class B2,class B3,class B4,class B5,class B6,class B7,class B8,class B9> struct K9 : public DerK< MeshType, B9, K8<MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8> > {};
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> struct K10 : public DerK< MeshType, B10, K9<MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9> > {}; 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> struct K10 : public DerK< MeshType, B10, K9<MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9> > {};
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> > {};
template <class MeshType, class A0, class A1, class A2> struct C2 : public Der< MeshType, A2, C1<MeshType, A0, A1> > {}; template <class MeshType, class A0, class A1, class A2> struct C2 : public Der< MeshType, A2, C1<MeshType, A0, A1> > {};
template <class MeshType, class A0, class A1, class A2,class A3> struct C3 : public Der< MeshType, A3, C2<MeshType, A0, A1, A2> > {}; template <class MeshType, class A0, class A1, class A2,class A3> struct C3 : public Der< MeshType, A3, C2<MeshType, A0, A1, A2> > {};
template <class MeshType, class A0, class A1, class A2,class A3,class A4> struct AttrAll : public Der< MeshType, A4, C3<MeshType, A0, A1, A2, A3> > {}; template <class MeshType, class A0, class A1, class A2,class A3,class A4> struct AttrAll : public Der< MeshType, A4, C3<MeshType, A0, A1, A2, A3> > {};
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);
@ -254,9 +254,9 @@ namespace io {
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);
@ -310,7 +310,7 @@ namespace io {
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;
// vertex quality // vertex quality
@ -504,52 +504,52 @@ namespace io {
} }
}; };
static int FaceMaskBitFromString(std::string s){ static int FaceMaskBitFromString(std::string s){
if( s.find("Color",0) != std::string::npos ) return Mask::IOM_FACECOLOR; else if( s.find("Color",0) != std::string::npos ) return Mask::IOM_FACECOLOR; else
if( s.find("BitFlags",0) != std::string::npos ) return Mask::IOM_FACEFLAGS; else if( s.find("BitFlags",0) != std::string::npos ) return Mask::IOM_FACEFLAGS; else
if( s.find("VertexRef",0) != std::string::npos ) return Mask::IOM_FACEINDEX; else if( s.find("VertexRef",0) != std::string::npos ) return Mask::IOM_FACEINDEX; else
if( s.find("Normal",0) != std::string::npos ) return Mask::IOM_FACENORMAL; else if( s.find("Normal",0) != std::string::npos ) return Mask::IOM_FACENORMAL; else
if( s.find("Quality",0) != std::string::npos ) return Mask::IOM_FACEQUALITY; else if( s.find("Quality",0) != std::string::npos ) return Mask::IOM_FACEQUALITY; else
if( s.find("Quality",0) != std::string::npos ) return Mask::IOM_FACEQUALITY; else if( s.find("Quality",0) != std::string::npos ) return Mask::IOM_FACEQUALITY; else
if( s.find("WedgeColor",0) != std::string::npos ) return Mask::IOM_WEDGCOLOR; else if( s.find("WedgeColor",0) != std::string::npos ) return Mask::IOM_WEDGCOLOR; else
if( s.find("WedgeNormal",0) != std::string::npos ) return Mask::IOM_WEDGNORMAL; else if( s.find("WedgeNormal",0) != std::string::npos ) return Mask::IOM_WEDGNORMAL; else
if( s.find("WedgeTexCoord",0) != std::string::npos) return Mask::IOM_WEDGTEXCOORD; else if( s.find("WedgeTexCoord",0) != std::string::npos) return Mask::IOM_WEDGTEXCOORD; else
return 0; return 0;
} }
static int VertexMaskBitFromString(std::string s){ static int VertexMaskBitFromString(std::string s){
if( s.find("Color",0) != std::string::npos ) return Mask::IOM_VERTCOLOR; else if( s.find("Color",0) != std::string::npos ) return Mask::IOM_VERTCOLOR; else
if( s.find("Coord",0) != std::string::npos ) return Mask::IOM_VERTCOORD; else if( s.find("Coord",0) != std::string::npos ) return Mask::IOM_VERTCOORD; else
if( s.find("BitFlags",0) != std::string::npos ) return Mask::IOM_VERTFLAGS; else if( s.find("BitFlags",0) != std::string::npos ) return Mask::IOM_VERTFLAGS; else
if( s.find("Quality",0) != std::string::npos ) return Mask::IOM_VERTQUALITY; else if( s.find("Quality",0) != std::string::npos ) return Mask::IOM_VERTQUALITY; else
if( s.find("Normal",0) != std::string::npos ) return Mask::IOM_VERTNORMAL; else if( s.find("Normal",0) != std::string::npos ) return Mask::IOM_VERTNORMAL; else
if( s.find("TexCoord",0) != std::string::npos ) return Mask::IOM_VERTTEXCOORD; else if( s.find("TexCoord",0) != std::string::npos ) return Mask::IOM_VERTTEXCOORD; else
if( s.find("Radius",0) != std::string::npos ) return Mask::IOM_VERTRADIUS; else if( s.find("Radius",0) != std::string::npos ) return Mask::IOM_VERTRADIUS; else
return 0; return 0;
} }
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);}
typedef typename OpenMeshType::FaceType FaceType; typedef typename OpenMeshType::FaceType FaceType;
typedef typename OpenMeshType::FaceContainer FaceContainer; typedef typename OpenMeshType::FaceContainer FaceContainer;
typedef typename OpenMeshType::FaceIterator FaceIterator; typedef typename OpenMeshType::FaceIterator FaceIterator;
typedef typename OpenMeshType::VertContainer VertContainer; typedef typename OpenMeshType::VertContainer VertContainer;
typedef typename OpenMeshType::VertexIterator VertexIterator; typedef typename OpenMeshType::VertexIterator VertexIterator;
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,
VMI_FAILED_OPEN VMI_FAILED_OPEN
}; };
/*! /*!
* Standard call for knowing the meaning of an error code * Standard call for knowing the meaning of an error code
@ -572,52 +572,52 @@ namespace io {
return error_msg[message_code]; return error_msg[message_code];
}; };
/* Read the info about the mesh. Note: in the header the bounding box is always written/readed /* Read the info about the mesh. Note: in the header the bounding box is always written/readed
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){
std::string name; std::string name;
unsigned int nameFsize,nameVsize,i; unsigned int nameFsize,nameVsize,i;
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();
ReadString( name); ReadString( name);
ReadInt( vertSize); ReadInt( vertSize);
ReadString( name); ReadString( name);
float float_value; float float_value;
for(unsigned int i =0; i < 2; ++i){ReadFloat( float_value); bbox.min[i]=float_value;} for(unsigned int i =0; i < 2; ++i){ReadFloat( float_value); bbox.min[i]=float_value;}
for(unsigned int i =0; i < 2; ++i){ReadFloat( float_value); bbox.max[i]=float_value;} for(unsigned int i =0; i < 2; ++i){ReadFloat( float_value); bbox.max[i]=float_value;}
ReadString( name); ReadString( name);
assert(strstr( name.c_str(),"end_header")!=NULL); assert(strstr( name.c_str(),"end_header")!=NULL);
return true; return true;
} }
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 const char * & In_mem(){static const char * in_mem; return in_mem;} static const char * & In_mem(){static const char * in_mem; return in_mem;}
@ -639,28 +639,28 @@ 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;
GetHeader(nameV,nameF,vertSize, faceSize, bbox, mask); GetHeader(nameV,nameF,vertSize, faceSize, bbox, mask);
return true; return true;
} }
static bool LoadMaskFromMem( const char * ptr, int & mask){ static bool LoadMaskFromMem( const char * ptr, 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;
In_mode() = 0; In_mode() = 0;
pos() = 0; pos() = 0;
In_mem() = ptr; In_mem() = ptr;
GetHeader(nameV,nameF,vertSize, faceSize, bbox, mask); GetHeader(nameV,nameF,vertSize, faceSize, bbox, mask);
return true; return true;
} }
static int Open(OpenMeshType &m, const char * filename, int & mask,CallBackPos * /*cb*/ = 0 ) { static int Open(OpenMeshType &m, const char * filename, int & mask,CallBackPos * /*cb*/ = 0 ) {
In_mode() = 1; In_mode() = 1;
@ -685,8 +685,8 @@ namespace io {
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;
@ -702,13 +702,13 @@ namespace io {
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 );
@ -719,35 +719,35 @@ namespace io {
Read(&m.C(),sizeof(Color4b),1 ); Read(&m.C(),sizeof(Color4b),1 );
/* resize the vector of vertices */ /* resize the vector of vertices */
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);
} }
read = 0; read = 0;
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());
@ -755,56 +755,56 @@ namespace io {
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);
} }
/* load the per mesh attributes */ /* load the per mesh attributes */
ReadString( _trash); ReadInt( n); ReadString( _trash); ReadInt( n);
for(unsigned int ia = 0 ; ia < n; ++ia){ for(unsigned int 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); 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);
} }
if(!m.face.empty()){ if(!m.face.empty()){
if(FaceVectorHasVFAdjacency(m.face)) if(FaceVectorHasVFAdjacency(m.face))
for(vi = m.vert.begin(); vi != m.vert.end(); ++vi){ for(vi = m.vert.begin(); vi != m.vert.end(); ++vi){
(*vi).VFp() = (*vi).VFp()-(FaceType*)offsetF+ &m.face[0]; (*vi).VFp() = (*vi).VFp()-(FaceType*)offsetF+ &m.face[0];
(*vi).VFp() = (*vi).VFp()-(FaceType*)offsetF+ &m.face[0]; (*vi).VFp() = (*vi).VFp()-(FaceType*)offsetF+ &m.face[0];
(*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];
(*fi).FFp(2) = (*fi).FFp(2)-(FaceType*)offsetF+ &m.face[0]; (*fi).FFp(2) = (*fi).FFp(2)-(FaceType*)offsetF+ &m.face[0];
} }
} }
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
} // end Namespace tri } // end Namespace tri