source: GTP/trunk/Lib/Vis/Preprocessing/src/PlyParser.cpp @ 752

#include <iostream>
using namespace std;
#include <ply.h>
#include <stdio.h>

#include "PlyParser.h"

#include "SceneGraph.h"
#include "Mesh.h"


// int facesPerMesh = 100000000;
int facesPerMesh = 30;
bool useRandomMaterial = false;
bool indexVertices = true;

/* user's vertex and face definitions for a polygonal object */

typedef struct Vertex {
  int id;
  float x,y,z;
  void *other_props;       /* other properties */
} Vertex;

typedef struct PlyFace {
  int id;
  unsigned char nverts;    /* number of vertex indices in list */
  int *verts;              /* vertex index list */
  void *other_props;       /* other properties */
} PlyFace;



char *elem_names[] = { /* list of the kinds of elements in the user's object */
  "vertex", "face"
};


PlyProperty vert_props[] = { /* list of property information for a vertex */
  {"x", PLY_FLOAT, PLY_FLOAT, offsetof(Vertex,x), 0, 0, 0, 0},
  {"y", PLY_FLOAT, PLY_FLOAT, offsetof(Vertex,y), 0, 0, 0, 0},
  {"z", PLY_FLOAT, PLY_FLOAT, offsetof(Vertex,z), 0, 0, 0, 0}
};

PlyProperty face_props[] = { /* list of property information for a face */
  {"vertex_indices", PLY_INT, PLY_INT, offsetof(PlyFace,verts),
   1, PLY_UCHAR, PLY_UCHAR, offsetof(PlyFace,nverts)}
};

unsigned char has_fverts;
static PlyFace **flist;


bool
PlyParser::ParseSingleFile(const string filename,
                                                   SceneGraphNode *root)
{
  /*** the PLY object ***/
  int nverts;
  Vertex **vlist;
  PlyOtherElems *other_elements = NULL;
  PlyOtherProp *vert_other;
  int nelems;
  char **elist;
  int num_comments;
  char **comments;
  int num_obj_info;
  char **obj_info;
  int file_type;
  
  int i,j;
  PlyFile *ply;
  int nprops;
  int num_elems;
  PlyProperty **plist;
  char *elem_name;
  float version;
  
 
  /*** Read in the original PLY object ***/
 FILE *file = fopen(filename.c_str(), "rb");
 
 ply  = ply_read (file, &nelems, &elist);
 ply_get_info (ply, &version, &file_type);

 int nfaces;
 
 for (i = 0; i < nelems; i++) {
   
   /* get the description of the first element */
   elem_name = elist[i];
   plist = ply_get_element_description (ply, elem_name, &num_elems, &nprops);
   
   if (equal_strings ("vertex", elem_name)) {
         
         /* create a vertex list to hold all the vertices */
         vlist = (Vertex **) malloc (sizeof (Vertex *) * num_elems);
         nverts = num_elems;
         
         /* set up for getting vertex elements */
         
         ply_get_property (ply, elem_name, &vert_props[0]);
         ply_get_property (ply, elem_name, &vert_props[1]);
         ply_get_property (ply, elem_name, &vert_props[2]);
         vert_other = ply_get_other_properties (ply, elem_name,
                                                                                        offsetof(Vertex,other_props));
         
         /* grab all the vertex elements */
         for (j = 0; j < num_elems; j++) {
           vlist[j] = (Vertex *) malloc (sizeof (Vertex));
           ply_get_element (ply, (void *) vlist[j]);
           vlist[j]->id = j;
           //      cout<<"("<<vlist[j]->x<<","<<vlist[j]->y<<","<<vlist[j]->z<<")"<<endl;
         }
   }
   else
         if (equal_strings ("face", elem_name)) {
           /* create a list to hold all the face elements */
           ALLOCN(flist, PlyFace *, num_elems);
           nfaces = num_elems;
           cerr<<"num faces="<<nfaces<<endl;
           
           /* set up for getting face elements */
           has_fverts = false;
           
           for (j=0; j<nprops; j++)
                 {
                   if (equal_strings("vertex_indices", plist[j]->name))
                         {
                           ply_get_property (ply, elem_name, &face_props[0]);
                           has_fverts = true;
                         }
                 }

           //      face_other = ply_get_other_properties (ply, elem_name,
           //                                                                                     offsetof(Face,other_props));
           
           /* test for necessary properties */
           if (!has_fverts) {
                 fprintf(stderr,"Faces must have vertex indices\n");
                 exit(-1);
           }

           /* grab all the face elements */
           for (j = 0; j < num_elems; j++) {
                 ALLOCN(flist[j], PlyFace, 1);
                 ply_get_element (ply, (void *) flist[j]);
                 flist[j]->id = j;

                 //              for (int k  = 0; k < flist[j]->nverts; k++) 
                 //                cout<<flist[j]->verts[k]<<" ";
                 //              cout<<endl;
           }
         } else
           other_elements = ply_get_other_element (ply, elem_name, num_elems);


 }


 
 comments = ply_get_comments (ply, &num_comments);
 obj_info = ply_get_obj_info (ply, &num_obj_info);
 
 ply_close (ply);

 SceneGraphNode *currentNode = root;

 cerr<<"Baking faces into meshes"<<endl;

 // bake the faces into meshes
 Mesh meshProxy;
 // only one face per mesh
 VertexContainer vertices;

 for (i = 0; i < nfaces; i++) {
   if (i % facesPerMesh == 0) {
         if (meshProxy.mFaces.size()) {

           if (indexVertices)
                 meshProxy.IndexVertices();
           
           Mesh *mesh = new Mesh(meshProxy.mVertices.size(),
                                                         meshProxy.mFaces.size());
           
           
           //      cout<<"C="<<mesh->mVertices.capacity();
           mesh->mVertices = meshProxy.mVertices;
           //      cout<<" NC="<<mesh->mVertices.capacity()<<" S="<<mesh->mVertices.size()<<endl;
           
           mesh->mFaces = meshProxy.mFaces;
           
           if (useRandomMaterial)
                 mesh->AssignRandomMaterial();

           mesh->Preprocess();
           // make an instance of this mesh
           MeshInstance *mi = new MeshInstance(mesh);
           currentNode->mGeometry.push_back(mi);
         }

         meshProxy.Clear();
   }
                 
   // only one face per mesh
   VertexIndexContainer vc;
   
   // add vertices
   for (int k  = 0; k < flist[i]->nverts; k++) {
         Vertex *v = vlist[flist[i]->verts[k]];
         vc.push_back(meshProxy.mVertices.size());
         meshProxy.mVertices.push_back(Vector3(v->x, v->y, v->z));
   }
   
   meshProxy.mFaces.push_back(new Face(vc));
 }
 
 if (meshProxy.mFaces.size()) {

   if (indexVertices)
         meshProxy.IndexVertices();

   Mesh *mesh = new Mesh(meshProxy.mVertices.size(),
                                                 meshProxy.mFaces.size());

   mesh->mVertices = meshProxy.mVertices;
   
   mesh->mFaces = meshProxy.mFaces;
   
   if (useRandomMaterial)
         mesh->AssignRandomMaterial();
   
   mesh->Preprocess();
   // make an instance of this mesh
   MeshInstance *mi = new MeshInstance(mesh);
   currentNode->mGeometry.push_back(mi);
 }

 // make sure that no face gets deleted by the destructor!
 meshProxy.Clear();

 for (i=0; i < nverts; i++)
   free(vlist[i]);

 free(vlist);

 for (i=0; i < nfaces; i++)
   free(flist[i]);

 free(flist);
 
 
 return true;


}

bool
PlyParser::ParseFile(const string filename,
                                         SceneGraphNode **root,
                                         const bool loadPolygonsAsMeshes)
{
  vector<string> filelist;
  
  if (strstr(filename.c_str(), ".plb")) {
        // parse the filelist
        FILE *f = fopen(filename.c_str(), "rt");
        char s[64];
        if (!f) {
          cerr<<"Cannot open .plb file"<<endl;
          exit(1);
        }
        while (fgets(s,64,f)) {
          // remove nl
          s[strlen(s)-1] = 0;
          filelist.push_back(s);
        }
        fclose(f);

  } else
        filelist.push_back(filename);

  *root = new SceneGraphNode;

  for (int i=0; i < filelist.size(); i++) {
        if (!ParseSingleFile(filelist[i], *root)) {
          cerr<<"Ply parse error. Quiting ...\n";
          exit(1);
        }
  }
  return true;
}