mesh_io.cpp

/***************************************************************************
 *   Copyright (C) 2007 by Pablo Diaz-Gutierrez   *
 *   pablo@ics.uci.edu   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library 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 Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <string>
#include <iterator>
#include "polyhedron.h"
#include "util.h"


using namespace std;
using namespace Geometry;
using namespace HE;

const int LEN = 128;


filetype_e HE::fileFormat(const char* filename)
{
        string name(filename);
        for (unsigned i=0 ; i<name.size() ; i++)
                name[i] = tolower(name[i]);

        // Can we detect by just looking at the filename?
  if (name.find(".obj") < name.size() || name.find(".OBJ") < name.size())
                return FT_OBJ;
  else if (name.find(".tri") < name.size() || name.find(".TRI") < name.size())
    return FT_TRI;

        ifstream in(filename);
        if (!in)
                throw HE_exception("Cannot open file", filename);

        // Check the header's magic string
        string s;
        in >> s;
  if (s == "OFF")
  {
    assert(name.find(".off") < name.size());
    in.close();
    return FT_OFF;
  }
  
  if (s == "ply")
        {
                assert(name.find(".ply") < name.size());

                in >> s;
                assert(s == "format");
                in >> s;
                in.close();
                if (s == "ascii")
                        return FT_PLY_ASCII;
                else
                        return FT_PLY_BIN;
        }

        in.close();
        return FT_NONE;
}

bool Polyhedron::readPly(const char* filename)
{
        ifstream in(filename);
        if (!in)
        {
                throw HE_exception("Cannot open file", filename);
                return false;
        }

        int nv, nf;
        short order[11];                // order of x,y,z, nx,ny,nz, red,green,blue, tu,tv vertex properties
        bool result = readPlyHeader(in, nv, nf, order);
        assert(result);

        vector<float> verts;
        vector<vector<int> > faces;
        result = readPlyData(in, nv, nf, order, verts, faces);
        assert(result);
        loadVertices(verts);
        loadFaces(faces);

        return true;
}

bool Polyhedron::readPlyHeader(ifstream& in, int& nv, int& nf, short order[11])
{
        char buf[LEN], type[LEN], c[LEN];
        int i;

  // read ply file header
        in.getline(buf, LEN);
        assert(strncmp(buf, "ply", 3) == 0);

        in.getline(buf, LEN);
        if (strncmp(buf, "format ascii", 12) != 0)
        {
                cerr << "Error: Input file is not in ASCII format. Line read: " << buf << endl;
                return false;
        }

        in.getline(buf, LEN);
        while (strncmp(buf, "comment", 7) == 0)
                in.getline(buf, LEN);

  // read number of vertices
        if (strncmp(buf, "element vertex", 14) == 0)
        {
                sscanf(buf, "element vertex %d\n", &nv);
        }
        else 
        {
                cerr << "Error: number of vertices expected\n";
                return false;
        }
        
        for (i=0 ; i<11 ; ++i)
                order[i] = -1;

  // read vertex properties order
        i = 0;
        in.getline(buf, LEN);
        while (strncmp(buf, "property", 8) == 0)
        {
                sscanf(buf, "property %s %s\n", type, c);
                if (strncmp(c, "x", 1) == 0)
                        order[0] = i;
                else if (strncmp(c, "y", 1) == 0)
                        order[1] = i;
                else if (strncmp(c, "z", 1) == 0)
                        order[2] = i;

                else if (strncmp(c, "nx", 2) == 0)
                        order[3] = i;
                else if (strncmp(c, "ny", 2) == 0)
                        order[4] = i;
                else if (strncmp(c, "nz", 2) == 0)
                        order[5] = i;

                else if (strncmp(c, "red", 3) == 0)
                        order[6] = i;
                else if (strncmp(c, "green", 5) == 0)
                        order[7] = i;
                else if (strncmp(c, "blue", 4) == 0)
                        order[8] = i;

                else if (strncmp(c, "tu", 2) == 0)
                        order[9] = i;
                else if (strncmp(c, "tv", 2) == 0)
                        order[10] = i;

                i++;
                in.getline(buf, LEN);
        }
        //nproperties = i;

        for (i=0; i<3; i++)
        {
                if (order[i] < 0)
                {
                        cerr << "Error: not enough vertex coordinate fields (nx, ny, nz)\n";
                        return false;
                }
        }
#if 0
        hasnormal = true;
        for (i = 3; i < 6; i++)
                if (order[i] < 0)
                        hasnormal = false;
        hascolor = true;
        for (i = 6; i < 9; i++)
                if (order[i] < 0)
                        hascolor = false;
        hastexture = true;
        for (i = 9; i < 11; i++)
                if (order[i] < 0)
                        hastexture = false;

        if (!hasnormal)
                cerr << "Notice: no normal coordinates used from file\n";
        if (!hascolor)
                cerr << "Notice: no color used from file\n";
        if (!hastexture)
                cerr << "Notice: no texture coordinates used from file\n";
#endif

  // number of faces and face properties
        if (strncmp(buf, "element face", 12) == 0)
                sscanf(buf, "element face %d\n", &nf);
        else
        {
                cerr << "Error: number of faces expected\n";
                return false;
        }

        in.getline(buf, LEN);
        if (strncmp(buf, "property list", 13) != 0)
        {
                cerr << "Error: property list expected\n";
                return false;
        }

        // Skip everything up to the end of the header
        in.getline(buf, LEN);
        while (strncmp(buf, "end_header", 10) != 0)
                in.getline(buf, LEN);

        return true;
}

bool Polyhedron::readPlyData(ifstream& in, int& nv, int& nf, const short order[11], vector<float>& verts, vector<vector<int> >& faces)
{
        char buf[LEN];
        int i, k, v;
        float values[32];
        verts.clear();
        for (i = 0; i < nv; i++)
        {
                in.getline(buf, LEN);
                sscanf(buf,"%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", &values[0], &values[1], &values[2], &values[3],
                                         &values[4], &values[5], &values[6], &values[7], &values[8], &values[9], &values[10], &values[11],
                                         &values[12], &values[13], &values[14], &values[15]);

                verts.push_back( values[order[0]] );
                verts.push_back( values[order[1]] );
                verts.push_back( values[order[2]] );
#if 0
                if (hasnormal)
                        for (j = 0; j < 3; j++)
                                normals[i][j] = values[order[3+j]];
                if (hascolor)
                        for (j = 0; j < 3; j++)
                                colors[i][j] = (unsigned char)values[order[6+j]];
                if (hastexture)
                        for (j = 0; j < 2; j++)
                                texcoords[i][j] = values[order[9+j]];
#endif
        }


  // read in face connectivity
        for (i = 0; i < nf; i++)
        {
                in >> k;
                vector<int> vi(k);
                for (int j=0 ; j<k ; j++)
                {
                        in >> v;
                        vi[j] = v;
                }

                faces.push_back(vi);
        }

        return true;
}

bool Polyhedron::readOff(const char* filename)
{
  ifstream in(filename);
  if (!in)
  {
    throw HE_exception("Cannot open file", filename);
    return false;
  }

  string s;
  int n, i, nv, nf, dunno;
  vector<int> face;
  in >> s;
  assert(s == "OFF");

  in >> nv >> nf >> dunno;
  vector<float> verts(nv*3);
  for (int v=0 ; v<nv*3 ; v++)
    in >> verts[v];
  loadVertices(verts);
  
  vector<vector<int> > faces;
  for (int f=0 ; f<nf ; f++)
  {
    face.clear();
    in >> n;
    while (n-- > 0)
    {
      in >> i;
      face.push_back(i);
    }
    faces.push_back(face);
  }
  loadFaces(faces);

  return true;
}

bool Polyhedron::readTri(const char* filename)
{
  ifstream in(filename);
  if (!in)
  {
    throw HE_exception("Cannot open file", filename);
    return false;
  }

  string s;
  int n, i, nv, nf;
  in >> nf;
  nv = 3*nf;

  vector<float> verts(nv*3);
  for (int v=0 ; v<nv*3 ; v++)
    in >> verts[v];
  loadVertices(verts);
  
  vector<vector<int> > faces;
  for (int f=0 ; f<nf ; f++)
  {
    vector<int> face(3);
    face[0] = 3*f;
    face[1] = 3*f+1;
    face[2] = 3*f+2;
    faces.push_back(face);
  }
  loadFaces(faces);

  return true;
}

bool Polyhedron::saveAsPly(const char* filename) const
{
        ofstream out(filename);
        if (!out)
        {
                throw HE_exception("Cannot open file", filename);
                return false;
        }
        cerr << "Saving model to " << filename << endl;

        out << "ply\n"
                        << "format ascii 1.0\n"
                        << "element vertex " << numVertices() << endl
                        << "property float32 x\n"
                        << "property float32 y\n"
                        << "property float32 z\n"
                        << "element face " << numFaces() << endl
                        << "property list uint8 int32 vertex_indices\n"
                        << "end_header\n";

        writeVertices(out);
        writeFaces(out);

        out.close();
        return true;
}


void Polyhedron::writeVertices(std::ostream& out) const
{
        for (const_vertex_iterator vit=vBegin() ; vit!=vEnd() ; ++vit)
                out << (*vit)->position() << endl;
}

void Polyhedron::writeHalfEdges(std::ostream& out) const
{
  for (const_edge_iterator eit=eBegin() ; eit!=eEnd() ; ++eit)
    out << (*eit)->prev()->dst()->index() << ' ' << (*eit)->dst()->index() << endl;
}

void Polyhedron::writeFaces(std::ostream& out, bool includeHoles) const
{
        for (const_face_iterator fit=fBegin() ; fit!=fEnd() ; ++fit)
        {
                const Face* f = *fit;
                if (!includeHoles && f->hole())
                        continue;
      if (includeHoles)
        out << (f->hole() ? "h " : "  " );
      out << f->size();

                Face::const_edge_circulator e = f->begin();
                Face::const_edge_circulator sentinel = e;
        
                do
                {
                        out  << ' ' << (*e)->dst()->index();
                        ++e;
                } while (e != sentinel) ;
                
                out << endl;
        }
}


bool Polyhedron::save(const char* filename) const
{
        switch(_type)
        {
                case FT_PLY_ASCII:
                        return saveAsPly(filename);

    case FT_OFF:
      return saveAsOff(filename);

    case FT_TRI:
      return saveAsTri(filename);

    default:
                        cerr << "Format not supported for output\n";
                        return false;
        }
}


bool Polyhedron::saveAsOff(const char* filename) const
{
  ofstream out(filename);
  if (!out)
  {
    throw HE_exception("Cannot open file", filename);
    return false;
  }

  out << "OFF\n";
  out << numVertices() << ' ' << numFaces()-numHoles() << ' ' << 0 << endl << endl;
  writeVertices( out);
  writeFaces( out);
  
  out.close();
  return true;
}

bool Polyhedron::saveAsTri(const char* filename) const
{
  ofstream out(filename);
  if (!out)
  {
    throw HE_exception("Cannot open file", filename);
    return false;
  }

  out << numFaces() << endl;
  
  for (const_face_iterator fit=fBegin() ; fit!=fEnd() ; ++fit)
  {
    const Face* f = *fit;
    if (f->hole())
      continue;

    Face::const_edge_circulator e = f->begin();
    Face::const_edge_circulator sentinel = e;
    do
    {
      out  << ' ' << (*e)->dst()->position();
      ++e;
    } while (e != sentinel) ;
    out << endl;
  }

  out.close();
  return true;
}


void Polyhedron::loadVertices(const std::vector<float>& verts)
{
  assert(0 == verts.size()%3);
#if 0
  cerr << verts.size()/3 << " vertices being loaded:\n";
                                for (unsigned i=0 ; i<verts.size() ; ++i)
                                cerr << (0==i%3 ? '\n' : ' ') << verts[i];
                                cerr << endl;
#endif

                                int nv = verts.size()/3;
                            _vertices.resize(nv);
                            for(int i=0 ; i<nv ; ++i)
                            {
                              Vector3Df v(verts[3*i], verts[3*i+1], verts[3*i+2]);
                              _vertices[i] = new Vertex(v, i);
                            }
}

void Polyhedron::loadFaces(const std::vector<std::vector<int> >& faces)
{
#if 0
  cerr << faces.size() << " faces being loaded\n";
                              for (unsigned i=0 ; i<faces.size() ; ++i)
                          {
                              for (unsigned j=0 ; j<faces[i].size() ; ++j)
                              cerr << faces[i][j] << ' ';
                              cerr << endl;
}
#endif

  for( unsigned i=0 ; i<faces.size() ; ++i)
    addFace( faces[i] );
  finalize();
}


Face* Polyhedron::addFace(int a, int b, int c)
{
  vector<int> corners(3);
  corners[0] = a;
  corners[1] = b;
  corners[2] = c;
  return addFace(corners);
}

Face* Polyhedron::addFace(const std::vector<int>& corners)
{
#if 0
  cerr << "Adding face #" << numFaces() << ": ";
  copy(corners.begin(), corners.end(), ostream_iterator<int>(cerr, ", "));
  cerr << endl;
#endif

  Face* f = new Face(0);
  _faces.push_back(f);

  // Create one HalfEdge per consecutive pair of corners
  vector<HalfEdge*> edges;
  const unsigned nc = corners.size();
  for (unsigned i=0 ; i<nc ; ++i)
  {
    int c1 = corners[i];
    int c2 = corners[(i+1)%nc];
    HalfEdge* he = new HalfEdge(_vertices[c2], f);
    assert(!he->twin());
    assert(he->face());
    _halfEdges.push_back(he);
    f->edge(he);
    _vertices[c1]->edge(he);
    edges.push_back(he);
  }
        
        // Connect each HalfEdge to its next in the face
  assert(nc == edges.size());
  const unsigned& ne = nc;
  for (unsigned e=0 ; e<ne ; e++)
    edges[e]->next( edges[(e+1)%ne] );

  return f;
}


ostream& HE::operator<<(ostream& out, const Polyhedron& p)
{
  out << p.numVertices() << " vertices:\n";
  p.writeVertices(out);
  out << p.numFaces() << " faces:\n";
  p.writeFaces(out, true);
  out << p.numHalfEdges() << " half-edges:\n";
  p.writeHalfEdges(out);

  return out;
}

---