igl::ply Namespace Reference

Classes
struct	OtherData
struct	OtherElem
struct	PlyElement
struct	PlyFile
struct	PlyOtherElems
struct	PlyOtherProp
struct	PlyProperty

Typedefs
typedef struct igl::ply::PlyProperty	PlyProperty
typedef struct igl::ply::PlyElement	PlyElement
typedef struct igl::ply::PlyOtherProp	PlyOtherProp
typedef struct igl::ply::OtherData	OtherData
typedef struct igl::ply::OtherElem	OtherElem
typedef struct igl::ply::PlyOtherElems	PlyOtherElems
typedef struct igl::ply::PlyFile	PlyFile

Functions
char *	my_alloc ()
int	get_native_binary_type2 ()
PlyFile *	ply_write (FILE *, int, const char **, int)
PlyFile *	ply_open_for_writing (char *, int, const char **, int, float *)
void	ply_describe_element (PlyFile *, const char *, int, int, PlyProperty *)
void	ply_describe_property (PlyFile *, const char *, PlyProperty *)
void	ply_element_count (PlyFile *, const char *, int)
void	ply_header_complete (PlyFile *)
void	ply_put_element_setup (PlyFile *, const char *)
void	ply_put_element (PlyFile *, void *, int *)
void	ply_put_comment (PlyFile *, char *)
void	ply_put_obj_info (PlyFile *, char *)
PlyFile *	ply_read (FILE *, int *, char ***)
PlyFile *	ply_open_for_reading (const char *, int *, char ***, int *, float *)
PlyProperty **	ply_get_element_description (PlyFile *, const char *, int *, int *)
void	ply_get_element_setup (PlyFile *, const char *, int, PlyProperty *)
void	ply_get_property (PlyFile *, const char *, PlyProperty *)
PlyOtherProp *	ply_get_other_properties (PlyFile *, const char *, int)
void	ply_get_element (PlyFile *, void *, int *)
char **	ply_get_comments (PlyFile *, int *)
char **	ply_get_obj_info (PlyFile *, int *)
void	ply_close (PlyFile *)
void	ply_get_info (PlyFile *, float *, int *)
PlyOtherElems *	ply_get_other_element (PlyFile *, const char *, int)
void	ply_describe_other_elements (PlyFile *, PlyOtherElems *)
void	ply_put_other_elements (PlyFile *)
void	ply_free_other_elements (PlyOtherElems *)
void	ply_describe_other_properties (PlyFile *, PlyOtherProp *, int)
int	equal_strings (const char *, const char *)
PlyElement *	find_element (PlyFile *, const char *)
PlyProperty *	find_property (PlyElement *, const char *, int *)
void	write_scalar_type (FILE *, int)
char **	get_words (FILE *, int *, char **)
char **	old_get_words (FILE *, int *)
void	write_binary_item (FILE *, int, int, unsigned int, double, int, int *)
void	write_ascii_item (FILE *, int, unsigned int, double, int)
double	old_write_ascii_item (FILE *, char *, int)
void	add_element (PlyFile *, char **)
void	add_property (PlyFile *, char **)
void	add_comment (PlyFile *, char *)
void	add_obj_info (PlyFile *, char *)
void	copy_property (PlyProperty *, PlyProperty *)
void	store_item (char *, int, int, unsigned int, double)
void	get_stored_item (void *, int, int *, unsigned int *, double *)
double	get_item_value (char *, int)
void	get_ascii_item (char *, int, int *, unsigned int *, double *)
void	get_binary_item (FILE *, int, int, int *, unsigned int *, double *, int *)
void	ascii_get_element (PlyFile *, char *)
void	binary_get_element (PlyFile *, char *, int *)
char *	my_alloc (int, int, const char *)
void	get_native_binary_type (int *)
void	swap_bytes (char *, int)
int	check_types ()
PlyFile *	ply_open_for_writing (const char *filename, int nelems, const char **elem_names, int file_type, float *version)
PlyFile *	ply_open_for_reading (char *filename, int *nelems, char ***elem_names, int *file_type, float *version)
void	setup_other_props (PlyElement *elem)
PlyOtherElems *	ply_get_other_element (PlyFile *plyfile, char *elem_name, int elem_count)
void	ply_put_other_elements (PlyFile *plyfile, int *native_binary_type)
int	get_prop_type (char *type_name)

---

Class Documentation

igl::ply::OtherData

struct igl::ply::OtherData

Class Members
void *	other_props

igl::ply::OtherElem

struct igl::ply::OtherElem

Collaboration diagram for igl::ply::OtherElem:

Class Members
int	elem_count
char *	elem_name
OtherData **	other_data
PlyOtherProp *	other_props

igl::ply::PlyElement

struct igl::ply::PlyElement

Collaboration diagram for igl::ply::PlyElement:

Class Members
const char *	name
int	nprops
int	num
int	other_offset
int	other_size
PlyProperty **	props
int	size
char *	store_prop

igl::ply::PlyFile

struct igl::ply::PlyFile

Collaboration diagram for igl::ply::PlyFile:

Class Members
char **	comments
PlyElement **	elems
int	file_type
FILE *	fp
int	nelems
int	num_comments
int	num_obj_info
char **	obj_info
PlyOtherElems *	other_elems
float	version
PlyElement *	which_elem

igl::ply::PlyOtherElems

struct igl::ply::PlyOtherElems

Collaboration diagram for igl::ply::PlyOtherElems:

Class Members
int	num_elems
OtherElem *	other_list

igl::ply::PlyOtherProp

struct igl::ply::PlyOtherProp

Collaboration diagram for igl::ply::PlyOtherProp:

Class Members
const char *	name
int	nprops
PlyProperty **	props
int	size

igl::ply::PlyProperty

struct igl::ply::PlyProperty

Class Members
int	count_external
int	count_internal
int	count_offset
int	external_type
int	internal_type
int	is_list
const char *	name
int	offset

Typedef Documentation

OtherData

typedef struct igl::ply::OtherData igl::ply::OtherData

OtherElem

typedef struct igl::ply::OtherElem igl::ply::OtherElem

PlyElement

typedef struct igl::ply::PlyElement igl::ply::PlyElement

PlyFile

typedef struct igl::ply::PlyFile igl::ply::PlyFile

PlyOtherElems

typedef struct igl::ply::PlyOtherElems igl::ply::PlyOtherElems

PlyOtherProp

typedef struct igl::ply::PlyOtherProp igl::ply::PlyOtherProp

PlyProperty

typedef struct igl::ply::PlyProperty igl::ply::PlyProperty

Function Documentation

add_comment()

void igl::ply::add_comment ( PlyFile *  plyfile, char *  line  )

inline

{
  int i;
 
  /* skip over "comment" and leading spaces and tabs */
  i = 7;
  while (line[i] == ' ' || line[i] == '\t')
    i++;
 
  ply_put_comment (plyfile, &line[i]);

References ply_put_comment().

Referenced by ply_read().

Here is the call graph for this function:

Here is the caller graph for this function:

add_element()

void igl::ply::add_element ( PlyFile *  plyfile, char **  words  )

inline

{
  PlyElement *elem;
 
  /* create the new element */
  elem = (PlyElement *) myalloc (sizeof (PlyElement));
  elem->name = strdup (words[1]);
  elem->num = atoi (words[2]);
  elem->nprops = 0;
 
  /* make room for new element in the object's list of elements */
  if (plyfile->nelems == 0)
    plyfile->elems = (PlyElement **) myalloc (sizeof (PlyElement *));
  else
    plyfile->elems = (PlyElement **) realloc (plyfile->elems,
                     sizeof (PlyElement *) * (plyfile->nelems + 1));
 
  /* add the new element to the object's list */
  plyfile->elems[plyfile->nelems] = elem;
  plyfile->nelems++;

References igl::ply::PlyFile::elems, myalloc, igl::ply::PlyElement::name, igl::ply::PlyFile::nelems, igl::ply::PlyElement::nprops, and igl::ply::PlyElement::num.

Referenced by ply_read().

Here is the caller graph for this function:

add_obj_info()

void igl::ply::add_obj_info ( PlyFile *  plyfile, char *  line  )

inline

{
  int i;
 
  /* skip over "obj_info" and leading spaces and tabs */
  i = 8;
  while (line[i] == ' ' || line[i] == '\t')
    i++;
 
  ply_put_obj_info (plyfile, &line[i]);

References ply_put_obj_info().

Referenced by ply_read().

Here is the call graph for this function:

Here is the caller graph for this function:

add_property()

void igl::ply::add_property ( PlyFile *  plyfile, char **  words  )

inline

{
  PlyProperty *prop;
  PlyElement *elem;
 
  /* create the new property */
 
  prop = (PlyProperty *) myalloc (sizeof (PlyProperty));
 
  if (equal_strings (words[1], "list")) {       /* is a list */
    prop->count_external = get_prop_type (words[2]);
    prop->external_type = get_prop_type (words[3]);
    prop->name = strdup (words[4]);
    prop->is_list = 1;
  }
  else {                                        /* not a list */
    prop->external_type = get_prop_type (words[1]);
    prop->name = strdup (words[2]);
    prop->is_list = 0;
  }
 
  /* add this property to the list of properties of the current element */
 
  elem = plyfile->elems[plyfile->nelems - 1];
 
  if (elem->nprops == 0)
    elem->props = (PlyProperty **) myalloc (sizeof (PlyProperty *));
  else
    elem->props = (PlyProperty **) realloc (elem->props,
                  sizeof (PlyProperty *) * (elem->nprops + 1));
 
  elem->props[elem->nprops] = prop;
  elem->nprops++;

References igl::ply::PlyProperty::count_external, igl::ply::PlyFile::elems, equal_strings(), igl::ply::PlyProperty::external_type, get_prop_type(), igl::ply::PlyProperty::is_list, myalloc, igl::ply::PlyProperty::name, igl::ply::PlyFile::nelems, igl::ply::PlyElement::nprops, and igl::ply::PlyElement::props.

Referenced by ply_read().

Here is the call graph for this function:

Here is the caller graph for this function:

ascii_get_element()

void igl::ply::ascii_get_element ( PlyFile *  plyfile, char *  elem_ptr  )

inline

{
  int ply_type_size[] = {
    0, 1, 2, 4, 1, 2, 4, 4, 8
  };
 
  int j,k;
  PlyElement *elem;
  PlyProperty *prop;
  char **words;
  int nwords;
  int which_word;
  char *elem_data,*item=NULL;
  char *item_ptr;
  int item_size;
  int int_val;
  unsigned int uint_val;
  double double_val;
  int list_count;
  int store_it;
  char **store_array;
  char *orig_line;
  char *other_data=NULL;
  int other_flag;
 
  /* the kind of element we're reading currently */
  elem = plyfile->which_elem;
 
  /* do we need to setup for other_props? */
 
  if (elem->other_offset != NO_OTHER_PROPS) {
    char **ptr;
    other_flag = 1;
    /* make room for other_props */
    other_data = (char *) myalloc (elem->other_size);
    /* store pointer in user's structure to the other_props */
    ptr = (char **) (elem_ptr + elem->other_offset);
    *ptr = other_data;
  }
  else
    other_flag = 0;
 
  /* read in the element */
 
  words = get_words (plyfile->fp, &nwords, &orig_line);
  if (words == NULL) {
    fprintf (stderr, "ply_get_element: unexpected end of file\n");
    exit (-1);
  }
 
  which_word = 0;
 
  for (j = 0; j < elem->nprops; j++) {
 
    prop = elem->props[j];
    store_it = (elem->store_prop[j] | other_flag);
 
    /* store either in the user's structure or in other_props */
  //  if (elem->store_prop[j])
      elem_data = elem_ptr;
    //else
      //elem_data = other_data;
 
    if (prop->is_list) {       /* a list */
 
      /* get and store the number of items in the list */
      get_ascii_item (words[which_word++], prop->count_external,
                      &int_val, &uint_val, &double_val);
      if (store_it) {
        item = elem_data + prop->count_offset;
        store_item(item, prop->count_internal, int_val, uint_val, double_val);
      }
 
      /* allocate space for an array of items and store a ptr to the array */
      list_count = int_val;
      item_size = ply_type_size[prop->internal_type];
      store_array = (char **) (elem_data + prop->offset);
 
      if (list_count == 0) {
        if (store_it)
          *store_array = NULL;
      }
      else {
        if (store_it) {
          item_ptr = (char *) myalloc (sizeof (char) * item_size * list_count);
           
          item = item_ptr;
          *store_array = item_ptr;
        }
 
        /* read items and store them into the array */
        for (k = 0; k < list_count; k++) {
          get_ascii_item (words[which_word++], prop->external_type,
                          &int_val, &uint_val, &double_val);
          if (store_it) {
            store_item (item, prop->internal_type,
                        int_val, uint_val, double_val);
            item += item_size;
          }
        }
      }
 
    }
    else {                     /* not a list */
      get_ascii_item (words[which_word++], prop->external_type,
                      &int_val, &uint_val, &double_val);
      if (store_it) {
        item = elem_data + prop->offset;
        store_item (item, prop->internal_type, int_val, uint_val, double_val);
      }
    }
 
  }
 
  free (words);

References igl::ply::PlyProperty::count_external, igl::ply::PlyProperty::count_internal, igl::ply::PlyProperty::count_offset, igl::ply::PlyProperty::external_type, igl::ply::PlyFile::fp, free(), get_ascii_item(), get_words(), igl::ply::PlyProperty::internal_type, igl::ply::PlyProperty::is_list, myalloc, NO_OTHER_PROPS, igl::ply::PlyElement::nprops, igl::ply::PlyProperty::offset, igl::ply::PlyElement::other_offset, igl::ply::PlyElement::other_size, igl::ply::PlyElement::props, store_item(), igl::ply::PlyElement::store_prop, and igl::ply::PlyFile::which_elem.

Referenced by ply_get_element().

Here is the call graph for this function:

Here is the caller graph for this function:

binary_get_element()

void igl::ply::binary_get_element ( PlyFile *  plyfile, char *  elem_ptr, int *  native_binary_type  )

inline

{
  int j,k;
  PlyElement *elem;
  PlyProperty *prop;
  FILE *fp = plyfile->fp;
  char *elem_data,*item=NULL;
  char *item_ptr;
  int item_size;
  int int_val;
  unsigned int uint_val;
  double double_val;
  int list_count;
  int store_it;
  char **store_array;
  char *other_data=NULL;
  int other_flag;
  
  int ply_type_size[] = {
    0, 1, 2, 4, 1, 2, 4, 4, 8
  };
 
 
  /* the kind of element we're reading currently */
  elem = plyfile->which_elem;
 
  /* do we need to setup for other_props? */
 
  if (elem->other_offset != NO_OTHER_PROPS) {
    char **ptr;
    other_flag = 1;
    /* make room for other_props */
    other_data = (char *) myalloc (elem->other_size);
    /* store pointer in user's structure to the other_props */
    ptr = (char **) (elem_ptr + elem->other_offset);
    *ptr = other_data;
  }
  else
    other_flag = 0;
 
  /* read in a number of elements */
 
  for (j = 0; j < elem->nprops; j++) {
 
    prop = elem->props[j];
    store_it = (elem->store_prop[j] | other_flag);
 
    /* store either in the user's structure or in other_props */
//    if (elem->store_prop[j])
      elem_data = elem_ptr;
//    else
//      elem_data = other_data;
 
    if (prop->is_list) {       /* a list */
 
      /* get and store the number of items in the list */
      get_binary_item (fp, plyfile->file_type, prop->count_external,
                      &int_val, &uint_val, &double_val, native_binary_type);
      if (store_it) {
        item = elem_data + prop->count_offset;
        store_item(item, prop->count_internal, int_val, uint_val, double_val);
      }
 
      /* allocate space for an array of items and store a ptr to the array */
      list_count = int_val;
       
      item_size = ply_type_size[prop->internal_type];
      store_array = (char **) (elem_data + prop->offset);
      if (list_count == 0) {
        if (store_it)
          *store_array = NULL;
      }
      else {
        if (store_it) {
          item_ptr = (char *) myalloc (sizeof (char) * item_size * list_count);
           
          item = item_ptr;
          *store_array = item_ptr;
        }
 
        // read items and store them into the array  
        for (k = 0; k < list_count; k++) {
          get_binary_item (fp, plyfile->file_type, prop->external_type,
                          &int_val, &uint_val, &double_val, native_binary_type);
          if (store_it) {
             store_item (item, prop->internal_type,
                       int_val, uint_val, double_val);
            item += item_size;
          }
        }
        
         
        
      }
 
    }
    else {                     /* not a list */
      get_binary_item (fp, plyfile->file_type, prop->external_type,
                      &int_val, &uint_val, &double_val, native_binary_type);
      if (store_it) {
        item = elem_data + prop->offset;
        store_item (item, prop->internal_type, int_val, uint_val, double_val);
      }
    }
 
  }

References igl::ply::PlyProperty::count_external, igl::ply::PlyProperty::count_internal, igl::ply::PlyProperty::count_offset, igl::ply::PlyProperty::external_type, igl::ply::PlyFile::file_type, igl::ply::PlyFile::fp, get_binary_item(), igl::ply::PlyProperty::internal_type, igl::ply::PlyProperty::is_list, myalloc, NO_OTHER_PROPS, igl::ply::PlyElement::nprops, igl::ply::PlyProperty::offset, igl::ply::PlyElement::other_offset, igl::ply::PlyElement::other_size, igl::ply::PlyElement::props, store_item(), igl::ply::PlyElement::store_prop, and igl::ply::PlyFile::which_elem.

Referenced by ply_get_element().

Here is the call graph for this function:

Here is the caller graph for this function:

check_types()

int igl::ply::check_types ( )

inline

{
  int ply_type_size[] = {
    0, 1, 2, 4, 1, 2, 4, 4, 8
  };
 
    if ((ply_type_size[PLY_CHAR] != sizeof(char)) ||
  (ply_type_size[PLY_SHORT] != sizeof(short)) ||  
  (ply_type_size[PLY_INT] != sizeof(int)) ||  
  (ply_type_size[PLY_UCHAR] != sizeof(unsigned char)) ||  
  (ply_type_size[PLY_USHORT] != sizeof(unsigned short)) ||  
  (ply_type_size[PLY_UINT] != sizeof(unsigned int)) ||  
  (ply_type_size[PLY_FLOAT] != sizeof(float)) ||  
  (ply_type_size[PLY_DOUBLE] != sizeof(double)))
    {
  fprintf(stderr, "ply: Type sizes do not match built-in types\n");
  fprintf(stderr, "ply: Exiting...\n");
  exit(1);
    }
 
  return 1;    

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, and PLY_USHORT.

Referenced by ply_read(), and ply_write().

Here is the caller graph for this function:

copy_property()

void igl::ply::copy_property ( PlyProperty *  dest, PlyProperty *  src  )

inline

{
  dest->name = strdup (src->name);
  dest->external_type = src->external_type;
  dest->internal_type = src->internal_type;
  dest->offset = src->offset;
 
  dest->is_list = src->is_list;
  dest->count_external = src->count_external;
  dest->count_internal = src->count_internal;
  dest->count_offset = src->count_offset;

References igl::ply::PlyProperty::count_external, igl::ply::PlyProperty::count_internal, igl::ply::PlyProperty::count_offset, igl::ply::PlyProperty::external_type, igl::ply::PlyProperty::internal_type, igl::ply::PlyProperty::is_list, igl::ply::PlyProperty::name, and igl::ply::PlyProperty::offset.

Referenced by ply_describe_element(), ply_describe_other_properties(), ply_describe_property(), ply_get_element_description(), and ply_get_other_properties().

Here is the caller graph for this function:

equal_strings()

int igl::ply::equal_strings ( const char *  s1, const char *  s2  )

inline

{
 
  while (*s1 && *s2)
    if (*s1++ != *s2++)
      return (0);
 
  if (*s1 != *s2)
    return (0);
  else
    return (1);

Referenced by add_property(), find_element(), find_property(), get_prop_type(), ply_read(), and igl::readPLY().

Here is the caller graph for this function:

find_element()

PlyElement * igl::ply::find_element ( PlyFile *  plyfile, const char *  element  )

inline

{
  int i;
 
  for (i = 0; i < plyfile->nelems; i++)
    if (equal_strings (element, plyfile->elems[i]->name))
      return (plyfile->elems[i]);
 
  return (NULL);

References igl::ply::PlyFile::elems, equal_strings(), igl::ply::PlyElement::name, and igl::ply::PlyFile::nelems.

Referenced by ply_describe_element(), ply_describe_other_properties(), ply_describe_property(), ply_element_count(), ply_get_element_description(), ply_get_element_setup(), ply_get_other_element(), ply_get_other_properties(), ply_get_property(), and ply_put_element_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

find_property()

PlyProperty * igl::ply::find_property ( PlyElement *  elem, const char *  prop_name, int *  index  )

inline

{
  int i;
 
  for (i = 0; i < elem->nprops; i++)
    if (equal_strings (prop_name, elem->props[i]->name)) {
      *index = i;
      return (elem->props[i]);
    }
 
  *index = -1;
  return (NULL);

References equal_strings(), igl::ply::PlyProperty::name, igl::ply::PlyElement::nprops, and igl::ply::PlyElement::props.

Referenced by ply_get_element_setup(), and ply_get_property().

Here is the call graph for this function:

Here is the caller graph for this function:

get_ascii_item()

void igl::ply::get_ascii_item ( char *  word, int  type, int *  int_val, unsigned int *  uint_val, double *  double_val  )

inline

{
  switch (type) {
    case PLY_CHAR:
    case PLY_UCHAR:
    case PLY_SHORT:
    case PLY_USHORT:
    case PLY_INT:
      *int_val = atoi (word);
      *uint_val = (unsigned int) *int_val;
      *double_val = (double) *int_val;
      break;
 
    case PLY_UINT:
      *uint_val = strtol (word, (char **) NULL, 10);
      *int_val = (int) *uint_val;
      *double_val = (double) *uint_val;
      break;
 
    case PLY_FLOAT:
    case PLY_DOUBLE:
      *double_val = atof (word);
      *int_val = (int) *double_val;
      *uint_val = (unsigned int) *double_val;
      break;
 
    default:
      fprintf (stderr, "get_ascii_item: bad type = %d\n", type);
      exit (-1);
  }

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, and PLY_USHORT.

Referenced by ascii_get_element().

Here is the caller graph for this function:

get_binary_item()

void igl::ply::get_binary_item ( FILE *  fp, int  file_type, int  type, int *  int_val, unsigned int *  uint_val, double *  double_val, int *  native_binary_type  )

inline

{
  char c[8];
  void *ptr;
 
  ptr = (void *) c;
  int ply_type_size[] = {
    0, 1, 2, 4, 1, 2, 4, 4, 8
  };
 
  if (fread (ptr, ply_type_size[type], 1, fp) != 1)
  {
      fprintf(stderr, "PLY ERROR: fread() failed -- aborting.\n");
      exit(1);
  }
  
 
  if ((file_type != *native_binary_type) && (ply_type_size[type] > 1))
     swap_bytes((char *)ptr, ply_type_size[type]);
 
  switch (type) {
    case PLY_CHAR:
      *int_val = *((char *) ptr);
      *uint_val = *int_val;
      *double_val = *int_val;
      break;
    case PLY_UCHAR:
      *uint_val = *((unsigned char *) ptr);
      *int_val = *uint_val;
      *double_val = *uint_val;
      break;
    case PLY_SHORT:
      *int_val = *((short int *) ptr);
      *uint_val = *int_val;
      *double_val = *int_val;
      break;
    case PLY_USHORT:
      *uint_val = *((unsigned short int *) ptr);
      *int_val = *uint_val;
      *double_val = *uint_val;
      break;
    case PLY_INT:
      *int_val = *((int *) ptr);
      *uint_val = *int_val;
      *double_val = *int_val;
      break;
    case PLY_UINT:
      *uint_val = *((unsigned int *) ptr);
      *int_val = *uint_val;
      *double_val = *uint_val;
      break;
    case PLY_FLOAT:
      *double_val = *((float *) ptr);
      *int_val = (int) *double_val;
      *uint_val = (unsigned int) *double_val;
      break;
    case PLY_DOUBLE:
      *double_val = *((double *) ptr);
      *int_val = (int) *double_val;
      *uint_val = (unsigned int) *double_val;
      break;
    default:
      fprintf (stderr, "get_binary_item: bad type = %d\n", type);
      exit (-1);
  }

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, PLY_USHORT, and swap_bytes().

Referenced by binary_get_element().

Here is the call graph for this function:

Here is the caller graph for this function:

get_item_value()

double igl::ply::get_item_value ( char *  item, int  type  )

inline

{
  unsigned char *puchar;
  char *pchar;
  short int *pshort;
  unsigned short int *pushort;
  int *pint;
  unsigned int *puint;
  float *pfloat;
  double *pdouble;
  int int_value;
  unsigned int uint_value;
  double double_value;
 
  switch (type) {
    case PLY_CHAR:
      pchar = (char *) item;
      int_value = *pchar;
      return ((double) int_value);
    case PLY_UCHAR:
      puchar = (unsigned char *) item;
      int_value = *puchar;
      return ((double) int_value);
    case PLY_SHORT:
      pshort = (short int *) item;
      int_value = *pshort;
      return ((double) int_value);
    case PLY_USHORT:
      pushort = (unsigned short int *) item;
      int_value = *pushort;
      return ((double) int_value);
    case PLY_INT:
      pint = (int *) item;
      int_value = *pint;
      return ((double) int_value);
    case PLY_UINT:
      puint = (unsigned int *) item;
      uint_value = *puint;
      return ((double) uint_value);
    case PLY_FLOAT:
      pfloat = (float *) item;
      double_value = *pfloat;
      return (double_value);
    case PLY_DOUBLE:
      pdouble = (double *) item;
      double_value = *pdouble;
      return (double_value);
    default:
      fprintf (stderr, "get_item_value: bad type = %d\n", type);
      exit (-1);
  }

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, and PLY_USHORT.

get_native_binary_type()

void igl::ply::get_native_binary_type ( int *  native_binary_type )

inline

{
    typedef union
  {
        int  int_value;
        char byte_values[sizeof(int)];
  } endian_test_type;
 
 
  endian_test_type test;
     
  test.int_value = 0;
    test.int_value = 1;
    if (test.byte_values[0] == 1)
       *native_binary_type = PLY_BINARY_LE;
    else if (test.byte_values[sizeof(int)-1] == 1)
       *native_binary_type = PLY_BINARY_BE;
    else
    {
  fprintf(stderr, "ply: Couldn't determine machine endianness.\n");
  fprintf(stderr, "ply: Exiting...\n");
  exit(1);
    }

References PLY_BINARY_BE, and PLY_BINARY_LE.

get_native_binary_type2()

int igl::ply::get_native_binary_type2 ( )

inline

{
  typedef union
  {
        int  int_value;
        char byte_values[sizeof(int)];
  } endian_test_type;
 
 
    endian_test_type test;
 
    test.int_value = 0;
    test.int_value = 1;
    if (test.byte_values[0] == 1)
       return PLY_BINARY_LE;
    else if (test.byte_values[sizeof(int)-1] == 1)
       return PLY_BINARY_BE;
    else
    {
  fprintf(stderr, "ply: Couldn't determine machine endianness.\n");
  fprintf(stderr, "ply: Exiting...\n");
  exit(1);
    }

References PLY_BINARY_BE, and PLY_BINARY_LE.

Referenced by ply_get_other_element(), ply_read(), ply_write(), igl::readPLY(), and igl::writePLY().

Here is the caller graph for this function:

get_prop_type()

int igl::ply::get_prop_type ( char *  type_name )

inline

{
  int i;
  const char *type_names[] = {
  "invalid",
  "char", "short", "int",
  "uchar", "ushort", "uint",
  "float", "double",
  };
  
  const char *alt_type_names[] = { 
  "invalid",
  "int8", "int16", "int32", "uint8", "uint16", "uint32", "float32", "float64",
  };
 
 
  for (i = PLY_START_TYPE + 1; i < PLY_END_TYPE; i++)
    if (equal_strings (type_name, type_names[i]))
      return (i);
 
  for (i = PLY_START_TYPE + 1; i < PLY_END_TYPE; i++)
    if (equal_strings (type_name, alt_type_names[i]))
      return (i);
 
  /* if we get here, we didn't find the type */
  return (0);

References equal_strings(), PLY_END_TYPE, and PLY_START_TYPE.

Referenced by add_property().

Here is the call graph for this function:

Here is the caller graph for this function:

get_stored_item()

void igl::ply::get_stored_item ( void *  ptr, int  type, int *  int_val, unsigned int *  uint_val, double *  double_val  )

inline

{
  switch (type) {
    case PLY_CHAR:
      *int_val = *((char *) ptr);
      *uint_val = *int_val;
      *double_val = *int_val;
      break;
    case PLY_UCHAR:
      *uint_val = *((unsigned char *) ptr);
      *int_val = *uint_val;
      *double_val = *uint_val;
      break;
    case PLY_SHORT:
      *int_val = *((short int *) ptr);
      *uint_val = *int_val;
      *double_val = *int_val;
      break;
    case PLY_USHORT:
      *uint_val = *((unsigned short int *) ptr);
      *int_val = *uint_val;
      *double_val = *uint_val;
      break;
    case PLY_INT:
      *int_val = *((int *) ptr);
      *uint_val = *int_val;
      *double_val = *int_val;
      break;
    case PLY_UINT:
      *uint_val = *((unsigned int *) ptr);
      *int_val = *uint_val;
      *double_val = *uint_val;
      break;
    case PLY_FLOAT:
      *double_val = *((float *) ptr);
      *int_val = (int) *double_val;
      *uint_val = (unsigned int) *double_val;
      break;
    case PLY_DOUBLE:
      *double_val = *((double *) ptr);
      *int_val = (int) *double_val;
      *uint_val = (unsigned int) *double_val;
      break;
    default:
      fprintf (stderr, "get_stored_item: bad type = %d\n", type);
      exit (-1);
  }

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, and PLY_USHORT.

Referenced by ply_put_element().

Here is the caller graph for this function:

get_words()

char ** igl::ply::get_words ( FILE *  fp, int *  nwords, char **  orig_line  )

inline

{
  #define BIG_STRING 4096
  char str[BIG_STRING];
  char str_copy[BIG_STRING];
  char **words;
  int max_words = 10;
  int num_words = 0;
  char *ptr,*ptr2;
  char *result;
  
  fpos_t pos; //keep track of file pointer
  int nbytes;
  int nonUNIX;
  nonUNIX=0;
  nbytes=0;
  fgetpos(fp, &pos);
 
  words = (char **) myalloc (sizeof (char *) * max_words);
 
  /* read in a line */
  result = fgets (str, BIG_STRING, fp);
  if (result == NULL) {
    *nwords = 0;
    *orig_line = NULL;
    return (NULL);
  }
 
  /* convert line-feed and tabs into spaces */
  /* (this guarantees that there will be a space before the */
  /*  null character at the end of the string) */
 
  str[BIG_STRING-2] = ' ';
  str[BIG_STRING-1] = '\0';
 
  for (ptr = str, ptr2 = str_copy; *ptr != '\0'; ptr++, ptr2++) {
    *ptr2 = *ptr;
    nbytes++;
    if (*ptr == '\t') {
      *ptr = ' ';
      *ptr2 = ' ';
    }
    else if (*ptr == '\n') {
      *ptr = ' '; //has to have a space, to be caught later when grouping words
      *ptr2 = '\0';
      break;
    }
    else if (*ptr == '\r') 
    {   //MAC line break
      nonUNIX=1;
      if(*(ptr+1)=='\n')      //actuall PC line break
      { 
        nbytes++;
      }
       
     *ptr = ' '; 
     
     *(ptr+1) = '\0'; //when reading mac, best end string here
     *ptr2 = '\0';    //note a pc \r is followed by \n
      
      break;
    }
  }
 
 
  /*check to see if a PC or MAC header was detected instead of UNIX*/
  if(nonUNIX==1)
  {
    fsetpos(fp, &pos);
    fseek(fp, nbytes, SEEK_CUR);  
  }
 
  /* find the words in the line */
 
  ptr = str;
  while (*ptr != '\0') {
 
    /* jump over leading spaces */
    while (*ptr == ' ')
      ptr++;
 
    /* break if we reach the end */
    if (*ptr == '\0')
      break;
 
    /* save pointer to beginning of word */
    if (num_words >= max_words) {
      max_words += 10;
      words = (char **) realloc (words, sizeof (char *) * max_words);
    }
    words[num_words++] = ptr;
 
    /* jump over non-spaces */
    while (*ptr != ' ')
      ptr++;
 
    /* place a null character here to mark the end of the word */
    *ptr++ = '\0';
  }
 
  /* return the list of words */
  *nwords = num_words;
  *orig_line = str_copy;
  return (words);

References BIG_STRING, and myalloc.

Referenced by ascii_get_element(), and ply_read().

Here is the caller graph for this function:

my_alloc() [1/2]

char * igl::ply::my_alloc

(

)

my_alloc() [2/2]

char * igl::ply::my_alloc ( int  size, int  lnum, const char *  fe  )

inline

{
  char *ptr;
 
  ptr = (char *) malloc (size);
 
  if (ptr == 0) {
    fprintf(stderr, "Memory allocation bombed on line %d in %s\n", lnum, fe);
  }
 
  return (ptr);

References malloc().

Here is the call graph for this function:

old_get_words()

char ** igl::ply::old_get_words ( FILE *  , int *    )

inline

old_write_ascii_item()

double igl::ply::old_write_ascii_item ( FILE *  fp, char *  item, int  type  )

inline

{
  unsigned char *puchar;
  char *pchar;
  short int *pshort;
  unsigned short int *pushort;
  int *pint;
  unsigned int *puint;
  float *pfloat;
  double *pdouble;
  int int_value;
  unsigned int uint_value;
  double double_value;
 
  switch (type) {
    case PLY_CHAR:
      pchar = (char *) item;
      int_value = *pchar;
      fprintf (fp, "%d ", int_value);
      return ((double) int_value);
    case PLY_UCHAR:
      puchar = (unsigned char *) item;
      int_value = *puchar;
      fprintf (fp, "%d ", int_value);
      return ((double) int_value);
    case PLY_SHORT:
      pshort = (short int *) item;
      int_value = *pshort;
      fprintf (fp, "%d ", int_value);
      return ((double) int_value);
    case PLY_USHORT:
      pushort = (unsigned short int *) item;
      int_value = *pushort;
      fprintf (fp, "%d ", int_value);
      return ((double) int_value);
    case PLY_INT:
      pint = (int *) item;
      int_value = *pint;
      fprintf (fp, "%d ", int_value);
      return ((double) int_value);
    case PLY_UINT:
      puint = (unsigned int *) item;
      uint_value = *puint;
      fprintf (fp, "%u ", uint_value);
      return ((double) uint_value);
    case PLY_FLOAT:
      pfloat = (float *) item;
      double_value = *pfloat;
      fprintf (fp, "%g ", double_value);
      return (double_value);
    case PLY_DOUBLE:
      pdouble = (double *) item;
      double_value = *pdouble;
      fprintf (fp, "%g ", double_value);
      return (double_value);
    default:
      fprintf (stderr, "old_write_ascii_item: bad type = %d\n", type);
      exit (-1);
  }

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, and PLY_USHORT.

ply_close()

void igl::ply::ply_close ( PlyFile *  plyfile )

inline

{
  fclose (plyfile->fp);
  // Alec:
  plyfile->fp = NULL;
 
  /* free up memory associated with the PLY file */
  free (plyfile);

References igl::ply::PlyFile::fp, and free().

Here is the call graph for this function:

ply_describe_element()

void igl::ply::ply_describe_element ( PlyFile *  plyfile, const char *  elem_name, int  nelems, int  nprops, PlyProperty *  prop_list  )

inline

{
  int i;
  PlyElement *elem;
  PlyProperty *prop;
 
  /* look for appropriate element */
  elem = find_element (plyfile, elem_name);
  if (elem == NULL) {
    fprintf(stderr,"ply_describe_element: can't find element '%s'\n",elem_name);
    exit (-1);
  }
 
  elem->num = nelems;
 
  /* copy the list of properties */
 
  elem->nprops = nprops;
  elem->props = (PlyProperty **) myalloc (sizeof (PlyProperty *) * nprops);
  elem->store_prop = (char *) myalloc (sizeof (char) * nprops);
 
  for (i = 0; i < nprops; i++) {
    prop = (PlyProperty *) myalloc (sizeof (PlyProperty));
    elem->props[i] = prop;
    elem->store_prop[i] = NAMED_PROP;
    copy_property (prop, &prop_list[i]);
  }

References copy_property(), find_element(), myalloc, NAMED_PROP, igl::ply::PlyElement::nprops, igl::ply::PlyElement::num, igl::ply::PlyElement::props, and igl::ply::PlyElement::store_prop.

Here is the call graph for this function:

ply_describe_other_elements()

void igl::ply::ply_describe_other_elements ( PlyFile *  plyfile, PlyOtherElems *  other_elems  )

inline

{
  int i;
  OtherElem *other;
  PlyElement *elem;
  
  /* ignore this call if there is no other element */
  if (other_elems == NULL)
    return;
 
  /* save pointer to this information */
  plyfile->other_elems = other_elems;
 
  /* describe the other properties of this element */
  /* store them in the main element list as elements with
     only other properties */
  
  REALLOCN(plyfile->elems, PlyElement *,
     plyfile->nelems, plyfile->nelems + other_elems->num_elems);
  for (i = 0; i < other_elems->num_elems; i++) {
      other = &(other_elems->other_list[i]);
      elem = (PlyElement *) myalloc (sizeof (PlyElement));
      plyfile->elems[plyfile->nelems++] = elem;
      elem->name = strdup (other->elem_name);
      elem->num = other->elem_count;
      elem->nprops = 0;
      ply_describe_other_properties (plyfile, other->other_props,
             offsetof(OtherData,other_props));
  }

References igl::ply::OtherElem::elem_count, igl::ply::OtherElem::elem_name, igl::ply::PlyFile::elems, myalloc, igl::ply::PlyElement::name, igl::ply::PlyFile::nelems, igl::ply::PlyElement::nprops, igl::ply::PlyElement::num, igl::ply::PlyOtherElems::num_elems, igl::ply::PlyFile::other_elems, igl::ply::PlyOtherElems::other_list, igl::ply::OtherElem::other_props, ply_describe_other_properties(), and REALLOCN.

Here is the call graph for this function:

ply_describe_other_properties()

void igl::ply::ply_describe_other_properties ( PlyFile *  plyfile, PlyOtherProp *  other, int  offset  )

inline

{
  int i;
  PlyElement *elem;
  PlyProperty *prop;
 
  /* look for appropriate element */
  elem = find_element (plyfile, other->name);
  if (elem == NULL) {
    fprintf(stderr, "ply_describe_other_properties: can't find element '%s'\n",
            other->name);
    return;
  }
 
  /* create room for other properties */
 
  if (elem->nprops == 0) {
    elem->props = (PlyProperty **)
                  myalloc (sizeof (PlyProperty *) * other->nprops);
    elem->store_prop = (char *) myalloc (sizeof (char) * other->nprops);
    elem->nprops = 0;
  }
  else {
    int newsize;
    newsize = elem->nprops + other->nprops;
    elem->props = (PlyProperty **)
                  realloc (elem->props, sizeof (PlyProperty *) * newsize);
    elem->store_prop = (char *)
                  realloc (elem->store_prop, sizeof (char) * newsize);
  }
 
  /* copy the other properties */
 
  for (i = 0; i < other->nprops; i++) {
    prop = (PlyProperty *) myalloc (sizeof (PlyProperty));
    copy_property (prop, other->props[i]);
    elem->props[elem->nprops] = prop;
    elem->store_prop[elem->nprops] = OTHER_PROP;
    elem->nprops++;
  }
 
  /* save other info about other properties */
  elem->other_size = other->size;
  elem->other_offset = offset;

References copy_property(), find_element(), myalloc, igl::ply::PlyOtherProp::name, igl::ply::PlyElement::nprops, igl::ply::PlyOtherProp::nprops, igl::ply::PlyElement::other_offset, OTHER_PROP, igl::ply::PlyElement::other_size, igl::ply::PlyElement::props, igl::ply::PlyOtherProp::props, igl::ply::PlyOtherProp::size, and igl::ply::PlyElement::store_prop.

Referenced by ply_describe_other_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

ply_describe_property()

void igl::ply::ply_describe_property ( PlyFile *  plyfile, const char *  elem_name, PlyProperty *  prop  )

inline

{
  PlyElement *elem;
  PlyProperty *elem_prop;
 
  /* look for appropriate element */
  elem = find_element (plyfile, elem_name);
  if (elem == NULL) {
    fprintf(stderr, "ply_describe_property: can't find element '%s'\n",
            elem_name);
    return;
  }
 
  /* create room for new property */
 
  if (elem->nprops == 0) {
    elem->props = (PlyProperty **) myalloc (sizeof (PlyProperty *));
    elem->store_prop = (char *) myalloc (sizeof (char));
    elem->nprops = 1;
  }
  else {
    elem->nprops++;
    elem->props = (PlyProperty **)
                  realloc (elem->props, sizeof (PlyProperty *) * elem->nprops);
    elem->store_prop = (char *)
                  realloc (elem->store_prop, sizeof (char) * elem->nprops);
  }
 
  /* copy the new property */
 
  elem_prop = (PlyProperty *) myalloc (sizeof (PlyProperty));
  elem->props[elem->nprops - 1] = elem_prop;
  elem->store_prop[elem->nprops - 1] = NAMED_PROP;
  copy_property (elem_prop, prop);

References copy_property(), find_element(), myalloc, NAMED_PROP, igl::ply::PlyElement::nprops, igl::ply::PlyElement::props, and igl::ply::PlyElement::store_prop.

Here is the call graph for this function:

ply_element_count()

void igl::ply::ply_element_count ( PlyFile *  plyfile, const char *  elem_name, int  nelems  )

inline

{
  PlyElement *elem;
 
  /* look for appropriate element */
  elem = find_element (plyfile, elem_name);
  if (elem == NULL) {
    fprintf(stderr,"ply_element_count: can't find element '%s'\n",elem_name);
    exit (-1);
  }
 
  elem->num = nelems;

References find_element(), and igl::ply::PlyElement::num.

Here is the call graph for this function:

ply_free_other_elements()

void igl::ply::ply_free_other_elements ( PlyOtherElems *  other_elems )

inline

{
  // Alec: 
  //other_elems = other_elems;
  delete(other_elems);

ply_get_comments()

char ** igl::ply::ply_get_comments ( PlyFile *  plyfile, int *  num_comments  )

inline

{
  *num_comments = plyfile->num_comments;
  return (plyfile->comments);

References igl::ply::PlyFile::comments, and igl::ply::PlyFile::num_comments.

ply_get_element()

void igl::ply::ply_get_element ( PlyFile *  plyfile, void *  elem_ptr, int *  native_binary_type  )

inline

{
  if (plyfile->file_type == PLY_ASCII)
    ascii_get_element (plyfile, (char *) elem_ptr);
  else
    binary_get_element (plyfile, (char *) elem_ptr, native_binary_type);

References ascii_get_element(), binary_get_element(), igl::ply::PlyFile::file_type, and PLY_ASCII.

Referenced by ply_get_other_element().

Here is the call graph for this function:

Here is the caller graph for this function:

ply_get_element_description()

PlyProperty ** igl::ply::ply_get_element_description ( PlyFile *  plyfile, const char *  elem_name, int *  nelems, int *  nprops  )

inline

{
  int i;
  PlyElement *elem;
  PlyProperty *prop;
  PlyProperty **prop_list;
 
  /* find information about the element */
  elem = find_element (plyfile, elem_name);
  if (elem == NULL)
    return (NULL);
 
  *nelems = elem->num;
  *nprops = elem->nprops;
 
  /* make a copy of the element's property list */
  prop_list = (PlyProperty **) myalloc (sizeof (PlyProperty *) * elem->nprops);
  for (i = 0; i < elem->nprops; i++) {
    prop = (PlyProperty *) myalloc (sizeof (PlyProperty));
    copy_property (prop, elem->props[i]);
    prop_list[i] = prop;
  }
 
  /* return this duplicate property list */
  return (prop_list);

References copy_property(), find_element(), myalloc, igl::ply::PlyElement::nprops, igl::ply::PlyElement::num, and igl::ply::PlyElement::props.

Here is the call graph for this function:

ply_get_element_setup()

void igl::ply::ply_get_element_setup ( PlyFile *  plyfile, const char *  elem_name, int  nprops, PlyProperty *  prop_list  )

inline

{
  int i;
  PlyElement *elem;
  PlyProperty *prop;
  int index;
 
  /* find information about the element */
  elem = find_element (plyfile, elem_name);
  plyfile->which_elem = elem;
 
  /* deposit the property information into the element's description */
  for (i = 0; i < nprops; i++) {
 
    /* look for actual property */
    prop = find_property (elem, prop_list[i].name, &index);
    if (prop == NULL) {
      fprintf (stderr, "Warning:  Can't find property '%s' in element '%s'\n",
               prop_list[i].name, elem_name);
      continue;
    }
 
    /* store its description */
    prop->internal_type = prop_list[i].internal_type;
    prop->offset = prop_list[i].offset;
    prop->count_internal = prop_list[i].count_internal;
    prop->count_offset = prop_list[i].count_offset;
 
    /* specify that the user wants this property */
    elem->store_prop[index] = STORE_PROP;
  }

References igl::ply::PlyProperty::count_internal, igl::ply::PlyProperty::count_offset, find_element(), find_property(), igl::ply::PlyProperty::internal_type, igl::ply::PlyProperty::offset, igl::ply::PlyElement::store_prop, STORE_PROP, and igl::ply::PlyFile::which_elem.

Here is the call graph for this function:

ply_get_info()

void igl::ply::ply_get_info ( PlyFile *  ply, float *  version, int *  file_type  )

inline

{
  if (ply == NULL)
    return;
 
  *version = ply->version;
  *file_type = ply->file_type;

References igl::ply::PlyFile::file_type, version, and igl::ply::PlyFile::version.

ply_get_obj_info()

char ** igl::ply::ply_get_obj_info ( PlyFile *  plyfile, int *  num_obj_info  )

inline

{
  *num_obj_info = plyfile->num_obj_info;
  return (plyfile->obj_info);

References igl::ply::PlyFile::num_obj_info, and igl::ply::PlyFile::obj_info.

ply_get_other_element() [1/2]

PlyOtherElems * igl::ply::ply_get_other_element ( PlyFile *  , const char *  , int    )

inline

ply_get_other_element() [2/2]

PlyOtherElems * igl::ply::ply_get_other_element ( PlyFile *  plyfile, char *  elem_name, int  elem_count  )

inline

{
  int i;
  PlyElement *elem;
  PlyOtherElems *other_elems;
  OtherElem *other;
 
  /* look for appropriate element */
  elem = find_element (plyfile, elem_name);
  if (elem == NULL) {
    fprintf (stderr,
             "ply_get_other_element: can't find element '%s'\n", elem_name);
    exit (-1);
  }
 
  /* create room for the new "other" element, initializing the */
  /* other data structure if necessary */
 
  if (plyfile->other_elems == NULL) {
    plyfile->other_elems = (PlyOtherElems *) myalloc (sizeof (PlyOtherElems));
    other_elems = plyfile->other_elems;
    other_elems->other_list = (OtherElem *) myalloc (sizeof (OtherElem));
    other = &(other_elems->other_list[0]);
    other_elems->num_elems = 1;
  }
  else {
    other_elems = plyfile->other_elems;
    other_elems->other_list = (OtherElem *) realloc (other_elems->other_list,
                              sizeof (OtherElem) * (other_elems->num_elems + 1));
    other = &(other_elems->other_list[other_elems->num_elems]);
    other_elems->num_elems++;
  }
 
  /* count of element instances in file */
  other->elem_count = elem_count;
 
  /* save name of element */
  other->elem_name = strdup (elem_name);
 
  /* create a list to hold all the current elements */
  other->other_data = (OtherData **)
                  malloc (sizeof (OtherData *) * other->elem_count);
 
  /* set up for getting elements */
  other->other_props = ply_get_other_properties (plyfile, elem_name,
                         offsetof(OtherData,other_props));
 
  /* grab all these elements */
  int native_binary_type = get_native_binary_type2();
  for (i = 0; i < other->elem_count; i++) {
    /* grab and element from the file */
    other->other_data[i] = (OtherData *) malloc (sizeof (OtherData));
    ply_get_element (plyfile, (void *) other->other_data[i], &native_binary_type);
  }
 
  /* return pointer to the other elements data */
  return (other_elems);

References igl::ply::OtherElem::elem_count, igl::ply::OtherElem::elem_name, find_element(), get_native_binary_type2(), malloc(), myalloc, igl::ply::PlyOtherElems::num_elems, igl::ply::OtherElem::other_data, igl::ply::PlyFile::other_elems, igl::ply::PlyOtherElems::other_list, igl::ply::OtherElem::other_props, ply_get_element(), and ply_get_other_properties().

Here is the call graph for this function:

ply_get_other_properties()

PlyOtherProp * igl::ply::ply_get_other_properties ( PlyFile *  plyfile, const char *  elem_name, int  offset  )

inline

{
  int i;
  PlyElement *elem;
  PlyOtherProp *other;
  PlyProperty *prop;
  int nprops;
 
  /* find information about the element */
  elem = find_element (plyfile, elem_name);
  if (elem == NULL) {
    fprintf (stderr, "ply_get_other_properties: Can't find element '%s'\n",
             elem_name);
    return (NULL);
  }
 
  /* remember that this is the "current" element */
  plyfile->which_elem = elem;
 
  /* save the offset to where to store the other_props */
  elem->other_offset = offset;
 
  /* place the appropriate pointers, etc. in the element's property list */
  setup_other_props (elem);
 
  /* create structure for describing other_props */
  other = (PlyOtherProp *) myalloc (sizeof (PlyOtherProp));
  other->name = strdup (elem_name);
#if 0
  if (elem->other_offset == NO_OTHER_PROPS) {
    other->size = 0;
    other->props = NULL;
    other->nprops = 0;
    return (other);
  }
#endif
  other->size = elem->other_size;
  other->props = (PlyProperty **) myalloc (sizeof(PlyProperty) * elem->nprops);
  
  /* save descriptions of each "other" property */
  nprops = 0;
  for (i = 0; i < elem->nprops; i++) {
    if (elem->store_prop[i])
      continue;
    prop = (PlyProperty *) myalloc (sizeof (PlyProperty));
    copy_property (prop, elem->props[i]);
    other->props[nprops] = prop;
    nprops++;
  }
  other->nprops = nprops;
 
#if 1
  /* set other_offset pointer appropriately if there are NO other properties */
  if (other->nprops == 0) {
    elem->other_offset = NO_OTHER_PROPS;
  }
#endif
  
  /* return structure */
  return (other);

References copy_property(), find_element(), myalloc, igl::ply::PlyOtherProp::name, NO_OTHER_PROPS, igl::ply::PlyElement::nprops, igl::ply::PlyOtherProp::nprops, igl::ply::PlyElement::other_offset, igl::ply::PlyElement::other_size, igl::ply::PlyElement::props, igl::ply::PlyOtherProp::props, setup_other_props(), igl::ply::PlyOtherProp::size, igl::ply::PlyElement::store_prop, and igl::ply::PlyFile::which_elem.

Referenced by ply_get_other_element().

Here is the call graph for this function:

Here is the caller graph for this function:

ply_get_property()

void igl::ply::ply_get_property ( PlyFile *  plyfile, const char *  elem_name, PlyProperty *  prop  )

inline

{
  PlyElement *elem;
  PlyProperty *prop_ptr;
  int index;
 
  /* find information about the element */
  elem = find_element (plyfile, elem_name);
  plyfile->which_elem = elem;
 
  /* deposit the property information into the element's description */
 
  prop_ptr = find_property (elem, prop->name, &index);
  if (prop_ptr == NULL) {
    fprintf (stderr, "Warning:  Can't find property '%s' in element '%s'\n",
             prop->name, elem_name);
    return;
  }
  prop_ptr->internal_type  = prop->internal_type;
  prop_ptr->offset         = prop->offset;
  prop_ptr->count_internal = prop->count_internal;
  prop_ptr->count_offset   = prop->count_offset;
 
  /* specify that the user wants this property */
  elem->store_prop[index] = STORE_PROP;

References igl::ply::PlyProperty::count_internal, igl::ply::PlyProperty::count_offset, find_element(), find_property(), igl::ply::PlyProperty::internal_type, igl::ply::PlyProperty::name, igl::ply::PlyProperty::offset, igl::ply::PlyElement::store_prop, STORE_PROP, and igl::ply::PlyFile::which_elem.

Here is the call graph for this function:

ply_header_complete()

void igl::ply::ply_header_complete ( PlyFile *  plyfile )

inline

{
  int i,j;
  FILE *fp = plyfile->fp;
  PlyElement *elem;
  PlyProperty *prop;
 
  fprintf (fp, "ply\n");
 
  switch (plyfile->file_type) {
    case PLY_ASCII:
      fprintf (fp, "format ascii 1.0\n");
      break;
    case PLY_BINARY_BE:
      fprintf (fp, "format binary_big_endian 1.0\n");
      break;
    case PLY_BINARY_LE:
      fprintf (fp, "format binary_little_endian 1.0\n");
      break;
    default:
      fprintf (stderr, "ply_header_complete: bad file type = %d\n",
               plyfile->file_type);
      exit (-1);
  }
 
  /* write out the comments */
 
  for (i = 0; i < plyfile->num_comments; i++)
    fprintf (fp, "comment %s\n", plyfile->comments[i]);
 
  /* write out object information */
 
  for (i = 0; i < plyfile->num_obj_info; i++)
    fprintf (fp, "obj_info %s\n", plyfile->obj_info[i]);
 
  /* write out information about each element */
 
  for (i = 0; i < plyfile->nelems; i++) {
 
    elem = plyfile->elems[i];
    fprintf (fp, "element %s %d\n", elem->name, elem->num);
 
    /* write out each property */
    for (j = 0; j < elem->nprops; j++) {
      prop = elem->props[j];
      if (prop->is_list) {
        fprintf (fp, "property list ");
        write_scalar_type (fp, prop->count_external);
        fprintf (fp, " ");
        write_scalar_type (fp, prop->external_type);
        fprintf (fp, " %s\n", prop->name);
      }
      else {
        fprintf (fp, "property ");
        write_scalar_type (fp, prop->external_type);
        fprintf (fp, " %s\n", prop->name);
      }
    }
  }
 
  fprintf (fp, "end_header\n");

References igl::ply::PlyFile::comments, igl::ply::PlyProperty::count_external, igl::ply::PlyFile::elems, igl::ply::PlyProperty::external_type, igl::ply::PlyFile::file_type, igl::ply::PlyFile::fp, igl::ply::PlyProperty::is_list, igl::ply::PlyProperty::name, igl::ply::PlyElement::name, igl::ply::PlyFile::nelems, igl::ply::PlyElement::nprops, igl::ply::PlyElement::num, igl::ply::PlyFile::num_comments, igl::ply::PlyFile::num_obj_info, igl::ply::PlyFile::obj_info, PLY_ASCII, PLY_BINARY_BE, PLY_BINARY_LE, igl::ply::PlyElement::props, and write_scalar_type().

Here is the call graph for this function:

ply_open_for_reading() [1/2]

PlyFile * igl::ply::ply_open_for_reading ( char *  filename, int *  nelems, char ***  elem_names, int *  file_type, float *  version  )

inline

{
  FILE *fp;
  PlyFile *plyfile;
  //char *name;
  
  
 
   /* tack on the extension .ply, if necessary */
 
  // removing below, to handle also macintosh alias filenames
  //name = (char *) myalloc (sizeof (char) * (strlen (filename) + 5));
  //strcpy (name, filename);
  //if (strlen (name) < 4 ||
  //    strcmp (name + strlen (name) - 4, ".ply") != 0)
  //    strcat (name, ".ply");
 
  /* open the file for reading */
 
  //fp = fopen (name, "r");
  
  //opening file in binary, ascii data can be read in binary with get_words
  fp = fopen (filename, "rb");
 
  if (fp == NULL)
    return (NULL);
  
  /* create the PlyFile data structure */
 
  plyfile = ply_read (fp, nelems, elem_names);
 
  /* determine the file type and version */
 
  *file_type = plyfile->file_type;
  *version = plyfile->version;
 
  /* return a pointer to the file's information */
 
  return (plyfile);

References igl::ply::PlyFile::file_type, ply_read(), version, and igl::ply::PlyFile::version.

Here is the call graph for this function:

ply_open_for_reading() [2/2]

PlyFile * igl::ply::ply_open_for_reading ( const char *  , int *  , char ***  , int *  , float *    )

inline

ply_open_for_writing() [1/2]

PlyFile * igl::ply::ply_open_for_writing ( char *  , int  , const char **  , int  , float *    )

inline

ply_open_for_writing() [2/2]

PlyFile * igl::ply::ply_open_for_writing ( const char *  filename, int  nelems, const char **  elem_names, int  file_type, float *  version  )

inline

{
  PlyFile *plyfile;
  char *name;
  FILE *fp;
 
  /* tack on the extension .ply, if necessary */
 
  name = (char *) myalloc (sizeof (char) * (strlen (filename) + 5));
  strcpy (name, filename);
  if (strlen (name) < 4 ||
      strcmp (name + strlen (name) - 4, ".ply") != 0)
      strcat (name, ".ply");
 
  /* open the file for writing */
 
  fp = fopen (name, "w");
  if (fp == NULL) {
    return (NULL);
  }
 
  /* create the actual PlyFile structure */
 
  plyfile = ply_write (fp, nelems, elem_names, file_type);
  if (plyfile == NULL)
    return (NULL);
 
  /* say what PLY file version number we're writing */
  *version = plyfile->version;
 
  /* return pointer to the file descriptor */
  return (plyfile);

References myalloc, ply_write(), version, and igl::ply::PlyFile::version.

Here is the call graph for this function:

ply_put_comment()

void igl::ply::ply_put_comment ( PlyFile *  plyfile, char *  comment  )

inline

{
  /* (re)allocate space for new comment */
  if (plyfile->num_comments == 0)
    plyfile->comments = (char **) myalloc (sizeof (char *));
  else
    plyfile->comments = (char **) realloc (plyfile->comments,
                         sizeof (char *) * (plyfile->num_comments + 1));
 
  /* add comment to list */
  plyfile->comments[plyfile->num_comments] = strdup (comment);
  plyfile->num_comments++;

References comment, igl::ply::PlyFile::comments, myalloc, and igl::ply::PlyFile::num_comments.

Referenced by add_comment().

Here is the caller graph for this function:

ply_put_element()

void igl::ply::ply_put_element ( PlyFile *  plyfile, void *  elem_ptr, int *  native_binary_type  )

inline

{
  int j,k;
  FILE *fp = plyfile->fp;
  PlyElement *elem;
  PlyProperty *prop;
  char *elem_data,*item;
  char **item_ptr;
  int list_count;
  int item_size;
  int int_val;
  unsigned int uint_val;
  double double_val;
  char **other_ptr;
 
  elem = plyfile->which_elem;
  elem_data = (char *)elem_ptr;
  other_ptr = (char **) (((char *) elem_ptr) + elem->other_offset);
 
  /* write out either to an ascii or binary file */
  int ply_type_size[] = {
    0, 1, 2, 4, 1, 2, 4, 4, 8
  };
 
  if (plyfile->file_type == PLY_ASCII) {
 
    /* write an ascii file */
 
    /* write out each property of the element */
    for (j = 0; j < elem->nprops; j++) {
      prop = elem->props[j];
      if (elem->store_prop[j] == OTHER_PROP)
        elem_data = *other_ptr;
      else
        elem_data = (char *)elem_ptr;
      if (prop->is_list) {
        item = elem_data + prop->count_offset;
        get_stored_item ((void *) item, prop->count_internal,
                         &int_val, &uint_val, &double_val);
        write_ascii_item (fp, int_val, uint_val, double_val,
                          prop->count_external);
        list_count = uint_val;
        item_ptr = (char **) (elem_data + prop->offset);
        item = item_ptr[0];
        item_size = ply_type_size[prop->internal_type];
        for (k = 0; k < list_count; k++) {
          get_stored_item ((void *) item, prop->internal_type,
                           &int_val, &uint_val, &double_val);
          write_ascii_item (fp, int_val, uint_val, double_val,
                            prop->external_type);
          item += item_size;
        }
      }
      else {
        item = elem_data + prop->offset;
        get_stored_item ((void *) item, prop->internal_type,
                         &int_val, &uint_val, &double_val);
        write_ascii_item (fp, int_val, uint_val, double_val,
                          prop->external_type);
      }
    }
 
    fprintf (fp, "\n");
  }
  else {
 
    /* write a binary file */
 
    /* write out each property of the element */
    for (j = 0; j < elem->nprops; j++) {
      prop = elem->props[j];
      if (elem->store_prop[j] == OTHER_PROP)
        elem_data = *other_ptr;
      else
        elem_data = (char *)elem_ptr;
      if (prop->is_list) {
        item = elem_data + prop->count_offset;
        item_size = ply_type_size[prop->count_internal];
        get_stored_item ((void *) item, prop->count_internal,
                         &int_val, &uint_val, &double_val);
        write_binary_item (fp, plyfile->file_type, int_val, uint_val,
         double_val, prop->count_external, native_binary_type);
        list_count = uint_val;
        item_ptr = (char **) (elem_data + prop->offset);
        item = item_ptr[0];
        item_size = ply_type_size[prop->internal_type];
        for (k = 0; k < list_count; k++) {
          get_stored_item ((void *) item, prop->internal_type,
                           &int_val, &uint_val, &double_val);
          write_binary_item (fp, plyfile->file_type, int_val, uint_val,
           double_val, prop->external_type, native_binary_type);
          item += item_size;
        }
      }
      else {
        item = elem_data + prop->offset;
        item_size = ply_type_size[prop->internal_type];
        get_stored_item ((void *) item, prop->internal_type,
                         &int_val, &uint_val, &double_val);
        write_binary_item (fp, plyfile->file_type, int_val, uint_val,
         double_val, prop->external_type, native_binary_type);
      }
    }
 
  }

References igl::ply::PlyProperty::count_external, igl::ply::PlyProperty::count_internal, igl::ply::PlyProperty::count_offset, igl::ply::PlyProperty::external_type, igl::ply::PlyFile::file_type, igl::ply::PlyFile::fp, get_stored_item(), igl::ply::PlyProperty::internal_type, igl::ply::PlyProperty::is_list, igl::ply::PlyElement::nprops, igl::ply::PlyProperty::offset, igl::ply::PlyElement::other_offset, OTHER_PROP, PLY_ASCII, igl::ply::PlyElement::props, igl::ply::PlyElement::store_prop, igl::ply::PlyFile::which_elem, write_ascii_item(), and write_binary_item().

Referenced by ply_put_other_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

ply_put_element_setup()

void igl::ply::ply_put_element_setup ( PlyFile *  plyfile, const char *  elem_name  )

inline

{
  PlyElement *elem;
 
  elem = find_element (plyfile, elem_name);
  if (elem == NULL) {
    fprintf(stderr, "ply_elements_setup: can't find element '%s'\n", elem_name);
    exit (-1);
  }
  
  plyfile->which_elem = elem;

References find_element(), and igl::ply::PlyFile::which_elem.

Referenced by ply_put_other_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

ply_put_obj_info()

void igl::ply::ply_put_obj_info ( PlyFile *  plyfile, char *  obj_info  )

inline

{
  /* (re)allocate space for new info */
  if (plyfile->num_obj_info == 0)
    plyfile->obj_info = (char **) myalloc (sizeof (char *));
  else
    plyfile->obj_info = (char **) realloc (plyfile->obj_info,
                         sizeof (char *) * (plyfile->num_obj_info + 1));
 
  /* add info to list */
  plyfile->obj_info[plyfile->num_obj_info] = strdup (obj_info);
  plyfile->num_obj_info++;

References myalloc, igl::ply::PlyFile::num_obj_info, and igl::ply::PlyFile::obj_info.

Referenced by add_obj_info().

Here is the caller graph for this function:

ply_put_other_elements() [1/2]

void igl::ply::ply_put_other_elements ( PlyFile *  )

inline

ply_put_other_elements() [2/2]

void igl::ply::ply_put_other_elements ( PlyFile *  plyfile, int *  native_binary_type  )

inline

{
  int i,j;
  OtherElem *other;
 
  /* make sure we have other elements to write */
  if (plyfile->other_elems == NULL)
    return;
 
  /* write out the data for each "other" element */
 
  for (i = 0; i < plyfile->other_elems->num_elems; i++) {
 
    other = &(plyfile->other_elems->other_list[i]);
    ply_put_element_setup (plyfile, other->elem_name);
 
    /* write out each instance of the current element */
    for (j = 0; j < other->elem_count; j++)
      ply_put_element (plyfile, (void *) other->other_data[j], native_binary_type);
  }

References igl::ply::OtherElem::elem_count, igl::ply::OtherElem::elem_name, igl::ply::PlyOtherElems::num_elems, igl::ply::OtherElem::other_data, igl::ply::PlyFile::other_elems, igl::ply::PlyOtherElems::other_list, ply_put_element(), and ply_put_element_setup().

Here is the call graph for this function:

ply_read()

PlyFile * igl::ply::ply_read ( FILE *  fp, int *  nelems, char ***  elem_names  )

inline

{
  int i,j;
  PlyFile *plyfile;
  int nwords;
  char **words;
  char **elist;
  PlyElement *elem;
  char *orig_line;
 
  /* check for NULL file pointer */
  if (fp == NULL)
    return (NULL);
  
  int native_binary_type = -1;
  int types_checked = 0;
  
  if (native_binary_type == -1)
     native_binary_type = get_native_binary_type2();
  if (!types_checked)
     types_checked = check_types();
  
  /* create record for this object */
 
  plyfile = (PlyFile *) myalloc (sizeof (PlyFile));
  plyfile->nelems = 0;
  plyfile->comments = NULL;
  plyfile->num_comments = 0;
  plyfile->obj_info = NULL;
  plyfile->num_obj_info = 0;
  plyfile->fp = fp;
  plyfile->other_elems = NULL;
 
  /* read and parse the file's header */
 
  words = get_words (plyfile->fp, &nwords, &orig_line);
  if (nwords == 0 || !words || !equal_strings (words[0], "ply"))
  {
       if (words)
   free(words);
     
     
      return (NULL);
  }
  
  while (words) {
 
    /* parse words */
 
    if (equal_strings (words[0], "format")) {
      if (nwords != 3) {
  free(words);
  return (NULL);
      }
      if (equal_strings (words[1], "ascii"))
        plyfile->file_type = PLY_ASCII;
      else if (equal_strings (words[1], "binary_big_endian"))
        plyfile->file_type = PLY_BINARY_BE;
      else if (equal_strings (words[1], "binary_little_endian"))
        plyfile->file_type = PLY_BINARY_LE;
      else {
  free(words);
        return (NULL);
      }
      plyfile->version = atof (words[2]);
    }
    else if (equal_strings (words[0], "element"))
      add_element (plyfile, words);
    else if (equal_strings (words[0], "property"))
      add_property (plyfile, words);
    else if (equal_strings (words[0], "comment"))
      add_comment (plyfile, orig_line);
    else if (equal_strings (words[0], "obj_info"))
      add_obj_info (plyfile, orig_line);
    else if (equal_strings (words[0], "end_header")) {
      free(words);
      break;
    }
    
    /* free up words space */
    free (words);
 
    words = get_words (plyfile->fp, &nwords, &orig_line);
  }
 
  /* create tags for each property of each element, to be used */
  /* later to say whether or not to store each property for the user */
 
  for (i = 0; i < plyfile->nelems; i++) {
    elem = plyfile->elems[i];
    elem->store_prop = (char *) myalloc (sizeof (char) * elem->nprops);
    for (j = 0; j < elem->nprops; j++)
      elem->store_prop[j] = DONT_STORE_PROP;
    elem->other_offset = NO_OTHER_PROPS; /* no "other" props by default */
  }
 
  /* set return values about the elements */
 
  elist = (char **) myalloc (sizeof (char *) * plyfile->nelems);
  for (i = 0; i < plyfile->nelems; i++)
    elist[i] = strdup (plyfile->elems[i]->name);
 
  *elem_names = elist;
  *nelems = plyfile->nelems;
 
  /* return a pointer to the file's information */
 
  return (plyfile);

References add_comment(), add_element(), add_obj_info(), add_property(), check_types(), igl::ply::PlyFile::comments, DONT_STORE_PROP, igl::ply::PlyFile::elems, equal_strings(), igl::ply::PlyFile::file_type, igl::ply::PlyFile::fp, free(), get_native_binary_type2(), get_words(), myalloc, igl::ply::PlyElement::name, igl::ply::PlyFile::nelems, NO_OTHER_PROPS, igl::ply::PlyElement::nprops, igl::ply::PlyFile::num_comments, igl::ply::PlyFile::num_obj_info, igl::ply::PlyFile::obj_info, igl::ply::PlyFile::other_elems, igl::ply::PlyElement::other_offset, PLY_ASCII, PLY_BINARY_BE, PLY_BINARY_LE, igl::ply::PlyElement::store_prop, and igl::ply::PlyFile::version.

Referenced by igl::guess_extension(), ply_open_for_reading(), and igl::readPLY().

Here is the call graph for this function:

Here is the caller graph for this function:

ply_write()

PlyFile * igl::ply::ply_write ( FILE *  fp, int  nelems, const char **  elem_names, int  file_type  )

inline

{
  int i;
  PlyFile *plyfile;
  PlyElement *elem;
 
  /* check for NULL file pointer */
  if (fp == NULL)
    return (NULL);
  
  int native_binary_type = -1;
  int types_checked = 0;
  if (native_binary_type == -1)
     native_binary_type = get_native_binary_type2();
  if (!types_checked)
     types_checked = check_types();
  
  /* create a record for this object */
 
  plyfile = (PlyFile *) myalloc (sizeof (PlyFile));
  if (file_type == PLY_BINARY_NATIVE)
     plyfile->file_type = native_binary_type;
  else
     plyfile->file_type = file_type;
  plyfile->num_comments = 0;
  plyfile->num_obj_info = 0;
  plyfile->nelems = nelems;
  plyfile->version = 1.0;
  plyfile->fp = fp;
  plyfile->other_elems = NULL;
 
  /* tuck aside the names of the elements */
 
  plyfile->elems = (PlyElement **) myalloc (sizeof (PlyElement *) * nelems);
  for (i = 0; i < nelems; i++) {
    elem = (PlyElement *) myalloc (sizeof (PlyElement));
    plyfile->elems[i] = elem;
    elem->name = strdup (elem_names[i]);
    elem->num = 0;
    elem->nprops = 0;
  }
 
  /* return pointer to the file descriptor */
  return (plyfile);

References check_types(), igl::ply::PlyFile::elems, igl::ply::PlyFile::file_type, igl::ply::PlyFile::fp, get_native_binary_type2(), myalloc, igl::ply::PlyElement::name, igl::ply::PlyFile::nelems, igl::ply::PlyElement::nprops, igl::ply::PlyElement::num, igl::ply::PlyFile::num_comments, igl::ply::PlyFile::num_obj_info, igl::ply::PlyFile::other_elems, PLY_BINARY_NATIVE, and igl::ply::PlyFile::version.

Referenced by ply_open_for_writing(), and igl::writePLY().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_other_props()

void igl::ply::setup_other_props ( PlyElement *  elem )

inline

{
  int i;
  PlyProperty *prop;
  int size = 0;
  int type_size;
 
  /* Examine each property in decreasing order of size. */
  /* We do this so that all data types will be aligned by */
  /* word, half-word, or whatever within the structure. */
  int ply_type_size[] = {
    0, 1, 2, 4, 1, 2, 4, 4, 8
  };
 
  for (type_size = 8; type_size > 0; type_size /= 2) {
 
    /* add up the space taken by each property, and save this information */
    /* away in the property descriptor */
 
    for (i = 0; i < elem->nprops; i++) {
 
      /* don't bother with properties we've been asked to store explicitly */
      if (elem->store_prop[i])
        continue;
 
      prop = elem->props[i];
 
      /* internal types will be same as external */
      prop->internal_type = prop->external_type;
      prop->count_internal = prop->count_external;
 
      /* check list case */
      if (prop->is_list) {
 
        /* pointer to list */
        if (type_size == sizeof (void *)) {
          prop->offset = size;
          size += sizeof (void *);    /* always use size of a pointer here */
        }
 
        /* count of number of list elements */
        if (type_size == ply_type_size[prop->count_external]) {
          prop->count_offset = size;
          size += ply_type_size[prop->count_external];
        }
      }
      /* not list */
      else if (type_size == ply_type_size[prop->external_type]) {
        prop->offset = size;
        size += ply_type_size[prop->external_type];
      }
    }
 
  }
 
  /* save the size for the other_props structure */
  elem->other_size = size;

References igl::ply::PlyProperty::count_external, igl::ply::PlyProperty::count_internal, igl::ply::PlyProperty::count_offset, igl::ply::PlyProperty::external_type, igl::ply::PlyProperty::internal_type, igl::ply::PlyProperty::is_list, igl::ply::PlyElement::nprops, igl::ply::PlyProperty::offset, igl::ply::PlyElement::other_size, igl::ply::PlyElement::props, and igl::ply::PlyElement::store_prop.

Referenced by ply_get_other_properties().

Here is the caller graph for this function:

store_item()

void igl::ply::store_item ( char *  item, int  type, int  int_val, unsigned int  uint_val, double  double_val  )

inline

{
  unsigned char *puchar;
  short int *pshort;
  unsigned short int *pushort;
  int *pint;
  unsigned int *puint;
  float *pfloat;
  double *pdouble;
 
  switch (type) {
    case PLY_CHAR:
      *item = int_val;
      break;
    case PLY_UCHAR:
      puchar = (unsigned char *) item;
      *puchar = uint_val;
      break;
    case PLY_SHORT:
      pshort = (short *) item;
      *pshort = int_val;
      break;
    case PLY_USHORT:
      pushort = (unsigned short *) item;
      *pushort = uint_val;
      break;
    case PLY_INT:
      pint = (int *) item;
      *pint = int_val;
      break;
    case PLY_UINT:
      puint = (unsigned int *) item;
      *puint = uint_val;
      break;
    case PLY_FLOAT:
      pfloat = (float *) item;
      *pfloat = double_val;
      break;
    case PLY_DOUBLE:
      pdouble = (double *) item;
      *pdouble = double_val;
      break;
    default:
      fprintf (stderr, "store_item: bad type = %d\n", type);
      exit (-1);
  }

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, and PLY_USHORT.

Referenced by ascii_get_element(), and binary_get_element().

Here is the caller graph for this function:

swap_bytes()

void igl::ply::swap_bytes ( char *  bytes, int  num_bytes  )

inline

{
    int i;
    char temp;
    
    for (i=0; i < num_bytes/2; i++)
    {
  temp = bytes[i];
  bytes[i] = bytes[(num_bytes-1)-i];
  bytes[(num_bytes-1)-i] = temp;
    }

Referenced by get_binary_item(), and write_binary_item().

Here is the caller graph for this function:

write_ascii_item()

void igl::ply::write_ascii_item ( FILE *  fp, int  int_val, unsigned int  uint_val, double  double_val, int  type  )

inline

{
  switch (type) {
    case PLY_CHAR:
    case PLY_SHORT:
    case PLY_INT:
      if (fprintf (fp, "%d ", int_val) <= 0)
      {
    fprintf(stderr, "PLY ERROR: fprintf() failed -- aborting.\n");
    exit(1);
      }
      break;
    case PLY_UCHAR:
    case PLY_USHORT:
    case PLY_UINT:
      if (fprintf (fp, "%u ", uint_val) <= 0)
      {
    fprintf(stderr, "PLY ERROR: fprintf() failed -- aborting.\n");
    exit(1);
      }
      break;
    case PLY_FLOAT:
    case PLY_DOUBLE:
      if (fprintf (fp, "%g ", double_val) <= 0)
      {
    fprintf(stderr, "PLY ERROR: fprintf() failed -- aborting.\n");
    exit(1);
      }
      break;
    default:
      fprintf (stderr, "write_ascii_item: bad type = %d\n", type);
      exit (-1);
  }

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, and PLY_USHORT.

Referenced by ply_put_element().

Here is the caller graph for this function:

write_binary_item()

void igl::ply::write_binary_item ( FILE *  fp, int  file_type, int  int_val, unsigned int  uint_val, double  double_val, int  type, int *  native_binary_type  )

inline

{
  unsigned char uchar_val;
  char char_val;
  unsigned short ushort_val;
  short short_val;
  float float_val;
  void  *value;
  
  switch (type) {
    case PLY_CHAR:
      char_val = int_val;
      value = &char_val;
      break;
    case PLY_SHORT:
      short_val = int_val;
      value = &short_val;
      break;
    case PLY_INT:
      value = &int_val;
      break;
    case PLY_UCHAR:
      uchar_val = uint_val;
      value = &uchar_val;
      break;
    case PLY_USHORT:
      ushort_val = uint_val;
      value = &ushort_val;
      break;
    case PLY_UINT:
      value = &uint_val;
      break;
    case PLY_FLOAT:
      float_val = double_val;
      value = &float_val;
      break;
    case PLY_DOUBLE:
      value = &double_val;
      break;
    default:
      fprintf (stderr, "write_binary_item: bad type = %d\n", type);
      exit (-1);
  }
  int ply_type_size[] = {
    0, 1, 2, 4, 1, 2, 4, 4, 8
  };
 
  if ((file_type != *native_binary_type) && (ply_type_size[type] > 1))
     swap_bytes((char *)value, ply_type_size[type]);
  
  if (fwrite (value, ply_type_size[type], 1, fp) != 1)
  {
      fprintf(stderr, "PLY ERROR: fwrite() failed -- aborting.\n");
      exit(1);
  }

References PLY_CHAR, PLY_DOUBLE, PLY_FLOAT, PLY_INT, PLY_SHORT, PLY_UCHAR, PLY_UINT, PLY_USHORT, and swap_bytes().

Referenced by ply_put_element().

Here is the call graph for this function:

Here is the caller graph for this function:

write_scalar_type()

void igl::ply::write_scalar_type ( FILE *  fp, int  code  )

inline

{
  /* make sure this is a valid code */
 
  if (code <= PLY_START_TYPE || code >= PLY_END_TYPE) {
    fprintf (stderr, "write_scalar_type: bad data code = %d\n", code);
    exit (-1);
  }
 
  /* write the code to a file */
  const char *type_names[] = {
  "invalid",
  "char", "short", "int",
  "uchar", "ushort", "uint",
  "float", "double",
  };
 
 
  fprintf (fp, "%s", type_names[code]);

References PLY_END_TYPE.

Referenced by ply_header_complete().

Here is the caller graph for this function: