$search

mesh_io.cc

Go to the documentation of this file.

/*
  James R. Diebel
  Stanford University

  Started: 24 August 2004
  Last revised: 27 Sugust 2004

  mesh.cc - class implementation of Mesh class (mesh.hh)
          - I/O functions only

  Depends on:
  - Mesh class (mesh.hh)
*/

#include "bmtk/mesh.hh"
#include <trimesh/trimesh.h>
#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <stdio.h>
#include <list>
#include <vector>
#include <IL/il.h>
#include <IL/ilu.h>
#include <IL/ilut.h>

using namespace std;
using namespace trimesh;

namespace bmtk {

// Export Mesh to ply format //
void Mesh::exportToPLY(char *plyfile) {
  if (po) {
    cout << endl
         << "/---------------------------------\\" << endl
         << "| Writing PLY Mesh to passed file |" << endl
         << "\\--------------------------------/" << endl << flush;
  }
  // create TriMesh to fill
  TriMesh tm(nv,nf);
  for (int i=0;i<nv;i++) {
    for (int j=0;j<3;j++) {
      tm.vertices[i][j] = v[i].x[j];
    }
  }
  for (int i=0;i<nf;i++) {
    for (int j=0;j<3;j++) {
      tm.faces[i][j] = f[i].v[j]->i;
    }
  }

  // write TriMesh from file
  tm.WritePly(plyfile);
}

// Function to build a fully-connected mesh //
// from passed plyfile                      //
void Mesh::buildFromPLY(char* plyfile) {
  if (po) {
    cout << endl
         << "/-----------------------------------\\" << endl
         << "| Reading PLY Mesh from passed file |" << endl
         << "\\----------------------------------/" << endl << flush;
  }
  // read TriMesh from file
  TriMesh *tm;
  tm = TriMesh::ReadPly(plyfile);
  if (!tm) exit(1);
  tm->need_faces();

  // parse TriMesh into standard vertex and face lists
  float* v = new float[3*tm->numvertices];
  int* f = new int[3*tm->numfaces];
  for (int i=0;i<tm->numvertices;i++) {
    v[3*i] = tm->vertices[i][0];
    v[3*i+1] = tm->vertices[i][1];
    v[3*i+2] = tm->vertices[i][2];
  }
  for (int i=0;i<tm->numfaces;i++) {
    f[3*i] = tm->faces[i][0];
    f[3*i+1] = tm->faces[i][1];
    f[3*i+2] = tm->faces[i][2];
  }

  // parse it into my new Mesh format
  buildFrom(v,tm->numvertices,f,tm->numfaces);

  // de-allocate memory
  delete [] v;
  delete [] f;
}

// Function to build a fully-connected mesh //
// from passed plyfile                      //
void Mesh::buildFromMAP(char* mapfile, char* intfile) {
  if (po) {
    cout << endl
         << "/-----------------------------------\\" << endl
         << "| Reading Disp Map from passed file |" << endl
         << "\\-----------------------------------/" << endl << flush;
  }

  // Load image from file
  // Initialize DevIL (Developer's Image Library)
  ILuint ImgId;
  ilInit(); iluInit();
  // Since we are only using one image at a time, initialize it now
  ilGenImages(1, &ImgId);
  // Bind this image name
  ilBindImage(ImgId);
  // Load the actual file from disk
  ILenum ilerr = ilLoadImage((const ILstring)mapfile);
  if (ilerr == IL_FALSE) {
    cerr << endl << "Error reading disp map, exiting..." << endl << flush;
    exit(1);
  }
  if (int(ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL)) != 1) {
    cerr << endl << "Error, image depth is not 1, exiting..." << endl << flush;
    exit(1);
  }
  // grab a pointer to the raw image data
  ILubyte* inData = ilGetData();
  int nj = int(ilGetInteger(IL_IMAGE_WIDTH));
  int ni = int(ilGetInteger(IL_IMAGE_HEIGHT));
  int num_vertices = ni*nj;
  int num_faces_max = (ni-1)*(nj-1)*2;
  if (po==1) cout << nj << " x " << ni << " x 1" << "... " << endl << flush;

  // Read camera intrinsics from file
  float fi,fj,s,pi,pj,dzMax,d0;
  ifstream fin(intfile);
  if (!fin) {
    cerr << endl << "Error reading intrinsics file, exiting..." << endl
         << flush;
    exit(1);
  } else {
    fin >> fi >> fj >> s >> pi >> pj >> dzMax >> d0;
    fin.close();
  }
  Mat3x3 proj(fi,s,pi,0.0f,fj,pj,0.0f,0.0f,1.0f);
  Mat3x3 iproj = proj.inv();

  // generate vertex list
  float* vertices = new float[num_vertices*3];
  for (int i=0,k=0;i<ni;i++) for (int j=0;j<nj;j++,k++) {
    // project point to given depth using intrinsics
    float z = 1/(float(inData[k])+d0);
    Vec3d w = Vec3d(float(i),float(j),1.0);
    Vec3d u = iproj*w;
    w = u*(z/u[2]);
    // add vertex to list
    for (int l=0;l<3;l++) vertices[3*k+l] = w[l];
  }

  // generate face list
  int* faces = new int[num_faces_max*3];
  int num_faces = 0;
  for (int i=0,k=0;i<ni;i++) for (int j=0;j<nj;j++,k++) {
    if (i > 0 && j > 0) {
      // if pixel is black, don't include it
      if (inData[k] == 0 || inData[k-1] == 0 ||
          inData[k-nj-1] == 0 || inData[k-nj] == 0) continue;

      // check if dz is too great; if not, add face to list
      float z0 = 1/(float(inData[k])+d0);
      float z1 = 1/(float(inData[k-1])+d0);
      float z2 = 1/(float(inData[k-nj-1])+d0);
      float z3 = 1/(float(inData[k-nj])+d0);
      if (fabsf(z0-z1) < dzMax &&
          fabsf(z0-z2) < dzMax &&
          fabsf(z1-z2) < dzMax) {
        faces[3*num_faces] = k;
        faces[3*num_faces+1] = k-1;
        faces[3*num_faces+2] = k-nj-1;
        num_faces++;
      }
      if (fabsf(z0-z2) < dzMax &&
          fabsf(z0-z3) < dzMax &&
          fabsf(z2-z3) < dzMax) {
        faces[3*num_faces] = k;
        faces[3*num_faces+1] = k-nj-1;
        faces[3*num_faces+2] = k-nj;
        num_faces++;
      }
    }
  }

  // parse it into my new Mesh format
  buildFrom(vertices,num_vertices,faces,num_faces);

  // de-allocate memory
  delete [] vertices;
  delete [] faces;
}

void Mesh::buildFromLST(char* listfile) {
  if (po) {
    cout << endl
         << "/-----------------------------------\\" << endl
         << "| Building SuperMesh from List File |" << endl
         << "\\----------------------------------/" << endl << flush;
  }
  ifstream fin(listfile);
  fin >> nd;

  // Read first file and build topology
  char filename[200];
  fin >> filename;
  buildFromPLY(filename);

  // Allocate memory for all other data sets and fill first set
  for (int i=0;i<nv;i++) {
    v[i].xs = new Vec3d[nd];
    v[i].xs[0] = v[i].x;
  }
  for (int i=0;i<nf;i++) {
    f[i].ns = new Vec3d[nd];
    f[i].ns[0] = f[i].n;
    r[i].ns = new Vec3d[nd];
  }

  // And fill the data sets
  TriMesh *tm;
  for (int i=1;i<nd;i++) {
    fin >> filename;
    tm = TriMesh::ReadPly(filename);
    tm->need_faces();
    tm->need_normals();
    if (!tm) exit(1);
    for (int j=0;j<nv;j++) {
      v[j].xs[i][0] = tm->vertices[j][0];
      v[j].xs[i][1] = tm->vertices[j][1];
      v[j].xs[i][2] = tm->vertices[j][2];
    }
    for (int j=0;j<nf;j++) {
      f[j].ns[i][0] = tm->facenormals[j][0];
      f[j].ns[i][1] = tm->facenormals[j][1];
      f[j].ns[i][2] = tm->facenormals[j][2];
    }
    tm->~TriMesh();
  }
}

// Export Mesh to TMF format //
void Mesh::exportToTMF(char *tmffile) {
  if (po) {
    cout << endl
         << "/---------------------------------\\" << endl
         << "| Writing TMF Mesh to passed file |" << endl
         << "\\--------------------------------/" << endl << flush;
  }

  ofstream fout(tmffile);
  fout << "# Blah" << endl;
  fout << "# " << nv << " vertices" << endl << "# " << nf << " faces" << endl;
  for (int i=0;i<nv;i++)
    fout <<"v " << v[i].x[0]
         << " " << v[i].x[1]
         << " " << v[i].x[2] << endl;
  for (int i=0;i<nf;i++)
    fout << "f "<< f[i].v[0]->i+1
         << " " << f[i].v[1]->i+1
         << " " << f[i].v[2]->i+1 << endl;
  fout.close();
}

// Function to build a fully-connected mesh //
// from passed TMF file                     //
void Mesh::buildFromTMF(char* tmffile) {
  if (po) {
    cout << endl
         << "/-----------------------------------\\" << endl
         << "| Reading TMF Mesh from passed file |" << endl
         << "\\----------------------------------/" << endl << flush;
  }

  ifstream fin(tmffile);
  fin >> nv >> nf;

  // parse TriMesh into standard vertex and face lists
  float* v = new float[3*nv];
  int* f = new int[3*nf];
  float tempFloat;
  for (int i=0;i<nv;i++) {
    for (int j=0;j<3;j++) {
      fin >> tempFloat;
      v[3*i+j] = tempFloat;
    }
  }
  int tempInt;
  for (int i=0;i<nf;i++) {
    for (int j=0;j<3;j++) {
      fin >> tempInt;
      f[3*i+j] = tempInt;
    }
  }

  // parse it into my new Mesh format
  buildFrom(v,nv,f,nf);

  // de-allocate memory
  delete [] v;
  delete [] f;
}

// Function to build a fully-connected mesh //
// from passed GTS file                     //
void Mesh::buildFromGTS(char* gtsfile) {
  if (po) {
    cout << endl
         << "/-----------------------------------\\" << endl
         << "| Reading GTS Mesh from passed file |" << endl
         << "\\----------------------------------/" << endl << flush;
  }

  int tempInt;
  int face[6];
  float tempFloat;
  char tempChar[100];

  ifstream fin(gtsfile);
  fin >> nv >> ne >> nf;
  fin >> tempChar >> tempChar >> tempChar >> tempChar;

  // parse TriMesh into standard vertex and face lists
  float* v = new float[3*nv];
  int* f = new int[3*nf];
  int* e = new int[2*ne];
  for (int i=0;i<nv;i++) {
    for (int j=0;j<3;j++) {
      fin >> tempFloat;
      v[3*i+j] = tempFloat;
    }
    if(strcmp(tempChar,"vertexoffset")==0)
      for (int j=0;j<3;j++) fin >> tempFloat;
  }
  for (int i=0;i<ne;i++) {
    for (int j=0;j<2;j++) {
      fin >> tempInt;
      e[2*i+j] = tempInt-1;
    }
  }
  for (int i=0;i<nf;i++) {
    for (int j=0;j<3;j++) {
      fin >> tempInt;
      face[2*j] = e[2*(tempInt-1)];
      face[2*j+1] = e[2*(tempInt-1)+1];
    }
    if (face[0] == face[2] || face[0] == face[3]) {
      tempInt = face[0]; face[0] = face[1]; face[1] = tempInt;
    }
    if (face[3] == face[1]) {
      tempInt = face[3]; face[3] = face[2]; face[2] = tempInt;
    }
    if (face[5] == face[3]) {
      tempInt = face[5]; face[5] = face[4]; face[4] = tempInt;
    }
    for (int j=0;j<3;j++) f[3*i+j] = face[2*j];
  }

  // parse it into my new Mesh format
  buildFrom(v,nv,f,nf);

  // de-allocate memory
  delete [] v;
  delete [] f;
}

// Function to build a fully-connected mesh //
// from passed OFF file                     //
void Mesh::buildFromOFF(char* offfile) {
  if (po) {
    cout << endl
         << "/-----------------------------------\\" << endl
         << "| Reading OFF Mesh from passed file |" << endl
         << "\\----------------------------------/" << endl << flush;
  }

  char buf[100];
  char dump[100];
  int tempInt;
  ifstream fin(offfile);

  for (int i=0;i<6;i++) fin >> buf;
  fin >> nv;
  for (int i=0;i<11;i++) fin >> buf;
  fin >> nf;
  for (int i=0;i<6;i++) fin >> buf;


  cout << nv << " " << nf << endl << flush;

  // parse TriMesh into standard vertex and face lists
  float* v = new float[3*nv];
  int* f = new int[3*nf];
  float tempFloat;
  for (int i=0;i<nv;i++) {
    for (int j=0;j<3;j++) {
      fin >> tempFloat;
      v[3*i+j] = tempFloat;
    }
  }
  for (int i=0;i<nf;i++) {
    fin >> tempInt;
    for (int j=0;j<3;j++) {
      fin >> tempInt;
      f[3*i+j] = tempInt;
    }
  }

  // parse it into my new Mesh format
  buildFrom(v,nv,f,nf);

  // de-allocate memory
  delete [] v;
  delete [] f;
}

// Function to export the current regions   //
// to passed file                           //
void Mesh::exportRegions(char* regfile) {
  if (po) {
    cout << endl
         << "/---------------------\\" << endl
         << "| Writing Region File |" << endl
         << "\\--------------------/" << endl << flush;
  }

  // find lists of faces in each region
  findRegionFaceLists();

  // open a file and write those lists to disk
  ofstream fout(regfile);
  fout << nr << endl;
  if (po) cout << "- Writing " << nr << " regions with " << nf
               << " faces to " << regfile << "." << flush << endl;
  for (int i=0;i<nr;i++) {
    fout << r[i].fi.size() << " ";
    for (int j=0;j<r[i].fi.size();j++) {
      fout << r[i].fi[j] << " ";
    }
    fout << endl;
  }
  fout.close();
  if (po) cout << "Done writing regions." << flush << endl;
}

// Function to export the current regions   //
// to passed file                           //
void Mesh::importRegions(char* regfile) {
  if (po) {
    cout << endl
         << "/---------------------\\" << endl
         << "| Reading Region File |" << endl
         << "\\--------------------/" << endl << flush;
  }

  // clear current region properties
  clearRegionProps();

  // open a file and write those lists to disk
  ifstream fin(regfile);
  int temp1,temp2;
  fin >> nr;
  if (po) cout << "- Reading " << nr << " regions with " << nf
               << " faces from " << regfile << "." << flush << endl;
  for (int i=0;i<nr;i++) {
    fin >> temp1;
    for (int j=0;j<temp1;j++) {
      fin >> temp2;
      r[i].fi.push_back(temp2);
      f[temp2].r = &(r[i]);
    }
  }
  fin.close();

  // recalculate region properties
  findRegionProps();

  // and compute the polygonal mesh
  findBoundaries();
  triangulateContours();
  findRegionSmoothNormalsOld();

  if (po) cout << "Done reading regions." << flush << endl;
}

// Create covariance matrices aligned with the line-of-sight //
// from the origin - used to apply reasonable uncertainties  //
// in cases where no such information has been recorded      //
void Mesh::applyLineOfSightCovar(float sr) {
  for (int i=0;i<nv;i++) {
    Vec3d e0 = v[i].x; e0[2] -= 100;
    e0.normalize();
    Vec3d e1(1,0,0); e1 = e0.cross(e1); e1.normalize();
    Vec3d e2 = e0.cross(e1);
    Vec3d lambda(sr,1,1); lambda.normalize();
    v[i].iCov = (Mat3x3::eigenReconst(e0,e1,e2,lambda)).inv();
    if (i==100) cout << v[i].iCov;
  }
}

// Function to build a fully-connected mesh //
// from lists of vertices and triangles     //
vector<int> Mesh::buildFrom(float* vertices, int numvertices,
                            int* faces, int numfaces) {

  // Tell the console that we have started
  if (po)
    cout << endl
         << "/------------------------------------------\\" << endl
         << "| Building Mesh from vertex and face lists |" << endl
         << "\\------------------------------------------/" << endl << flush;

  // Fill vertex and face lists
  fillVertsAndFaces(vertices, numvertices, faces, numfaces);

  // Find links between neighboring faces
  vector<int> badFaces;
  int nbad = findInterFaceLinks();
  if (nbad) {
    if (po) cout << endl << nbad << " Bad triangles, removing "
                 << "offending triangles and trying again..."
                 << endl << flush;

    // remove bad triangles
    for (int in=0,out=0;in<nf;in++) if (f[in].flag != -101) {
      if (in != out) for (int j=0;j<3;j++) {
        faces[out*3+j] = faces[in*3+j];
      }
      out++;
    } else badFaces.push_back(in);

    cout << "." << flush;

    delete [] v;
    delete [] f;
    delete [] r;
    delete [] q;
    delete [] qv;
    nv = ne = nf = nr = nn = 0;
    numfaces -= nbad;

    cout << "." << flush;

    // Fill vertex and face lists
    fillVertsAndFaces(vertices, numvertices, faces, numfaces);

    // Find links between neighboring faces
    nbad = findInterFaceLinks();
    if (nbad) exit(1);
  }

  // Allocate memory for edges //
  //ne = 3*nf-nn/2;
  ne = 3*nf;
  if (po) cout << "- Allocating memory for " << ne << " edges..." << flush;
  e = new Edge[ne];
  if (po) cout << "Done." << endl << flush;

  // Go back through faces to create edges //
  if (po)
    cout << "- Creating face-to-edge and edge-to-face mappings..." << endl
         << flush;
  list<int> nbrs; // list of possible neighboring faces
  list<int>::iterator i1,i2; // iterators to scan list for valid neighbors
  int ce=0;
  for (int i=0;i<nf;i++) {
    for (int j=0;j<3;j++) {
      // for each of the three edges per face:
      // assume edge is a new one and add it to the global list
      e[ce].i = ce;
      e[ce].m = this;
      e[ce].v[0] = f[i].v[j]; e[ce].v[1] = f[i].v[(j+1)%3];
      if (e[ce].v[0] ==  e[ce].v[1]) {
        cerr << endl << "PROBLEM: triangle with repeated vertex" << endl
             << f[i] << "Exiting now." << endl <<  flush;
        exit(1);
      }
      // Find the faces that this edge separates
      nbrs.clear();
      // add (faces attached to given edge) to a list
      for (int k=0;k<f[i].v[j]->nf;k++) {
        if (e[ce]<*(f[i].v[j]->f[k]))
          nbrs.push_back(f[i].v[j]->f[k]->i);
      }
      for (int k=0;k<f[i].v[(j+1)%3]->nf;k++) {
        if (e[ce]<*(f[i].v[(j+1)%3]->f[k]))
          nbrs.push_back(f[i].v[(j+1)%3]->f[k]->i);
      }
      // sort list and prune out duplicates
      nbrs.sort();
      nbrs.unique();

      // check those faces if that edge already exists
      bool exists = false;
      for (i1 = nbrs.begin();i1!=nbrs.end();i1++) {
        for (int k=0;k<f[*i1].ne;k++) {
          exists = exists || (e[ce] == *f[*i1].e[k]);
        }
      }
      if (!exists) { // then finish building new edge
        // allocate memory for this edge's face list
        e[ce].nf = nbrs.size();
        if (e[ce].nf > 2) {
          cerr << endl
               << "PROBLEM: found edge with at least three faces." << endl
               << "Mesh is not 2d manifold." << endl
               << "Ignoring." << endl
               << "Edge " << ce << " has " << e[ce].nf << " faces." << endl
               << flush;
        }
        int temp = e[ce].nf;
        e[ce].nf = 0; // reset for use as counter

        for (i1 = nbrs.begin();i1!=nbrs.end();i1++) {
          // add edge to faces
          if (f[*i1].ne > 2) {
            cerr << endl << "PROBLEM: too many edges for this face " << endl
                 << f[*i1] << e[ce] << *f[*i1].e[0]
                 << *f[*i1].e[1] << *f[*i1].e[2]
                 << "Ignoring..." << endl << flush;
            continue;
          }
          f[*i1].e[f[*i1].ne] = &e[ce];
          f[*i1].ne++;
          // add faces to edge
          if (e[ce].nf > 1) break;
          e[ce].f[e[ce].nf] = &f[*i1];
          e[ce].nf++;
        }

        // increment counters of edges leaving each vertex
        e[ce].v[0]->ne++; e[ce].v[1]->ne++;

        // and increment our current edge counter
        ce++;
      }
    }
  }
  ne = ce;
  if (po) cout << "  " << ce << " edges added, Done." << endl << flush;

  // Create vertex-to-edge and vertex-to-vertex mappings //
  if (po) cout << "- Creating vertex-to-edge and vertex-to-vertex mappings..."
               << flush;
  // Go back through vertices to create edge lists
  for (int i=0;i<nv;i++) {
    if (v[i].ne) {
      v[i].e = new Edge*[v[i].ne];
      v[i].v = new Vert*[v[i].ne];
    }
    v[i].ne = 0; // reset for use as counter
  }
  if (po) cout << "." << flush;
  // And go back through the edges to fill the vertex-to-edge mappings
  for (int i=0,iv0,iv1;i<ne;i++) {
    // create vertex-to-edge mappings
    iv0 = e[i].v[0]->i; iv1 = e[i].v[1]->i;
    v[iv0].e[v[iv0].ne] = &e[i];
    v[iv1].e[v[iv1].ne] = &e[i];
    if (e[i].nf == 1) v[iv0].bound = v[iv1].bound = true;
    // create vertex-to-vertex mappings
    v[iv0].v[v[iv0].ne] = &v[iv1];
    v[iv1].v[v[iv1].ne] = &v[iv0];
    // increment counters
    v[iv0].ne++;
    v[iv1].ne++;
  }
  // and go through and flag edge faces and vertices
  for (int i=0;i<nv;i++) {
    if (v[i].bound) for (int j=0;j<v[i].nf;j++) v[i].f[j]->bound = 1;
  }
  if (po) cout << "Done." << endl << flush;

  // and find various other derived quantities
  findMeshProps();

  // and set original face normals
  for (int i=0;i<nf;i++) {
    f[i].n0 = f[i].n;
  }

  if (po) cout << "Done building Mesh." << endl << endl << flush;

  return badFaces;
}

// Fill Mesh with passed vertices and faces //
void Mesh::fillVertsAndFaces(float* vertices, int numvertices,
                             int* faces, int numfaces) {
  // Allocate memory for vertices and faces //
  nv = numvertices;
  nr = nf = numfaces;
  if (po) cout << "- Allocating memory for " << nv << " vertices and "
               << nf << " faces..." << flush;
  v = new Vert[nv];
  f = new Face[nf];
  r = new Region[nf];
  q = new int[nf];
  qv = new int[nv];
  if (po) cout << "Done." << endl << flush;

  // Add faces from TriMesh to Mesh //
  if (po) cout << "- Adding faces to global face list..." << flush;
  for (int i=0;i<nf;i++) {
    // add self-reference, parent-mesh reference, region reference
    f[i].i = i;
    r[i].i = i;
    r[i].m = this;
    f[i].m = this;
    f[i].r = &r[i];
    // add links to all three vertices of face
    for (int j=0;j<3;j++) {
      int in = faces[3*i+j];
      if (in < 0 || in >= nv) {
        cerr << "Error! vertex index out of range in face " << i << " " << in;
        exit(1);
      }
      f[i].v[j] = &v[in];
      v[in].nf++;
    }
  }
  if (po) cout << "Done." << endl << flush;

  // Add vertices from TriMesh to Mesh //
  if (po) cout << "- Adding vertices to global vertex list..." << flush;
  for (int i=0;i<nv;i++) {
    // add vertex position, self-reference, parent-mesh reference,
    // default variance
    for (int j=0;j<3;j++) v[i].x0[j] = v[i].x[j] = vertices[3*i+j];
    v[i].i = i;
    v[i].m = this;
    // allocate memory for adjacent face list
    if (v[i].nf) v[i].f = new Face*[v[i].nf];
    // reset adjacent face counter for use as index in mappings (next)
    v[i].nf = 0;
  }
  if (po) cout << "Done." << endl << flush;

  // Create links from vertices to faces by scanning all faces //
  if (po) cout << "- Creating vertex-to-face mappings..." << flush;
  for (int i=0;i<nf;i++) {
    for (int j=0;j<3;j++) {
      // add link from every vertex of every face to said face
      f[i].v[j]->f[f[i].v[j]->nf] = &f[i];
      f[i].v[j]->nf++;
    }
  }
  if (po) cout << "Done." << endl << flush;
}


// Create links from faces to neighboring faces //
int Mesh::findInterFaceLinks() {
  if (po) cout << "- Creating face-to-face mappings..." << flush;
  int nbad = 0; // number of bad triangles in case of failure
  list<int> nbrs; // list of possible neighboring faces
  list<int>::iterator i1,i2; // iterators to scan list for valid neighbors
  for (int i=0;i<nf;i++) {
    nbrs.clear();
    for (int j=0;j<3;j++) {
      for (int k=0;k<f[i].v[j]->nf;k++) {
        // add every face of every vertex of every face to a list
        if ((((*f[i].v[0]<*f[i].v[j]->f[k])+(*f[i].v[1]<*f[i].v[j]->f[k])+
              (*f[i].v[2]<*f[i].v[j]->f[k]))>=2) && (f[i].v[j]->f[k]->i != i))
          nbrs.push_back(f[i].v[j]->f[k]->i);
      }
    }
    // sort list and prune out duplicates
    nbrs.sort();
    nbrs.unique();

    // and stream the list into the array meant for it
    f[i].nf = nbrs.size();
    if (f[i].nf > 3) {
      nbad++;
      f[i].flag = -101;
      f[i].nf = 3;
    }
    nn += f[i].nf; // keep track of total number of neighbors to compute ne
    i1=nbrs.begin();
    for (int j=0;j<f[i].nf;j++,i1++) f[i].f[j] = &f[*i1];
  }
  if (!nbad) if (po) cout << "Done." << endl << flush;
  return nbad;
}

// Function to read options file from disk //
int Mesh::readOptions(char *filename_) {
  if (po) cout << "- Loading MRF options..." << flush;
  ifstream fin(filename_);
  if (fin) {
    fin >> gs2;
    fin >> gsn2;
    fin >> segThresh;
    fin >> maxIter;
  }
  fin.close();
  setVertVar(gs2);
  setNormalVar(gsn2);
  if (po) cout << "Done." << endl << flush;
  return 1;
}

// Function to write options file to disk //
int Mesh::writeOptions(char *filename_) {
  if (po) cout << "- Saving MRF options..." << flush;
  ofstream fout(filename_);
  if (fout) {
    fout << gs2 << endl;
    fout << gsn2 << endl;
    fout << segThresh << endl;
    fout << maxIter << endl;
  }
  fout.close();
  if (po) cout << "Done." << endl << flush;
  return 1;
}


/********************************************
 ********************************************
 * Function to write Mesh to disk           *
 ********************************************
 ********************************************/
int Mesh::writeMesh(char *filename_) {
  // tell the console that we have started
  if (po) cout << endl
               << "/-------------------------------\\" << endl
               << "| Writing Mesh in native format |" << endl
               << "\\-------------------------------/" << endl << flush;


  // open file for writing //
  if (po) cout << "- Opening " << filename_ << " for writing..." << flush;
  FILE *file;
  if((file = fopen(filename_, "wb" )) == NULL) {
    cerr << "Failed to open file " << filename_ << endl;
    return 1;
  }
  if (po) cout << "Done." << endl << flush;

  // write mesh to disk //
  if (po) cout << "- Writing Mesh data..." << flush;
  // write overall sizes to disk
  fwrite(&nv,sizeof(int),1,file);
  fwrite(&nf,sizeof(int),1,file);
  fwrite(&ne,sizeof(int),1,file);
  fwrite(&nd,sizeof(int),1,file);

  // write vertices to disk
  if (po) cout << " vertices" << flush;
  for (int i=0;i<nv;i++) {
    // per-vertex properties
    fwrite(v[i].x0.x,sizeof(float[3]),1,file);
    fwrite(v[i].x.x,sizeof(float[3]),1,file);
    for (int j=0;j<nd;j++) fwrite(v[i].xs[j].x,sizeof(float[3]),1,file);
    fwrite(v[i].n.x,sizeof(float[3]),1,file);
    fwrite(v[i].c.x,sizeof(float[3]),1,file);
    fwrite(v[i].iCov.x,sizeof(float[9]),1,file);
    fwrite(&(v[i].bound),sizeof(bool),1,file);

    // vertex-face connectivity
    fwrite(&(v[i].nf),sizeof(int),1,file);
    for (int j=0;j<v[i].nf;j++) {
      fwrite(&(v[i].f[j]->i),sizeof(int),1,file);
    }

    // vertex-edge and vertex-vertex connectivty
    fwrite(&(v[i].ne),sizeof(int),1,file);
    for (int j=0;j<v[i].ne;j++) {
      fwrite(&(v[i].e[j]->i),sizeof(int),1,file);
      fwrite(&(v[i].v[j]->i),sizeof(int),1,file);
    }
  }

  // write faces to disk
  if (po) cout << ", faces" << flush;
  for (int i=0;i<nf;i++) {
    // per-face properties
    fwrite(f[i].n0.x,sizeof(float[3]),1,file);
    fwrite(f[i].n.x,sizeof(float[3]),1,file);
    for (int j=0;j<nd;j++) fwrite(f[i].ns[j].x,sizeof(float[3]),1,file);
    fwrite(&(f[i].bound),sizeof(bool),1,file);
    // face-vertex and face-edge connectivity
    for (int j=0;j<3;j++) {
      fwrite(&(f[i].v[j]->i),sizeof(int),1,file);
      fwrite(&(f[i].e[j]->i),sizeof(int),1,file);
    }
    // face-face connectivity
    fwrite(&(f[i].nf),sizeof(int),1,file);
    for (int j=0;j<f[i].nf;j++) {
      fwrite(&(f[i].f[j]->i),sizeof(int),1,file);
    }
  }

  // write edges to disk
  if (po) cout << ", edges" << flush;
  for (int i=0;i<ne;i++) {
    // edge-vertex connectivity
    for (int j=0;j<2;j++) {
      fwrite(&(e[i].v[j]->i),sizeof(int),1,file);
    }

    // edge-face connectivity
    fwrite(&(e[i].nf),sizeof(int),1,file);
    for (int j=0;j<e[i].nf;j++) {
      fwrite(&(e[i].f[j]->i),sizeof(int),1,file);
    }
  }

  if (po) cout << ", Done." << endl << flush;

  // close file //
  if (po) cout << "- Closing " << filename_ << "..." << flush;
  if (fclose(file)) {
    cout << "Failed to close file " << filename_ << endl;
    return 1;
  }
  if (po) cout << "Done." << endl << flush;

  // normal return
  if (po) cout << "Done saving Mesh." << endl << endl << flush;
  return 0;
}



/********************************************
 ********************************************
 * Function to read Mesh from disk          *
 ********************************************
 ********************************************/
int Mesh::readMesh(char *filename_) {
  // tell the console that we have started
  if (po) cout << endl
               << "/-------------------------------\\" << endl
               << "| Reading Mesh in native format |" << endl
               << "\\-------------------------------/" << endl << flush;

  // open file for reading //
  if (po) cout << "- Opening " << filename_ << " for reading..." << flush;
  filename = filename_;
  FILE *file;
  if((file = fopen(filename_, "rb" )) == NULL) {
    cerr << "Failed to open file " << filename_ << endl;
    return 1;
  }
  if (po) cout << "Done." << endl << flush;

  // read mesh from disk //
  if (po) cout << "- Reading Mesh data..." << endl << flush;
  // read overall sizes from disk
  fread(&nv,sizeof(int),1,file);
  fread(&nf,sizeof(int),1,file);
  nr = nf;
  fread(&ne,sizeof(int),1,file);
  fread(&nd,sizeof(int),1,file);

  // Allocate memory for vertex, face, edge lists
  if (po) cout << "  - Allocating memory for " << endl
               << "    " << nv << " vertices" << endl
               << "    " << nf << " faces" << endl
               << "    " << ne << " edges..." << flush;
  v = new Vert[nv];
  f = new Face[nf];
  e = new Edge[ne];
  r = new Region[nf];
  q = new int[nf];
  qv = new int[nv];
  if (po) cout << "Done." << endl << flush;

  // read vertices from disk
  if (po) cout << "  - Reading vertices..." << flush;
  for (int i=0;i<nv;i++) {
    // self-reference, parent-mesh reference
    v[i].i = i;
    v[i].m = this;
    // per-vertex properties
    fread(v[i].x0.x,sizeof(float[3]),1,file);
    fread(v[i].x.x,sizeof(float[3]),1,file);
    v[i].xs = new Vec3d[nd];
    for (int j=0;j<nd;j++) fread(v[i].xs[j].x,sizeof(float[3]),1,file);
    fread(v[i].n.x,sizeof(float[3]),1,file);
    fread(v[i].c.x,sizeof(float[3]),1,file);
    fread(v[i].iCov.x,sizeof(float[9]),1,file);
    fread(&(v[i].bound),sizeof(bool),1,file);

    // vertex-face connectivity
    fread(&(v[i].nf),sizeof(int),1,file);
    if (v[i].nf) v[i].f = new Face*[v[i].nf];
    for (int j=0,k;j<v[i].nf;j++) {
      fread(&k,sizeof(int),1,file);
      v[i].f[j] = &f[k];
    }

    // vertex-edge and vertex-vertex connectivity
    fread(&(v[i].ne),sizeof(int),1,file);
    if (v[i].ne) {
      v[i].e = new Edge*[v[i].ne];
      v[i].v = new Vert*[v[i].ne];
    }
    for (int j=0,k;j<v[i].ne;j++) {
      fread(&k,sizeof(int),1,file);
      v[i].e[j] = &e[k];
      fread(&k,sizeof(int),1,file);
      v[i].v[j] = &v[k];
    }
  }
  if (po) cout << "Done." << endl << flush;

  // read faces from disk
  if (po) cout << "  - Reading faces..." << flush;
  for (int i=0;i<nf;i++) {
    // self-reference, parent-mesh reference, region reference
    f[i].i = i;
    r[i].i = i;
    f[i].m = this;
    f[i].r = &r[i];
    // per-face properties
    fread(f[i].n0.x,sizeof(float[3]),1,file);
    fread(f[i].n.x,sizeof(float[3]),1,file);
    f[i].ns = new Vec3d[nd];
    r[i].ns = new Vec3d[nd];
    for (int j=0;j<nd;j++) fread(f[i].ns[j].x,sizeof(float[3]),1,file);
    fread(&(f[i].bound),sizeof(bool),1,file);
    // face-vertex and face-edge connectivity
    f[i].ne = 3;
    for (int j=0,k;j<3;j++) {
      fread(&k,sizeof(int),1,file);
      f[i].v[j] = &v[k];
      fread(&k,sizeof(int),1,file);
      f[i].e[j] = &e[k];
    }

    // face-face connectivity
    fread(&(f[i].nf),sizeof(int),1,file);
    for (int j=0,k;j<f[i].nf;j++) {
      fread(&k,sizeof(int),1,file);
      f[i].f[j] = &f[k];
    }
  }
  if (po) cout << "Done." << endl << flush;

  // read edges from disk
  if (po) cout << "  - Reading edges..." << flush;
  for (int i=0;i<ne;i++) {
    // self-reference, parent-mesh reference
    e[i].i = i;
    e[i].m = this;
    // edge-vertex connectivity
    for (int j=0,k;j<2;j++) {
      fread(&k,sizeof(int),1,file);
      e[i].v[j] = &v[k];
    }

    // edge-face connectivity
    fread(&(e[i].nf),sizeof(int),1,file);
    for (int j=0,k;j<e[i].nf;j++) {
      fread(&k,sizeof(int),1,file);
      e[i].f[j] = &f[k];
    }
  }
  if (po) cout << "Done." << endl << flush;
  if (po) cout << "  Done." << endl << flush;

  // close file //
  if (po) cout << "- Closing " << filename_ << "..." << flush;
  if (fclose(file)) {
    cout << "Failed to close file " << filename_ << endl;
    return 1;
  }
  if (po) cout << "Done." << endl << flush;

  // normal return
  if (po) cout << "Done reading Mesh." << endl << flush;
  return 0;

}

} // namespace bmtk

---

bmtk
Author(s): Benjamin Pitzer
autogenerated on Mon Mar 4 11:05:51 2013