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

added support for vertex attributes 

experimental. next: test / factorize / extend to faces and edges
This commit is contained in:
ganovelli 2009-07-29 13:44:00 +00:00
parent 286ac9162a
commit 8484f4522e
2 changed files with 462 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
wrap/io_trimesh/export_vmi.h
View File

@ -51,6 +51,8 @@ namespace vcg {
namespace tri {
namespace io {
template <int N> struct PlaceHolderType{ char A[N];};
template <class SaveMeshType>
class ExporterVMI
{
@ -58,6 +60,7 @@ namespace io {
typedef typename SaveMeshType::FaceIterator FaceIterator;
typedef typename SaveMeshType::VertexIterator VertexIterator;
typedef typename SaveMeshType::VertexType VertexType;
typedef SimpleTempDataBase<typename SaveMeshType::VertContainer> STDB;
static void Save(const SaveMeshType &m,char * filename){
unsigned int i;
@ -80,14 +83,17 @@ namespace io {
fprintf(f,"end_header\n");
if(vertSize!=0){
unsigned int offsetV = (unsigned int) &m.vert[0];
/* write the address of the first vertex */
fwrite(&offsetV,sizeof(unsigned int),1,f);
}
if(faceSize!=0){
int offsetF= ( int) &m.face[0];
/* write the address of the first face */
fwrite(&offsetF,sizeof( int),1,f);
}
/* save the object mesh */
fwrite(&m.shot,sizeof(Shot<typename SaveMeshType::ScalarType>),1,f);
fwrite(&m.vn,sizeof(int),1,f);
@ -97,13 +103,50 @@ namespace io {
fwrite(&m.C(),sizeof(Color4b),1,f);
int written;
if(vertSize!=0){
/* save the vertices */
written = fwrite((void*)&m.vert[0],sizeof(typename SaveMeshType::VertexType),m.vert.size(),f);
assert(written==m.vert.size());
}
if(faceSize!=0){
/* save the faces */
written = fwrite((void*)&m.face[0],sizeof(typename SaveMeshType::FaceType),m.face.size(),f);
assert(written==m.face.size());
}
/* save the attribtues */
typename std::set< SaveMeshType::PointerToAttribute>::const_iterator ai;
/* save the per vertex attributes */
fprintf(f,"N_PER_VERTEX_ATTRIBUTES %d \n",m.vert_attr.size());
for(ai = m.vert_attr.begin(); ai != m.vert_attr.end(); ++ai){
STDB * stdb = (STDB *) (*ai)._handle;
fprintf(f,"PER_VERTEX_ATTR_NAME %s \n",(*ai)._name.c_str());
fprintf(f,"PER_VERTEX_ATTR_SIZE %d \n",stdb->SizeOf() );
fwrite(stdb->DataBegin(),m.vert.size(),stdb->SizeOf(),f);
}
///* save the per face attributes */
//fprintf(f,"N_PER_FACE_ATTRIBUTES %d\n",m.face_attr.size());
//for(ai = m.face_attr.begin(); ai != m.face_attr.end(); ++ai){
// SimpleTempDataBase<SaveMeshType::FaceContainer>* handle;
// fprintf(f,"PER_FACE_ATTR_NAME %s\n",(*ai)._name.c_str());
// fprintf(f,"PER_FACE_ATTR_SIZE %d\n",(*ai)._handle->SizeOf() );
// fwrite((*ai)._handle->DataBegin(),m.face.size(),(*ai)._handle->SizeOf(),f);
// }
///* save the per mesh attributes */
//fprintf(f,"N_PER_MESH_ATTRIBUTES %d\n",m.mesh_attr.size());
//for(ai = m.mesh_attr.begin(); ai != m.mesh_attr.end(); ++ai){
// AttributeBase * handle = (AttributeBase *) (*ai)._handle ;
// fprintf(f,"PER_MESH_ATTR_NAME %s\n",(*ai)._name.c_str());
// fprintf(f,"PER_MESH_ATTR_SIZE %d\n",(*ai)._handle->SizeOf() );
// fwrite((*ai)._handle->DataBegin(),1,(*ai)._handle->SizeOf(),f);
// }
// fflush(f);
fclose(f);

121
wrap/io_trimesh/import_vmi.h
View File

@ -52,8 +52,102 @@ namespace vcg {
namespace tri {
namespace io {
template <class OpenMeshType>
class ImporterVMI
/* derivation chain */
template <int N> struct DummyType{ char placeholder[N]; };
template <class MeshType, class A, class T>
struct Der:public T{
typedef typename std::set<typename MeshType::PointerToAttribute >::iterator HWIte;
static void AddAttrib(MeshType &m, char * name, int s, void * data){
if(s == sizeof(A)){
typename MeshType::template PerVertexAttributeHandle<A> h = vcg::tri::Allocator<MeshType>:: template AddPerVertexAttribute<A>(m,name);
for(int i = 0; i < m.vert.size(); ++i)
memcpy(&h[i], (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion
}
else
T::AddAttrib(m,name,s,data);
}
};
template <class MeshType, class A, class T>
struct DerK:public T{
typedef typename std::set<typename MeshType::PointerToAttribute >::iterator HWIte;
static void AddAttrib(MeshType &m, char * name, int s, void * data){
if(s == sizeof(A)){
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)
memcpy((void*) &(h[i]), (void*) &((A*)data)[i],sizeof(A)); // we don't want the type conversion
}
else
if(s < sizeof(A)){
// padding
int padd = sizeof(A) - s;
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){
char * dest = &((char*)(&h[i]))[padd];
memcpy( (void *)dest , (void*) &((A*)data)[i],s); // we don't want the type conversion
}
typename MeshType::PointerToAttribute pa;
pa._name = std::string(name);
HWIte res = m.vert_attr.find(pa);
pa = *res;
m.vert_attr.erase(res);
pa._padding = padd;
std::pair<HWIte,bool > new_pa = m.vert_attr.insert(pa);
assert(new_pa.second);
}
else
T::AddAttrib(m,name,s,data);
}
};
template <class MeshType> struct K {
static void AddAttrib(MeshType &m, char * name, int s, void * data){
assert(0);
}
};
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, 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,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,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,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,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,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,
class B0 = DummyType<1048576>,
class B1 = DummyType<2048>,
class B2 = DummyType<1024>,
class B3 = DummyType<512>,
class B4 = DummyType<256>,
class B5 = DummyType<128>,
class B6 = DummyType<64>,
class B7 = DummyType<32>,
class B8 = DummyType<16>,
class B9 = DummyType<8>,
class B10 = DummyType<4>,
class B11 = DummyType<2>,
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> > {};
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,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> > {};
/* end derivation chain */
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>
{
public:
typedef typename OpenMeshType::FaceIterator FaceIterator;
@ -90,8 +184,9 @@ namespace io {
return GetHeader(f,nameV, nameF, vertSize, faceSize);
fclose(f);
}
static bool Open(OpenMeshType &m,char * filename){
int i;
typedef typename OpenMeshType::VertexType VertexType;
typedef typename OpenMeshType::FaceType FaceType;
typename OpenMeshType::FaceIterator fi;
@ -112,9 +207,12 @@ namespace io {
if(fnameF != nameF) return false;
int offsetV,offsetF;
if(vertSize!=0)
/* read the address of the first vertex */
fread(&offsetV,sizeof( int),1,f);
if(faceSize!=0)
/* read the address of the first face */
fread(&offsetF,sizeof( int),1,f);
@ -126,9 +224,11 @@ namespace io {
fread(&m.bbox,sizeof(Box3<typename OpenMeshType::ScalarType>),1,f);
fread(&m.C(),sizeof(Color4b),1,f);
/* resize the vector of vertices */
m.vert.resize(vertSize);
int read = 0;
/* load the vertices */
if(vertSize>0)
@ -145,6 +245,21 @@ namespace io {
assert(!feof(f));
assert(read==faceSize);
/* load the per vertex attributes */
char _string[65536],_trash[65536];
int n,sz;
fscanf(f,"%s %d",&_trash[0],&n);
for(int ia = 0 ; ia < n; ++ia){
fscanf(f,"%s %s",&_trash[0],&_string[0]);
fscanf(f,"%s %d",&_trash[0],&sz);
void * data = malloc(sz*m.vert.size());
fread(data,sz,m.vert.size(),f);
AddAttrib(m,_string,sz,data);
free(data);
}
if(FaceType::HasVFAdjacency())
for(vi = m.vert.begin(); vi != m.vert.end(); ++vi){
(*vi).VFp() = (*vi).VFp()-(FaceType*)offsetF+ &m.face[0];