MeshReader.ih

// IMPLEMENTATION of inline methods.

#include <cstdlib>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>



// Implementation of inline methods                                          //




template <typename TPoint>
inline
bool
DGtal::MeshReader<TPoint>::importOFFFile(const std::string & aFilename, 
                                         DGtal::MeshFromPoints<TPoint> & aMesh, 
                                         bool invertVertexOrder) throw(DGtal::IOException)
{
  ifstream infile;
  DGtal::IOException dgtalio;
  try 
    {
      infile.open (aFilename.c_str(), ifstream::in);
    }
  catch( ... )
    {
      trace.error() << "MeshReader : can't open " << aFilename << endl;
      throw dgtalio;
    }
  string str;
  getline( infile, str );
  
  if ( ! infile.good() )
    {
      trace.error() << "MeshReader : can't read " << aFilename << endl;
      throw dgtalio;
    }
  if ( str.substr(0,3) != "OFF")
    {
      cerr <<"*" <<str<<"*"<< endl;
      trace.error() << "MeshReader : No OFF format in " << aFilename << endl;
      throw dgtalio;
    }
  
  // Processing comments
  do
    {
      getline( infile, str );
      if ( ! infile.good() ){
        trace.error() << "MeshReader : Invalid format in " << aFilename << endl;
        throw dgtalio;
      } 
    }
  while ( str[ 0 ] == '#' || str=="");
  istringstream str_in( str );
  int nbPoints, nbFaces, nbEdges;
  str_in >> nbPoints;
  str_in >> nbFaces;
  str_in >> nbEdges;

  // Reading mesh vertex 
  for(int i=0; i<nbPoints; i++){
    TPoint p;
    infile >> p[0];
    infile >> p[1];
    infile >> p[2];
    aMesh.addVertex(p);
    // Needed since a line can also contain vertex colors
    getline(infile, str);
  }
  
  // Reading mesh faces
  for(int i=0; i<nbFaces; i++){
    // Reading the number of face vertex
    unsigned int aNbFaceVertex;
    infile >> aNbFaceVertex;
    vector<unsigned int> aFace;
    for (unsigned int j=0; j< aNbFaceVertex; j++){
      unsigned int anIndex;
      infile >> anIndex;
      aFace.push_back(anIndex);
    }
    if( invertVertexOrder ){
      for(unsigned int j=0; j < aFace.size()/2; j++){
        unsigned int tmp=aFace.at(j);
        aFace.at(j)=aFace.at(aFace.size()-1-j);
        aFace.at(aFace.size()-1-j)=tmp;
      }
    }
    
    // Needed since a can also contain vertex colors
    getline(infile, str);
    // Contains colors:
    bool findValidColor=true;
    if(str!=""){
      istringstream inColor(str);
      double colorR, colorG, colorB, colorT;
      findValidColor=inColor.good();
      if(findValidColor && inColor.good()){
        inColor >> colorR;
      }
      findValidColor &=!inColor.fail();
      if(findValidColor && inColor.good()){
        inColor >> colorG;
      }
      findValidColor &=!inColor.fail();
      if(findValidColor && inColor.good()){
        inColor >> colorB;
      }
      findValidColor &=!inColor.fail();
      
      if(findValidColor && inColor.good()){
        inColor >> colorT;
        // Since alpha is optional:
        if(inColor.fail()){
          colorT=1.0;
        }

      }else{
        colorT=1.0;
      }
      if(findValidColor){
        DGtal::Color c((unsigned int)(colorR*255.0), (unsigned int)(colorG*255.0),
                       (unsigned int)(colorB*255.0), (unsigned int)(colorT*255.0));
        aMesh.addFace(aFace, c);
      }else{
        aMesh.addFace(aFace);
      }
    }else{
      aMesh.addFace(aFace);
    }
  }
  
  return true;
}






template <typename TPoint>
inline
bool
DGtal::MeshReader<TPoint>::importOFSFile(const std::string & aFilename, 
                                         DGtal::MeshFromPoints<TPoint> & aMesh, 
                                         bool invertVertexOrder, double scale) throw(DGtal::IOException)
{
  ifstream infile;
  DGtal::IOException dgtalio;
  try 
    {
      infile.open (aFilename.c_str(), ifstream::in);
    }
  catch( ... )
    {
      trace.error() << "MeshReader : can't open " << aFilename << endl;
      throw dgtalio;
    }
  string str;
  getline( infile, str );
  
  if ( ! infile.good() )
    {
      trace.error() << "MeshReader : can't read " << aFilename << endl;
      throw dgtalio;
    }
  if ( str.substr(0,3) != "OFS")
    {
      trace.error() << "MeshReader : No OFS format in " << aFilename << endl;
      throw dgtalio;
    }
  
  // Processing comments
  do
    {
      getline( infile, str );
      if ( ! infile.good() ){
        trace.error() << "MeshReader : Invalid format in " << aFilename << endl;
        throw dgtalio;
      } 
    }
  while ( str[ 0 ] == '#' || str=="");
  istringstream str_in( str );
  int nbPoints;
  str_in >> nbPoints;
  
  // Reading mesh vertex 
  for(int i=0; i<nbPoints; i++){
    TPoint p;
    infile >> p[0];
    infile >> p[1];
    infile >> p[2];
    p[0]*=scale;
    p[1]*=scale;
    p[2]*=scale;
    aMesh.addVertex(p);
    // Needed since a line can also contain vertex colors
    getline(infile, str);
  }
  do
    {
      getline( infile, str );
      if ( ! infile.good() ){
        trace.error() << "MeshReader : Invalid format in " << aFilename << endl;
        throw dgtalio;
      } 
    }
  while ( str[ 0 ] == '#' || str=="");
  istringstream str_in2( str );
  unsigned int nbFaces;
  str_in2 >> nbFaces;
  // Reading mesh faces
  for(unsigned int i=0; i<nbFaces; i++){
    // Reading the number of face vertex
    vector<unsigned int> aFace;
    for (unsigned int j=0; j< 3; j++){
      unsigned int anIndex;
      infile >> anIndex;
      aFace.push_back(anIndex);
    }
    if( invertVertexOrder ){
      unsigned int tmp=aFace.at(0);
        aFace.at(0)=aFace.at(2);
        aFace.at(2)=tmp;
    }
    aMesh.addFace(aFace);
    getline(infile, str);
          
  }

  return true;
   
}


  template <typename TPoint>
  bool
  DGtal::operator<< (   MeshFromPoints<TPoint> & mesh, const std::string &filename ){
    string extension = filename.substr(filename.find_last_of(".") + 1);
    if(extension== "off") {
      DGtal::MeshReader<TPoint>::importOFFFile(filename, mesh);
      return true;
    }else if(extension== "ofs") {
      DGtal::MeshReader< TPoint>::importOFSFile(filename, mesh);
      return true;
    }
    
    return false;
  }







//                                                                           //