forked from bartvdbraak/blender
f5f25b81e8
also fix for building ghost test and fix double free in one of the tests
2546 lines
66 KiB
C
2546 lines
66 KiB
C
/**
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): none yet.
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
/*
|
|
|
|
|
|
The interface routines for reading and writing PLY polygon files.
|
|
|
|
Greg Turk, February 1994
|
|
|
|
---------------------------------------------------------------
|
|
|
|
A PLY file contains a single polygonal _object_.
|
|
|
|
An object is composed of lists of _elements_. Typical elements are
|
|
vertices, faces, edges and materials.
|
|
|
|
Each type of element for a given object has one or more _properties_
|
|
associated with the element type. For instance, a vertex element may
|
|
have as properties the floating-point values x,y,z and the three unsigned
|
|
chars representing red, green and blue.
|
|
|
|
---------------------------------------------------------------
|
|
|
|
Copyright (c) 1994 The Board of Trustees of The Leland Stanford
|
|
Junior University. All rights reserved.
|
|
|
|
Permission to use, copy, modify and distribute this software and its
|
|
documentation for any purpose is hereby granted without fee, provided
|
|
that the above copyright notice and this permission notice appear in
|
|
all copies of this software and that you do not sell the software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND,
|
|
EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
|
|
WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include <string.h>
|
|
#include "ply.h"
|
|
|
|
char *type_names[] = {
|
|
"invalid",
|
|
"char", "short", "int",
|
|
"uchar", "ushort", "uint",
|
|
"float", "double",
|
|
};
|
|
|
|
int ply_type_size[] = {
|
|
0, 1, 2, 4, 1, 2, 4, 4, 8
|
|
};
|
|
|
|
#define NO_OTHER_PROPS -1
|
|
|
|
#define DONT_STORE_PROP 0
|
|
#define STORE_PROP 1
|
|
|
|
#define OTHER_PROP 0
|
|
#define NAMED_PROP 1
|
|
|
|
|
|
/* returns 1 if strings are equal, 0 if not */
|
|
int equal_strings(char *, char *);
|
|
|
|
/* find an element in a plyfile's list */
|
|
PlyElement *find_element(PlyFile *, char *);
|
|
|
|
/* find a property in an element's list */
|
|
PlyProperty *find_property(PlyElement *, char *, int *);
|
|
|
|
/* write to a file the word describing a PLY file data type */
|
|
void write_scalar_type(FILE *, int);
|
|
|
|
/* read a line from a file and break it up into separate words */
|
|
char **get_words(FILE *, int *, char **);
|
|
char **old_get_words(FILE *, int *);
|
|
|
|
/* write an item to a file */
|
|
void write_binary_item(FILE *, int, unsigned int, double, int);
|
|
void write_ascii_item(FILE *, int, unsigned int, double, int);
|
|
double old_write_ascii_item(FILE *, char *, int);
|
|
|
|
/* add information to a PLY file descriptor */
|
|
void add_element(PlyFile *, char **);
|
|
void add_property(PlyFile *, char **);
|
|
void add_comment(PlyFile *, char *);
|
|
void add_obj_info(PlyFile *, char *);
|
|
|
|
/* copy a property */
|
|
void copy_property(PlyProperty *, PlyProperty *);
|
|
|
|
/* store a value into where a pointer and a type specify */
|
|
void store_item(char *, int, int, unsigned int, double);
|
|
|
|
/* return the value of a stored item */
|
|
void get_stored_item(void *, int, int *, unsigned int *, double *);
|
|
|
|
/* return the value stored in an item, given ptr to it and its type */
|
|
double get_item_value(char *, int);
|
|
|
|
/* get binary or ascii item and store it according to ptr and type */
|
|
void get_ascii_item(char *, int, int *, unsigned int *, double *);
|
|
void get_binary_item(FILE *, int, int *, unsigned int *, double *);
|
|
|
|
/* get a bunch of elements from a file */
|
|
void ascii_get_element(PlyFile *, char *);
|
|
void binary_get_element(PlyFile *, char *);
|
|
|
|
/* memory allocation */
|
|
char *my_alloc(int, int, char *);
|
|
|
|
|
|
/*************/
|
|
/* Writing */
|
|
/*************/
|
|
|
|
|
|
/******************************************************************************
|
|
Given a file pointer, get ready to write PLY data to the file.
|
|
|
|
Entry:
|
|
fp - the given file pointer
|
|
nelems - number of elements in object
|
|
elem_names - list of element names
|
|
file_type - file type, either ascii or binary
|
|
|
|
Exit:
|
|
returns a pointer to a PlyFile, used to refer to this file, or NULL if error
|
|
******************************************************************************/
|
|
|
|
PlyFile *ply_write(
|
|
FILE *fp,
|
|
int nelems,
|
|
char **elem_names,
|
|
int file_type
|
|
)
|
|
{
|
|
int i;
|
|
PlyFile *plyfile;
|
|
PlyElement *elem;
|
|
|
|
/* check for NULL file pointer */
|
|
if (fp == NULL)
|
|
return (NULL);
|
|
|
|
/* create a record for this object */
|
|
|
|
plyfile = (PlyFile *) myalloc(sizeof(PlyFile));
|
|
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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Open a polygon file for writing.
|
|
|
|
Entry:
|
|
filename - name of file to read from
|
|
nelems - number of elements in object
|
|
elem_names - list of element names
|
|
file_type - file type, either ascii or binary
|
|
|
|
Exit:
|
|
version - version number of PLY file
|
|
returns a file identifier, used to refer to this file, or NULL if error
|
|
******************************************************************************/
|
|
|
|
PlyFile *ply_open_for_writing(
|
|
char *filename,
|
|
int nelems,
|
|
char **elem_names,
|
|
int file_type,
|
|
float *version
|
|
)
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Describe an element, including its properties and how many will be written
|
|
to the file.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_name - name of element that information is being specified about
|
|
nelems - number of elements of this type to be written
|
|
nprops - number of properties contained in the element
|
|
prop_list - list of properties
|
|
******************************************************************************/
|
|
|
|
void ply_describe_element(
|
|
PlyFile *plyfile,
|
|
char *elem_name,
|
|
int nelems,
|
|
int nprops,
|
|
PlyProperty *prop_list
|
|
)
|
|
{
|
|
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]);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Describe a property of an element.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_name - name of element that information is being specified about
|
|
prop - the new property
|
|
******************************************************************************/
|
|
|
|
void ply_describe_property(
|
|
PlyFile *plyfile,
|
|
char *elem_name,
|
|
PlyProperty *prop
|
|
)
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Describe what the "other" properties are that are to be stored, and where
|
|
they are in an element.
|
|
******************************************************************************/
|
|
|
|
void ply_describe_other_properties(
|
|
PlyFile *plyfile,
|
|
PlyOtherProp *other,
|
|
int offset
|
|
)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
State how many of a given element will be written.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_name - name of element that information is being specified about
|
|
nelems - number of elements of this type to be written
|
|
******************************************************************************/
|
|
|
|
void ply_element_count(
|
|
PlyFile *plyfile,
|
|
char *elem_name,
|
|
int nelems
|
|
)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Signal that we've described everything a PLY file's header and that the
|
|
header should be written to the file.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
******************************************************************************/
|
|
|
|
void ply_header_complete(PlyFile *plyfile)
|
|
{
|
|
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");
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Specify which elements are going to be written. This should be called
|
|
before a call to the routine ply_put_element().
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_name - name of element we're talking about
|
|
******************************************************************************/
|
|
|
|
void ply_put_element_setup(PlyFile *plyfile, char *elem_name)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Write an element to the file. This routine assumes that we're
|
|
writing the type of element specified in the last call to the routine
|
|
ply_put_element_setup().
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_ptr - pointer to the element
|
|
******************************************************************************/
|
|
|
|
void ply_put_element(PlyFile *plyfile, void *elem_ptr)
|
|
{
|
|
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 = elem_ptr;
|
|
other_ptr = (char **) (((char *) elem_ptr) + elem->other_offset);
|
|
|
|
/* write out either to an ascii or binary file */
|
|
|
|
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 = 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 = 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, 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_binary_item(fp, int_val, uint_val, double_val,
|
|
prop->external_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, int_val, uint_val, double_val,
|
|
prop->external_type);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Specify a comment that will be written in the header.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
comment - the comment to be written
|
|
******************************************************************************/
|
|
|
|
void ply_put_comment(PlyFile *plyfile, char *comment)
|
|
{
|
|
/* (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++;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Specify a piece of object information (arbitrary text) that will be written
|
|
in the header.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
obj_info - the text information to be written
|
|
******************************************************************************/
|
|
|
|
void ply_put_obj_info(PlyFile *plyfile, char *obj_info)
|
|
{
|
|
/* (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++;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*************/
|
|
/* Reading */
|
|
/*************/
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
Given a file pointer, get ready to read PLY data from the file.
|
|
|
|
Entry:
|
|
fp - the given file pointer
|
|
|
|
Exit:
|
|
nelems - number of elements in object
|
|
elem_names - list of element names
|
|
returns a pointer to a PlyFile, used to refer to this file, or NULL if error
|
|
******************************************************************************/
|
|
|
|
PlyFile *ply_read(FILE *fp, int *nelems, char ***elem_names)
|
|
{
|
|
int i, j;
|
|
PlyFile *plyfile;
|
|
int nwords;
|
|
char **words;
|
|
int found_format = 0;
|
|
char **elist;
|
|
PlyElement *elem;
|
|
char *orig_line;
|
|
|
|
/* check for NULL file pointer */
|
|
if (fp == NULL)
|
|
return (NULL);
|
|
|
|
/* 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 (!words || !equal_strings(words[0], "ply"))
|
|
return (NULL);
|
|
|
|
while (words) {
|
|
|
|
/* parse words */
|
|
|
|
if (equal_strings(words[0], "format")) {
|
|
if (nwords != 3)
|
|
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
|
|
return (NULL);
|
|
plyfile->version = (float)atof(words[2]);
|
|
found_format = 1;
|
|
}
|
|
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"))
|
|
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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Open a polygon file for reading.
|
|
|
|
Entry:
|
|
filename - name of file to read from
|
|
|
|
Exit:
|
|
nelems - number of elements in object
|
|
elem_names - list of element names
|
|
file_type - file type, either ascii or binary
|
|
version - version number of PLY file
|
|
returns a file identifier, used to refer to this file, or NULL if error
|
|
******************************************************************************/
|
|
|
|
PlyFile *ply_open_for_reading(
|
|
char *filename,
|
|
int *nelems,
|
|
char ***elem_names,
|
|
int *file_type,
|
|
float *version
|
|
)
|
|
{
|
|
FILE *fp;
|
|
PlyFile *plyfile;
|
|
char *name;
|
|
|
|
/* 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 reading */
|
|
|
|
fp = fopen(name, "r");
|
|
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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Get information about a particular element.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_name - name of element to get information about
|
|
|
|
Exit:
|
|
nelems - number of elements of this type in the file
|
|
nprops - number of properties
|
|
returns a list of properties, or NULL if the file doesn't contain that elem
|
|
******************************************************************************/
|
|
|
|
PlyProperty **ply_get_element_description(
|
|
PlyFile *plyfile,
|
|
char *elem_name,
|
|
int *nelems,
|
|
int *nprops
|
|
)
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Specify which properties of an element are to be returned. This should be
|
|
called before a call to the routine ply_get_element().
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_name - which element we're talking about
|
|
nprops - number of properties
|
|
prop_list - list of properties
|
|
******************************************************************************/
|
|
|
|
void ply_get_element_setup(
|
|
PlyFile *plyfile,
|
|
char *elem_name,
|
|
int nprops,
|
|
PlyProperty *prop_list
|
|
)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Specify a property of an element that is to be returned. This should be
|
|
called (usually multiple times) before a call to the routine ply_get_element().
|
|
This routine should be used in preference to the less flexible old routine
|
|
called ply_get_element_setup().
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_name - which element we're talking about
|
|
prop - property to add to those that will be returned
|
|
******************************************************************************/
|
|
|
|
void ply_get_property(
|
|
PlyFile *plyfile,
|
|
char *elem_name,
|
|
PlyProperty *prop
|
|
)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Read one element from the file. This routine assumes that we're reading
|
|
the type of element specified in the last call to the routine
|
|
ply_get_element_setup().
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_ptr - pointer to location where the element information should be put
|
|
******************************************************************************/
|
|
|
|
void ply_get_element(PlyFile *plyfile, void *elem_ptr)
|
|
{
|
|
if (plyfile->file_type == PLY_ASCII)
|
|
ascii_get_element(plyfile, (char *) elem_ptr);
|
|
else
|
|
binary_get_element(plyfile, (char *) elem_ptr);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Extract the comments from the header information of a PLY file.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
|
|
Exit:
|
|
num_comments - number of comments returned
|
|
returns a pointer to a list of comments
|
|
******************************************************************************/
|
|
|
|
char **ply_get_comments(PlyFile *plyfile, int *num_comments)
|
|
{
|
|
*num_comments = plyfile->num_comments;
|
|
return (plyfile->comments);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Extract the object information (arbitrary text) from the header information
|
|
of a PLY file.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
|
|
Exit:
|
|
num_obj_info - number of lines of text information returned
|
|
returns a pointer to a list of object info lines
|
|
******************************************************************************/
|
|
|
|
char **ply_get_obj_info(PlyFile *plyfile, int *num_obj_info)
|
|
{
|
|
*num_obj_info = plyfile->num_obj_info;
|
|
return (plyfile->obj_info);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Make ready for "other" properties of an element-- those properties that
|
|
the user has not explicitly asked for, but that are to be stashed away
|
|
in a special structure to be carried along with the element's other
|
|
information.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem - element for which we want to save away other properties
|
|
******************************************************************************/
|
|
|
|
void setup_other_props(PlyElement *elem)
|
|
{
|
|
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. */
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Specify that we want the "other" properties of an element to be tucked
|
|
away within the user's structure. The user needn't be concerned for how
|
|
these properties are stored.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_name - name of element that we want to store other_props in
|
|
offset - offset to where other_props will be stored inside user's structure
|
|
|
|
Exit:
|
|
returns pointer to structure containing description of other_props
|
|
******************************************************************************/
|
|
|
|
PlyOtherProp *ply_get_other_properties(
|
|
PlyFile *plyfile,
|
|
char *elem_name,
|
|
int offset
|
|
)
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*************************/
|
|
/* Other Element Stuff */
|
|
/*************************/
|
|
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
Grab all the data for an element that a user does not want to explicitly
|
|
read in.
|
|
|
|
Entry:
|
|
plyfile - pointer to file
|
|
elem_name - name of element whose data is to be read in
|
|
elem_count - number of instances of this element stored in the file
|
|
|
|
Exit:
|
|
returns pointer to ALL the "other" element data for this PLY file
|
|
******************************************************************************/
|
|
|
|
PlyOtherElems *ply_get_other_element(
|
|
PlyFile *plyfile,
|
|
char *elem_name,
|
|
int elem_count
|
|
)
|
|
{
|
|
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 */
|
|
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]);
|
|
}
|
|
|
|
/* return pointer to the other elements data */
|
|
return (other_elems);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Pass along a pointer to "other" elements that we want to save in a given
|
|
PLY file. These other elements were presumably read from another PLY file.
|
|
|
|
Entry:
|
|
plyfile - file pointer in which to store this other element info
|
|
other_elems - info about other elements that we want to store
|
|
******************************************************************************/
|
|
|
|
void ply_describe_other_elements(
|
|
PlyFile *plyfile,
|
|
PlyOtherElems *other_elems
|
|
)
|
|
{
|
|
int i;
|
|
OtherElem *other;
|
|
|
|
/* 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 */
|
|
|
|
for (i = 0; i < other_elems->num_elems; i++) {
|
|
other = &(other_elems->other_list[i]);
|
|
ply_element_count(plyfile, other->elem_name, other->elem_count);
|
|
ply_describe_other_properties(plyfile, other->other_props,
|
|
offsetof(OtherData, other_props));
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Write out the "other" elements specified for this PLY file.
|
|
|
|
Entry:
|
|
plyfile - pointer to PLY file to write out other elements for
|
|
******************************************************************************/
|
|
|
|
void ply_put_other_elements(PlyFile *plyfile)
|
|
{
|
|
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]);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Free up storage used by an "other" elements data structure.
|
|
|
|
Entry:
|
|
other_elems - data structure to free up
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
|
|
/*******************/
|
|
/* Miscellaneous */
|
|
/*******************/
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
Close a PLY file.
|
|
|
|
Entry:
|
|
plyfile - identifier of file to close
|
|
******************************************************************************/
|
|
|
|
void ply_close(PlyFile *plyfile)
|
|
{
|
|
fclose(plyfile->fp);
|
|
|
|
/* free up memory associated with the PLY file */
|
|
free(plyfile);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Get version number and file type of a PlyFile.
|
|
|
|
Entry:
|
|
ply - pointer to PLY file
|
|
|
|
Exit:
|
|
version - version of the file
|
|
file_type - PLY_ASCII, PLY_BINARY_BE, or PLY_BINARY_LE
|
|
******************************************************************************/
|
|
|
|
void ply_get_info(PlyFile *ply, float *version, int *file_type)
|
|
{
|
|
if (ply == NULL)
|
|
return;
|
|
|
|
*version = ply->version;
|
|
*file_type = ply->file_type;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Compare two strings. Returns 1 if they are the same, 0 if not.
|
|
******************************************************************************/
|
|
|
|
int equal_strings(char *s1, char *s2)
|
|
{
|
|
|
|
while (*s1 && *s2)
|
|
if (*s1++ != *s2++)
|
|
return (0);
|
|
|
|
if (*s1 != *s2)
|
|
return (0);
|
|
else
|
|
return (1);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Find an element from the element list of a given PLY object.
|
|
|
|
Entry:
|
|
plyfile - file id for PLY file
|
|
element - name of element we're looking for
|
|
|
|
Exit:
|
|
returns the element, or NULL if not found
|
|
******************************************************************************/
|
|
|
|
PlyElement *find_element(PlyFile *plyfile, char *element)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < plyfile->nelems; i++)
|
|
if (equal_strings(element, plyfile->elems[i]->name))
|
|
return (plyfile->elems[i]);
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Find a property in the list of properties of a given element.
|
|
|
|
Entry:
|
|
elem - pointer to element in which we want to find the property
|
|
prop_name - name of property to find
|
|
|
|
Exit:
|
|
index - index to position in list
|
|
returns a pointer to the property, or NULL if not found
|
|
******************************************************************************/
|
|
|
|
PlyProperty *find_property(PlyElement *elem, char *prop_name, int *index)
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Read an element from an ascii file.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_ptr - pointer to element
|
|
******************************************************************************/
|
|
|
|
void ascii_get_element(PlyFile *plyfile, char *elem_ptr)
|
|
{
|
|
int j, k;
|
|
PlyElement *elem;
|
|
PlyProperty *prop;
|
|
char **words;
|
|
int nwords;
|
|
int which_word;
|
|
char *elem_data, *item;
|
|
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;
|
|
int other_flag;
|
|
|
|
other_flag = 0;
|
|
other_data = NULL;
|
|
item = NULL;
|
|
item_size = 0;
|
|
|
|
/* 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;
|
|
other_data = NULL;
|
|
item = NULL;
|
|
item_size = 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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Read an element from a binary file.
|
|
|
|
Entry:
|
|
plyfile - file identifier
|
|
elem_ptr - pointer to an element
|
|
******************************************************************************/
|
|
|
|
void binary_get_element(PlyFile *plyfile, char *elem_ptr)
|
|
{
|
|
int j, k;
|
|
PlyElement *elem;
|
|
PlyProperty *prop;
|
|
FILE *fp = plyfile->fp;
|
|
char *elem_data, *item;
|
|
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;
|
|
int other_flag;
|
|
|
|
|
|
other_flag = 0;
|
|
other_data = NULL;
|
|
item = NULL;
|
|
item_size = 0;
|
|
|
|
/* 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;
|
|
other_data = NULL;
|
|
item = NULL;
|
|
item_size = 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, 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;
|
|
/* The "if" was added by Afra Zomorodian 8/22/95
|
|
* so that zipper won't crash reading plies that have additional
|
|
* properties.
|
|
*/
|
|
if (store_it) {
|
|
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, 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_binary_item(fp, 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);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Write to a file the word that represents a PLY data type.
|
|
|
|
Entry:
|
|
fp - file pointer
|
|
code - code for type
|
|
******************************************************************************/
|
|
|
|
void write_scalar_type(FILE *fp, int code)
|
|
{
|
|
/* 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 */
|
|
|
|
fprintf(fp, "%s", type_names[code]);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Get a text line from a file and break it up into words.
|
|
|
|
IMPORTANT: The calling routine call "free" on the returned pointer once
|
|
finished with it.
|
|
|
|
Entry:
|
|
fp - file to read from
|
|
|
|
Exit:
|
|
nwords - number of words returned
|
|
orig_line - the original line of characters
|
|
returns a list of words from the line, or NULL if end-of-file
|
|
******************************************************************************/
|
|
|
|
char **get_words(FILE *fp, int *nwords, char **orig_line)
|
|
{
|
|
#define BIG_STRING 4096
|
|
static char str[BIG_STRING];
|
|
static char str_copy[BIG_STRING];
|
|
char **words;
|
|
int max_words = 10;
|
|
int num_words = 0;
|
|
char *ptr, *ptr2;
|
|
char *result;
|
|
|
|
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 guarentees 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;
|
|
if (*ptr == '\t') {
|
|
*ptr = ' ';
|
|
*ptr2 = ' ';
|
|
}
|
|
else if (*ptr == '\n') {
|
|
*ptr = ' ';
|
|
*ptr2 = '\0';
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* 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);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Return the value of an item, given a pointer to it and its type.
|
|
|
|
Entry:
|
|
item - pointer to item
|
|
type - data type that "item" points to
|
|
|
|
Exit:
|
|
returns a double-precision float that contains the value of the item
|
|
******************************************************************************/
|
|
|
|
double get_item_value(char *item, int type)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Write out an item to a file as raw binary bytes.
|
|
|
|
Entry:
|
|
fp - file to write to
|
|
int_val - integer version of item
|
|
uint_val - unsigned integer version of item
|
|
double_val - double-precision float version of item
|
|
type - data type to write out
|
|
******************************************************************************/
|
|
|
|
void write_binary_item(
|
|
FILE *fp,
|
|
int int_val,
|
|
unsigned int uint_val,
|
|
double double_val,
|
|
int type
|
|
)
|
|
{
|
|
unsigned char uchar_val;
|
|
char char_val;
|
|
unsigned short ushort_val;
|
|
short short_val;
|
|
float float_val;
|
|
|
|
switch (type) {
|
|
case PLY_CHAR:
|
|
char_val = (char)int_val;
|
|
fwrite(&char_val, 1, 1, fp);
|
|
break;
|
|
case PLY_SHORT:
|
|
short_val = (short)int_val;
|
|
fwrite(&short_val, 2, 1, fp);
|
|
break;
|
|
case PLY_INT:
|
|
fwrite(&int_val, 4, 1, fp);
|
|
break;
|
|
case PLY_UCHAR:
|
|
uchar_val = (unsigned char) uint_val;
|
|
fwrite(&uchar_val, 1, 1, fp);
|
|
break;
|
|
case PLY_USHORT:
|
|
ushort_val = (unsigned short)uint_val;
|
|
fwrite(&ushort_val, 2, 1, fp);
|
|
break;
|
|
case PLY_UINT:
|
|
fwrite(&uint_val, 4, 1, fp);
|
|
break;
|
|
case PLY_FLOAT:
|
|
float_val = (float) double_val;
|
|
fwrite(&float_val, 4, 1, fp);
|
|
break;
|
|
case PLY_DOUBLE:
|
|
fwrite(&double_val, 8, 1, fp);
|
|
break;
|
|
default:
|
|
fprintf(stderr, "write_binary_item: bad type = %d\n", type);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Write out an item to a file as ascii characters.
|
|
|
|
Entry:
|
|
fp - file to write to
|
|
int_val - integer version of item
|
|
uint_val - unsigned integer version of item
|
|
double_val - double-precision float version of item
|
|
type - data type to write out
|
|
******************************************************************************/
|
|
|
|
void write_ascii_item(
|
|
FILE *fp,
|
|
int int_val,
|
|
unsigned int uint_val,
|
|
double double_val,
|
|
int type
|
|
)
|
|
{
|
|
switch (type) {
|
|
case PLY_CHAR:
|
|
case PLY_SHORT:
|
|
case PLY_INT:
|
|
fprintf(fp, "%d ", int_val);
|
|
break;
|
|
case PLY_UCHAR:
|
|
case PLY_USHORT:
|
|
case PLY_UINT:
|
|
fprintf(fp, "%u ", uint_val);
|
|
break;
|
|
case PLY_FLOAT:
|
|
case PLY_DOUBLE:
|
|
fprintf(fp, "%g ", double_val);
|
|
break;
|
|
default:
|
|
fprintf(stderr, "write_ascii_item: bad type = %d\n", type);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Write out an item to a file as ascii characters.
|
|
|
|
Entry:
|
|
fp - file to write to
|
|
item - pointer to item to write
|
|
type - data type that "item" points to
|
|
|
|
Exit:
|
|
returns a double-precision float that contains the value of the written item
|
|
******************************************************************************/
|
|
|
|
double old_write_ascii_item(FILE *fp, char *item, int type)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Get the value of an item that is in memory, and place the result
|
|
into an integer, an unsigned integer and a double.
|
|
|
|
Entry:
|
|
ptr - pointer to the item
|
|
type - data type supposedly in the item
|
|
|
|
Exit:
|
|
int_val - integer value
|
|
uint_val - unsigned integer value
|
|
double_val - double-precision floating point value
|
|
******************************************************************************/
|
|
|
|
void get_stored_item(
|
|
void *ptr,
|
|
int type,
|
|
int *int_val,
|
|
unsigned int *uint_val,
|
|
double *double_val
|
|
)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Get the value of an item from a binary file, and place the result
|
|
into an integer, an unsigned integer and a double.
|
|
|
|
Entry:
|
|
fp - file to get item from
|
|
type - data type supposedly in the word
|
|
|
|
Exit:
|
|
int_val - integer value
|
|
uint_val - unsigned integer value
|
|
double_val - double-precision floating point value
|
|
******************************************************************************/
|
|
|
|
void get_binary_item(
|
|
FILE *fp,
|
|
int type,
|
|
int *int_val,
|
|
unsigned int *uint_val,
|
|
double *double_val
|
|
)
|
|
{
|
|
char c[8];
|
|
void *ptr;
|
|
|
|
ptr = (void *) c;
|
|
|
|
switch (type) {
|
|
case PLY_CHAR:
|
|
fread(ptr, 1, 1, fp);
|
|
*int_val = *((char *) ptr);
|
|
*uint_val = *int_val;
|
|
*double_val = *int_val;
|
|
break;
|
|
case PLY_UCHAR:
|
|
fread(ptr, 1, 1, fp);
|
|
*uint_val = *((unsigned char *) ptr);
|
|
*int_val = *uint_val;
|
|
*double_val = *uint_val;
|
|
break;
|
|
case PLY_SHORT:
|
|
fread(ptr, 2, 1, fp);
|
|
*int_val = *((short int *) ptr);
|
|
*uint_val = *int_val;
|
|
*double_val = *int_val;
|
|
break;
|
|
case PLY_USHORT:
|
|
fread(ptr, 2, 1, fp);
|
|
*uint_val = *((unsigned short int *) ptr);
|
|
*int_val = *uint_val;
|
|
*double_val = *uint_val;
|
|
break;
|
|
case PLY_INT:
|
|
fread(ptr, 4, 1, fp);
|
|
*int_val = *((int *) ptr);
|
|
*uint_val = *int_val;
|
|
*double_val = *int_val;
|
|
break;
|
|
case PLY_UINT:
|
|
fread(ptr, 4, 1, fp);
|
|
*uint_val = *((unsigned int *) ptr);
|
|
*int_val = *uint_val;
|
|
*double_val = *uint_val;
|
|
break;
|
|
case PLY_FLOAT:
|
|
fread(ptr, 4, 1, fp);
|
|
*double_val = *((float *) ptr);
|
|
*int_val = (int)*double_val;
|
|
*uint_val = (unsigned int) *double_val;
|
|
break;
|
|
case PLY_DOUBLE:
|
|
fread(ptr, 8, 1, fp);
|
|
*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);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Extract the value of an item from an ascii word, and place the result
|
|
into an integer, an unsigned integer and a double.
|
|
|
|
Entry:
|
|
word - word to extract value from
|
|
type - data type supposedly in the word
|
|
|
|
Exit:
|
|
int_val - integer value
|
|
uint_val - unsigned integer value
|
|
double_val - double-precision floating point value
|
|
******************************************************************************/
|
|
|
|
void get_ascii_item(
|
|
char *word,
|
|
int type,
|
|
int *int_val,
|
|
unsigned int *uint_val,
|
|
double *double_val
|
|
)
|
|
{
|
|
switch (type) {
|
|
case PLY_CHAR:
|
|
case PLY_UCHAR:
|
|
case PLY_SHORT:
|
|
case PLY_USHORT:
|
|
case PLY_INT:
|
|
*int_val = atoi(word);
|
|
*uint_val = *int_val;
|
|
*double_val = *int_val;
|
|
break;
|
|
|
|
case PLY_UINT:
|
|
*uint_val = strtoul(word, (char **) NULL, 10);
|
|
*int_val = *uint_val;
|
|
*double_val = *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);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Store a value into a place being pointed to, guided by a data type.
|
|
|
|
Entry:
|
|
item - place to store value
|
|
type - data type
|
|
int_val - integer version of value
|
|
uint_val - unsigned integer version of value
|
|
double_val - double version of value
|
|
|
|
Exit:
|
|
item - pointer to stored value
|
|
******************************************************************************/
|
|
|
|
void store_item(
|
|
char *item,
|
|
int type,
|
|
int int_val,
|
|
unsigned int uint_val,
|
|
double double_val
|
|
)
|
|
{
|
|
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 = (char) int_val;
|
|
break;
|
|
case PLY_UCHAR:
|
|
puchar = (unsigned char *) item;
|
|
*puchar = (unsigned char)uint_val;
|
|
break;
|
|
case PLY_SHORT:
|
|
pshort = (short *) item;
|
|
*pshort = (short)int_val;
|
|
break;
|
|
case PLY_USHORT:
|
|
pushort = (unsigned short *) item;
|
|
*pushort = (unsigned short)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 = (float)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);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Add an element to a PLY file descriptor.
|
|
|
|
Entry:
|
|
plyfile - PLY file descriptor
|
|
words - list of words describing the element
|
|
nwords - number of words in the list
|
|
******************************************************************************/
|
|
|
|
void add_element(PlyFile *plyfile, char **words)
|
|
{
|
|
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++;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Return the type of a property, given the name of the property.
|
|
|
|
Entry:
|
|
name - name of property type
|
|
|
|
Exit:
|
|
returns integer code for property, or 0 if not found
|
|
******************************************************************************/
|
|
|
|
int get_prop_type(char *type_name)
|
|
{
|
|
int i;
|
|
|
|
for (i = PLY_START_TYPE + 1; i < PLY_END_TYPE; i++)
|
|
if (equal_strings(type_name, type_names[i]))
|
|
return (i);
|
|
|
|
/* if we get here, we didn't find the type */
|
|
return (0);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Add a property to a PLY file descriptor.
|
|
|
|
Entry:
|
|
plyfile - PLY file descriptor
|
|
words - list of words describing the property
|
|
nwords - number of words in the list
|
|
******************************************************************************/
|
|
|
|
void add_property(PlyFile *plyfile, char **words)
|
|
{
|
|
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++;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Add a comment to a PLY file descriptor.
|
|
|
|
Entry:
|
|
plyfile - PLY file descriptor
|
|
line - line containing comment
|
|
******************************************************************************/
|
|
|
|
void add_comment(PlyFile *plyfile, char *line)
|
|
{
|
|
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]);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Add a some object information to a PLY file descriptor.
|
|
|
|
Entry:
|
|
plyfile - PLY file descriptor
|
|
line - line containing text info
|
|
******************************************************************************/
|
|
|
|
void add_obj_info(PlyFile *plyfile, char *line)
|
|
{
|
|
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]);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Copy a property.
|
|
******************************************************************************/
|
|
|
|
void copy_property(PlyProperty *dest, PlyProperty *src)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Allocate some memory.
|
|
|
|
Entry:
|
|
size - amount of memory requested (in bytes)
|
|
lnum - line number from which memory was requested
|
|
fname - file name from which memory was requested
|
|
******************************************************************************/
|
|
|
|
static char *my_alloc(int size, int lnum, char *fname)
|
|
{
|
|
char *ptr;
|
|
|
|
ptr = (char *) malloc(size);
|
|
|
|
if (ptr == 0) {
|
|
fprintf(stderr, "Memory allocation bombed on line %d in %s\n", lnum, fname);
|
|
}
|
|
|
|
return (ptr);
|
|
}
|
|
|