Subversion Repositories gelsvn

/*

 *  ply_load.cpp

 *  GEL

 *

 *  Created by J. Andreas Bærentzen on 08/08/07.

 *  Copyright 2007 __MyCompanyName__. All rights reserved.

 *

 */

#include <stdio.h>

#include <math.h>

#include <strings.h>

#include "ply_load.h"

using namespace std;

using namespace Geometry;

using namespace CGLA;

typedef struct Vertex {

  float x,y,z;

  float r,g,b;

  float nx,ny,nz;

  void *other_props;       /* other properties */

} Vertex;

typedef struct Face {

  unsigned char nverts;    /* number of vertex indices in list */

  int *verts;              /* vertex index list */

  void *other_props;       /* other properties */

} Face;

char *elem_names[] = { /* list of the elements in the object */

  "vertex", "face"

};

PlyProperty vert_props[] = { /* list of property information for a vertex */

  {"x", Float32, Float32, offsetof(Vertex,x), 0, 0, 0, 0},

  {"y", Float32, Float32, offsetof(Vertex,y), 0, 0, 0, 0},

  {"z", Float32, Float32, offsetof(Vertex,z), 0, 0, 0, 0},

  {"r", Float32, Float32, offsetof(Vertex,r), 0, 0, 0, 0},

  {"g", Float32, Float32, offsetof(Vertex,g), 0, 0, 0, 0},

  {"b", Float32, Float32, offsetof(Vertex,b), 0, 0, 0, 0},

  {"nx", Float32, Float32, offsetof(Vertex,nx), 0, 0, 0, 0},

  {"ny", Float32, Float32, offsetof(Vertex,ny), 0, 0, 0, 0},

  {"nz", Float32, Float32, offsetof(Vertex,nz), 0, 0, 0, 0},

};

PlyProperty face_props[] = { /* list of property information for a face */

  {"vertex_indices", Int32, Int32, offsetof(Face,verts),

   1, Uint8, Uint8, offsetof(Face,nverts)},

};

/*** the PLY object ***/

static int nverts,nfaces;

static Vertex **vlist;

static Face **flist;

static PlyOtherProp *vert_other,*face_other;

static int per_vertex_color = 0;

static int has_normals = 0;

void read_file(FILE* f)

{

  int i,j;

  int elem_count;

  char *elem_name;

  PlyFile *in_ply;

  /*** Read in the original PLY object ***/

  in_ply  = read_ply (f);

  for (i = 0; i < in_ply->num_elem_types; i++) {

    /* prepare to read the i'th list of elements */

    elem_name = setup_element_read_ply (in_ply, i, &elem_count);

    if (equal_strings ("vertex", elem_name)) {

      /* create a vertex list to hold all the vertices */

      vlist = (Vertex **) malloc (sizeof (Vertex *) * elem_count);

      nverts = elem_count;

      /* set up for getting vertex elements */

      setup_property_ply (in_ply, &vert_props[0]);

      setup_property_ply (in_ply, &vert_props[1]);

      setup_property_ply (in_ply, &vert_props[2]);

      for (j = 0; j < in_ply->elems[i]->nprops; j++) {

	PlyProperty *prop;

	prop = in_ply->elems[i]->props[j];

	if (equal_strings ("r", prop->name)) {

	  setup_property_ply (in_ply, &vert_props[3]);

	  per_vertex_color = 1;

	}

	if (equal_strings ("g", prop->name)) {

	  setup_property_ply (in_ply, &vert_props[4]);

	  per_vertex_color = 1;

	}

	if (equal_strings ("b", prop->name)) {

	  setup_property_ply (in_ply, &vert_props[5]);

	  per_vertex_color = 1;

	}

	if (equal_strings ("nx", prop->name)) {

	  setup_property_ply (in_ply, &vert_props[6]);

	  has_normals = 1;

	}

	if (equal_strings ("ny", prop->name)) {

	  setup_property_ply (in_ply, &vert_props[7]);

	  has_normals = 1;

	}

	if (equal_strings ("nz", prop->name)) {

	  setup_property_ply (in_ply, &vert_props[8]);

	  has_normals = 1;

	}

      }

      vert_other = get_other_properties_ply (in_ply, 

					     offsetof(Vertex,other_props));

      /* grab all the vertex elements */

      for (j = 0; j < elem_count; j++) {

        vlist[j] = (Vertex *) malloc (sizeof (Vertex));

	vlist[j]->r = 1;

	vlist[j]->g = 1;

	vlist[j]->b = 1;

        get_element_ply (in_ply, (void *) vlist[j]);

      }

    }

    else if (equal_strings ("face", elem_name)) {

      /* create a list to hold all the face elements */

      flist = (Face **) malloc (sizeof (Face *) * elem_count);

      nfaces = elem_count;

      /* set up for getting face elements */

      setup_property_ply (in_ply, &face_props[0]);

      face_other = get_other_properties_ply (in_ply, 

					     offsetof(Face,other_props));

      /* grab all the face elements */

      for (j = 0; j < elem_count; j++) {

        flist[j] = (Face *) malloc (sizeof (Face));

        get_element_ply (in_ply, (void *) flist[j]);

      }

    }

    else

      get_other_element_ply (in_ply);

  }

  close_ply (in_ply);

  free_ply (in_ply);

}

void ply_load(const std::string& fn, Geometry::TriMesh& mesh)

{

	Vec3f v;

	FILE* f = fopen(fn.c_str(),"rb");

	read_file(f);

	mesh.materials.resize(1);

	int i;

	for (i = 0; i < nverts; i++)

		mesh.geometry.add_vertex(Vec3f(vlist[i]->x, vlist[i]->y, vlist[i]->z));

	for (i = 0; i < nfaces; i++) {

		 for(int j=2;j<flist[i]->nverts;++j)

			{

				mesh.mat_idx.push_back(0);

				Vec3i f_geo(Vec3i(flist[i]->verts[0], flist[i]->verts[1], flist[i]->verts[j]));

				mesh.geometry.add_face(f_geo);

			}

  }

  cout << "LOADED " << nverts << " verts " << nfaces << " faces " << endl;

}