1163 lines
47 KiB
C++
1163 lines
47 KiB
C++
/****************************************************************************
|
|
* VCGLib o o *
|
|
* Visual and Computer Graphics Library o o *
|
|
* _ O _ *
|
|
* Copyright(C) 2004 \/)\/ *
|
|
* Visual Computing Lab /\/| *
|
|
* ISTI - Italian National Research Council | *
|
|
* \ *
|
|
* All rights reserved. *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
|
|
* for more details. *
|
|
* *
|
|
****************************************************************************/
|
|
#ifndef __VCGLIB_IMPORTERPLY
|
|
#define __VCGLIB_IMPORTERPLY
|
|
|
|
#include <stddef.h>
|
|
#include<wrap/callback.h>
|
|
#include<wrap/ply/plylib.h>
|
|
#include<wrap/io_trimesh/io_mask.h>
|
|
#include<wrap/io_trimesh/io_ply.h>
|
|
#include<vcg/complex/algorithms/create/platonic.h>
|
|
|
|
namespace vcg {
|
|
namespace tri {
|
|
namespace io {
|
|
|
|
template <class TYPE>
|
|
int PlyType () { return 0;}
|
|
|
|
|
|
// 10/6/05 Cignoni this specialization must be inlined becouse otherwise if we include this
|
|
// .h in two different cpp we should get a double definition error during linking
|
|
|
|
template <> inline int PlyType <float >() { return ply::T_FLOAT; }
|
|
template <> inline int PlyType <double>() { return ply::T_DOUBLE; }
|
|
template <> inline int PlyType <int >() { return ply::T_INT; }
|
|
template <> inline int PlyType <short >() { return ply::T_SHORT; }
|
|
template <> inline int PlyType <unsigned char >() { return ply::T_UCHAR; }
|
|
|
|
/**
|
|
This class encapsulate a filter for opening ply meshes.
|
|
The ply file format is quite extensible...
|
|
*/
|
|
template <class OpenMeshType>
|
|
class ImporterPLY
|
|
{
|
|
public:
|
|
|
|
typedef ::vcg::ply::PropDescriptor PropDescriptor ;
|
|
typedef typename OpenMeshType::VertexPointer VertexPointer;
|
|
typedef typename OpenMeshType::ScalarType ScalarType;
|
|
typedef typename OpenMeshType::VertexType VertexType;
|
|
typedef typename OpenMeshType::FaceType FaceType;
|
|
typedef typename OpenMeshType::VertexIterator VertexIterator;
|
|
typedef typename OpenMeshType::FaceIterator FaceIterator;
|
|
typedef typename OpenMeshType::EdgeIterator EdgeIterator;
|
|
|
|
#define MAX_USER_DATA 256
|
|
// Auxiliary structure for reading ply files
|
|
struct LoadPly_FaceAux
|
|
{
|
|
unsigned char size;
|
|
int v[512];
|
|
int flags;
|
|
float q;
|
|
float texcoord[32];
|
|
unsigned char ntexcoord;
|
|
int texcoordind;
|
|
float colors[32];
|
|
unsigned char ncolors;
|
|
|
|
unsigned char r;
|
|
unsigned char g;
|
|
unsigned char b;
|
|
|
|
unsigned char data[MAX_USER_DATA];
|
|
};
|
|
|
|
struct LoadPly_TristripAux
|
|
{
|
|
int size;
|
|
int *v;
|
|
unsigned char data[MAX_USER_DATA];
|
|
};
|
|
|
|
struct LoadPly_EdgeAux
|
|
{
|
|
int v1,v2;
|
|
unsigned char data[MAX_USER_DATA];
|
|
};
|
|
|
|
// Yet another auxiliary data structure for loading some strange ply files
|
|
// the original stanford range data...
|
|
struct LoadPly_RangeGridAux {
|
|
unsigned char num_pts;
|
|
int pts[5];
|
|
};
|
|
|
|
|
|
// Auxiliary structure to load vertex data
|
|
template<class S>
|
|
struct LoadPly_VertAux
|
|
{
|
|
S p[3];
|
|
S n[3];
|
|
int flags;
|
|
float q; // the confidence
|
|
float intensity;
|
|
unsigned char r;
|
|
unsigned char g;
|
|
unsigned char b;
|
|
unsigned char data[MAX_USER_DATA];
|
|
float radius;
|
|
float u,v,w;
|
|
};
|
|
|
|
// Auxiliary structure to load the camera
|
|
struct LoadPly_Camera
|
|
{
|
|
float view_px;
|
|
float view_py;
|
|
float view_pz;
|
|
float x_axisx;
|
|
float x_axisy;
|
|
float x_axisz;
|
|
float y_axisx;
|
|
float y_axisy;
|
|
float y_axisz;
|
|
float z_axisx;
|
|
float z_axisy;
|
|
float z_axisz;
|
|
float focal;
|
|
float scalex;
|
|
float scaley;
|
|
float centerx;
|
|
float centery;
|
|
int viewportx;
|
|
int viewporty;
|
|
float k1;
|
|
float k2;
|
|
float k3;
|
|
float k4;
|
|
};
|
|
|
|
#define _VERTDESC_LAST_ 30
|
|
static const PropDescriptor &VertDesc(int i)
|
|
{
|
|
static const PropDescriptor pv[_VERTDESC_LAST_]={
|
|
/*00*/ {"vertex", "x", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p),0,0,0,0,0 ,0},
|
|
/*01*/ {"vertex", "y", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p) + sizeof(ScalarType),0,0,0,0,0 ,0},
|
|
/*02*/ {"vertex", "z", ply::T_FLOAT, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,p) + 2*sizeof(ScalarType),0,0,0,0,0 ,0},
|
|
/*03*/ {"vertex", "flags", ply::T_INT, ply::T_INT, offsetof(LoadPly_VertAux<ScalarType>,flags),0,0,0,0,0 ,0},
|
|
/*04*/ {"vertex", "quality", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,q),0,0,0,0,0 ,0},
|
|
/*05*/ {"vertex", "red" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,r),0,0,0,0,0 ,0},
|
|
/*06*/ {"vertex", "green", ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,g),0,0,0,0,0 ,0},
|
|
/*07*/ {"vertex", "blue" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux<ScalarType>,b),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},
|
|
/*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},
|
|
/*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},
|
|
/*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},
|
|
/*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},
|
|
/*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},
|
|
/*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},
|
|
// DOUBLE
|
|
/*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},
|
|
/*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},
|
|
/*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},
|
|
/*28*/ {"vertex", "radius", ply::T_DOUBLE, ply::T_FLOAT, offsetof(LoadPly_VertAux<ScalarType>,radius),0,0,0,0,0 ,0},
|
|
/*29*/ {"vertex", "quality", ply::T_DOUBLE, PlyType<ScalarType>(),offsetof(LoadPly_VertAux<ScalarType>,q),0,0,0,0,0 ,0}
|
|
};
|
|
return pv[i];
|
|
}
|
|
|
|
#define _FACEDESC_FIRST_ 9 // the first descriptor with possible vertex indices
|
|
#define _FACEDESC_LAST_ 21
|
|
static const PropDescriptor &FaceDesc(int i)
|
|
{
|
|
static const PropDescriptor qf[_FACEDESC_LAST_]=
|
|
{
|
|
/* 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},
|
|
/* 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},
|
|
/* 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},
|
|
/* 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},
|
|
/* 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},
|
|
/* 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},
|
|
/* 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},
|
|
/* 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},
|
|
/* 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},
|
|
/* 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},
|
|
/* 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}
|
|
};
|
|
return qf[i];
|
|
}
|
|
static const PropDescriptor &TristripDesc(int i)
|
|
{
|
|
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},
|
|
};
|
|
return qf[i];
|
|
}
|
|
|
|
static const PropDescriptor &EdgeDesc(int i)
|
|
{
|
|
static const PropDescriptor qf[2]=
|
|
{
|
|
{"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},
|
|
};
|
|
return qf[i];
|
|
}
|
|
|
|
// Descriptor for the Stanford Data Repository Range Maps.
|
|
// In practice a grid with some invalid elements. Coords are saved only for good elements
|
|
static const PropDescriptor &RangeDesc(int i)
|
|
{
|
|
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},
|
|
};
|
|
return range_props[i];
|
|
}
|
|
|
|
|
|
static const PropDescriptor &CameraDesc(int i)
|
|
{
|
|
static const PropDescriptor cad[23] =
|
|
{
|
|
{"camera","view_px",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,view_px),0,0,0,0,0 ,0},
|
|
{"camera","view_py",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,view_py),0,0,0,0,0 ,0},
|
|
{"camera","view_pz",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,view_pz),0,0,0,0,0 ,0},
|
|
{"camera","x_axisx",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,x_axisx),0,0,0,0,0 ,0},
|
|
{"camera","x_axisy",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,x_axisy),0,0,0,0,0 ,0},
|
|
{"camera","x_axisz",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,x_axisz),0,0,0,0,0 ,0},
|
|
{"camera","y_axisx",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,y_axisx),0,0,0,0,0 ,0},
|
|
{"camera","y_axisy",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,y_axisy),0,0,0,0,0 ,0},
|
|
{"camera","y_axisz",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,y_axisz),0,0,0,0,0 ,0},
|
|
{"camera","z_axisx",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,z_axisx),0,0,0,0,0 ,0},
|
|
{"camera","z_axisy",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,z_axisy),0,0,0,0,0 ,0},
|
|
{"camera","z_axisz",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,z_axisz),0,0,0,0,0 ,0},
|
|
{"camera","focal" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,focal ),0,0,0,0,0 ,0},
|
|
{"camera","scalex" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,scalex ),0,0,0,0,0 ,0},
|
|
{"camera","scaley" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,scaley ),0,0,0,0,0 ,0},
|
|
{"camera","centerx",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,centerx),0,0,0,0,0 ,0},
|
|
{"camera","centery",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,centery),0,0,0,0,0 ,0},
|
|
{"camera","viewportx",ply::T_INT,ply::T_INT ,offsetof(LoadPly_Camera,viewportx),0,0,0,0,0 ,0},
|
|
{"camera","viewporty",ply::T_INT,ply::T_INT ,offsetof(LoadPly_Camera,viewporty),0,0,0,0,0 ,0},
|
|
{"camera","k1" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,k1 ),0,0,0,0,0 ,0},
|
|
{"camera","k2" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,k2 ),0,0,0,0,0 ,0},
|
|
{"camera","k3" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,k3 ),0,0,0,0,0 ,0},
|
|
{"camera","k4" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,k4 ),0,0,0,0,0 ,0}
|
|
};
|
|
return cad[i];
|
|
}
|
|
/// Standard call for knowing the meaning of an error code
|
|
static const char *ErrorMsg(int error)
|
|
{
|
|
static std::vector<std::string> ply_error_msg;
|
|
if(ply_error_msg.empty())
|
|
{
|
|
ply_error_msg.resize(PlyInfo::E_MAXPLYINFOERRORS );
|
|
ply_error_msg[ply::E_NOERROR ]="No errors";
|
|
ply_error_msg[ply::E_CANTOPEN ]="Can't open file";
|
|
ply_error_msg[ply::E_NOTHEADER ]="Header not found";
|
|
ply_error_msg[ply::E_UNESPECTEDEOF ]="Eof in header";
|
|
ply_error_msg[ply::E_NOFORMAT ]="Format not found";
|
|
ply_error_msg[ply::E_SYNTAX ]="Syntax error on header";
|
|
ply_error_msg[ply::E_PROPOUTOFELEMENT]="Property without element";
|
|
ply_error_msg[ply::E_BADTYPENAME ]="Bad type name";
|
|
ply_error_msg[ply::E_ELEMNOTFOUND ]="Element 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_INCOMPATIBLETYPE]="Incompatible type";
|
|
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_FACE ]="No face field found";
|
|
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_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_NO_6TCOORD ]="Face with no 6 texture coordinates";
|
|
ply_error_msg[PlyInfo::E_DIFFER_COLORS ]="Number of color differ from vertices";
|
|
}
|
|
|
|
if(error>PlyInfo::E_MAXPLYINFOERRORS || error<0) return "Unknown error";
|
|
else return ply_error_msg[error].c_str();
|
|
};
|
|
|
|
// to check if a given error is critical or not.
|
|
static bool ErrorCritical(int err)
|
|
{
|
|
if ((err == ply::E_NOERROR) || (err == PlyInfo::E_NO_FACE)) return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
/// Standard call for reading a mesh, returns 0 on success.
|
|
static int Open( OpenMeshType &m, const char * filename, CallBackPos *cb=0)
|
|
{
|
|
PlyInfo pi;
|
|
pi.cb=cb;
|
|
return Open(m, filename, pi);
|
|
}
|
|
|
|
/// Read a mesh and store in loadmask the loaded field
|
|
/// Note that loadmask is not read! just modified. You cannot specify what fields
|
|
/// have to be read. ALL the data for which your mesh HasSomething and are present
|
|
/// in the file are read in.
|
|
static int Open( OpenMeshType &m, const char * filename, int & loadmask, CallBackPos *cb =0)
|
|
{
|
|
PlyInfo pi;
|
|
pi.cb=cb;
|
|
int r = Open(m, filename,pi);
|
|
loadmask=pi.mask;
|
|
return r;
|
|
}
|
|
|
|
|
|
/// 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 )
|
|
{
|
|
assert(filename!=0);
|
|
std::vector<VertexPointer> index;
|
|
LoadPly_FaceAux fa;
|
|
LoadPly_EdgeAux ea;
|
|
LoadPly_TristripAux tsa;
|
|
LoadPly_VertAux<ScalarType> va;
|
|
|
|
LoadPly_RangeGridAux rga;
|
|
std::vector<int> RangeGridAuxVec;
|
|
int RangeGridCols=0;
|
|
int RangeGridRows=0;
|
|
|
|
|
|
pi.mask = 0;
|
|
bool hasIntensity = false; // the intensity is a strange way to code single channel color used sometimes in rangemap. it is a kind of color. so it do not need another entry in the IOM mask.
|
|
bool multit = false; // true if texture has a per face int spec the texture index
|
|
|
|
va.flags = 42;
|
|
|
|
pi.status = ::vcg::ply::E_NOERROR;
|
|
|
|
/*
|
|
// TO BE REMOVED: tv not used AND "spurious" vertex declaration causes error if ocf
|
|
|
|
// init defaults
|
|
VertexType tv;
|
|
//tv.ClearFlags();
|
|
|
|
if (vcg::tri::HasPerVertexQuality(m)) tv.Q() = (typename OpenMeshType::VertexType::QualityType)1.0;
|
|
if (vcg::tri::HasPerVertexColor (m)) tv.C() = Color4b(Color4b::White);
|
|
*/
|
|
|
|
// Descrittori delle strutture
|
|
|
|
//bool isvflags = false; // Il file contiene i flags
|
|
|
|
|
|
// The main descriptor of the ply file
|
|
vcg::ply::PlyFile pf;
|
|
|
|
// Open the file and parse the header
|
|
if( pf.Open(filename,vcg::ply::PlyFile::MODE_READ)==-1 )
|
|
{
|
|
pi.status = pf.GetError();
|
|
return pi.status;
|
|
}
|
|
pi.header = pf.GetHeader();
|
|
|
|
// Descrittori della camera
|
|
{ // Check that all the camera properties are present.
|
|
bool found = true;
|
|
for(int i=0;i<23;++i)
|
|
{
|
|
if( pf.AddToRead(CameraDesc(i))==-1 ) {
|
|
found = false;
|
|
break;
|
|
}
|
|
}
|
|
if(found) pi.mask |= Mask::IOM_CAMERA;
|
|
}
|
|
|
|
// 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(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(FaceDesc(0))==-1 ) // Se fallisce si prova anche la sintassi di rapidform con index al posto di indices
|
|
{
|
|
int ii;
|
|
for (ii=_FACEDESC_FIRST_;ii< _FACEDESC_LAST_;++ii)
|
|
if( pf.AddToRead(FaceDesc(ii))!=-1 ) break;
|
|
|
|
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(RangeDesc(0))==-1) // Se fallisce tutto si prova a vedere se ci sono rangemap alla levoy.
|
|
{
|
|
pi.status = PlyInfo::E_NO_FACE;
|
|
//return pi.status; no face is not a critical error. let's continue.
|
|
}
|
|
|
|
}
|
|
// Optional flag descriptors
|
|
if(pf.AddToRead(EdgeDesc(0) )!= -1 && pf.AddToRead(EdgeDesc(1)) != -1 )
|
|
pi.mask |= Mask::IOM_EDGEINDEX;
|
|
|
|
if(vcg::tri::HasPerVertexFlags(m) && pf.AddToRead(VertDesc(3))!=-1 )
|
|
pi.mask |= Mask::IOM_VERTFLAGS;
|
|
|
|
if( vcg::tri::HasPerVertexNormal(m) )
|
|
{
|
|
if( pf.AddToRead(VertDesc(12))!=-1 && pf.AddToRead(VertDesc(13))!=-1 && pf.AddToRead(VertDesc(14))!=-1 )
|
|
pi.mask |= Mask::IOM_VERTNORMAL;
|
|
else // try also for Normals stored with doubles
|
|
if( pf.AddToRead(VertDesc(25))!=-1 && pf.AddToRead(VertDesc(26))!=-1 && pf.AddToRead(VertDesc(27))!=-1 )
|
|
pi.mask |= Mask::IOM_VERTNORMAL;
|
|
|
|
}
|
|
|
|
if( vcg::tri::HasPerVertexQuality(m) )
|
|
{
|
|
if( pf.AddToRead(VertDesc(4))!=-1 ||
|
|
pf.AddToRead(VertDesc(11))!=-1 )
|
|
pi.mask |= Mask::IOM_VERTQUALITY;
|
|
else
|
|
if (pf.AddToRead(VertDesc(29))!=-1)
|
|
pi.mask |= Mask::IOM_VERTQUALITY;
|
|
}
|
|
|
|
if(vcg::tri::HasPerVertexColor(m) )
|
|
{
|
|
if( pf.AddToRead(VertDesc(5))!=-1 )
|
|
{
|
|
pf.AddToRead(VertDesc(6));
|
|
pf.AddToRead(VertDesc(7));
|
|
pi.mask |= Mask::IOM_VERTCOLOR;
|
|
}
|
|
if( pf.AddToRead(VertDesc(8))!=-1 )
|
|
{
|
|
pf.AddToRead(VertDesc(9));
|
|
pf.AddToRead(VertDesc(10));
|
|
pi.mask |= Mask::IOM_VERTCOLOR;
|
|
}
|
|
if( pf.AddToRead(VertDesc(19))!=-1 )
|
|
{
|
|
hasIntensity = true;
|
|
pi.mask |= Mask::IOM_VERTCOLOR;
|
|
}
|
|
|
|
}
|
|
if( tri::HasPerVertexTexCoord(m) )
|
|
{
|
|
if(( pf.AddToRead(VertDesc(20))!=-1 )&& (pf.AddToRead(VertDesc(21))!=-1))
|
|
{
|
|
pi.mask |= Mask::IOM_VERTTEXCOORD;
|
|
}
|
|
if(( pf.AddToRead(VertDesc(16))!=-1 )&& (pf.AddToRead(VertDesc(17))!=-1))
|
|
{
|
|
pi.mask |= Mask::IOM_VERTTEXCOORD;
|
|
}
|
|
}
|
|
if(tri::HasPerVertexRadius(m))
|
|
{
|
|
if( pf.AddToRead(VertDesc(15))!=-1 )
|
|
pi.mask |= Mask::IOM_VERTRADIUS;
|
|
else if( pf.AddToRead(VertDesc(28))!=-1 )
|
|
pi.mask |= Mask::IOM_VERTRADIUS;
|
|
}
|
|
// se ci sono i flag per vertice ci devono essere anche i flag per faccia
|
|
if( pf.AddToRead(FaceDesc(1))!=-1 )
|
|
pi.mask |= Mask::IOM_FACEFLAGS;
|
|
|
|
if( vcg::tri::HasPerFaceQuality(m) )
|
|
{
|
|
if( pf.AddToRead(FaceDesc(2))!=-1 )
|
|
pi.mask |= Mask::IOM_FACEQUALITY;
|
|
}
|
|
|
|
if( vcg::tri::HasPerFaceColor(m) )
|
|
{
|
|
if( pf.AddToRead(FaceDesc(6))!=-1 )
|
|
{
|
|
pf.AddToRead(FaceDesc(7));
|
|
pf.AddToRead(FaceDesc(8));
|
|
pi.mask |= Mask::IOM_FACECOLOR;
|
|
}
|
|
}
|
|
|
|
|
|
if( vcg::tri::HasPerWedgeTexCoord(m) )
|
|
{
|
|
if( pf.AddToRead(FaceDesc(3))!=-1 )
|
|
{
|
|
if(pf.AddToRead(FaceDesc(5))==0) {
|
|
multit=true; // try to read also the multi texture indicies
|
|
pi.mask |= Mask::IOM_WEDGTEXMULTI;
|
|
}
|
|
pi.mask |= Mask::IOM_WEDGTEXCOORD;
|
|
}
|
|
}
|
|
|
|
if( vcg::tri::HasPerFaceColor(m) || vcg::tri::HasPerVertexColor(m) || vcg::tri::HasPerWedgeColor(m) )
|
|
{
|
|
if( pf.AddToRead(FaceDesc(4))!=-1 )
|
|
{
|
|
pi.mask |= Mask::IOM_WEDGCOLOR;
|
|
}
|
|
}
|
|
|
|
// User defined descriptors
|
|
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
|
|
if(pi.vdn>0){
|
|
// Compute the total size needed to load additional per vertex data.
|
|
size_t totsz=0;
|
|
for(int i=0;i<pi.vdn;i++){
|
|
VPV[i] = pi.VertexData[i];
|
|
VPV[i].offset1=offsetof(LoadPly_VertAux<ScalarType>,data)+totsz;
|
|
totsz+=pi.VertexData[i].memtypesize();
|
|
if( pf.AddToRead(VPV[i])==-1 ) { pi.status = pf.GetError(); return pi.status; }
|
|
}
|
|
if(totsz > MAX_USER_DATA)
|
|
{
|
|
pi.status = vcg::ply::E_BADTYPE;
|
|
return pi.status;
|
|
}
|
|
}
|
|
if(pi.fdn>0){
|
|
size_t totsz=0;
|
|
for(int i=0;i<pi.fdn;i++){
|
|
FPV[i] = pi.FaceData[i];
|
|
FPV[i].offset1=offsetof(LoadPly_FaceAux,data)+totsz;
|
|
totsz+=pi.FaceData[i].memtypesize();
|
|
if( pf.AddToRead(FPV[i])==-1 ) { pi.status = pf.GetError(); return pi.status; }
|
|
}
|
|
if(totsz > MAX_USER_DATA)
|
|
{
|
|
pi.status = vcg::ply::E_BADTYPE;
|
|
return pi.status;
|
|
}
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* Main Reading Loop */
|
|
/**************************************************************/
|
|
m.Clear();
|
|
for(int i=0;i<int(pf.elements.size());i++)
|
|
{
|
|
int n = pf.ElemNumber(i);
|
|
|
|
if( !strcmp( pf.ElemName(i),"camera" ) )
|
|
{
|
|
pf.SetCurElement(i);
|
|
|
|
LoadPly_Camera ca;
|
|
|
|
for(int j=0;j<n;++j)
|
|
{
|
|
if( pf.Read( (void *)&(ca) )==-1 )
|
|
{
|
|
pi.status = PlyInfo::E_SHORTFILE;
|
|
return pi.status;
|
|
}
|
|
//camera.valid = true;
|
|
|
|
// extrinsic
|
|
m.shot.Extrinsics.SetIdentity();
|
|
// view point
|
|
m.shot.Extrinsics.SetTra(Point3<ScalarType>( ca.view_px,ca.view_py,ca.view_pz));
|
|
|
|
// axis (i.e. rotation).
|
|
Matrix44<ScalarType> rm;
|
|
rm.SetIdentity();
|
|
rm[0][0] = ca.x_axisx;
|
|
rm[0][1] = ca.x_axisy;
|
|
rm[0][2] = ca.x_axisz;
|
|
|
|
rm[1][0] = ca.y_axisx;
|
|
rm[1][1] = ca.y_axisy;
|
|
rm[1][2] = ca.y_axisz;
|
|
|
|
rm[2][0] = ca.z_axisx;
|
|
rm[2][1] = ca.z_axisy;
|
|
rm[2][2] = ca.z_axisz;
|
|
|
|
m.shot.Extrinsics.SetRot(rm);
|
|
|
|
//intrinsic
|
|
m.shot.Intrinsics.FocalMm = ca.focal;
|
|
m.shot.Intrinsics.PixelSizeMm[0] = ca.scalex;
|
|
m.shot.Intrinsics.PixelSizeMm[1] = ca.scaley;
|
|
m.shot.Intrinsics.CenterPx[0] = ca.centerx;
|
|
m.shot.Intrinsics.CenterPx[1] = ca.centery;
|
|
m.shot.Intrinsics.ViewportPx[0] = ca.viewportx;
|
|
m.shot.Intrinsics.ViewportPx[1] = ca.viewporty;
|
|
m.shot.Intrinsics.k[0] = ca.k1;
|
|
m.shot.Intrinsics.k[1] = ca.k2;
|
|
m.shot.Intrinsics.k[2] = ca.k3;
|
|
m.shot.Intrinsics.k[3] = ca.k4;
|
|
|
|
}
|
|
}
|
|
else if( !strcmp( pf.ElemName(i),"vertex" ) )
|
|
{
|
|
int j;
|
|
|
|
pf.SetCurElement(i);
|
|
VertexIterator vi=Allocator<OpenMeshType>::AddVertices(m,n);
|
|
|
|
for(j=0;j<n;++j)
|
|
{
|
|
if(pi.cb && (j%1000)==0) pi.cb(j*50/n,"Vertex Loading");
|
|
if( pf.Read( (void *)&(va) )==-1 )
|
|
{
|
|
pi.status = PlyInfo::E_SHORTFILE;
|
|
return pi.status;
|
|
}
|
|
|
|
(*vi).P()[0] = va.p[0];
|
|
(*vi).P()[1] = va.p[1];
|
|
(*vi).P()[2] = va.p[2];
|
|
|
|
if( HasPerVertexFlags(m) && (pi.mask & Mask::IOM_VERTFLAGS) )
|
|
(*vi).Flags() = va.flags;
|
|
|
|
if( pi.mask & Mask::IOM_VERTQUALITY )
|
|
(*vi).Q() = (typename OpenMeshType::VertexType::QualityType)va.q;
|
|
|
|
if( pi.mask & Mask::IOM_VERTNORMAL )
|
|
{
|
|
(*vi).N()[0]=va.n[0];
|
|
(*vi).N()[1]=va.n[1];
|
|
(*vi).N()[2]=va.n[2];
|
|
}
|
|
|
|
if( pi.mask & Mask::IOM_VERTTEXCOORD )
|
|
{
|
|
(*vi).T().P().X() = va.u;
|
|
(*vi).T().P().Y() = va.v;
|
|
}
|
|
|
|
if( pi.mask & Mask::IOM_VERTCOLOR )
|
|
{
|
|
if(hasIntensity)
|
|
(*vi).C().SetGrayShade(va.intensity);
|
|
else
|
|
{
|
|
(*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 )
|
|
(*vi).R() = va.radius;
|
|
|
|
|
|
for(int k=0;k<pi.vdn;k++)
|
|
memcpy((char *)(&*vi) + pi.VertexData[k].offset1,
|
|
(char *)(&va) + VPV[k].offset1,
|
|
VPV[k].memtypesize());
|
|
++vi;
|
|
}
|
|
|
|
index.resize(n);
|
|
for(j=0,vi=m.vert.begin();j<n;++j,++vi)
|
|
index[j] = &*vi;
|
|
}
|
|
else if( !strcmp( pf.ElemName(i),"edge") && (n>0) )/******************** EDGE READING *******************************/
|
|
{
|
|
assert( pi.mask & Mask::IOM_EDGEINDEX );
|
|
EdgeIterator ei=Allocator<OpenMeshType>::AddEdges(m,n);
|
|
pf.SetCurElement(i);
|
|
for(int j=0;j<n;++j)
|
|
{
|
|
if(pi.cb && (j%1000)==0) pi.cb(50+j*50/n,"Edge Loading");
|
|
if( pf.Read(&ea)==-1 )
|
|
{
|
|
pi.status = PlyInfo::E_SHORTFILE;
|
|
return pi.status;
|
|
}
|
|
if( ea.v1<0 || ea.v2<0 || ea.v1>=m.vn || ea.v2>=m.vn)
|
|
{
|
|
pi.status = PlyInfo::E_BAD_VERT_INDEX_EDGE;
|
|
return pi.status;
|
|
}
|
|
(*ei).V(0) = index[ ea.v1 ];
|
|
(*ei).V(1) = index[ ea.v2 ];
|
|
++ei;
|
|
}
|
|
}
|
|
else if( !strcmp( pf.ElemName(i),"face") && (n>0) )/******************** FACE READING ****************************************/
|
|
{
|
|
int j;
|
|
|
|
FaceIterator fi=Allocator<OpenMeshType>::AddFaces(m,n);
|
|
pf.SetCurElement(i);
|
|
|
|
for(j=0;j<n;++j)
|
|
{
|
|
int k;
|
|
|
|
if(pi.cb && (j%1000)==0) pi.cb(50+j*50/n,"Face Loading");
|
|
if( pf.Read(&fa)==-1 )
|
|
{
|
|
pi.status = PlyInfo::E_SHORTFILE;
|
|
return pi.status;
|
|
}
|
|
if(fa.size!=3)
|
|
{ // Non triangular face are manageable ONLY if there are no Per Wedge attributes
|
|
if( ( pi.mask & Mask::IOM_WEDGCOLOR ) || ( pi.mask & Mask::IOM_WEDGTEXCOORD ) )
|
|
{
|
|
pi.status = PlyInfo::E_NO_3VERTINFACE;
|
|
return pi.status;
|
|
}
|
|
}
|
|
|
|
if(HasPolyInfo(m)) (*fi).Alloc(3);
|
|
|
|
if(HasPerFaceFlags(m) &&( pi.mask & Mask::IOM_FACEFLAGS) )
|
|
{
|
|
(*fi).Flags() = fa.flags;
|
|
}
|
|
|
|
if( pi.mask & Mask::IOM_FACEQUALITY )
|
|
{
|
|
(*fi).Q() = (typename OpenMeshType::FaceType::QualityType) fa.q;
|
|
}
|
|
|
|
if( pi.mask & Mask::IOM_FACECOLOR )
|
|
{
|
|
(*fi).C()[0] = fa.r;
|
|
(*fi).C()[1] = fa.g;
|
|
(*fi).C()[2] = fa.b;
|
|
(*fi).C()[3] = 255;
|
|
}
|
|
|
|
if( pi.mask & Mask::IOM_WEDGTEXCOORD )
|
|
{
|
|
for(int k=0;k<3;++k)
|
|
{
|
|
(*fi).WT(k).u() = fa.texcoord[k*2+0];
|
|
(*fi).WT(k).v() = fa.texcoord[k*2+1];
|
|
if(multit) (*fi).WT(k).n() = fa.texcoordind;
|
|
else (*fi).WT(k).n()=0; // safely intialize texture index
|
|
}
|
|
}
|
|
|
|
if( pi.mask & Mask::IOM_WEDGCOLOR )
|
|
{
|
|
if(FaceType::HasWedgeColor()){
|
|
for(int k=0;k<3;++k)
|
|
{
|
|
(*fi).WC(k)[0] = (unsigned char)(fa.colors[k*3+0]*255);
|
|
(*fi).WC(k)[1] = (unsigned char)(fa.colors[k*3+1]*255);
|
|
(*fi).WC(k)[2] = (unsigned char)(fa.colors[k*3+2]*255);
|
|
}
|
|
}
|
|
//if(FaceType::HasFaceColor()){
|
|
//if(pi.mask & Mask::IOM_FACECOLOR){
|
|
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()[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);
|
|
}
|
|
}
|
|
/// Now the temporary struct 'fa' is ready to be copied into the real face '*fi'
|
|
/// This loop
|
|
for(k=0;k<3;++k)
|
|
{
|
|
if( fa.v[k]<0 || fa.v[k]>=m.vn )
|
|
{
|
|
pi.status = PlyInfo::E_BAD_VERT_INDEX;
|
|
return pi.status;
|
|
}
|
|
(*fi).V(k) = index[ fa.v[k] ];
|
|
}
|
|
|
|
// tag faux vertices of first face
|
|
if (fa.size>3) fi->SetF(2);
|
|
|
|
for(k=0;k<pi.fdn;k++)
|
|
memcpy((char *)(&(*fi)) + pi.FaceData[k].offset1,
|
|
(char *)(&fa) + FPV[k].offset1,
|
|
FPV[k].memtypesize());
|
|
|
|
|
|
++fi;
|
|
|
|
// Non Triangular Faces Loop
|
|
// It performs a simple fan triangulation.
|
|
if(fa.size>3)
|
|
{
|
|
int curpos=int(fi-m.face.begin());
|
|
Allocator<OpenMeshType>::AddFaces(m,fa.size-3);
|
|
fi=m.face.begin()+curpos;
|
|
pi.mask |= Mask::IOM_BITPOLYGONAL;
|
|
}
|
|
for(int qq=0;qq<fa.size-3;++qq)
|
|
{
|
|
(*fi).V(0) = index[ fa.v[0] ];
|
|
for(k=1;k<3;++k)
|
|
{
|
|
if( fa.v[2+qq]<0 || fa.v[2+qq]>=m.vn )
|
|
{
|
|
pi.status = PlyInfo::E_BAD_VERT_INDEX;
|
|
return pi.status;
|
|
}
|
|
(*fi).V(k) = index[ fa.v[1+qq+k] ];
|
|
|
|
}
|
|
if( pi.mask & Mask::IOM_FACEQUALITY )
|
|
(*fi).Q() = (typename OpenMeshType::FaceType::QualityType)
|
|
fa.q;
|
|
if( pi.mask & Mask::IOM_FACECOLOR )
|
|
(*fi).C() = Color4b(fa.r,fa.g,fa.b,255);
|
|
// tag faux vertices of extra faces
|
|
fi->SetF(0);
|
|
if(qq<(fa.size-4)) fi->SetF(2);
|
|
|
|
for(k=0;k<pi.fdn;k++)
|
|
memcpy((char *)(&(*fi)) + pi.FaceData[k].offset1,
|
|
(char *)(&fa) + FPV[k].offset1, FPV[k].memtypesize());
|
|
++fi;
|
|
}
|
|
|
|
}
|
|
}else if( !strcmp( pf.ElemName(i),"tristrips") )//////////////////// LETTURA TRISTRIP DI STANFORD
|
|
{
|
|
int j;
|
|
pf.SetCurElement(i);
|
|
int numvert_tmp = (int)m.vert.size();
|
|
for(j=0;j<n;++j)
|
|
{
|
|
int k;
|
|
if(pi.cb && (j%1000)==0) pi.cb(50+j*50/n,"Tristrip Face Loading");
|
|
if( pf.Read(&tsa)==-1 )
|
|
{
|
|
pi.status = PlyInfo::E_SHORTFILE;
|
|
return pi.status;
|
|
}
|
|
int remainder=0;
|
|
for(k=0;k<tsa.size-2;++k)
|
|
{
|
|
if(pi.cb && (k%1000)==0) pi.cb(50+k*50/tsa.size,"Tristrip Face Loading");
|
|
if(tsa.v[k]<0 || tsa.v[k]>=numvert_tmp ) {
|
|
pi.status = PlyInfo::E_BAD_VERT_INDEX;
|
|
return pi.status;
|
|
}
|
|
if(tsa.v[k+2]==-1)
|
|
{
|
|
k+=2;
|
|
if(k%2) remainder=0;
|
|
else remainder=1;
|
|
continue;
|
|
}
|
|
Allocator<OpenMeshType>::AddFaces(m,1);
|
|
FaceType &tf =m.face.back();
|
|
tf.V(0) = index[ tsa.v[k+0] ];
|
|
tf.V(1) = index[ tsa.v[k+1] ];
|
|
tf.V(2) = index[ tsa.v[k+2] ];
|
|
if((k+remainder)%2) std::swap (tf.V(0), tf.V(1) );
|
|
}
|
|
}
|
|
}
|
|
else if( !strcmp( pf.ElemName(i),"range_grid") )//////////////////// LETTURA RANGEMAP DI STANFORD
|
|
{
|
|
//qDebug("Starting Reading of Range Grid");
|
|
if(RangeGridCols==0) // not initialized.
|
|
{
|
|
for(int co=0;co<int(pf.comments.size());++co)
|
|
{
|
|
std::string num_cols = "num_cols";
|
|
std::string num_rows = "num_rows";
|
|
std::string &c = pf.comments[co];
|
|
std::string bufstr,bufclean;
|
|
if( num_cols == c.substr(0,num_cols.length()) )
|
|
{
|
|
bufstr = c.substr(num_cols.length()+1);
|
|
RangeGridCols = atoi(bufstr.c_str());
|
|
}
|
|
if( num_rows == c.substr(0,num_cols.length()) )
|
|
{
|
|
bufstr = c.substr(num_rows.length()+1);
|
|
RangeGridRows = atoi(bufstr.c_str());
|
|
}
|
|
}
|
|
//qDebug("Rows %i Cols %i",RangeGridRows,RangeGridCols);
|
|
}
|
|
int totPnt = RangeGridCols*RangeGridRows;
|
|
// standard reading;
|
|
pf.SetCurElement(i);
|
|
for(int j=0;j<totPnt;++j)
|
|
{
|
|
if(pi.cb && (j%1000)==0) pi.cb(50+j*50/totPnt,"RangeMap Face Loading");
|
|
if( pf.Read(&rga)==-1 )
|
|
{
|
|
//qDebug("Error after loading %i elements",j);
|
|
pi.status = PlyInfo::E_SHORTFILE;
|
|
return pi.status;
|
|
}
|
|
else
|
|
{
|
|
if(rga.num_pts == 0)
|
|
RangeGridAuxVec.push_back(-1);
|
|
else
|
|
RangeGridAuxVec.push_back(rga.pts[0]);
|
|
}
|
|
}
|
|
//qDebug("Completed the reading of %i indexes",RangeGridAuxVec.size());
|
|
tri::FaceGrid(m, RangeGridAuxVec, RangeGridCols,RangeGridRows);
|
|
}
|
|
else
|
|
{
|
|
// Skippaggio elementi non gestiti
|
|
int n = pf.ElemNumber(i);
|
|
pf.SetCurElement(i);
|
|
|
|
for(int j=0;j<n;j++)
|
|
{
|
|
if( pf.Read(0)==-1)
|
|
{
|
|
pi.status = PlyInfo::E_SHORTFILE;
|
|
return pi.status;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Parsing texture names
|
|
m.textures.clear();
|
|
m.normalmaps.clear();
|
|
|
|
for(int co=0;co<int(pf.comments.size());++co)
|
|
{
|
|
std::string TFILE = "TextureFile";
|
|
std::string NFILE = "TextureNormalFile";
|
|
std::string &c = pf.comments[co];
|
|
// char buf[256];
|
|
std::string bufstr,bufclean;
|
|
int i,n;
|
|
|
|
if( TFILE == c.substr(0,TFILE.length()) )
|
|
{
|
|
bufstr = c.substr(TFILE.length()+1);
|
|
n = static_cast<int>(bufstr.length());
|
|
for(i=0;i<n;i++)
|
|
if( bufstr[i]!=' ' && bufstr[i]!='\t' && bufstr[i]>32 && bufstr[i]<125 ) bufclean.push_back(bufstr[i]);
|
|
|
|
char buf2[255];
|
|
ply::interpret_texture_name( bufclean.c_str(),filename,buf2 );
|
|
m.textures.push_back( std::string(buf2) );
|
|
}
|
|
/*if( !strncmp(c,NFILE,strlen(NFILE)) )
|
|
{
|
|
strcpy(buf,c+strlen(NFILE)+1);
|
|
n = strlen(buf);
|
|
for(i=j=0;i<n;i++)
|
|
if( buf[i]!=' ' && buf[i]!='\t' && buf[i]>32 && buf[i]<125 ) buf[j++] = buf[i];
|
|
|
|
buf[j] = 0;
|
|
char buf2[255];
|
|
__interpret_texture_name( buf,filename,buf2 );
|
|
m.normalmaps.push_back( string(buf2) );
|
|
}*/
|
|
}
|
|
|
|
// vn and fn should be correct but if someone wrongly saved some deleted elements they can be wrong.
|
|
m.vn = 0;
|
|
for(VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi)
|
|
if( ! (*vi).IsD() )
|
|
++m.vn;
|
|
|
|
m.fn = 0;
|
|
for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
|
|
if( ! (*fi).IsD() )
|
|
++m.fn;
|
|
|
|
tri::UpdateBounding<OpenMeshType>::Box(m);
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Caricamento camera da un ply
|
|
int LoadCamera(const char * filename)
|
|
{
|
|
vcg::ply::PlyFile pf;
|
|
if( pf.Open(filename,vcg::ply::PlyFile::MODE_READ)==-1 )
|
|
{
|
|
this->pi.status = pf.GetError();
|
|
return this->pi.status;
|
|
}
|
|
|
|
|
|
bool found = true;
|
|
int i;
|
|
for(i=0;i<23;++i)
|
|
{
|
|
if( pf.AddToRead(CameraDesc(i))==-1 )
|
|
{
|
|
found = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!found)
|
|
return this->pi.status;
|
|
|
|
for(i=0;i<int(pf.elements.size());i++)
|
|
{
|
|
int n = pf.ElemNumber(i);
|
|
|
|
if( !strcmp( pf.ElemName(i),"camera" ) )
|
|
{
|
|
pf.SetCurElement(i);
|
|
|
|
LoadPly_Camera ca;
|
|
|
|
for(int j=0;j<n;++j)
|
|
{
|
|
if( pf.Read( (void *)&(ca) )==-1 )
|
|
{
|
|
this->pi.status = PlyInfo::E_SHORTFILE;
|
|
return this->pi.status;
|
|
}
|
|
this->camera.valid = true;
|
|
this->camera.view_p[0] = ca.view_px;
|
|
this->camera.view_p[1] = ca.view_py;
|
|
this->camera.view_p[2] = ca.view_pz;
|
|
this->camera.x_axis[0] = ca.x_axisx;
|
|
this->camera.x_axis[1] = ca.x_axisy;
|
|
this->camera.x_axis[2] = ca.x_axisz;
|
|
this->camera.y_axis[0] = ca.y_axisx;
|
|
this->camera.y_axis[1] = ca.y_axisy;
|
|
this->camera.y_axis[2] = ca.y_axisz;
|
|
this->camera.z_axis[0] = ca.z_axisx;
|
|
this->camera.z_axis[1] = ca.z_axisy;
|
|
this->camera.z_axis[2] = ca.z_axisz;
|
|
this->camera.f = ca.focal;
|
|
this->camera.s[0] = ca.scalex;
|
|
this->camera.s[1] = ca.scaley;
|
|
this->camera.c[0] = ca.centerx;
|
|
this->camera.c[1] = ca.centery;
|
|
this->camera.viewport[0] = ca.viewportx;
|
|
this->camera.viewport[1] = ca.viewporty;
|
|
this->camera.k[0] = ca.k1;
|
|
this->camera.k[1] = ca.k2;
|
|
this->camera.k[2] = ca.k3;
|
|
this->camera.k[3] = ca.k4;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static bool LoadMask(const char * filename, int &mask)
|
|
{
|
|
PlyInfo pi;
|
|
return LoadMask(filename, mask,pi);
|
|
}
|
|
static bool LoadMask(const char * filename, int &mask, PlyInfo &pi)
|
|
{
|
|
mask=0;
|
|
vcg::ply::PlyFile pf;
|
|
if( pf.Open(filename,vcg::ply::PlyFile::MODE_READ)==-1 )
|
|
{
|
|
pi.status = pf.GetError();
|
|
return false;
|
|
}
|
|
|
|
if( pf.AddToRead(VertDesc( 0))!=-1 &&
|
|
pf.AddToRead(VertDesc( 1))!=-1 &&
|
|
pf.AddToRead(VertDesc( 2))!=-1 ) mask |= Mask::IOM_VERTCOORD;
|
|
if( pf.AddToRead(VertDesc(22))!=-1 &&
|
|
pf.AddToRead(VertDesc(23))!=-1 &&
|
|
pf.AddToRead(VertDesc(24))!=-1 ) mask |= Mask::IOM_VERTCOORD;
|
|
|
|
if( pf.AddToRead(VertDesc(12))!=-1 &&
|
|
pf.AddToRead(VertDesc(13))!=-1 &&
|
|
pf.AddToRead(VertDesc(14))!=-1 ) mask |= Mask::IOM_VERTNORMAL;
|
|
if( pf.AddToRead(VertDesc(25))!=-1 &&
|
|
pf.AddToRead(VertDesc(26))!=-1 &&
|
|
pf.AddToRead(VertDesc(27))!=-1 ) mask |= Mask::IOM_VERTNORMAL;
|
|
|
|
if( pf.AddToRead(VertDesc( 3))!=-1 ) mask |= Mask::IOM_VERTFLAGS;
|
|
if( pf.AddToRead(VertDesc( 4))!=-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(28))!=-1 ) mask |= Mask::IOM_VERTRADIUS;
|
|
if( pf.AddToRead(VertDesc(29))!=-1 ) mask |= Mask::IOM_VERTQUALITY;
|
|
if( pf.AddToRead(VertDesc( 5))!=-1 &&
|
|
pf.AddToRead(VertDesc( 6))!=-1 &&
|
|
pf.AddToRead(VertDesc( 7))!=-1 ) mask |= Mask::IOM_VERTCOLOR;
|
|
if( pf.AddToRead(VertDesc( 8))!=-1 &&
|
|
pf.AddToRead(VertDesc( 9))!=-1 &&
|
|
pf.AddToRead(VertDesc(10))!=-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) mask |= Mask::IOM_VERTTEXCOORD;
|
|
|
|
if( pf.AddToRead(VertDesc(16))!=-1 &&
|
|
pf.AddToRead(VertDesc(17))!=-1) mask |= Mask::IOM_VERTTEXCOORD;
|
|
|
|
if( pf.AddToRead(FaceDesc(0))!=-1 ) mask |= Mask::IOM_FACEINDEX;
|
|
if( pf.AddToRead(FaceDesc(1))!=-1 ) mask |= Mask::IOM_FACEFLAGS;
|
|
|
|
if( pf.AddToRead(FaceDesc(2))!=-1 ) mask |= Mask::IOM_FACEQUALITY;
|
|
if( pf.AddToRead(FaceDesc(3))!=-1 ) mask |= Mask::IOM_WEDGTEXCOORD;
|
|
if( pf.AddToRead(FaceDesc(5))!=-1 ) mask |= Mask::IOM_WEDGTEXMULTI;
|
|
if( pf.AddToRead(FaceDesc(4))!=-1 ) mask |= Mask::IOM_WEDGCOLOR;
|
|
if( pf.AddToRead(FaceDesc(6))!=-1 &&
|
|
pf.AddToRead(FaceDesc(7))!=-1 &&
|
|
pf.AddToRead(FaceDesc(8))!=-1 ) mask |= Mask::IOM_FACECOLOR;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
}; // end class
|
|
|
|
|
|
} // end namespace tri
|
|
} // end namespace io
|
|
} // end namespace vcg
|
|
|
|
#endif
|
|
|