---

PLYFile.cc

Go to the documentation of this file.

/*
    File:       PLYFile.cc
 
    Function:   
 
    Authors:    Greg Turk, Andrew Willmott
 
    Notes:      
*/

#include "ply.h"
#include "gcl/SceneLang.h"
#include "gcl/VecUtil.h"

/*
 
    Based on example programs by:
 
    Greg Turk
 
    -----------------------------------------------------------------------
 
    Copyright (c) 1998 Georgia Institute of Technology.  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.   
 
*/

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

struct Vertex
{
    float x, y, z;
    float nx, ny, nz;
    unsigned char r, g, b;
    void *other_props;         /* other properties */
};

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

struct TriStrips
{
    int nverts;      /* number of vertex indices in list */
    int *verts;                /* vertex index list */
    void *other_props;         /* other properties */
};

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

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

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

PlyProperty tristrip_props[] = { /* list of property information for a vertex */
    {"vertex_indices", PLY_INT, PLY_INT, offsetof(TriStrips, verts),
     1, PLY_INT, PLY_INT, offsetof(TriStrips, nverts)},
};

/*** the PLY object ***/

static int nverts, nfaces, ntristrips;
static Vertex *vlist;
static Face *flist;
static TriStrips *tslist;
static PlyOtherElems *other_elements = NULL;
static PlyOtherProp *vert_other, *face_other, *tristrip_other;
static int nelems;
static char **elist;
static int num_comments;
static char **comments;
static int num_obj_info;
static char **obj_info;
static int file_type;

static int has_normals, has_rgb;   /* are normals in PLY file? */


/******************************************************************************
Read in the PLY file from standard in.
******************************************************************************/

void read_file(FILE *file)
{
    int         i, j, k;
    PlyFile     *ply;
    int         nprops;
    int         num_elems;
    PlyProperty **plist;
    char        *elem_name;
    float       version;


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


    ply = ply_read (file, &nelems, &elist);
    ply_get_info (ply, &version, &file_type);

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

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

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

            /* see if vertex holds any normal information */
            has_normals = has_rgb = 0;
            for (j = 0; j < nprops; j++)
            {
                if (equal_strings ("nx", plist[j]->name)) has_normals = 1;
                if (equal_strings ("red", plist[j]->name)) has_rgb = 1;
            }

            /* create a vertex list to hold all the vertices */
            vlist = (Vertex *) malloc (sizeof (Vertex) * num_elems);
            nverts = num_elems;

            /* set up for getting vertex elements */

            ply_get_property (ply, elem_name, &vert_props[0]);
            ply_get_property (ply, elem_name, &vert_props[1]);
            ply_get_property (ply, elem_name, &vert_props[2]);
            if (has_normals)
            {
                ply_get_property (ply, elem_name, &vert_props[3]);
                ply_get_property (ply, elem_name, &vert_props[4]);
                ply_get_property (ply, elem_name, &vert_props[5]);
            }
            if (has_rgb)
            {
                ply_get_property (ply, elem_name, &vert_props[6]);
                ply_get_property (ply, elem_name, &vert_props[7]);
                ply_get_property (ply, elem_name, &vert_props[8]);
            }
            vert_other = ply_get_other_properties (ply, elem_name,
                                                   offsetof(Vertex, other_props));

            /* grab all the vertex elements */
            for (j = 0; j < num_elems; j++)
                ply_get_element (ply, (void *) (vlist + j));
        }
        else if (equal_strings ("face", elem_name))
        {

            /* create a list to hold all the face elements */
            flist = (Face *) malloc (sizeof(Face) * num_elems);
            nfaces = num_elems;

            /* set up for getting face elements */

            ply_get_property (ply, elem_name, &face_props[0]);
            face_other = ply_get_other_properties (ply, elem_name,
                                                   offsetof(Face, other_props));

            /* grab all the face elements */
            for (j = 0; j < num_elems; j++)
                ply_get_element (ply, (void *) (flist + j));
        }
        else if (equal_strings ("tristrips", elem_name))
        {

            /* create a list to hold all the tristrip elements */
            tslist = (TriStrips *) malloc (sizeof(TriStrips) * num_elems);
            ntristrips = num_elems;

            /* set up for getting tristrip elements */

            ply_get_property (ply, elem_name, &tristrip_props[0]);
            tristrip_other = ply_get_other_properties (ply, elem_name,
                             offsetof(TriStrips, other_props));

            /* grab all the tristrip elements */
            for (j = 0; j < num_elems; j++)
                ply_get_element (ply, (void *) (tslist + j));
        }
        else
            other_elements = ply_get_other_element (ply, elem_name, num_elems);
    }

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

    ply_close (ply);
}


/******************************************************************************
Write out the PLY file to standard out.
******************************************************************************/

write_file()
{
    int i, j, k;
    PlyFile *ply;
    int num_elems;
    char *elem_name;

    /*** Write out the final PLY object ***/


    ply = ply_write (stdout, 3, elem_names, file_type);


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

    ply_element_count (ply, "vertex", nverts);
    ply_describe_property (ply, "vertex", &vert_props[0]);
    ply_describe_property (ply, "vertex", &vert_props[1]);
    ply_describe_property (ply, "vertex", &vert_props[2]);
    if (has_normals)
    {
        ply_describe_property (ply, "vertex", &vert_props[3]);
        ply_describe_property (ply, "vertex", &vert_props[4]);
        ply_describe_property (ply, "vertex", &vert_props[5]);
    }
    ply_describe_other_properties (ply, vert_other, offsetof(Vertex, other_props));

    ply_element_count (ply, "face", nfaces);
    ply_describe_property (ply, "face", &face_props[0]);
    ply_describe_other_properties (ply, face_other, offsetof(Face, other_props));

    ply_describe_other_elements (ply, other_elements);

    for (i = 0; i < num_comments; i++)
        ply_put_comment (ply, comments[i]);

    for (i = 0; i < num_obj_info; i++)
        ply_put_obj_info (ply, obj_info[i]);

    ply_header_complete (ply);

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

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

    ply_put_other_elements (ply);

    /* close the PLY file */
    ply_close (ply);
}



// --- GCL stuff -------------------------------

Void AccumNormals(
    Int tri[3],
    PointList   &points,
    NormalList  &normals,
    ScalarList  &areas
)
{
    Vector  normal;
    GCLReal normalLen;

    CalcTriAreaNormal(
        points[tri[0]],
        points[tri[1]],
        points[tri[2]],
        normal
    );

    normal *= 0.5;
    normalLen = len(normal);

    normals[tri[0]] += normal;
    normals[tri[1]] += normal;
    normals[tri[2]] += normal;
    areas[tri[0]] += normalLen;
    areas[tri[1]] += normalLen;
    areas[tri[2]] += normalLen;
}

Void MakeNormals()
{
    scPoints    *sp = SL_GET(Points);
    scNormals   *sn = new scNormals;
    NormalList  &normals = *sn;
    PointList   &points = *sp;
    ScalarList  areas(nverts);
    Int         i, j;
    Int         tri[3], triStripLen;

    normals.SetSize(nverts);
    normals.ClearTo(vl_0);
    areas.ClearTo(0.0);

    if (nfaces > 0)
        for (i = 0; i < nfaces; i++)
        {
            Face    *face = flist + i;

            tri[0] = face->verts[face->nverts - 2];
            tri[1] = face->verts[face->nverts - 1];
            for (j = 0; j < face->nverts; j++)
            {
                tri[2] = face->verts[j];
                AccumNormals(tri, points, normals, areas);
                tri[0] = tri[1];
                tri[1] = tri[2];
            }
        }

    if (ntristrips > 0)
    {
        for (i = 0; i < ntristrips; i++)
        {
            TriStrips   *tristrip = tslist + i;

            triStripLen = 0;

            for (j = 0; j < tristrip->nverts; j++)
                if (tristrip->verts[j] == -1)
                    triStripLen = 0;
                else
                {
                    triStripLen++;
                    if (triStripLen < 3)
                        continue;
                    else if (triStripLen % 2)
                    {
                        tri[0] = tristrip->verts[j - 2];
                        tri[1] = tristrip->verts[j - 1];
                    }
                    else
                    {
                        tri[0] = tristrip->verts[j - 1];
                        tri[1] = tristrip->verts[j - 2];
                    }
                    tri[2] = tristrip->verts[j];

                    AccumNormals(tri, points, normals, areas);
                }
        }
    }

    for (i = 0; i < normals.NumItems(); i++)
    {
        if (areas[i] > 0.0)
            normals[i] /= areas[i];
    }

    slAttribute(sn);
}

scScenePtr ParsePLYFile(const Char *filename)
{
    FILE *plyFile;
    scScenePtr  result;
    Int i, j;

    plyFile = fopen(filename, "r");
    read_file(plyFile);
    // ply does the close??? hard to tell

    cerr << nfaces << " faces" << endl;
    cerr << ntristrips << " triangle strips" << endl;
    cerr << nverts << " vertices" << endl;
    cerr << "converting..." << endl;

    result = slBeginObject(filename);

    cerr << "making point list" << endl;
    slPointList();
    SL_GET(Points)->PreAllocate(nverts);
    for (i = 0; i < nverts; i++)
    {
        Vertex *v = vlist + i;
        slPoint(Point(v->x, v->y, v->z));
    }

    if (has_normals)
    {
        cerr << "making normals list" << endl;
        slNormalList();
        SL_GET(Normals)->PreAllocate(nverts);

        for (i = 0; i < nverts; i++)
        {
            Vertex *v = vlist + i;
            slNormal(Vector(v->nx, v->ny, v->nz));
        }
    }
    else
    {
        cerr << "creating a normals list" << endl;
        MakeNormals();
    }
    
    if (has_rgb)
    {
        cerr << "making colours list" << endl;
        slColourList();
        SL_GET(Colours)->PreAllocate(nverts);

        for (i = 0; i < nverts; i++)
        {
            Vertex *v = vlist + i;
            slColour(Colour(v->r, v->g, v->b) / 255.0);
        }
    }

    free(vlist);

    if (nfaces > 0)
    {
        cerr << "making faces list" << endl;
        slBeginFaces();
        for (i = 0; i < nfaces; i++)
        {
            Face    *face = flist + i;

            for (j = 0; j < face->nverts; j++)
                slPointIndex(face->verts[j]);

            slFace();
            free(face->verts);
        }
        slEndFaces();
    }
    free(flist);

    if (ntristrips > 0)
    {
        Int strips = 0;

        cerr << "making tristrips list" << endl;

        slMeshType(renTriStrip);
        slBeginFaces();

        for (i = 0; i < ntristrips; i++)
        {
            TriStrips   *tristrip = tslist + i;

            for (j = 0; j < tristrip->nverts; j++)
                if (tristrip->verts[j] == -1)
                {
                    strips++;
                    slFace();
                }
                else
                    slPointIndex(tristrip->verts[j]);

            strips++;
            free(tristrip->verts);
        }

        slEndFaces();
        slEndAttribute(aMeshType);
    }
    free(tslist);

    slEndObject();

    cerr << "done." << endl;

    return (result);
}

#include "plyfile.c"

---