Beispiel #1
0
returnPLY loadPly(FILE* f) 
{

  PlyFile* input;

  // get the ply structure and open the file
  input = read_ply(f);

  // read in the data
  store_ply(input, 
	    &vertices, &faces, 
	    &vertexcount, &facecount,
	    &vertexnormals, &facenormals);

  // close the file
  close_ply(input);
  printf("vertexcount: %d\n", vertexcount);

  /*find_center(cx, cy, cz, x_min, x_max, 
	      y_min, y_max, z_min, z_max); 
  printf("geometry center = %f %f %f \n", cx, cy, cz); 
  printf("geometry bound = x: %f %f y: %f %f z: %f %f\n", 
	 x_min, x_max, y_min, y_max, z_min, z_max); */

  returnPLY _returnPLY(vertices,faces,vertexcount,facecount,vertexnormals, facenormals);

  return _returnPLY;
}
Beispiel #2
0
void	write_file(const char* strName)
{
  int i;
  PlyFile *ply;
  int num_elem_types;

  /*** Write out the transformed PLY object ***/
  FILE* pFile = fopen(strName,"w");

  ply = write_ply (pFile, nelems, elem_names, PLY_ASCII);

  /* describe what properties go into the vertex elements */

  describe_element_ply (ply, "vertex", nverts);
  describe_property_ply (ply, &vert_props[0]);
  describe_property_ply (ply, &vert_props[1]);
  describe_property_ply (ply, &vert_props[2]);
  if (has_normals) {
    describe_property_ply (ply, &vert_props[4]);
    describe_property_ply (ply, &vert_props[5]);
    describe_property_ply (ply, &vert_props[6]);
  }
  if (texture_coords) {
    describe_property_ply (ply, &vert_props[7]);
    describe_property_ply (ply, &vert_props[8]);
  }

  describe_element_ply (ply, "face", nfaces);
  describe_property_ply (ply, &face_props[0]);

  for (i = 0; i < ncomments; i++)
    append_comment_ply (ply, comments[i]);

  append_comment_ply (ply, "converted from OBJ by obj2ply");

  header_complete_ply (ply);

  /* set up and write the vertex elements */
  put_element_setup_ply (ply, "vertex");
  for (i = 0; i < nverts; i++)
    put_element_ply (ply, &vVertex[i]);//(void *) &vlist[i]);

  /* set up and write the face elements */
  put_element_setup_ply (ply, "face");
  for (i = 0; i < nfaces; i++){
	  int idx[3];
	  memcpy(idx,&vIndex[i*3],sizeof(int)*3);
	  Face f;
	  f.nverts	=	3;
	  f.verts	=	idx;
    put_element_ply (ply, (void *)&f);// &flist[i]);
  }

  close_ply (ply);
  free_ply (ply);

  fclose(pFile);
}
Beispiel #3
0
read_file()
{
  int i,j;
  int elem_count;
  char *elem_name;

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

  in_ply = read_ply (stdin);

  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]);
      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));
        get_element_ply (in_ply, (void *) vlist[j]);
      }
    }
    else
      get_other_element_ply (in_ply);
  }

  close_ply (in_ply);
}
Beispiel #4
0
write_file()
{
  int i;
  PlyFile *ply;
  char **elist;
  int num_elem_types;

  /*** Write out the transformed PLY object ***/

  elist = get_element_list_ply (in_ply, &num_elem_types);
  ply = write_ply (stdout, num_elem_types, elist, in_ply->file_type);

  /* describe what properties go into the vertex elements */

  describe_element_ply (ply, "vertex", nverts);
  describe_property_ply (ply, &vert_props[0]);
  describe_property_ply (ply, &vert_props[1]);
  describe_property_ply (ply, &vert_props[2]);
  describe_other_properties_ply (ply, vert_other, offsetof(Vertex,other_props));

  describe_other_elements_ply (ply, in_ply->other_elems);

  copy_comments_ply (ply, in_ply);
  append_comment_ply (ply, "modified by xformply");
  copy_obj_info_ply (ply, in_ply);

  header_complete_ply (ply);

  /* set up and write the vertex elements */
  put_element_setup_ply (ply, "vertex");
  for (i = 0; i < nverts; i++)
    put_element_ply (ply, (void *) vlist[i]);

  put_other_elements_ply (ply);

  close_ply (ply);
  free_ply (ply);
}
Beispiel #5
0
write_file()
{
  int i;
  PlyFile *ply;
  int num_elem_types;

  /*** Write out the transformed PLY object ***/

  ply = write_ply (stdout, nelems, elem_names, PLY_ASCII);

  /* describe what properties go into the vertex elements */

  describe_element_ply (ply, "vertex", nverts);
  describe_property_ply (ply, &vert_props[0]);
  describe_property_ply (ply, &vert_props[1]);
  describe_property_ply (ply, &vert_props[2]);

  describe_element_ply (ply, "face", nfaces);
  describe_property_ply (ply, &face_props[0]);

  append_comment_ply (ply, "created by platoply");

  header_complete_ply (ply);

  /* set up and write the vertex elements */
  put_element_setup_ply (ply, "vertex");
  for (i = 0; i < nverts; i++)
    put_element_ply (ply, (void *) &vlist[i]);

  /* set up and write the face elements */
  put_element_setup_ply (ply, "face");
  for (i = 0; i < nfaces; i++)
    put_element_ply (ply, (void *) &flist[i]);

  close_ply (ply);
  free_ply (ply);
}
Beispiel #6
0
void
read_file(void)
{
  int i,j;
  int elem_count;
  char *elem_name;
  PlyFile *in_ply;

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

  in_ply  = read_ply (stdin);

  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);
}
Beispiel #7
0
void write_file ( void )

/******************************************************************************/
/*
  Purpose:

    WRITE_FILE writes the PLY file to the standard output unit.

  Modified:

    17 January 2011

  Author:

    Greg Turk
*/
{
  int i;
  int num_elem_types;
  PlyFile *ply;
/*
  Write out the transformed PLY object.
*/
  ply = write_ply (stdout, nelems, elem_names, PLY_ASCII);
/*
  Describe what properties go into the vertex elements.
*/
  describe_element_ply (ply, "vertex", nverts);
  describe_property_ply (ply, &vert_props[0]);
  describe_property_ply (ply, &vert_props[1]);
  describe_property_ply (ply, &vert_props[2]);

  if ( has_normals )
  {
    describe_property_ply (ply, &vert_props[3]);
    describe_property_ply (ply, &vert_props[4]);
    describe_property_ply (ply, &vert_props[5]);
  }

  if (texture_coords)
  {
    describe_property_ply (ply, &vert_props[6]);
    describe_property_ply (ply, &vert_props[7]);
  }

  describe_element_ply (ply, "face", nfaces);
  describe_property_ply (ply, &face_props[0]);
/*
  Insert the comments.
*/
  for (i = 0; i < ncomments; i++)
  {
    append_comment_ply (ply, comments[i]);
  }
  append_comment_ply (ply, "converted from OBJ by obj2ply");

  header_complete_ply (ply);
/*
  Set up and write the vertex elements.
*/
  put_element_setup_ply (ply, "vertex");
  for (i = 0; i < nverts; i++)
  {
    put_element_ply (ply, (void *) &vlist[i]);
  }
/*
  Set up and write the face elements.
*/
  put_element_setup_ply (ply, "face");
  for (i = 0; i < nfaces; i++)
  {
    put_element_ply (ply, (void *) &flist[i]);
  }

  close_ply ( ply );
  free_ply ( ply );

  return;
}
Beispiel #8
0
main(int argc, char *argv[])
{
  int i,j,k;
  PlyFile *in_ply;
  PlyFile *out_ply;
  int nelems;
  char **elist;
  int file_type;
  float version;
  int nprops;
  int num_elems;
  PlyProperty **plist;
  PlyProperty **plist_copy;
  PlyProperty *prop;
  char *elem_name;
  char *data;
  int offset;
  int *offset_list;
  int **lists;
  int *list_count;
  char **list_ptr;
  int verbose_flag = 0;

#ifndef WRITE_ASCII
#ifndef WRITE_BINARY

  fprintf (stderr, "'%s' compiled incorrectly.\n", argv[0]);
  fprintf (stderr,
           "Must have WRITE_ASCII or WRITE_BINARY defined during compile.\n");
  exit (-1);

#endif
#endif

  /* maybe print out help message */

#ifdef WRITE_ASCII
  if (argc > 2 || (argc == 2 && !equal_strings (argv[1], "-p"))) {
    fprintf (stderr, "usage: %s [flags] <infile >outfile\n", argv[0]);
    fprintf (stderr, "          -p (print element labels)\n");
    exit (0);
  }
#endif

#ifdef WRITE_BINARY
  if (argc > 1) {
    fprintf (stderr, "usage: %s <infile >outfile\n", argv[0]);
    exit (0);
  }
#endif

  if (argc == 2 && equal_strings (argv[1], "-p"))
    verbose_flag = 1;

  /* open the input and output files */

  in_ply  = read_ply (stdin);
  elist = get_element_list_ply (in_ply, &nelems);

#ifdef WRITE_ASCII
  out_ply = write_ply (stdout, nelems, elist, PLY_ASCII);
#endif

#ifdef WRITE_BINARY
  out_ply = write_ply (stdout, nelems, elist, PLY_BINARY_BE);
#endif

  /* allocate space for various lists that keep track of the elements */

  plist_copy = (PlyProperty **) malloc (sizeof (PlyProperty *) * nelems);
  offset_list = (int *) malloc (sizeof (int) * nelems);
  lists = (int **) malloc (sizeof (int *) * nelems);
  list_count = (int *) malloc (sizeof (int));

  /* go through each kind of element that we learned is in the file */
  /* and come up with a list that has offsets for all properties */

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

    /* get the description of the element */
    elem_name = elist[i];
    plist = get_element_description_ply(in_ply, elem_name, &num_elems, &nprops);

    /* make room for a list of the lists in an element, so that */
    /* we can later easily free up the space created by malloc'ed lists */

    list_count[i] = 0;
    lists[i] = (int *) malloc (sizeof (int) * nprops);

    /* set up pointers into data */

    offset = 0;
    for (j = 0; j < nprops; j++) {
      plist[j]->offset = offset;
      offset += 8;
      if (plist[j]->is_list) {
        plist[j]->count_offset = offset;
        lists[i][list_count[i]] = offset - 8;
        list_count[i]++;
        offset += 8;
      }
    }

    offset_list[i] = offset;

    /* copy the property list */

    plist_copy[i] = (PlyProperty *) malloc (sizeof (PlyProperty) * nprops);
    prop = plist_copy[i];

    for (j = 0; j < nprops; j++) {
      prop->name = plist[j]->name;
      prop->external_type = plist[j]->external_type;
      prop->internal_type = plist[j]->external_type;
      prop->offset = plist[j]->offset;
      prop->is_list = plist[j]->is_list;
      prop->count_external = plist[j]->count_external;
      prop->count_internal = plist[j]->count_external;
      prop->count_offset = plist[j]->count_offset;
      prop++;
    }

    element_layout_ply (out_ply, elem_name, num_elems, nprops, plist_copy[i]);
  }

  /* copy the comments and obj_info */

  copy_comments_ply (out_ply, in_ply);
  copy_obj_info_ply (out_ply, in_ply);

  /* finish the header for the output file */
  header_complete_ply (out_ply);

  /* copy all the element information */

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

    /* get the description of the element */
    elem_name = elist[i];
    plist = get_element_description_ply(in_ply, elem_name, &num_elems, &nprops);

    /* allocate space for an element */
    data = (char *) malloc (8 * offset_list[i]);

    /* set up for getting elements */
    get_element_setup_ply (in_ply, elem_name, nprops, plist_copy[i]);
    put_element_setup_ply (out_ply, elem_name);

    /* possibly print out name of element */
    if (verbose_flag)
      fprintf (out_ply->fp, "%s:\n", elem_name);

    /* copy all the elements */

    if (list_count[i]) {
      /* need to free the lists */
      for (j = 0; j < num_elems; j++) {
        get_element_ply (in_ply, (void *) data);
        put_element_ply (out_ply, (void *) data);
        for (k = 0; k < list_count[i]; k++) {
          list_ptr = (char **) (data + lists[i][k]);
          free (*list_ptr);
        }
      }
    }
    else {
      /* no lists */
      for (j = 0; j < num_elems; j++) {
        get_element_ply (in_ply, (void *) data);
        put_element_ply (out_ply, (void *) data);
      }
    }

  }

  /* close the PLY files */

  close_ply (in_ply);
  close_ply (out_ply);
}
Beispiel #9
0
bool
TrisetObject::loadPLY(QString flnm)
{
  m_position = Vec(0,0,0);
  m_scale = Vec(1,1,1);

  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;

  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},
    {"red", Float32, Float32, offsetof(Vertex,r), 0, 0, 0, 0},
    {"green", Float32, Float32, offsetof(Vertex,g), 0, 0, 0, 0},
    {"blue", 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 ***/

  int nverts,nfaces;
  Vertex **vlist;
  Face **flist;

  PlyOtherProp *vert_other,*face_other;

  bool per_vertex_color = false;
  bool has_normals = false;

  int i,j;
  int elem_count;
  char *elem_name;
  PlyFile *in_ply;


  /*** Read in the original PLY object ***/
  FILE *fp = fopen(flnm.toAscii().data(), "rb");

  in_ply  = read_ply (fp);

  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) ||
	    equal_strings ("red", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[3]);
	  per_vertex_color = true;
	}
	if (equal_strings ("g", prop->name) ||
	    equal_strings ("green", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[4]);
	  per_vertex_color = true;
	}
	if (equal_strings ("b", prop->name) ||
	    equal_strings ("blue", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[5]);
	  per_vertex_color = true;
	}
	if (equal_strings ("nx", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[6]);
	  has_normals = true;
	}
	if (equal_strings ("ny", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[7]);
	  has_normals = true;
	}
	if (equal_strings ("nz", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[8]);
	  has_normals = true;
	}
      }

      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));
        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);
  
  if (Global::volumeType() == Global::DummyVolume)
    {
      float minX, maxX;
      float minY, maxY;
      float minZ, maxZ;
      minX = maxX = vlist[0]->x;
      minY = maxY = vlist[0]->y;
      minZ = maxZ = vlist[0]->z;
      for(int i=0; i<nverts; i++)
	{
	  minX = qMin(minX, vlist[i]->x);
	  maxX = qMax(maxX, vlist[i]->x);
	  minY = qMin(minY, vlist[i]->y);
	  maxY = qMax(maxY, vlist[i]->y);
	  minZ = qMin(minZ, vlist[i]->z);
	  maxZ = qMax(maxZ, vlist[i]->z);
	}
      minX = floor(minX);
      minY = floor(minY);
      minZ = floor(minZ);
      maxX = ceil(maxX);
      maxY = ceil(maxY);
      maxZ = ceil(maxZ);
      int h = maxX-minX+1;
      int w = maxY-minY+1;
      int d = maxZ-minZ+1;

      m_nX = d;
      m_nY = w;
      m_nZ = h;
      m_position = Vec(-minX, -minY, -minZ);

//      bool ok;
//      QString text = QInputDialog::getText(0,
//					   "Please enter grid size",
//					   "Grid Size",
//					   QLineEdit::Normal,
//					   QString("%1 %2 %3").\
//					   arg(d).arg(w).arg(h),
//					   &ok);
//      if (!ok || text.isEmpty())
//	{
//	  QMessageBox::critical(0, "Cannot load PLY", "No grid");
//	  return false;
//	}
//      
//      int nx=0;
//      int ny=0;
//      int nz=0;
//      QStringList gs = text.split(" ", QString::SkipEmptyParts);
//      if (gs.count() > 0) nx = gs[0].toInt();
//      if (gs.count() > 1) ny = gs[1].toInt();
//      if (gs.count() > 2) nz = gs[2].toInt();
//      if (nx > 0 && ny > 0 && nz > 0)
//	{
//	  m_nX = nx;
//	  m_nY = ny;
//	  m_nZ = nz;
//	}
//      else
//	{
//	  QMessageBox::critical(0, "Cannot load triset", "No grid");
//	  return false;
//	}
//
//      if (d == m_nX && w == m_nY && h == m_nZ)
//	m_position = Vec(-minX, -minY, -minZ);
    }
  else
    {
      Vec dim = VolumeInformation::volumeInformation(0).dimensions;
      m_nZ = dim.x;
      m_nY = dim.y;
      m_nX = dim.z;
    }

  m_vertices.resize(nverts);
  for(int i=0; i<nverts; i++)
    m_vertices[i] = Vec(vlist[i]->x,
			vlist[i]->y,
			vlist[i]->z);


  m_normals.clear();
  if (has_normals)
    {
      m_normals.resize(nverts);
      for(int i=0; i<nverts; i++)
	m_normals[i] = Vec(vlist[i]->nx,
			   vlist[i]->ny,
			   vlist[i]->nz);
    }

  m_vcolor.clear();
  if (per_vertex_color)
    {
      m_vcolor.resize(nverts);
      for(int i=0; i<nverts; i++)
	m_vcolor[i] = Vec(vlist[i]->r/255.0f,
			  vlist[i]->g/255.0f,
			  vlist[i]->b/255.0f);
    }

  // only triangles considered
  int ntri=0;
  for (int i=0; i<nfaces; i++)
    {
      if (flist[i]->nverts >= 3)
	ntri++;
    }
  m_triangles.resize(3*ntri);

  int tri=0;
  for(int i=0; i<nfaces; i++)
    {
      if (flist[i]->nverts >= 3)
	{
	  m_triangles[3*tri+0] = flist[i]->verts[0];
	  m_triangles[3*tri+1] = flist[i]->verts[1];
	  m_triangles[3*tri+2] = flist[i]->verts[2];
	  tri++;
	}
    }



  m_tvertices.resize(nverts);
  m_tnormals.resize(nverts);
  m_texValues.resize(nverts);


  Vec bmin = m_vertices[0];
  Vec bmax = m_vertices[0];
  for(int i=0; i<nverts; i++)
    {
      bmin = StaticFunctions::minVec(bmin, m_vertices[i]);
      bmax = StaticFunctions::maxVec(bmax, m_vertices[i]);
    }
  m_centroid = (bmin + bmax)/2;

  m_enclosingBox[0] = Vec(bmin.x, bmin.y, bmin.z);
  m_enclosingBox[1] = Vec(bmax.x, bmin.y, bmin.z);
  m_enclosingBox[2] = Vec(bmax.x, bmax.y, bmin.z);
  m_enclosingBox[3] = Vec(bmin.x, bmax.y, bmin.z);
  m_enclosingBox[4] = Vec(bmin.x, bmin.y, bmax.z);
  m_enclosingBox[5] = Vec(bmax.x, bmin.y, bmax.z);
  m_enclosingBox[6] = Vec(bmax.x, bmax.y, bmax.z);
  m_enclosingBox[7] = Vec(bmin.x, bmax.y, bmax.z);


  m_pointStep = qMax(1, nverts/50000);

//  QMessageBox::information(0, "", QString("%1 %2 %3\n%4 %5").	\
//			   arg(m_nX).arg(m_nY).arg(m_nZ).	\
//			   arg(m_vertices.count()).		\
//			   arg(m_triangles.count()/3));

  m_fileName = flnm;

  return true;
}
Beispiel #10
0
void
TrisetObject::save()
{
  bool has_normals = (m_normals.count() > 0);
  bool per_vertex_color = (m_vcolor.count() > 0);

  QString flnm = QFileDialog::getSaveFileName(0,
					      "Export mesh to file",
					      Global::previousDirectory(),
					      "*.ply");
  if (flnm.size() == 0)
    return;

  typedef struct PlyFace
  {
    unsigned char nverts;    /* number of Vertex indices in list */
    int *verts;              /* Vertex index list */
  } PlyFace;

  typedef struct
  {
    float  x,  y,  z;  /**< Vertex coordinates */
    float nx, ny, nz;  /**< Vertex normal */
    uchar r, g, b;
  } myVertex ;


  PlyProperty vert_props[]  = { /* list of property information for a PlyVertex */
    {"x", Float32, Float32,  offsetof( myVertex,x ), 0, 0, 0, 0},
    {"y", Float32, Float32,  offsetof( myVertex,y ), 0, 0, 0, 0},
    {"z", Float32, Float32,  offsetof( myVertex,z ), 0, 0, 0, 0},
    {"nx", Float32, Float32, offsetof( myVertex,nx ), 0, 0, 0, 0},
    {"ny", Float32, Float32, offsetof( myVertex,ny ), 0, 0, 0, 0},
    {"nz", Float32, Float32, offsetof( myVertex,nz ), 0, 0, 0, 0},
    {"red", Uint8, Uint8,    offsetof( myVertex,r ), 0, 0, 0, 0},
    {"green", Uint8, Uint8,  offsetof( myVertex,g ), 0, 0, 0, 0},
    {"blue", Uint8, Uint8,   offsetof( myVertex,b ), 0, 0, 0, 0}
  };

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


  PlyFile    *ply;
  FILE       *fp = fopen(flnm.toAscii().data(),
			 bin ? "wb" : "w");

  PlyFace     face ;
  int         verts[3] ;
  char       *elem_names[]  = { "vertex", "face" };
  ply = write_ply (fp,
		   2,
		   elem_names,
		   bin? PLY_BINARY_LE : PLY_ASCII );

  int nvertices = m_vertices.count();
  /* describe what properties go into the PlyVertex elements */
  describe_element_ply ( ply, "vertex", nvertices );
  describe_property_ply ( ply, &vert_props[0] );
  describe_property_ply ( ply, &vert_props[1] );
  describe_property_ply ( ply, &vert_props[2] );
  describe_property_ply ( ply, &vert_props[3] );
  describe_property_ply ( ply, &vert_props[4] );
  describe_property_ply ( ply, &vert_props[5] );
  describe_property_ply ( ply, &vert_props[6] );
  describe_property_ply ( ply, &vert_props[7] );
  describe_property_ply ( ply, &vert_props[8] );

  /* describe PlyFace properties (just list of PlyVertex indices) */
  int ntriangles = m_triangles.count()/3;
  describe_element_ply ( ply, "face", ntriangles );
  describe_property_ply ( ply, &face_props[0] );

  header_complete_ply ( ply );


  /* set up and write the PlyVertex elements */
  put_element_setup_ply ( ply, "vertex" );

  for(int i=0; i<m_vertices.count(); i++)
    {
      myVertex vertex;
      vertex.x = m_vertices[i].x*m_scale.x;
      vertex.y = m_vertices[i].y*m_scale.y;
      vertex.z = m_vertices[i].z*m_scale.z;
      if (has_normals)
	{
	  vertex.nx = m_normals[i].x;
	  vertex.ny = m_normals[i].y;
	  vertex.nz = m_normals[i].z;
	}
      if (per_vertex_color)
	{
	  vertex.r = 255*m_vcolor[i].x;
	  vertex.g = 255*m_vcolor[i].y;
	  vertex.b = 255*m_vcolor[i].z;
	}
      put_element_ply ( ply, ( void * ) &vertex );
    }

  put_element_setup_ply ( ply, "face" );
  face.nverts = 3 ;
  face.verts  = verts ;
  for(int i=0; i<m_triangles.count()/3; i++)
    {
      int v0 = m_triangles[3*i];
      int v1 = m_triangles[3*i+1];
      int v2 = m_triangles[3*i+2];

      face.verts[0] = v0;
      face.verts[1] = v1;
      face.verts[2] = v2;

      put_element_ply ( ply, ( void * ) &face );
    }

  close_ply ( ply );
  free_ply ( ply );
  fclose( fp ) ;

  QMessageBox::information(0, "Save Mesh", "done");
}
bool
MeshGenerator::loadPLY(QString flnm)
{
  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},
    {"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},
    {"red", Uint8, Uint8, offsetof(Vertex,r), 0, 0, 0, 0},
    {"green", Uint8, Uint8, offsetof(Vertex,g), 0, 0, 0, 0},
    {"blue", Uint8, Uint8, offsetof(Vertex,b), 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 ***/
  PlyOtherProp *vert_other,*face_other;

  bool per_vertex_color = false;
  bool has_normals = false;

  int i,j;
  int elem_count;
  char *elem_name;
  PlyFile *in_ply;


  /*** Read in the original PLY object ***/
  FILE *fp = fopen(flnm.toLatin1().data(), "rb");

  in_ply  = read_ply (fp);

  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 */
      m_vlist = (Vertex **) malloc (sizeof (Vertex *) * elem_count);
      m_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) ||
	    equal_strings ("red", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[3]);
	  per_vertex_color = true;
	}
	if (equal_strings ("g", prop->name) ||
	    equal_strings ("green", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[4]);
	  per_vertex_color = true;
	}
	if (equal_strings ("b", prop->name) ||
	    equal_strings ("blue", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[5]);
	  per_vertex_color = true;
	}
	if (equal_strings ("nx", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[6]);
	  has_normals = true;
	}
	if (equal_strings ("ny", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[7]);
	  has_normals = true;
	}
	if (equal_strings ("nz", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[8]);
	  has_normals = true;
	}
      }

      /* grab all the vertex elements */
      for (j = 0; j < elem_count; j++) {
        m_vlist[j] = (Vertex *) malloc (sizeof (Vertex));
        get_element_ply (in_ply, (void *) m_vlist[j]);
      }
    }
    else if (equal_strings ("face", elem_name)) {

      /* create a list to hold all the face elements */
      m_flist = (Face **) malloc (sizeof (Face *) * elem_count);
      m_nfaces = elem_count;

      /* set up for getting face elements */

      setup_property_ply (in_ply, &face_props[0]);

      /* grab all the face elements */
      for (j = 0; j < elem_count; j++) {
        m_flist[j] = (Face *) malloc (sizeof (Face));
        get_element_ply (in_ply, (void *) m_flist[j]);
      }
    }
    else
      get_other_element_ply (in_ply);
  }

  close_ply (in_ply);
  free_ply (in_ply);
  

  vcolor = new float[m_nverts*3];
  for(int i=0; i<m_nverts; i++)
    {
      vcolor[3*i+0] = m_vlist[i]->r/255.0f;
      vcolor[3*i+1] = m_vlist[i]->g/255.0f;
      vcolor[3*i+2] = m_vlist[i]->b/255.0f;
    }

  QMessageBox::information(0, "", QString("Loaded input mesh : vertices %1  faces %2").\
			   arg(m_nverts).\
			   arg(m_nfaces));

  return true;
}
void
MeshGenerator::savePLY(QString flnm)
{
  m_meshLog->moveCursor(QTextCursor::End);
  m_meshLog->insertPlainText("Saving Mesh");

  PlyProperty vert_props[]  = { /* list of property information for a PlyVertex */
    {"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},
    {"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},
    {"red", Uint8, Uint8,    offsetof( Vertex,r ), 0, 0, 0, 0},
    {"green", Uint8, Uint8,  offsetof( Vertex,g ), 0, 0, 0, 0},
    {"blue", Uint8, Uint8,   offsetof( Vertex,b ), 0, 0, 0, 0}
  };

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


  PlyFile    *ply;
  FILE    *fp = fopen(flnm.toLatin1().data(), "wb");

  Face     face ;
  int      verts[3] ;
  char    *elem_names[]  = { "vertex", "face" };
  ply = write_ply (fp,
		   2,
		   elem_names,
		   PLY_BINARY_LE );

  /* describe what properties go into the PlyVertex elements */
  describe_element_ply ( ply, "vertex", m_nverts );
  describe_property_ply ( ply, &vert_props[0] );
  describe_property_ply ( ply, &vert_props[1] );
  describe_property_ply ( ply, &vert_props[2] );
  describe_property_ply ( ply, &vert_props[3] );
  describe_property_ply ( ply, &vert_props[4] );
  describe_property_ply ( ply, &vert_props[5] );
  describe_property_ply ( ply, &vert_props[6] );
  describe_property_ply ( ply, &vert_props[7] );
  describe_property_ply ( ply, &vert_props[8] );

  /* describe PlyFace properties (just list of PlyVertex indices) */
  describe_element_ply ( ply, "face", m_nfaces );
  describe_property_ply ( ply, &face_props[0] );

  header_complete_ply ( ply );

  /* set up and write the PlyVertex elements */
  put_element_setup_ply ( ply, "vertex" );
  for(int ni=0; ni<m_nverts; ni++)
    put_element_ply ( ply, ( void * ) m_vlist[ni] );

  /* set up and write the PlyFace elements */
  put_element_setup_ply ( ply, "face" );
  for(int ni=0; ni<m_nfaces; ni++)
    put_element_ply ( ply, ( void * ) m_flist[ni] );

  close_ply ( ply );
  free_ply ( ply );

  m_meshProgress->setValue(100);
}
Beispiel #13
0
write_file()
{
  int i;
  PlyFile *ply;
  char **elist;
  int num_elem_types;

  /*** Write out the transformed PLY object ***/

  elist = get_element_list_ply (in_ply, &num_elem_types);
  ply = write_ply (stdout, num_elem_types, elist, in_ply->file_type);

  /* describe what properties go into the vertex elements */
  /* (position x,y,z and normals nx,ny,nz if they were provided) */

  describe_element_ply (ply, "vertex", nverts);
  describe_property_ply (ply, &vert_props[0]);
  describe_property_ply (ply, &vert_props[1]);
  describe_property_ply (ply, &vert_props[2]);
  if (has_nx) describe_property_ply (ply, &vert_props[3]);
  if (has_ny) describe_property_ply (ply, &vert_props[4]);
  if (has_nz) describe_property_ply (ply, &vert_props[5]);

  /* all other vertex properties besides position and normal */
  describe_other_properties_ply (ply, vert_other, offsetof(Vertex,other_props));

  /* describe face properties (just list of vertex indices) */
  describe_element_ply (ply, "face", nfaces);
  describe_property_ply (ply, &face_props[0]);
  describe_other_properties_ply (ply, face_other, offsetof(Face,other_props));

  /* all other properties that we tucked away are mentioned here */
  describe_other_elements_ply (ply, in_ply->other_elems);

  /* copy the comments and other textual object information */
  copy_comments_ply (ply, in_ply);
  append_comment_ply (ply, "modified by flipply");
  copy_obj_info_ply (ply, in_ply);

  /* we've told the routines enough information so that the file header */
  /* can be written out now */
  header_complete_ply (ply);

  /* set up and write the vertex elements */
  put_element_setup_ply (ply, "vertex");
  for (i = 0; i < nverts; i++)
    put_element_ply (ply, (void *) vlist[i]);

  /* set up and write the face elements */
  put_element_setup_ply (ply, "face");
  for (i = 0; i < nfaces; i++)
    put_element_ply (ply, (void *) flist[i]);

  /* the other properties that we tucked away are written out here */
  put_other_elements_ply (ply);

  /* close the file and free up the memory */

  close_ply (ply);
  free_ply (ply);
}
Beispiel #14
0
read_file()
{
  int i,j;
  int elem_count;
  char *elem_name;

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

  in_ply = read_ply (stdin);

  /* examine each element type that is in the file (vertex, face) */

  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 */
      /* (we want x,y,z) */

      setup_property_ply (in_ply, &vert_props[0]);
      setup_property_ply (in_ply, &vert_props[1]);
      setup_property_ply (in_ply, &vert_props[2]);

      /* we also want normal information if it is there (nx,ny,nz) */

      for (j = 0; j < in_ply->elems[i]->nprops; j++) {
	PlyProperty *prop;
	prop = in_ply->elems[i]->props[j];
	if (equal_strings ("nx", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[3]);
	  has_nx = 1;
	}
	if (equal_strings ("ny", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[4]);
	  has_ny = 1;
	}
	if (equal_strings ("nz", prop->name)) {
	  setup_property_ply (in_ply, &vert_props[5]);
	  has_nz = 1;
	}
      }

      /* also grab anything else that we don't need to know about */

      vert_other = get_other_properties_ply (in_ply, 
					     offsetof(Vertex,other_props));

      /* grab the vertex elements and store them in our list */

      for (j = 0; j < elem_count; j++) {
        vlist[j] = (Vertex *) malloc (sizeof (Vertex));
        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 */
      /* (all we need are vertex indices) */

      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 and place them in our list */

      for (j = 0; j < elem_count; j++) {
        flist[j] = (Face *) malloc (sizeof (Face));
        get_element_ply (in_ply, (void *) flist[j]);
      }
    }
    else  /* all non-vertex and non-face elements are grabbed here */
      get_other_element_ply (in_ply);
  }

  /* close the file */
  /* (we won't free up the memory for in_ply because we will use it */
  /*  to help describe the file that we will write out) */

  close_ply (in_ply);
}
Beispiel #15
0
int CTriangleObj::_loadPLYFile(FILE *fp)
{
	Vector3i*& m_pTriangle = (Vector3i*&)m_pPolygon;
	int i, j, elem_count, nverts, nfaces;
	char *elem_name, buff[200];
	Vertex vlist;
	Face flist;
	PlyOtherProp *vert_other,*face_other;
	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},
		{"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},
	};
	char *elem_names[] = { /* list of the kinds of elements in the user's object */
		"vertex", "face"
	};

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

	/*** Read in the original PLY object ***/
	Free();
	PlyFile *in_ply = read_ply (fp);
	if (in_ply==NULL) return 0;

	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 */
			m_nVertexCount = nverts = elem_count;
			m_pVertex = new Vector3d [m_nVertexCount];
			assert(m_pVertex!=NULL);
			/* 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]);
			vert_other = get_other_properties_ply (in_ply, offsetof(Vertex,other_props));
			/* grab all the vertex elements */
			for (j = 0; j < elem_count; j++) {
				get_element_ply (in_ply, (void *) &vlist);
				Vector3d *p = &m_pVertex[j];
				p->x = vlist.x;
				p->y = vlist.y;
				p->z = vlist.z;
			}
		}
		else if (equal_strings ("face", elem_name)) {
			m_nPolygonCount = nfaces = elem_count;
			/* create a list to hold all the face elements */
			m_pTriangle = new Vector3i[m_nPolygonCount];
			assert(m_pTriangle!=NULL);
			/* 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++) {
				get_element_ply (in_ply, (void *) &flist);
				if (flist.nverts !=3){
					sprintf(buff, "Found a face with %d vertices!\n", (int)flist.nverts);
					puts(buff);
				}
				Vector3i *ptri = &m_pTriangle[j];
				ptri->x = flist.verts[0];
				ptri->y = flist.verts[2];
				ptri->z = flist.verts[1];
			}
		}
		else if (equal_strings ("tristrips", elem_name)) {
			int *ibuff = _readTriangleStrip(fp, elem_count);
			m_pTriangle=_parseStrip2Triangles(ibuff, elem_count, m_nPolygonCount);
			delete [] ibuff;
		}
		else{
			get_other_element_ply (in_ply);
		}
	}

	close_ply (in_ply);
	return 1;
}
Beispiel #16
0
PLYLoader::PLYLoader(FILE *fp) {
#ifdef DEBUG
	std::cout << "Loading PLY from disk..." << std::endl;
#endif /* DEBUG */
	int i, j;
	int elem_count;
	char *elem_name;

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

	PlyFile *in_ply = ::read_ply(fp);
	if (vertexData) {
		delete vertexData;
		vertexData = NULL;
	}

	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 */
			vertexData = new vec3[elem_count];//(vec3 *) malloc (sizeof (vec3 *) * elem_count);
			vertCount = 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]);
			//      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));
				get_element_ply(in_ply, (void *) &(vertexData[j]));
			}
		} else if (equal_strings("face", elem_name)) {
			/* create a list to hold all the face elements */
			face_t *flist = new face_t[elem_count];
			int *triangles = new int[elem_count * 3];
			triCount = 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]));
				if (flist[j].vertCount == 2) {
					triangles[j * 3] = flist[j].vertIdx[0];
					triangles[j * 3 + 1] = flist[j].vertIdx[1];
					triangles[j * 3 + 2] = flist[j].vertIdx[2];
				}
			}
			delete flist;
			this->triangles = triangles;
		} else
			get_other_element_ply(in_ply);
	}

	close_ply(in_ply);
#ifdef DEBUG
	std::cout << "Loaded: " << vertCount << " vertices, " << triCount << " faces." << std::endl;
#endif /* DEBUG */
}