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

(nothing, really: comment cleanup, indent, beautification, translation...)

This commit is contained in:
mtarini 2013-06-04 11:55:33 +00:00
parent 6b7ca162ce
commit 2c3d20ca40
1 changed files with 314 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

566
wrap/io_trimesh/import_ply.h
View File

@ -63,12 +63,10 @@ typedef typename OpenMeshType::VertexType VertexType;
typedef typename OpenMeshType::FaceType FaceType; typedef typename OpenMeshType::FaceType FaceType;
typedef typename OpenMeshType::VertexIterator VertexIterator; typedef typename OpenMeshType::VertexIterator VertexIterator;
typedef typename OpenMeshType::FaceIterator FaceIterator; typedef typename OpenMeshType::FaceIterator FaceIterator;
typedef typename OpenMeshType::EdgeIterator EdgeIterator; typedef typename OpenMeshType::EdgeIterator EdgeIterator;
//template <class T> int PlyType () { assert(0); return 0;}
#define MAX_USER_DATA 256 #define MAX_USER_DATA 256
// Struttura ausiliaria per la lettura del file ply // Auxiliary structure for reading ply files
struct LoadPly_FaceAux struct LoadPly_FaceAux
{ {
unsigned char size; unsigned char size;
@ -104,12 +102,12 @@ struct LoadPly_EdgeAux
// Yet another auxiliary data structure for loading some strange ply files // Yet another auxiliary data structure for loading some strange ply files
// the original stanford range data... // the original stanford range data...
struct LoadPly_RangeGridAux { struct LoadPly_RangeGridAux {
unsigned char num_pts; unsigned char num_pts;
int pts[5]; int pts[5];
}; };
// Struttura ausiliaria per la lettura del file ply // Auxiliary structure to load vertex data
template<class S> template<class S>
struct LoadPly_VertAux struct LoadPly_VertAux
{ {
@ -126,7 +124,7 @@ struct LoadPly_VertAux
float u,v,w; float u,v,w;
}; };
// Struttura ausiliaria caricamento camera // Auxiliary structure to load the camera
struct LoadPly_Camera struct LoadPly_Camera
{ {
float view_px; float view_px;
@ -169,25 +167,25 @@ static const PropDescriptor &VertDesc(int i)
/*08*/ {"vertex", "diffuse_red" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,r),0,0,0,0,0 ,0}, /*08*/ {"vertex", "diffuse_red" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,r),0,0,0,0,0 ,0},
/*09*/ {"vertex", "diffuse_green", ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,g),0,0,0,0,0 ,0}, /*09*/ {"vertex", "diffuse_green", ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,g),0,0,0,0,0 ,0},
/*10*/ {"vertex", "diffuse_blue" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,b),0,0,0,0,0 ,0}, /*10*/ {"vertex", "diffuse_blue" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,b),0,0,0,0,0 ,0},
/*11*/ {"vertex", "confidence",ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,q),0,0,0,0,0 ,0}, /*11*/ {"vertex", "confidence", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,q),0,0,0,0,0 ,0},
/*12*/ {"vertex", "nx", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) ,0,0,0,0,0 ,0}, /*12*/ {"vertex", "nx", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) ,0,0,0,0,0 ,0},
/*13*/ {"vertex", "ny", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) + 1*sizeof(ScalarType),0,0,0,0,0 ,0}, /*13*/ {"vertex", "ny", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) + 1*sizeof(ScalarType),0,0,0,0,0 ,0},
/*14*/ {"vertex", "nz", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) + 2*sizeof(ScalarType),0,0,0,0,0 ,0}, /*14*/ {"vertex", "nz", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) + 2*sizeof(ScalarType),0,0,0,0,0 ,0},
/*15*/ {"vertex", "radius", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,radius),0,0,0,0,0 ,0}, /*15*/ {"vertex", "radius", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,radius),0,0,0,0,0 ,0},
/*16*/ {"vertex", "texture_u", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,u),0,0,0,0,0 ,0}, /*16*/ {"vertex", "texture_u", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,u),0,0,0,0,0 ,0},
/*17*/ {"vertex", "texture_v", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,v),0,0,0,0,0 ,0}, /*17*/ {"vertex", "texture_v", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,v),0,0,0,0,0 ,0},
/*18*/ {"vertex", "texture_w", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,w),0,0,0,0,0 ,0}, /*18*/ {"vertex", "texture_w", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,w),0,0,0,0,0 ,0},
/*19*/ {"vertex", "intensity", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,intensity),0,0,0,0,0 ,0}, /*19*/ {"vertex", "intensity", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,intensity),0,0,0,0,0 ,0},
/*20*/ {"vertex", "s", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,u),0,0,0,0,0 ,0}, /*20*/ {"vertex", "s", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,u),0,0,0,0,0 ,0},
/*21*/ {"vertex", "t", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,v),0,0,0,0,0 ,0}, /*21*/ {"vertex", "t", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,v),0,0,0,0,0 ,0},
// DOUBLE // DOUBLE
/*22*/ {"vertex", "x", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p),0,0,0,0,0 ,0}, /*22*/ {"vertex", "x", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p),0,0,0,0,0 ,0},
/*23*/ {"vertex", "y", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p) + sizeof(ScalarType),0,0,0,0,0 ,0}, /*23*/ {"vertex", "y", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p) + sizeof(ScalarType) ,0,0,0,0,0 ,0},
/*24*/ {"vertex", "z", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p) + 2*sizeof(ScalarType),0,0,0,0,0 ,0}, /*24*/ {"vertex", "z", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p) + 2*sizeof(ScalarType),0,0,0,0,0 ,0},
/*25*/ {"vertex", "nx", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) ,0,0,0,0,0 ,0}, /*25*/ {"vertex", "nx", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) ,0,0,0,0,0 ,0},
/*26*/ {"vertex", "ny", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) + 1*sizeof(ScalarType),0,0,0,0,0 ,0}, /*26*/ {"vertex", "ny", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) + 1*sizeof(ScalarType),0,0,0,0,0 ,0},
/*27*/ {"vertex", "nz", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) + 2*sizeof(ScalarType),0,0,0,0,0 ,0}, /*27*/ {"vertex", "nz", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,n) + 2*sizeof(ScalarType),0,0,0,0,0 ,0},
/*28*/ {"vertex", "radius", ply::T_DOUBLE, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,radius),0,0,0,0,0 ,0}, /*28*/ {"vertex", "radius", ply::T_DOUBLE, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,radius),0,0,0,0,0 ,0},
}; };
return pv[i]; return pv[i];
@ -199,44 +197,44 @@ static const PropDescriptor &FaceDesc(int i)
{ {
static const PropDescriptor qf[_FACEDESC_LAST_]= static const PropDescriptor qf[_FACEDESC_LAST_]=
{ {
/* on file on memory on file on memory */ /* on file on memory on file on memory */
/* 0 */ {"face", "vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR,ply::T_UCHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 0 */ {"face", "vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR, ply::T_UCHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 1 */ {"face", "flags", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,flags), 0,0,0,0,0 ,0}, /* 1 */ {"face", "flags", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,flags), 0,0,0,0,0 ,0},
/* 2 */ {"face", "quality", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_FaceAux,q), 0,0,0,0,0 ,0}, /* 2 */ {"face", "quality", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_FaceAux,q), 0,0,0,0,0 ,0},
/* 3 */ {"face", "texcoord", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_FaceAux,texcoord), 1,0,ply::T_UCHAR,ply::T_UCHAR,offsetof(LoadPly_FaceAux,ntexcoord) ,0}, /* 3 */ {"face", "texcoord", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_FaceAux,texcoord), 1,0,ply::T_UCHAR, ply::T_UCHAR,offsetof(LoadPly_FaceAux,ntexcoord) ,0},
/* 4 */ {"face", "color", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_FaceAux,colors), 1,0,ply::T_UCHAR,ply::T_UCHAR,offsetof(LoadPly_FaceAux,ncolors) ,0}, /* 4 */ {"face", "color", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_FaceAux,colors), 1,0,ply::T_UCHAR, ply::T_UCHAR,offsetof(LoadPly_FaceAux,ncolors) ,0},
/* 5 */ {"face", "texnumber", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,texcoordind), 0,0,0,0,0 ,0}, /* 5 */ {"face", "texnumber", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,texcoordind), 0,0,0,0,0 ,0},
/* 6 */ {"face", "red" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_FaceAux,r), 0,0,0,0,0 ,0}, /* 6 */ {"face", "red" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_FaceAux,r), 0,0,0,0,0 ,0},
/* 7 */ {"face", "green", ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_FaceAux,g), 0,0,0,0,0 ,0}, /* 7 */ {"face", "green", ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_FaceAux,g), 0,0,0,0,0 ,0},
/* 8 */ {"face", "blue" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_FaceAux,b), 0,0,0,0,0 ,0}, /* 8 */ {"face", "blue" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_FaceAux,b), 0,0,0,0,0 ,0},
/* 9 */ {"face", "vertex_index", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR,ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 9 */ {"face", "vertex_index", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 10 */ {"face", "vertex_index", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_CHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 10 */ {"face", "vertex_index", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_CHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 11 */ {"face", "vertex_index", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_INT, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 11 */ {"face", "vertex_index", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_INT, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 12 */ {"face", "vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_CHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 12 */ {"face", "vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_CHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 13 */ {"face", "vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_INT, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 13 */ {"face", "vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_INT, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 14 */ {"face", "vertex_indices", ply::T_UINT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR,ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 14 */ {"face", "vertex_indices", ply::T_UINT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 15 */ {"face", "vertex_indices", ply::T_UINT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_CHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 15 */ {"face", "vertex_indices", ply::T_UINT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_CHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 16 */ {"face", "vertex_indices", ply::T_UINT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_INT, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 16 */ {"face", "vertex_indices", ply::T_UINT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_INT, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 17 */ {"face", "vertex_indices", ply::T_SHORT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_CHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 17 */ {"face", "vertex_indices", ply::T_SHORT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_CHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 18 */ {"face", "vertex_indices", ply::T_SHORT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR,ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 18 */ {"face", "vertex_indices", ply::T_SHORT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 19 */ {"face", "vertex_indices", ply::T_SHORT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_INT, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}, /* 19 */ {"face", "vertex_indices", ply::T_SHORT, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_INT, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0},
/* 20 */ {"face", "vertex_indices", ply::T_CHAR, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0} /* 20 */ {"face", "vertex_indices", ply::T_CHAR, ply::T_INT, offsetof(LoadPly_FaceAux,v), 1,0,ply::T_UCHAR, ply::T_CHAR,offsetof(LoadPly_FaceAux,size) ,0}
}; };
return qf[i]; return qf[i];
} }
static const PropDescriptor &TristripDesc(int i) static const PropDescriptor &TristripDesc(int i)
{ {
static const PropDescriptor qf[1]= static const PropDescriptor qf[1]=
{ {
{"tristrips","vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_TristripAux,v), 1,1,ply::T_INT,ply::T_INT,offsetof(LoadPly_TristripAux,size) ,0}, {"tristrips","vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_TristripAux,v), 1,1,ply::T_INT,ply::T_INT,offsetof(LoadPly_TristripAux,size) ,0},
}; };
return qf[i]; return qf[i];
} }
static const PropDescriptor &EdgeDesc(int i) static const PropDescriptor &EdgeDesc(int i)
{ {
static const PropDescriptor qf[2]= static const PropDescriptor qf[2]=
{ {
{"edge","vertex1", ply::T_INT, ply::T_INT, offsetof(LoadPly_EdgeAux,v1), 0,0,0,0,0 ,0}, {"edge","vertex1", ply::T_INT, ply::T_INT, offsetof(LoadPly_EdgeAux,v1), 0,0,0,0,0 ,0},
{"edge","vertex2", ply::T_INT, ply::T_INT, offsetof(LoadPly_EdgeAux,v2), 0,0,0,0,0 ,0}, {"edge","vertex2", ply::T_INT, ply::T_INT, offsetof(LoadPly_EdgeAux,v2), 0,0,0,0,0 ,0},
@ -249,8 +247,8 @@ static const PropDescriptor &EdgeDesc(int i)
static const PropDescriptor &RangeDesc(int i) static const PropDescriptor &RangeDesc(int i)
{ {
static const PropDescriptor range_props[1] = { static const PropDescriptor range_props[1] = {
{"range_grid","vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_RangeGridAux,pts), 1, 0, ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_RangeGridAux,num_pts),0}, {"range_grid","vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_RangeGridAux,pts), 1, 0, ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_RangeGridAux,num_pts),0},
}; };
return range_props[i]; return range_props[i];
} }
@ -288,36 +286,36 @@ static const PropDescriptor &CameraDesc(int i)
/// Standard call for knowing the meaning of an error code /// Standard call for knowing the meaning of an error code
static const char *ErrorMsg(int error) static const char *ErrorMsg(int error)
{ {
static std::vector<std::string> ply_error_msg; static std::vector<std::string> ply_error_msg;
if(ply_error_msg.empty()) if(ply_error_msg.empty())
{ {
ply_error_msg.resize(PlyInfo::E_MAXPLYINFOERRORS ); ply_error_msg.resize(PlyInfo::E_MAXPLYINFOERRORS );
ply_error_msg[ply::E_NOERROR ]="No errors"; ply_error_msg[ply::E_NOERROR ]="No errors";
ply_error_msg[ply::E_CANTOPEN ]="Can't open file"; ply_error_msg[ply::E_CANTOPEN ]="Can't open file";
ply_error_msg[ply::E_NOTHEADER ]="Header not found"; ply_error_msg[ply::E_NOTHEADER ]="Header not found";
ply_error_msg[ply::E_UNESPECTEDEOF ]="Eof in header"; ply_error_msg[ply::E_UNESPECTEDEOF ]="Eof in header";
ply_error_msg[ply::E_NOFORMAT ]="Format not found"; ply_error_msg[ply::E_NOFORMAT ]="Format not found";
ply_error_msg[ply::E_SYNTAX ]="Syntax error on header"; ply_error_msg[ply::E_SYNTAX ]="Syntax error on header";
ply_error_msg[ply::E_PROPOUTOFELEMENT]="Property without element"; ply_error_msg[ply::E_PROPOUTOFELEMENT]="Property without element";
ply_error_msg[ply::E_BADTYPENAME ]="Bad type name"; ply_error_msg[ply::E_BADTYPENAME ]="Bad type name";
ply_error_msg[ply::E_ELEMNOTFOUND ]="Element not found"; ply_error_msg[ply::E_ELEMNOTFOUND ]="Element not found";
ply_error_msg[ply::E_PROPNOTFOUND ]="Property not found"; ply_error_msg[ply::E_PROPNOTFOUND ]="Property not found";
ply_error_msg[ply::E_BADTYPE ]="Bad type on addtoread"; ply_error_msg[ply::E_BADTYPE ]="Bad type on addtoread";
ply_error_msg[ply::E_INCOMPATIBLETYPE]="Incompatible type"; ply_error_msg[ply::E_INCOMPATIBLETYPE]="Incompatible type";
ply_error_msg[ply::E_BADCAST ]="Bad cast"; ply_error_msg[ply::E_BADCAST ]="Bad cast";
ply_error_msg[PlyInfo::E_NO_VERTEX ]="No vertex field found"; ply_error_msg[PlyInfo::E_NO_VERTEX ]="No vertex field found";
ply_error_msg[PlyInfo::E_NO_FACE ]="No face field found"; ply_error_msg[PlyInfo::E_NO_FACE ]="No face field found";
ply_error_msg[PlyInfo::E_SHORTFILE ]="Unespected eof"; ply_error_msg[PlyInfo::E_SHORTFILE ]="Unespected eof";
ply_error_msg[PlyInfo::E_NO_3VERTINFACE ]="Face with more than 3 vertices"; ply_error_msg[PlyInfo::E_NO_3VERTINFACE ]="Face with more than 3 vertices";
ply_error_msg[PlyInfo::E_BAD_VERT_INDEX ]="Bad vertex index in face"; ply_error_msg[PlyInfo::E_BAD_VERT_INDEX ]="Bad vertex index in face";
ply_error_msg[PlyInfo::E_BAD_VERT_INDEX_EDGE ]="Bad vertex index in edge"; ply_error_msg[PlyInfo::E_BAD_VERT_INDEX_EDGE ]="Bad vertex index in edge";
ply_error_msg[PlyInfo::E_NO_6TCOORD ]="Face with no 6 texture coordinates"; ply_error_msg[PlyInfo::E_NO_6TCOORD ]="Face with no 6 texture coordinates";
ply_error_msg[PlyInfo::E_DIFFER_COLORS ]="Number of color differ from vertices"; ply_error_msg[PlyInfo::E_DIFFER_COLORS ]="Number of color differ from vertices";
} }
if(error>PlyInfo::E_MAXPLYINFOERRORS || error<0) return "Unknown error"; if(error>PlyInfo::E_MAXPLYINFOERRORS || error<0) return "Unknown error";
else return ply_error_msg[error].c_str(); else return ply_error_msg[error].c_str();
}; };
// to check if a given error is critical or not. // to check if a given error is critical or not.
@ -332,8 +330,8 @@ static bool ErrorCritical(int err)
static int Open( OpenMeshType &m, const char * filename, CallBackPos *cb=0) static int Open( OpenMeshType &m, const char * filename, CallBackPos *cb=0)
{ {
PlyInfo pi; PlyInfo pi;
pi.cb=cb; pi.cb=cb;
return Open(m, filename, pi); return Open(m, filename, pi);
} }
/// Read a mesh and store in loadmask the loaded field /// Read a mesh and store in loadmask the loaded field
@ -342,18 +340,18 @@ static int Open( OpenMeshType &m, const char * filename, CallBackPos *cb=0)
/// in the file are read in. /// in the file are read in.
static int Open( OpenMeshType &m, const char * filename, int & loadmask, CallBackPos *cb =0) static int Open( OpenMeshType &m, const char * filename, int & loadmask, CallBackPos *cb =0)
{ {
PlyInfo pi; PlyInfo pi;
pi.cb=cb; pi.cb=cb;
int r = Open(m, filename,pi); int r = Open(m, filename,pi);
loadmask=pi.mask; loadmask=pi.mask;
return r; return r;
} }
/// read a mesh with all the possible option specified in the PlyInfo obj, returns 0 on success. /// read a mesh with all the possible option specified in the PlyInfo obj, returns 0 on success.
static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi ) static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
{ {
assert(filename!=0); assert(filename!=0);
std::vector<VertexPointer> index; std::vector<VertexPointer> index;
LoadPly_FaceAux fa; LoadPly_FaceAux fa;
LoadPly_EdgeAux ea; LoadPly_EdgeAux ea;
@ -372,7 +370,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
va.flags = 42; va.flags = 42;
pi.status = ::vcg::ply::E_NOERROR; pi.status = ::vcg::ply::E_NOERROR;
/* /*
// TO BE REMOVED: tv not used AND "spurious" vertex declaration causes error if ocf // TO BE REMOVED: tv not used AND "spurious" vertex declaration causes error if ocf
@ -387,19 +385,19 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
// Descrittori delle strutture // Descrittori delle strutture
//bool isvflags = false; // Il file contiene i flags //bool isvflags = false; // Il file contiene i flags
// The main descriptor of the ply file // The main descriptor of the ply file
vcg::ply::PlyFile pf; vcg::ply::PlyFile pf;
// Open the file and parse the header // Open the file and parse the header
if( pf.Open(filename,vcg::ply::PlyFile::MODE_READ)==-1 ) if( pf.Open(filename,vcg::ply::PlyFile::MODE_READ)==-1 )
{ {
pi.status = pf.GetError(); pi.status = pf.GetError();
return pi.status; return pi.status;
} }
pi.header = pf.GetHeader(); pi.header = pf.GetHeader();
// Descrittori della camera // Descrittori della camera
{ // Check that all the camera properties are present. { // Check that all the camera properties are present.
@ -414,46 +412,46 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
if(found) pi.mask |= Mask::IOM_CAMERA; if(found) pi.mask |= Mask::IOM_CAMERA;
} }
// Descrittori dati standard (vertex coord e faces) // Standard data desciptors (vertex coord and faces)
if( pf.AddToRead(VertDesc(0))==-1 && pf.AddToRead(VertDesc(22)) ) { pi.status = PlyInfo::E_NO_VERTEX; return pi.status; } if( pf.AddToRead(VertDesc(0))==-1 && pf.AddToRead(VertDesc(22)) ) { pi.status = PlyInfo::E_NO_VERTEX; return pi.status; }
if( pf.AddToRead(VertDesc(1))==-1 && pf.AddToRead(VertDesc(23)) ) { pi.status = PlyInfo::E_NO_VERTEX; return pi.status; } if( pf.AddToRead(VertDesc(1))==-1 && pf.AddToRead(VertDesc(23)) ) { pi.status = PlyInfo::E_NO_VERTEX; return pi.status; }
if( pf.AddToRead(VertDesc(2))==-1 && pf.AddToRead(VertDesc(24)) ) { pi.status = PlyInfo::E_NO_VERTEX; return pi.status; } if( pf.AddToRead(VertDesc(2))==-1 && pf.AddToRead(VertDesc(24)) ) { pi.status = PlyInfo::E_NO_VERTEX; return pi.status; }
if( pf.AddToRead(FaceDesc(0))==-1 ) // Se fallisce si prova anche la sintassi di rapidform con index al posto di indices if( pf.AddToRead(FaceDesc(0))==-1 ) // Se fallisce si prova anche la sintassi di rapidform con index al posto di indices
{ {
int ii; int ii;
for(ii=_FACEDESC_FIRST_;ii< _FACEDESC_LAST_;++ii) for (ii=_FACEDESC_FIRST_;ii< _FACEDESC_LAST_;++ii)
if( pf.AddToRead(FaceDesc(ii))!=-1 ) break; if( pf.AddToRead(FaceDesc(ii))!=-1 ) break;
if(ii==_FACEDESC_LAST_) if (ii==_FACEDESC_LAST_)
if(pf.AddToRead(TristripDesc(0))==-1) // Se fallisce tutto si prova a vedere se ci sono tristrip alla levoy. if(pf.AddToRead(TristripDesc(0))==-1) // Se fallisce tutto si prova a vedere se ci sono tristrip alla levoy.
if(pf.AddToRead(RangeDesc(0))==-1) // Se fallisce tutto si prova a vedere se ci sono rangemap alla levoy. if(pf.AddToRead(RangeDesc(0))==-1) // Se fallisce tutto si prova a vedere se ci sono rangemap alla levoy.
{ {
pi.status = PlyInfo::E_NO_FACE; pi.status = PlyInfo::E_NO_FACE;
//return pi.status; no face is not a critical error. let's continue. //return pi.status; no face is not a critical error. let's continue.
} }
} }
// Descrittori facoltativi dei flags // Optional flag descriptors
if(pf.AddToRead(EdgeDesc(0) )!= -1 && pf.AddToRead(EdgeDesc(1)) != -1 ) if(pf.AddToRead(EdgeDesc(0) )!= -1 && pf.AddToRead(EdgeDesc(1)) != -1 )
pi.mask |= Mask::IOM_EDGEINDEX; pi.mask |= Mask::IOM_EDGEINDEX;
if(vcg::tri::HasPerVertexFlags(m) && pf.AddToRead(VertDesc(3))!=-1 ) if(vcg::tri::HasPerVertexFlags(m) && pf.AddToRead(VertDesc(3))!=-1 )
pi.mask |= Mask::IOM_VERTFLAGS; pi.mask |= Mask::IOM_VERTFLAGS;
if( vcg::tri::HasPerVertexNormal(m) ) if( vcg::tri::HasPerVertexNormal(m) )
{ {
if( pf.AddToRead(VertDesc(12))!=-1 && pf.AddToRead(VertDesc(13))!=-1 && pf.AddToRead(VertDesc(14))!=-1 ) if( pf.AddToRead(VertDesc(12))!=-1 && pf.AddToRead(VertDesc(13))!=-1 && pf.AddToRead(VertDesc(14))!=-1 )
pi.mask |= Mask::IOM_VERTNORMAL; pi.mask |= Mask::IOM_VERTNORMAL;
else // try also for Normals stored with doubles else // try also for Normals stored with doubles
if( pf.AddToRead(VertDesc(25))!=-1 && pf.AddToRead(VertDesc(26))!=-1 && pf.AddToRead(VertDesc(27))!=-1 ) if( pf.AddToRead(VertDesc(25))!=-1 && pf.AddToRead(VertDesc(26))!=-1 && pf.AddToRead(VertDesc(27))!=-1 )
pi.mask |= Mask::IOM_VERTNORMAL; pi.mask |= Mask::IOM_VERTNORMAL;
} }
if( vcg::tri::HasPerVertexQuality(m) ) if( vcg::tri::HasPerVertexQuality(m) )
{ {
if( pf.AddToRead(VertDesc(4))!=-1 || if( pf.AddToRead(VertDesc(4))!=-1 ||
pf.AddToRead(VertDesc(11))!=-1 ) pf.AddToRead(VertDesc(11))!=-1 )
pi.mask |= Mask::IOM_VERTQUALITY; pi.mask |= Mask::IOM_VERTQUALITY;
} }
@ -473,7 +471,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
if( pf.AddToRead(VertDesc(19))!=-1 ) if( pf.AddToRead(VertDesc(19))!=-1 )
{ {
hasIntensity = true; hasIntensity = true;
pi.mask |= Mask::IOM_VERTCOLOR; pi.mask |= Mask::IOM_VERTCOLOR;
} }
@ -489,18 +487,18 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
pi.mask |= Mask::IOM_VERTTEXCOORD; pi.mask |= Mask::IOM_VERTTEXCOORD;
} }
} }
if(tri::HasPerVertexRadius(m)) if(tri::HasPerVertexRadius(m))
{ {
if( pf.AddToRead(VertDesc(15))!=-1 ) if( pf.AddToRead(VertDesc(15))!=-1 )
pi.mask |= Mask::IOM_VERTRADIUS; pi.mask |= Mask::IOM_VERTRADIUS;
else if( pf.AddToRead(VertDesc(28))!=-1 ) else if( pf.AddToRead(VertDesc(28))!=-1 )
pi.mask |= Mask::IOM_VERTRADIUS; pi.mask |= Mask::IOM_VERTRADIUS;
} }
// se ci sono i flag per vertice ci devono essere anche i flag per faccia // se ci sono i flag per vertice ci devono essere anche i flag per faccia
if( pf.AddToRead(FaceDesc(1))!=-1 ) if( pf.AddToRead(FaceDesc(1))!=-1 )
pi.mask |= Mask::IOM_FACEFLAGS; pi.mask |= Mask::IOM_FACEFLAGS;
if( vcg::tri::HasPerFaceQuality(m) ) if( vcg::tri::HasPerFaceQuality(m) )
{ {
if( pf.AddToRead(FaceDesc(2))!=-1 ) if( pf.AddToRead(FaceDesc(2))!=-1 )
pi.mask |= Mask::IOM_FACEQUALITY; pi.mask |= Mask::IOM_FACEQUALITY;
@ -529,7 +527,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
} }
if( vcg::tri::HasPerFaceColor(m) || vcg::tri::HasPerVertexColor(m) || vcg::tri::HasPerWedgeColor(m) ) if( vcg::tri::HasPerFaceColor(m) || vcg::tri::HasPerVertexColor(m) || vcg::tri::HasPerWedgeColor(m) )
{ {
if( pf.AddToRead(FaceDesc(4))!=-1 ) if( pf.AddToRead(FaceDesc(4))!=-1 )
{ {
@ -537,11 +535,11 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
} }
// Descrittori definiti dall'utente, // User defined descriptors
std::vector<PropDescriptor> VPV(pi.vdn); // property descriptor relative al tipo LoadPly_VertexAux std::vector<PropDescriptor> VPV(pi.vdn); // property descriptor relative al tipo LoadPly_VertexAux
std::vector<PropDescriptor> FPV(pi.fdn); // property descriptor relative al tipo LoadPly_FaceAux std::vector<PropDescriptor> FPV(pi.fdn); // property descriptor relative al tipo LoadPly_FaceAux
if(pi.vdn>0){ if(pi.vdn>0){
// Compute the total size needed to load additional per vertex data. // Compute the total size needed to load additional per vertex data.
size_t totsz=0; size_t totsz=0;
for(int i=0;i<pi.vdn;i++){ for(int i=0;i<pi.vdn;i++){
VPV[i] = pi.VertexData[i]; VPV[i] = pi.VertexData[i];
@ -565,16 +563,16 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
if(totsz > MAX_USER_DATA) if(totsz > MAX_USER_DATA)
{ {
pi.status = vcg::ply::E_BADTYPE; pi.status = vcg::ply::E_BADTYPE;
return pi.status; return pi.status;
} }
} }
/**************************************************************/ /**************************************************************/
/* Main Reading Loop */ /* Main Reading Loop */
/**************************************************************/ /**************************************************************/
m.Clear(); m.Clear();
for(int i=0;i<int(pf.elements.size());i++) for(int i=0;i<int(pf.elements.size());i++)
{ {
int n = pf.ElemNumber(i); int n = pf.ElemNumber(i);
@ -600,7 +598,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
// axis (i.e. rotation). // axis (i.e. rotation).
Matrix44<ScalarType> rm; Matrix44<ScalarType> rm;
rm.SetIdentity(); rm.SetIdentity();
rm[0][0] = ca.x_axisx; rm[0][0] = ca.x_axisx;
rm[0][1] = ca.x_axisy; rm[0][1] = ca.x_axisy;
rm[0][2] = ca.x_axisz; rm[0][2] = ca.x_axisz;
@ -635,12 +633,12 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
int j; int j;
pf.SetCurElement(i); pf.SetCurElement(i);
VertexIterator vi=Allocator<OpenMeshType>::AddVertices(m,n); VertexIterator vi=Allocator<OpenMeshType>::AddVertices(m,n);
for(j=0;j<n;++j) for(j=0;j<n;++j)
{ {
if(pi.cb && (j%1000)==0) pi.cb(j*50/n,"Vertex Loading"); if(pi.cb && (j%1000)==0) pi.cb(j*50/n,"Vertex Loading");
if( pf.Read( (void *)&(va) )==-1 ) if( pf.Read( (void *)&(va) )==-1 )
{ {
pi.status = PlyInfo::E_SHORTFILE; pi.status = PlyInfo::E_SHORTFILE;
return pi.status; return pi.status;
@ -657,40 +655,40 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
(*vi).Q() = (typename OpenMeshType::VertexType::QualityType)va.q; (*vi).Q() = (typename OpenMeshType::VertexType::QualityType)va.q;
if( pi.mask & Mask::IOM_VERTNORMAL ) if( pi.mask & Mask::IOM_VERTNORMAL )
{ {
(*vi).N()[0]=va.n[0]; (*vi).N()[0]=va.n[0];
(*vi).N()[1]=va.n[1]; (*vi).N()[1]=va.n[1];
(*vi).N()[2]=va.n[2]; (*vi).N()[2]=va.n[2];
} }
if( pi.mask & Mask::IOM_VERTTEXCOORD ) if( pi.mask & Mask::IOM_VERTTEXCOORD )
{ {
(*vi).T().P().X() = va.u; (*vi).T().P().X() = va.u;
(*vi).T().P().Y() = va.v; (*vi).T().P().Y() = va.v;
} }
if( pi.mask & Mask::IOM_VERTCOLOR ) if( pi.mask & Mask::IOM_VERTCOLOR )
{
if(hasIntensity)
(*vi).C().SetGrayShade(va.intensity);
else
{ {
if(hasIntensity) (*vi).C()[0] = va.r;
(*vi).C().SetGrayShade(va.intensity); (*vi).C()[1] = va.g;
else (*vi).C()[2] = va.b;
{ (*vi).C()[3] = 255;
(*vi).C()[0] = va.r;
(*vi).C()[1] = va.g;
(*vi).C()[2] = va.b;
(*vi).C()[3] = 255;
}
} }
}
if( pi.mask & Mask::IOM_VERTRADIUS ) if( pi.mask & Mask::IOM_VERTRADIUS )
(*vi).R() = va.radius; (*vi).R() = va.radius;
for(int k=0;k<pi.vdn;k++) for(int k=0;k<pi.vdn;k++)
memcpy((char *)(&*vi) + pi.VertexData[k].offset1, memcpy((char *)(&*vi) + pi.VertexData[k].offset1,
(char *)(&va) + VPV[k].offset1, (char *)(&va) + VPV[k].offset1,
VPV[k].memtypesize()); VPV[k].memtypesize());
++vi; ++vi;
} }
index.resize(n); index.resize(n);
for(j=0,vi=m.vert.begin();j<n;++j,++vi) for(j=0,vi=m.vert.begin();j<n;++j,++vi)
@ -698,32 +696,32 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
else if( !strcmp( pf.ElemName(i),"edge") && (n>0) )/******************** EDGE READING *******************************/ else if( !strcmp( pf.ElemName(i),"edge") && (n>0) )/******************** EDGE READING *******************************/
{ {
assert( pi.mask & Mask::IOM_EDGEINDEX ); assert( pi.mask & Mask::IOM_EDGEINDEX );
EdgeIterator ei=Allocator<OpenMeshType>::AddEdges(m,n); EdgeIterator ei=Allocator<OpenMeshType>::AddEdges(m,n);
pf.SetCurElement(i); pf.SetCurElement(i);
for(int j=0;j<n;++j) for(int j=0;j<n;++j)
{ {
if(pi.cb && (j%1000)==0) pi.cb(50+j*50/n,"Edge Loading"); if(pi.cb && (j%1000)==0) pi.cb(50+j*50/n,"Edge Loading");
if( pf.Read(&ea)==-1 ) if( pf.Read(&ea)==-1 )
{ {
pi.status = PlyInfo::E_SHORTFILE; pi.status = PlyInfo::E_SHORTFILE;
return pi.status; return pi.status;
} }
if( ea.v1<0 || ea.v2<0 || ea.v1>=m.vn || ea.v2>=m.vn) if( ea.v1<0 || ea.v2<0 || ea.v1>=m.vn || ea.v2>=m.vn)
{ {
pi.status = PlyInfo::E_BAD_VERT_INDEX_EDGE; pi.status = PlyInfo::E_BAD_VERT_INDEX_EDGE;
return pi.status; return pi.status;
} }
(*ei).V(0) = index[ ea.v1 ]; (*ei).V(0) = index[ ea.v1 ];
(*ei).V(1) = index[ ea.v2 ]; (*ei).V(1) = index[ ea.v2 ];
++ei; ++ei;
} }
} }
else if( !strcmp( pf.ElemName(i),"face") && (n>0) )/******************** FACE READING ****************************************/ else if( !strcmp( pf.ElemName(i),"face") && (n>0) )/******************** FACE READING ****************************************/
{ {
int j; int j;
FaceIterator fi=Allocator<OpenMeshType>::AddFaces(m,n); FaceIterator fi=Allocator<OpenMeshType>::AddFaces(m,n);
pf.SetCurElement(i); pf.SetCurElement(i);
for(j=0;j<n;++j) for(j=0;j<n;++j)
@ -738,11 +736,11 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
if(fa.size!=3) if(fa.size!=3)
{ // Non triangular face are manageable ONLY if there are no Per Wedge attributes { // Non triangular face are manageable ONLY if there are no Per Wedge attributes
if( ( pi.mask & Mask::IOM_WEDGCOLOR ) || ( pi.mask & Mask::IOM_WEDGTEXCOORD ) ) if( ( pi.mask & Mask::IOM_WEDGCOLOR ) || ( pi.mask & Mask::IOM_WEDGTEXCOORD ) )
{ {
pi.status = PlyInfo::E_NO_3VERTINFACE; pi.status = PlyInfo::E_NO_3VERTINFACE;
return pi.status; return pi.status;
} }
} }
if(HasPolyInfo(m)) (*fi).Alloc(3); if(HasPolyInfo(m)) (*fi).Alloc(3);
@ -772,7 +770,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
(*fi).WT(k).u() = fa.texcoord[k*2+0]; (*fi).WT(k).u() = fa.texcoord[k*2+0];
(*fi).WT(k).v() = fa.texcoord[k*2+1]; (*fi).WT(k).v() = fa.texcoord[k*2+1];
if(multit) (*fi).WT(k).n() = fa.texcoordind; if(multit) (*fi).WT(k).n() = fa.texcoordind;
else (*fi).WT(k).n()=0; // safely intialize texture index else (*fi).WT(k).n()=0; // safely intialize texture index
} }
} }
@ -789,13 +787,13 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
//if(FaceType::HasFaceColor()){ //if(FaceType::HasFaceColor()){
//if(pi.mask & Mask::IOM_FACECOLOR){ //if(pi.mask & Mask::IOM_FACECOLOR){
if(HasPerFaceColor(m)) { if(HasPerFaceColor(m)) {
(*fi).C()[0] = (unsigned char)((fa.colors[0*3+0]*255+fa.colors[1*3+0]*255+fa.colors[2*3+0]*255)/3.0f); (*fi).C()[0] = (unsigned char)((fa.colors[0*3+0]*255+fa.colors[1*3+0]*255+fa.colors[2*3+0]*255)/3.0f);
(*fi).C()[1] = (unsigned char)((fa.colors[0*3+1]*255+fa.colors[1*3+1]*255+fa.colors[2*3+1]*255)/3.0f); (*fi).C()[1] = (unsigned char)((fa.colors[0*3+1]*255+fa.colors[1*3+1]*255+fa.colors[2*3+1]*255)/3.0f);
(*fi).C()[2] = (unsigned char)((fa.colors[0*3+2]*255+fa.colors[1*3+2]*255+fa.colors[2*3+2]*255)/3.0f); (*fi).C()[2] = (unsigned char)((fa.colors[0*3+2]*255+fa.colors[1*3+2]*255+fa.colors[2*3+2]*255)/3.0f);
} }
} }
/// Now the temporary struct 'fa' is ready to be copied into the real face '*fi' /// Now the temporary struct 'fa' is ready to be copied into the real face '*fi'
/// This loop /// This loop
for(k=0;k<3;++k) for(k=0;k<3;++k)
{ {
if( fa.v[k]<0 || fa.v[k]>=m.vn ) if( fa.v[k]<0 || fa.v[k]>=m.vn )
@ -806,51 +804,51 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
(*fi).V(k) = index[ fa.v[k] ]; (*fi).V(k) = index[ fa.v[k] ];
} }
// tag faux vertices of first face // tag faux vertices of first face
if (fa.size>3) fi->SetF(2); if (fa.size>3) fi->SetF(2);
for(k=0;k<pi.fdn;k++) for(k=0;k<pi.fdn;k++)
memcpy((char *)(&(*fi)) + pi.FaceData[k].offset1, memcpy((char *)(&(*fi)) + pi.FaceData[k].offset1,
(char *)(&fa) + FPV[k].offset1, (char *)(&fa) + FPV[k].offset1,
FPV[k].memtypesize()); FPV[k].memtypesize());
++fi; ++fi;
// Non Triangular Faces Loop // Non Triangular Faces Loop
// It performs a simple fan triangulation. // It performs a simple fan triangulation.
if(fa.size>3) if(fa.size>3)
{ {
int curpos=int(fi-m.face.begin()); int curpos=int(fi-m.face.begin());
Allocator<OpenMeshType>::AddFaces(m,fa.size-3); Allocator<OpenMeshType>::AddFaces(m,fa.size-3);
fi=m.face.begin()+curpos; fi=m.face.begin()+curpos;
pi.mask |= Mask::IOM_BITPOLYGONAL; pi.mask |= Mask::IOM_BITPOLYGONAL;
} }
for(int qq=0;qq<fa.size-3;++qq) for(int qq=0;qq<fa.size-3;++qq)
{ {
(*fi).V(0) = index[ fa.v[0] ]; (*fi).V(0) = index[ fa.v[0] ];
for(k=1;k<3;++k) for(k=1;k<3;++k)
{ {
if( fa.v[2+qq]<0 || fa.v[2+qq]>=m.vn ) if( fa.v[2+qq]<0 || fa.v[2+qq]>=m.vn )
{ {
pi.status = PlyInfo::E_BAD_VERT_INDEX; pi.status = PlyInfo::E_BAD_VERT_INDEX;
return pi.status; return pi.status;
} }
(*fi).V(k) = index[ fa.v[1+qq+k] ]; (*fi).V(k) = index[ fa.v[1+qq+k] ];
} }
// tag faux vertices of extra faces // tag faux vertices of extra faces
fi->SetF(0); fi->SetF(0);
if (qq!=fa.size-3) fi->SetF(2); if (qq!=fa.size-3) fi->SetF(2);
for(k=0;k<pi.fdn;k++) for(k=0;k<pi.fdn;k++)
memcpy((char *)(&(*fi)) + pi.FaceData[k].offset1, memcpy((char *)(&(*fi)) + pi.FaceData[k].offset1,
(char *)(&fa) + FPV[k].offset1, FPV[k].memtypesize()); (char *)(&fa) + FPV[k].offset1, FPV[k].memtypesize());
++fi; ++fi;
} }
} }
}else if( !strcmp( pf.ElemName(i),"tristrips") )//////////////////// LETTURA TRISTRIP DI STANFORD }else if( !strcmp( pf.ElemName(i),"tristrips") )//////////////////// LETTURA TRISTRIP DI STANFORD
{ {
int j; int j;
@ -877,7 +875,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
{ {
k+=2; k+=2;
if(k%2) remainder=0; if(k%2) remainder=0;
else remainder=1; else remainder=1;
continue; continue;
} }
Allocator<OpenMeshType>::AddFaces(m,1); Allocator<OpenMeshType>::AddFaces(m,1);
@ -938,7 +936,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
else else
{ {
// Skippaggio elementi non gestiti // Skippaggio elementi non gestiti
int n = pf.ElemNumber(i); int n = pf.ElemNumber(i);
pf.SetCurElement(i); pf.SetCurElement(i);
@ -953,28 +951,28 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
} }
// Parsing texture names // Parsing texture names
m.textures.clear(); m.textures.clear();
m.normalmaps.clear(); m.normalmaps.clear();
for(int co=0;co<int(pf.comments.size());++co) for(int co=0;co<int(pf.comments.size());++co)
{ {
std::string TFILE = "TextureFile"; std::string TFILE = "TextureFile";
std::string NFILE = "TextureNormalFile"; std::string NFILE = "TextureNormalFile";
std::string &c = pf.comments[co]; std::string &c = pf.comments[co];
// char buf[256]; // char buf[256];
std::string bufstr,bufclean; std::string bufstr,bufclean;
int i,n; int i,n;
if( TFILE == c.substr(0,TFILE.length()) ) if( TFILE == c.substr(0,TFILE.length()) )
{ {
bufstr = c.substr(TFILE.length()+1); bufstr = c.substr(TFILE.length()+1);
n = static_cast<int>(bufstr.length()); n = static_cast<int>(bufstr.length());
for(i=0;i<n;i++) for(i=0;i<n;i++)
if( bufstr[i]!=' ' && bufstr[i]!='\t' && bufstr[i]>32 && bufstr[i]<125 ) bufclean.push_back(bufstr[i]); if( bufstr[i]!=' ' && bufstr[i]!='\t' && bufstr[i]>32 && bufstr[i]<125 ) bufclean.push_back(bufstr[i]);
char buf2[255]; char buf2[255];
ply::interpret_texture_name( bufclean.c_str(),filename,buf2 ); ply::interpret_texture_name( bufclean.c_str(),filename,buf2 );
m.textures.push_back( std::string(buf2) ); m.textures.push_back( std::string(buf2) );
} }
/*if( !strncmp(c,NFILE,strlen(NFILE)) ) /*if( !strncmp(c,NFILE,strlen(NFILE)) )
@ -991,7 +989,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
}*/ }*/
} }
// vn and fn should be correct but if someone wrongly saved some deleted elements they can be wrong. // vn and fn should be correct but if someone wrongly saved some deleted elements they can be wrong.
m.vn = 0; m.vn = 0;
VertexIterator vi; VertexIterator vi;
for(vi=m.vert.begin();vi!=m.vert.end();++vi) for(vi=m.vert.begin();vi!=m.vert.end();++vi)
@ -1008,7 +1006,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
} }
// Caricamento camera da un ply // Caricamento camera da un ply
int LoadCamera(const char * filename) int LoadCamera(const char * filename)
{ {
vcg::ply::PlyFile pf; vcg::ply::PlyFile pf;
@ -1085,8 +1083,8 @@ int LoadCamera(const char * filename)
static bool LoadMask(const char * filename, int &mask) static bool LoadMask(const char * filename, int &mask)
{ {
PlyInfo pi; PlyInfo pi;
return LoadMask(filename, mask,pi); return LoadMask(filename, mask,pi);
} }
static bool LoadMask(const char * filename, int &mask, PlyInfo &pi) static bool LoadMask(const char * filename, int &mask, PlyInfo &pi)
{ {
@ -1098,59 +1096,57 @@ static bool LoadMask(const char * filename, int &mask, PlyInfo &pi)
return false; return false;
} }
if( pf.AddToRead(VertDesc(0))!=-1 && if( pf.AddToRead(VertDesc( 0))!=-1 &&
pf.AddToRead(VertDesc(1))!=-1 && pf.AddToRead(VertDesc( 1))!=-1 &&
pf.AddToRead(VertDesc(2))!=-1 ) mask |= Mask::IOM_VERTCOORD; pf.AddToRead(VertDesc( 2))!=-1 ) mask |= Mask::IOM_VERTCOORD;
if( pf.AddToRead(VertDesc(22))!=-1 && if( pf.AddToRead(VertDesc(22))!=-1 &&
pf.AddToRead(VertDesc(23))!=-1 && pf.AddToRead(VertDesc(23))!=-1 &&
pf.AddToRead(VertDesc(24))!=-1 ) mask |= Mask::IOM_VERTCOORD; pf.AddToRead(VertDesc(24))!=-1 ) mask |= Mask::IOM_VERTCOORD;
if( pf.AddToRead(VertDesc(12))!=-1 && if( pf.AddToRead(VertDesc(12))!=-1 &&
pf.AddToRead(VertDesc(13))!=-1 && pf.AddToRead(VertDesc(13))!=-1 &&
pf.AddToRead(VertDesc(14))!=-1 ) mask |= Mask::IOM_VERTNORMAL; pf.AddToRead(VertDesc(14))!=-1 ) mask |= Mask::IOM_VERTNORMAL;
if( pf.AddToRead(VertDesc(25))!=-1 && if( pf.AddToRead(VertDesc(25))!=-1 &&
pf.AddToRead(VertDesc(26))!=-1 && pf.AddToRead(VertDesc(26))!=-1 &&
pf.AddToRead(VertDesc(27))!=-1 ) mask |= Mask::IOM_VERTNORMAL; pf.AddToRead(VertDesc(27))!=-1 ) mask |= Mask::IOM_VERTNORMAL;
if( pf.AddToRead(VertDesc(3))!=-1 ) mask |= Mask::IOM_VERTFLAGS; if( pf.AddToRead(VertDesc( 3))!=-1 ) mask |= Mask::IOM_VERTFLAGS;
if( pf.AddToRead(VertDesc(4))!=-1 ) mask |= Mask::IOM_VERTQUALITY; if( pf.AddToRead(VertDesc( 4))!=-1 ) mask |= Mask::IOM_VERTQUALITY;
if( pf.AddToRead(VertDesc(11))!=-1 ) mask |= Mask::IOM_VERTQUALITY; if( pf.AddToRead(VertDesc(11))!=-1 ) mask |= Mask::IOM_VERTQUALITY;
if( pf.AddToRead(VertDesc(15))!=-1 ) mask |= Mask::IOM_VERTRADIUS; if( pf.AddToRead(VertDesc(15))!=-1 ) mask |= Mask::IOM_VERTRADIUS;
if( pf.AddToRead(VertDesc(28))!=-1 ) mask |= Mask::IOM_VERTRADIUS; if( pf.AddToRead(VertDesc(28))!=-1 ) mask |= Mask::IOM_VERTRADIUS;
if( ( pf.AddToRead(VertDesc( 5))!=-1 ) && if( pf.AddToRead(VertDesc( 5))!=-1 &&
( pf.AddToRead(VertDesc( 6))!=-1 ) && pf.AddToRead(VertDesc( 6))!=-1 &&
( pf.AddToRead(VertDesc( 7))!=-1 ) ) mask |= Mask::IOM_VERTCOLOR; pf.AddToRead(VertDesc( 7))!=-1 ) mask |= Mask::IOM_VERTCOLOR;
if( ( pf.AddToRead(VertDesc( 8))!=-1 ) && if( pf.AddToRead(VertDesc( 8))!=-1 &&
( pf.AddToRead(VertDesc( 9))!=-1 ) && pf.AddToRead(VertDesc( 9))!=-1 &&
( pf.AddToRead(VertDesc(10))!=-1 ) ) mask |= Mask::IOM_VERTCOLOR; pf.AddToRead(VertDesc(10))!=-1 ) mask |= Mask::IOM_VERTCOLOR;
if( pf.AddToRead(VertDesc(19))!=-1 ) mask |= Mask::IOM_VERTCOLOR; if( pf.AddToRead(VertDesc(19))!=-1 ) mask |= Mask::IOM_VERTCOLOR;
if(( pf.AddToRead(VertDesc(20))!=-1 ) && (pf.AddToRead(VertDesc(21))!=-1)) if( pf.AddToRead(VertDesc(20))!=-1 &&
mask |= Mask::IOM_VERTTEXCOORD; pf.AddToRead(VertDesc(21))!=-1) mask |= Mask::IOM_VERTTEXCOORD;
if(( pf.AddToRead(VertDesc(16))!=-1 ) && (pf.AddToRead(VertDesc(17))!=-1)) if( pf.AddToRead(VertDesc(16))!=-1 &&
mask |= Mask::IOM_VERTTEXCOORD; pf.AddToRead(VertDesc(17))!=-1) mask |= Mask::IOM_VERTTEXCOORD;
if( pf.AddToRead(FaceDesc(0))!=-1 ) mask |= Mask::IOM_FACEINDEX; if( pf.AddToRead(FaceDesc(0))!=-1 ) mask |= Mask::IOM_FACEINDEX;
if( pf.AddToRead(FaceDesc(1))!=-1 ) mask |= Mask::IOM_FACEFLAGS; if( pf.AddToRead(FaceDesc(1))!=-1 ) mask |= Mask::IOM_FACEFLAGS;
if( pf.AddToRead(FaceDesc(2))!=-1 ) mask |= Mask::IOM_FACEQUALITY; if( pf.AddToRead(FaceDesc(2))!=-1 ) mask |= Mask::IOM_FACEQUALITY;
if( pf.AddToRead(FaceDesc(3))!=-1 ) mask |= Mask::IOM_WEDGTEXCOORD; if( pf.AddToRead(FaceDesc(3))!=-1 ) mask |= Mask::IOM_WEDGTEXCOORD;
if( pf.AddToRead(FaceDesc(5))!=-1 ) mask |= Mask::IOM_WEDGTEXMULTI; if( pf.AddToRead(FaceDesc(5))!=-1 ) mask |= Mask::IOM_WEDGTEXMULTI;
if( pf.AddToRead(FaceDesc(4))!=-1 ) mask |= Mask::IOM_WEDGCOLOR; if( pf.AddToRead(FaceDesc(4))!=-1 ) mask |= Mask::IOM_WEDGCOLOR;
if( ( pf.AddToRead(FaceDesc(6))!=-1 ) && if( pf.AddToRead(FaceDesc(6))!=-1 &&
( pf.AddToRead(FaceDesc(7))!=-1 ) && pf.AddToRead(FaceDesc(7))!=-1 &&
( pf.AddToRead(FaceDesc(8))!=-1 ) ) mask |= Mask::IOM_FACECOLOR; pf.AddToRead(FaceDesc(8))!=-1 ) mask |= Mask::IOM_FACECOLOR;
return true;
return true;
} }
}; // end class }; // end class
} // end namespace tri } // end namespace tri
} // end namespace io } // end namespace io
} // end namespace vcg } // end namespace vcg