stl_reader.h

Go to the documentation of this file.

/*
 Copyright (c) 2018, Sebastian Reiter (s.b.reiter@gmail.com)
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
     * Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
     * Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
 
#ifndef __H__STL_READER
#define __H__STL_READER
 
#include <algorithm>
#include <exception>
#include <fstream>
#include <sstream>
#include <vector>
 
#ifdef STL_READER_NO_EXCEPTIONS
  #define STL_READER_THROW(msg) return false;
  #define STL_READER_COND_THROW(cond, msg) if(cond) return false;
#else
  #define STL_READER_THROW(msg) {std::stringstream ss; ss << msg; throw(std::runtime_error(ss.str()));}
 
  #define STL_READER_COND_THROW(cond, msg)  if(cond){std::stringstream ss; ss << msg; throw(std::runtime_error(ss.str()));}
#endif
 
 
namespace stl_reader {
 
 
template <class TNumberContainer, class TIndexContainer>
bool ReadStlFile(const char* filename,
                TNumberContainer& coordsOut,
                TNumberContainer& normalsOut,
                TIndexContainer& trisOut,
        TIndexContainer& solidRangesOut);
 
 
 
template <class TNumberContainer, class TIndexContainer>
bool ReadStlFile_ASCII(const char* filename,
                       TNumberContainer& coordsOut,
                       TNumberContainer& normalsOut,
                       TIndexContainer& trisOut,
             TIndexContainer& solidRangesOut);
 
 
template <class TNumberContainer, class TIndexContainer>
bool ReadStlFile_BINARY(const char* filename,
                        TNumberContainer& coordsOut,
                        TNumberContainer& normalsOut,
                        TIndexContainer& trisOut,
              TIndexContainer& solidRangesOut);
 
 
inline bool StlFileHasASCIIFormat(const char* filename);
 
 
template <class TNumber = float, class TIndex = unsigned int>
class StlMesh {
public:
  StlMesh ()
  {
    solids.resize (2, 0);
  }
 
  StlMesh (const char* filename)
  {
    read_file (filename);
  }
 
  bool read_file (const char* filename)
  {
    bool res = false;
 
    #ifndef STL_READER_NO_EXCEPTIONS
    try {
    #endif
 
      res = ReadStlFile (filename, coords, normals, tris, solids);
 
    #ifndef STL_READER_NO_EXCEPTIONS
    } catch (std::exception& e) {
    #else
    if (!res) {
    #endif
 
      coords.clear ();
      normals.clear ();
      tris.clear ();
      solids.clear ();
      STL_READER_THROW (e.what());
    }
 
    return res;
  }
 
  size_t num_vrts () const
  {
    return coords.size() / 3;
  }
 
  const TNumber* vrt_coords (const size_t vi) const
  {
    return &coords[vi * 3];
  }
 
  size_t num_tris () const
  {
    return tris.size() / 3;
  }
 
  const TIndex* tri_corner_inds (const size_t ti) const
  {
    return &tris [ti * 3];
  }
 
  const TIndex tri_corner_ind (const size_t ti, const size_t ci) const
  {
    return tris [ti * 3 + ci];
  }
 
  const TNumber* tri_corner_coords (const size_t ti, const size_t ci) const
  {
    return &coords[tri_corner_ind(ti, ci) * 3];
  }
 
  const TNumber* tri_normal (const size_t ti) const
  {
    return &normals [ti * 3];
  }
 
 
  size_t num_solids () const
  {
    if(solids.empty ())
      return 0;
    return solids.size () - 1;
  }
 
  TIndex solid_tris_begin (const size_t si) const
  {
    return solids [si];
  }
 
  TIndex solid_tris_end (const size_t si) const
  {
    return solids [si + 1];
  }
 
 
  const TNumber* raw_coords () const
  {
    if(coords.empty())
      return NULL;
    return &coords[0];
  }
 
 
  const TNumber* raw_normals () const
  {
    if(normals.empty())
      return NULL;
    return &normals[0];
  }
 
 
  const TIndex* raw_tris () const
  {
    if(tris.empty())
      return NULL;
    return &tris[0];
  }
 
 
  const TIndex* raw_solids () const
  {
    if(solids.empty())
      return NULL;
    return &solids[0];
  }
 
private:
  std::vector<TNumber>  coords;
  std::vector<TNumber>  normals;
  std::vector<TIndex>   tris;
  std::vector<TIndex>   solids;
};
 
 
//  IMPLEMENTATION
 
 
namespace stl_reader_impl {
 
  // a coordinate triple with an additional index. The index is required
  // for RemoveDoubles, so that triangles can be reindexed properly.
  template <typename number_t, typename index_t>
  struct CoordWithIndex {
    number_t data[3];
    index_t index;
 
    bool operator == (const CoordWithIndex& c) const
    {
      return (c[0] == data[0]) && (c[1] == data[1]) && (c[2] == data[2]);
    }
 
    bool operator != (const CoordWithIndex& c) const
    {
      return (c[0] != data[0]) || (c[1] != data[1]) || (c[2] != data[2]);
    }
 
    bool operator < (const CoordWithIndex& c) const
    {
      return    (data[0] < c[0])
          ||  (data[0] == c[0] && data[1] < c[1])
          ||  (data[0] == c[0] && data[1] == c[1] && data[2] < c[2]);
    }
 
    inline number_t& operator [] (const size_t i)   {return data[i];}
    inline number_t operator [] (const size_t i) const  {return data[i];}
  };
 
  // sorts the array coordsWithIndexInOut and copies unique indices to coordsOut.
  // Triangle-corners are re-indexed on the fly and degenerated triangles are removed.
  template <class TNumberContainer, class TIndexContainer>
  void RemoveDoubles (TNumberContainer& uniqueCoordsOut,
                      TIndexContainer& trisInOut,
                      std::vector <CoordWithIndex<
                        typename TNumberContainer::value_type,
                        typename TIndexContainer::value_type> >
                          &coordsWithIndexInOut)
  {
    using namespace std;
 
    typedef typename TNumberContainer::value_type number_t;
    typedef typename TIndexContainer::value_type  index_t;
 
    sort (coordsWithIndexInOut.begin(), coordsWithIndexInOut.end());
  
  //  first count unique indices
    size_t numUnique = 1;
    for(size_t i = 1; i < coordsWithIndexInOut.size(); ++i){
      if(coordsWithIndexInOut[i] != coordsWithIndexInOut[i - 1])
        ++numUnique;
    }
 
    uniqueCoordsOut.resize (numUnique * 3);
    vector<index_t> newIndex (coordsWithIndexInOut.size());
 
  //  copy unique coordinates to 'uniqueCoordsOut' and create an index-map
  //  'newIndex', which allows to re-index triangles later on.
    size_t curInd = 0;
    newIndex[0] = 0;
    for(size_t i = 0; i < 3; ++i)
      uniqueCoordsOut[i] = coordsWithIndexInOut[0][i];
 
    for(size_t i = 1; i < coordsWithIndexInOut.size(); ++i){
      const CoordWithIndex <number_t, index_t> c = coordsWithIndexInOut[i];
      if(c != coordsWithIndexInOut[i - 1]){
        ++curInd;
        for(size_t j = 0; j < 3; ++j)
          uniqueCoordsOut[curInd * 3 + j] = coordsWithIndexInOut[i][j];
      }
 
      newIndex[c.index] = curInd;
    }
 
  //  re-index triangles, so that they refer to 'uniqueCoordsOut'
  //  make sure to only add triangles which refer to three different indices
    size_t numUniqueTriInds = 0;
    for(size_t i = 0; i < trisInOut.size(); i+=3){
      int ni[3];
      for(int j = 0; j < 3; ++j)
        ni[j] = newIndex[trisInOut[i+j]];
 
      if((ni[0] != ni[1]) && (ni[0] != ni[2]) && (ni[1] != ni[2])){
        for(int j = 0; j < 3; ++j)
          trisInOut[numUniqueTriInds + j] = ni[j];
        numUniqueTriInds += 3;
      }
    }
 
    if(numUniqueTriInds < trisInOut.size())
      trisInOut.resize (numUniqueTriInds);
  }
}// end of namespace stl_reader_impl
 
 
template <class TNumberContainer, class TIndexContainer>
bool ReadStlFile(const char* filename,
                TNumberContainer& coordsOut,
                TNumberContainer& normalsOut,
                TIndexContainer& trisOut,
        TIndexContainer& solidRangesOut)
{
  if(StlFileHasASCIIFormat(filename))
    return ReadStlFile_ASCII(filename, coordsOut, normalsOut, trisOut, solidRangesOut);
  else
    return ReadStlFile_BINARY(filename, coordsOut, normalsOut, trisOut, solidRangesOut);
}
 
 
template <class TNumberContainer, class TIndexContainer>
bool ReadStlFile_ASCII(const char* filename,
                       TNumberContainer& coordsOut,
                       TNumberContainer& normalsOut,
                       TIndexContainer& trisOut,
             TIndexContainer& solidRangesOut)
{
  using namespace std;
  using namespace stl_reader_impl;
 
  typedef typename TNumberContainer::value_type number_t;
  typedef typename TIndexContainer::value_type  index_t;
 
  coordsOut.clear();
  normalsOut.clear();
  trisOut.clear();
  solidRangesOut.clear();
 
  ifstream in(filename);
  STL_READER_COND_THROW(!in, "Couldn't open file " << filename);
 
  vector<CoordWithIndex <number_t, index_t> > coordsWithIndex;
 
  string buffer;
  vector<string> tokens;
  int lineCount = 1;
  int maxNumTokens = 0;
  size_t numFaceVrts = 0;
 
  while(!(in.eof() || in.fail()))
  {
  //  read the line and tokenize.
  //  In order to reuse memory in between lines, 'tokens' won't be cleared.
  //  Instead we count the number of tokens using 'tokenCount'.
    getline(in, buffer);
 
    istringstream line(buffer);
    int tokenCount = 0;
    while(!(line.eof() || line.fail())){
      if(tokenCount >= maxNumTokens){
        maxNumTokens = tokenCount + 1;
        tokens.resize(maxNumTokens);
      }
      line >> tokens[tokenCount];
      ++tokenCount;
    }
 
    if(tokenCount > 0)
    {
      string& tok = tokens[0];
      if(tok.compare("vertex") == 0){
        if(tokenCount < 4){
          STL_READER_THROW("ERROR while reading from " << filename <<
            ": vertex not specified correctly in line " << lineCount);
        }
        
      //  read the position
        CoordWithIndex <number_t, index_t> c;
        for(size_t i = 0; i < 3; ++i)
          c[i] = atof(tokens[i+1].c_str());
        c.index = static_cast<index_t>(coordsWithIndex.size());
        coordsWithIndex.push_back(c);
        ++numFaceVrts;
      }
      else if(tok.compare("facet") == 0)
      {
        STL_READER_COND_THROW(tokenCount < 5,
            "ERROR while reading from " << filename <<
            ": triangle not specified correctly in line " << lineCount);
        
        STL_READER_COND_THROW(tokens[1].compare("normal") != 0,
            "ERROR while reading from " << filename <<
            ": Missing normal specifier in line " << lineCount);
        
      //  read the normal
        for(size_t i = 0; i < 3; ++i)
          normalsOut.push_back (atof(tokens[i+2].c_str()));
 
        numFaceVrts = 0;
      }
      else if(tok.compare("outer") == 0){
        STL_READER_COND_THROW ((tokenCount < 2) || (tokens[1].compare("loop") != 0),
            "ERROR while reading from " << filename <<
          ": expecting outer loop in line " << lineCount);
      }
      else if(tok.compare("endfacet") == 0){
        STL_READER_COND_THROW(numFaceVrts != 3,
          "ERROR while reading from " << filename <<
          ": bad number of vertices specified for face in line " << lineCount);
 
        trisOut.push_back(coordsWithIndex.size() - 3);
        trisOut.push_back(coordsWithIndex.size() - 2);
        trisOut.push_back(coordsWithIndex.size() - 1);
      }
      else if(tok.compare("solid") == 0){
        solidRangesOut.push_back(trisOut.size() / 3);
      }
    }
    lineCount++;
  }
 
  solidRangesOut.push_back(trisOut.size() / 3);
 
  RemoveDoubles (coordsOut, trisOut, coordsWithIndex);
 
  return true;
}
 
 
template <class TNumberContainer, class TIndexContainer>
bool ReadStlFile_BINARY(const char* filename,
                        TNumberContainer& coordsOut,
                        TNumberContainer& normalsOut,
                        TIndexContainer& trisOut,
              TIndexContainer& solidRangesOut)
{
  using namespace std;
  using namespace stl_reader_impl;
 
  typedef typename TNumberContainer::value_type number_t;
  typedef typename TIndexContainer::value_type  index_t;
 
  coordsOut.clear();
  normalsOut.clear();
  trisOut.clear();
  solidRangesOut.clear();
 
  ifstream in(filename, ios::binary);
  STL_READER_COND_THROW(!in, "Couldnt open file " << filename);
 
  char stl_header[80];
  in.read(stl_header, 80);
  STL_READER_COND_THROW(!in, "Error while parsing binary stl header in file " << filename);
 
  unsigned int numTris = 0;
  in.read((char*)&numTris, 4);
  STL_READER_COND_THROW(!in, "Couldnt determine number of triangles in binary stl file " << filename);
 
  vector<CoordWithIndex <number_t, index_t> > coordsWithIndex;
 
  for(unsigned int tri = 0; tri < numTris; ++tri){
    float d[12];
    in.read((char*)d, 12 * 4);
    STL_READER_COND_THROW(!in, "Error while parsing trianlge in binary stl file " << filename);
 
    for(int i = 0; i < 3; ++i)
      normalsOut.push_back (d[i]);
 
    for(size_t ivrt = 1; ivrt < 4; ++ivrt){
      CoordWithIndex <number_t, index_t> c;
      for(size_t i = 0; i < 3; ++i)
        c[i] = d[ivrt * 3 + i];
      c.index = static_cast<index_t>(coordsWithIndex.size());
      coordsWithIndex.push_back(c);
    }
 
    trisOut.push_back(coordsWithIndex.size() - 3);
    trisOut.push_back(coordsWithIndex.size() - 2);
    trisOut.push_back(coordsWithIndex.size() - 1);
 
    char addData[2];
    in.read(addData, 2);
    STL_READER_COND_THROW(!in, "Error while parsing additional triangle data in binary stl file " << filename);
  }
 
  solidRangesOut.push_back(0);
  solidRangesOut.push_back(trisOut.size() / 3);
 
  RemoveDoubles (coordsOut, trisOut, coordsWithIndex);
 
  return true;
}
 
 
inline bool StlFileHasASCIIFormat(const char* filename)
{
  using namespace std;
  ifstream in(filename);
  STL_READER_COND_THROW(!in, "Couldnt open file " << filename);
 
  string firstWord;
  in >> firstWord;
  transform(firstWord.begin(), firstWord.end(), firstWord.begin(), ::tolower);
 
  return firstWord.compare("solid") == 0;
}
 
} // end of namespace stl_reader
 
#endif  //__H__STL_READER