Merge branch 'persistent_edge_properties' into 'master'

Persistent edge properties

See merge request !184

Doc/changelog.docu

@@ -18,6 +18,9 @@
 <ul>
 <li>PLY Reader: Allowing the PLY reader to read custom face ( Thanks to morgan Leborgne for the patch)</li>
 <li>PLY Reader: Fixed endless loop on unknown property list type</li>
+<li>OM Writer/Reader: Update file format version to 2.0. Older files can still be read, but older OpenMesh versions cannot read new format.</li>
+<li>OM Writer/Reader: Fixed inconsistent writing/reading of edge properties</li>
+<li>OM Writer/Reader: Add option to store status</li>
 </ul>
 
 <b>Tools</b>

src/OpenMesh/Core/IO/OMFormat.cc

@@ -113,6 +113,19 @@ namespace OMFormat {
     return hdr;
   }
 
+//-----------------------------------------------------------------------------
+
+
+  std::string as_string(uint8 version)
+  {
+    std::stringstream ss;
+    ss << major_version(version);
+    ss << ".";
+    ss << minor_version(version);
+    return ss.str();
+  }
+
+
 //-----------------------------------------------------------------------------
 
   const char *as_string(Chunk::Entity e)

src/OpenMesh/Core/IO/OMFormat.hh

@@ -469,6 +469,8 @@ namespace OMFormat {
 
   // ---------------------------------------- convenience functions
 
+  std::string as_string(uint8 version);
+
   const char *as_string(Chunk::Type t);
   const char *as_string(Chunk::Entity e);
   const char *as_string(Chunk::Dim d);

src/OpenMesh/Core/IO/Options.hh

@@ -115,7 +115,8 @@ public:
       FaceTexCoord   = 0x0400, ///< Has (r) / store (w) face texture coordinates
       ColorAlpha     = 0x0800, ///< Has (r) / store (w) alpha values for colors
       ColorFloat     = 0x1000, ///< Has (r) / store (w) float values for colors (currently only implemented for PLY and OFF files)
-      Custom         = 0x2000  ///< Has (r)             custom properties (currently only implemented in PLY Reader ASCII version)
+      Custom         = 0x2000, ///< Has (r)             custom properties (currently only implemented in PLY Reader ASCII version)
+      Status         = 0x4000  ///< Has (r) / store (w) status properties
   };
 
 public:
@@ -206,10 +207,14 @@ public:
   bool vertex_has_normal()   const { return check(VertexNormal); }
   bool vertex_has_color()    const { return check(VertexColor); }
   bool vertex_has_texcoord() const { return check(VertexTexCoord); }
+  bool vertex_has_status()   const { return check(Status); }
   bool edge_has_color()      const { return check(EdgeColor); }
+  bool edge_has_status()     const { return check(Status); }
+  bool halfedge_has_status() const { return check(Status); }
   bool face_has_normal()     const { return check(FaceNormal); }
   bool face_has_color()      const { return check(FaceColor); }
   bool face_has_texcoord()   const { return check(FaceTexCoord); }
+  bool face_has_status()     const { return check(Status); }
   bool color_has_alpha()     const { return check(ColorAlpha); }
   bool color_is_float()      const { return check(ColorFloat); }
 

src/OpenMesh/Core/IO/exporter/BaseExporter.hh

@@ -104,12 +104,14 @@ public:
   virtual Vec4f colorAf(VertexHandle _vh)   const = 0;
   virtual Vec2f  texcoord(VertexHandle _vh) const = 0;
   virtual Vec2f  texcoord(HalfedgeHandle _heh) const = 0;
+  virtual OpenMesh::Attributes::StatusInfo  status(VertexHandle _vh) const = 0;
 
 
   // get face data
   virtual unsigned int
   get_vhandles(FaceHandle _fh,
 	       std::vector<VertexHandle>& _vhandles) const=0;
+
   ///
   /// \brief getHeh returns the HalfEdgeHandle that belongs to the face
   ///  specified by _fh and has a toVertexHandle that corresponds to _vh.
@@ -127,6 +129,7 @@ public:
   virtual Vec4ui colorAi(FaceHandle _fh)   const = 0;
   virtual Vec3f colorf(FaceHandle _fh)    const = 0;
   virtual Vec4f colorAf(FaceHandle _fh)   const = 0;
+  virtual OpenMesh::Attributes::StatusInfo  status(FaceHandle _fh) const = 0;
 
   // get edge data
   virtual Vec3uc color(EdgeHandle _eh)    const = 0;
@@ -135,6 +138,15 @@ public:
   virtual Vec4ui colorAi(EdgeHandle _eh)   const = 0;
   virtual Vec3f colorf(EdgeHandle _eh)    const = 0;
   virtual Vec4f colorAf(EdgeHandle _eh)   const = 0;
+  virtual OpenMesh::Attributes::StatusInfo  status(EdgeHandle _eh) const = 0;
+
+  // get halfedge data
+  virtual int get_halfedge_id(VertexHandle _vh) = 0;
+  virtual int get_halfedge_id(FaceHandle _vh) = 0;
+  virtual int get_next_halfedge_id(HalfedgeHandle _heh) = 0;
+  virtual int get_to_vertex_id(HalfedgeHandle _heh) = 0;
+  virtual int get_face_id(HalfedgeHandle _heh) = 0;
+  virtual OpenMesh::Attributes::StatusInfo  status(HalfedgeHandle _heh) const = 0;
 
   // get reference to base kernel
   virtual const BaseKernel* kernel() { return 0; }
@@ -150,10 +162,14 @@ public:
   virtual bool is_triangle_mesh()     const { return false; }
   virtual bool has_vertex_normals()   const { return false; }
   virtual bool has_vertex_colors()    const { return false; }
+  virtual bool has_vertex_status()    const { return false; }
   virtual bool has_vertex_texcoords() const { return false; }
   virtual bool has_edge_colors()      const { return false; }
+  virtual bool has_edge_status()      const { return false; }
+  virtual bool has_halfedge_status()  const { return false; }
   virtual bool has_face_normals()     const { return false; }
   virtual bool has_face_colors()      const { return false; }
+  virtual bool has_face_status()      const { return false; }
 };
 
 

src/OpenMesh/Core/IO/exporter/ExporterT.hh

@@ -171,6 +171,13 @@ public:
         : Vec2f(0.0f, 0.0f));
   }
 
+  OpenMesh::Attributes::StatusInfo  status(VertexHandle _vh) const
+  {
+    if (mesh_.has_vertex_status())
+      return mesh_.status(_vh);
+    return OpenMesh::Attributes::StatusInfo();
+  }
+
   // get edge data
 
   Vec3uc color(EdgeHandle _eh)    const
@@ -215,6 +222,47 @@ public:
       : Vec4f(0, 0, 0, 0));
   }
 
+  OpenMesh::Attributes::StatusInfo  status(EdgeHandle _eh) const
+  {
+    if (mesh_.has_edge_status())
+      return mesh_.status(_eh);
+    return OpenMesh::Attributes::StatusInfo();
+  }
+
+  // get halfedge data
+
+  int get_halfedge_id(VertexHandle _vh) override
+  {
+    return mesh_.halfedge_handle(_vh).idx();
+  }
+
+  int get_halfedge_id(FaceHandle _fh) override
+  {
+    return mesh_.halfedge_handle(_fh).idx();
+  }
+
+  int get_next_halfedge_id(HalfedgeHandle _heh) override
+  {
+    return mesh_.next_halfedge_handle(_heh).idx();
+  }
+
+  int get_to_vertex_id(HalfedgeHandle _heh) override
+  {
+    return mesh_.to_vertex_handle(_heh).idx();
+  }
+
+  int get_face_id(HalfedgeHandle _heh) override
+  {
+    return mesh_.face_handle(_heh).idx();
+  }
+
+  OpenMesh::Attributes::StatusInfo  status(HalfedgeHandle _heh) const
+  {
+    if (mesh_.has_halfedge_status())
+      return mesh_.status(_heh);
+    return OpenMesh::Attributes::StatusInfo();
+  }
+
   // get face data
 
   unsigned int get_vhandles(FaceHandle _fh,
@@ -304,6 +352,13 @@ public:
       : Vec4f(0, 0, 0, 0));
   }
 
+  OpenMesh::Attributes::StatusInfo  status(FaceHandle _fh) const
+  {
+    if (mesh_.has_face_status())
+      return mesh_.status(_fh);
+    return OpenMesh::Attributes::StatusInfo();
+  }
+
   virtual const BaseKernel* kernel() { return &mesh_; }
 
 
@@ -320,9 +375,13 @@ public:
   bool has_vertex_normals()   const { return mesh_.has_vertex_normals();   }
   bool has_vertex_colors()    const { return mesh_.has_vertex_colors();    }
   bool has_vertex_texcoords() const { return mesh_.has_vertex_texcoords2D(); }
+  bool has_vertex_status()    const { return mesh_.has_vertex_status();    }
   bool has_edge_colors()      const { return mesh_.has_edge_colors();      }
+  bool has_edge_status()      const { return mesh_.has_edge_status();      }
+  bool has_halfedge_status()  const { return mesh_.has_halfedge_status();  }
   bool has_face_normals()     const { return mesh_.has_face_normals();     }
   bool has_face_colors()      const { return mesh_.has_face_colors();      }
+  bool has_face_status()      const { return mesh_.has_face_status();      }
 
 private:
 

src/OpenMesh/Core/IO/importer/BaseImporter.hh

@@ -99,10 +99,16 @@ public:
   // add a vertex without coordinate. Use set_point to set the position deferred
   virtual VertexHandle add_vertex() = 0;
 
+  // add an edge. Use set_next, set_vertex and set_face to set corresponding entities for halfedges
+  virtual HalfedgeHandle add_edge(VertexHandle _vh0, VertexHandle _vh1) = 0;
+
   // add a face with indices _indices refering to vertices
   typedef std::vector<VertexHandle> VHandles;
   virtual FaceHandle add_face(const VHandles& _indices) = 0;
 
+  // add a face with incident halfedge
+  virtual FaceHandle add_face(HalfedgeHandle _heh) = 0;
+
   // add texture coordinates per face, _vh references the first texcoord
   virtual void add_face_texcoords( FaceHandle _fh, VertexHandle _vh, const std::vector<Vec2f>& _face_texcoords) = 0;
 
@@ -115,6 +121,9 @@ public:
   // Set coordinate of the given vertex. Use this function, if you created a vertex without coordinate
   virtual void set_point(VertexHandle _vh, const Vec3f& _point) = 0;
 
+  // Set outgoing halfedge for the given vertex.
+  virtual void set_halfedge(VertexHandle _vh, HalfedgeHandle _heh) = 0;
+
   // set vertex normal
   virtual void set_normal(VertexHandle _vh, const Vec3f& _normal) = 0;
 
@@ -133,6 +142,15 @@ public:
   // set vertex texture coordinate
   virtual void set_texcoord(VertexHandle _vh, const Vec2f& _texcoord) = 0;
 
+  // set vertex status
+  virtual void set_status(VertexHandle _vh, const OpenMesh::Attributes::StatusInfo& _status) = 0;
+
+  // set next halfedge handle
+  virtual void set_next(HalfedgeHandle _heh, HalfedgeHandle _next) = 0;
+
+  // set incident face handle for given halfedge
+  virtual void set_face(HalfedgeHandle _heh, FaceHandle _fh) = 0;
+
   // set vertex texture coordinate
   virtual void set_texcoord(HalfedgeHandle _heh, const Vec2f& _texcoord) = 0;
 
@@ -142,6 +160,9 @@ public:
   // set 3d vertex texture coordinate
   virtual void set_texcoord(HalfedgeHandle _heh, const Vec3f& _texcoord) = 0;
 
+  // set halfedge status
+  virtual void set_status(HalfedgeHandle _heh, const OpenMesh::Attributes::StatusInfo& _status) = 0;
+
   // set edge color
   virtual void set_color(EdgeHandle _eh, const Vec3uc& _color) = 0;
 
@@ -154,6 +175,9 @@ public:
   // set edge color
   virtual void set_color(EdgeHandle _eh, const Vec4f& _color) = 0;
 
+  // set edge status
+  virtual void set_status(EdgeHandle _eh, const OpenMesh::Attributes::StatusInfo& _status) = 0;
+
   // set face normal
   virtual void set_normal(FaceHandle _fh, const Vec3f& _normal) = 0;
 
@@ -169,6 +193,9 @@ public:
   // set face color
   virtual void set_color(FaceHandle _fh, const Vec4f& _color) = 0;
 
+  // set face status
+  virtual void set_status(FaceHandle _fh, const OpenMesh::Attributes::StatusInfo& _status) = 0;
+
   // Store a property in the mesh mapping from an int to a texture file
   // Use set_face_texindex to set the index for each face
   virtual void add_texture_information( int _id , std::string _name ) = 0;

src/OpenMesh/Core/IO/importer/ImporterT.hh

@@ -107,6 +107,11 @@ public:
     return mesh_.new_vertex();
   }
 
+  virtual HalfedgeHandle add_edge(VertexHandle _vh0, VertexHandle _vh1) override
+  {
+    return mesh_.new_edge(_vh0, _vh1);
+  }
+
   virtual FaceHandle add_face(const VHandles& _indices)
   {
     FaceHandle fh;
@@ -192,6 +197,13 @@ public:
     return fh;
   }
 
+  virtual FaceHandle add_face(HalfedgeHandle _heh) override
+  {
+    auto fh = mesh_.new_face();
+    mesh_.set_halfedge_handle(fh, _heh);
+    return fh;
+  }
+
   // vertex attributes
 
   virtual void set_point(VertexHandle _vh, const Vec3f& _point)
@@ -199,6 +211,11 @@ public:
     mesh_.set_point(_vh,vector_cast<Point>(_point));
   }
 
+  virtual void set_halfedge(VertexHandle _vh, HalfedgeHandle _heh) override
+  {
+    mesh_.set_halfedge_handle(_vh, _heh);
+  }
+
   virtual void set_normal(VertexHandle _vh, const Vec3f& _normal)
   {
     if (mesh_.has_vertex_normals())
@@ -240,6 +257,24 @@ public:
       mesh_.set_texcoord2D(_vh, vector_cast<TexCoord2D>(_texcoord));
   }
 
+  virtual void set_status(VertexHandle _vh, const OpenMesh::Attributes::StatusInfo& _status)
+  {
+    if (!mesh_.has_vertex_status())
+      mesh_.request_vertex_status();
+    mesh_.status(_vh) = _status;
+  }
+
+  virtual void set_next(HalfedgeHandle _heh, HalfedgeHandle _next) override
+  {
+    mesh_.set_next_halfedge_handle(_heh, _next);
+  }
+
+  virtual void set_face(HalfedgeHandle _heh, FaceHandle _fh) override
+  {
+    mesh_.set_face_handle(_heh, _fh);
+  }
+
+
   virtual void set_texcoord(HalfedgeHandle _heh, const Vec2f& _texcoord)
   {
     if (mesh_.has_halfedge_texcoords2D())
@@ -258,6 +293,12 @@ public:
       mesh_.set_texcoord3D(_heh, vector_cast<TexCoord3D>(_texcoord));
   }
 
+  virtual void set_status(HalfedgeHandle _heh, const OpenMesh::Attributes::StatusInfo& _status)
+  {
+    if (!mesh_.has_halfedge_status())
+      mesh_.request_halfedge_status();
+    mesh_.status(_heh) = _status;
+  }
 
   // edge attributes
 
@@ -285,6 +326,13 @@ public:
           mesh_.set_color(_eh, color_cast<Color>(_color));
   }
 
+  virtual void set_status(EdgeHandle _eh, const OpenMesh::Attributes::StatusInfo& _status)
+  {
+    if (!mesh_.has_edge_status())
+      mesh_.request_edge_status();
+    mesh_.status(_eh) = _status;
+  }
+
   // face attributes
 
   virtual void set_normal(FaceHandle _fh, const Vec3f& _normal)
@@ -317,6 +365,13 @@ public:
       mesh_.set_color(_fh, color_cast<Color>(_color));
   }
 
+  virtual void set_status(FaceHandle _fh, const OpenMesh::Attributes::StatusInfo& _status)
+  {
+    if (!mesh_.has_face_status())
+      mesh_.request_face_status();
+    mesh_.status(_fh) = _status;
+  }
+
   virtual void add_face_texcoords( FaceHandle _fh, VertexHandle _vh, const std::vector<Vec2f>& _face_texcoords)
   {
     // get first halfedge handle

src/OpenMesh/Core/IO/reader/OMReader.cc

@@ -61,6 +61,7 @@
 #include <OpenMesh/Core/Utils/Endian.hh>
 #include <OpenMesh/Core/IO/OMFormat.hh>
 #include <OpenMesh/Core/IO/reader/OMReader.hh>
+#include <OpenMesh/Core/IO/writer/OMWriter.hh>
 
 
 //=== NAMESPACES ==============================================================
@@ -176,6 +177,15 @@ bool _OMReader_::read_binary(std::istream& _is, BaseImporter& _bi, Options& _opt
   bytes_ += restore(_is, header_, swap);
 
 
+  if (header_.version_ > _OMWriter_::get_version())
+  {
+    omerr() << "File uses .om version " << OMFormat::as_string(header_.version_) << " but reader only "
+            << "supports up to version " << OMFormat::as_string(_OMWriter_::get_version()) << ".\n"
+            << "Please update your OpenMesh." << std::endl;
+    return false;
+  }
+
+
   while (!_is.eof()) {
     bytes_ += restore(_is, chunk_header_, swap);
 
@@ -294,6 +304,7 @@ bool _OMReader_::read_binary_vertex_chunk(std::istream &_is, BaseImporter &_bi,
   OpenMesh::Vec3f v3f;
   OpenMesh::Vec2f v2f;
   OpenMesh::Vec3uc v3uc; // rgb
+  OpenMesh::Attributes::StatusInfo status;
 
   OMFormat::Chunk::PropertyName custom_prop;
 
@@ -343,6 +354,20 @@ bool _OMReader_::read_binary_vertex_chunk(std::istream &_is, BaseImporter &_bi,
       }
       break;
 
+    case Chunk::Type_Status:
+    {
+      assert( OMFormat::dimensions(chunk_header_) == 1);
+
+      fileOptions_ += Options::Status;
+
+      for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) {
+        bytes_ += restore(_is, status, _swap);
+        if (fileOptions_.vertex_has_status() && _opt.vertex_has_status())
+          _bi.set_status(VertexHandle(int(vidx)), status);
+      }
+      break;
+    }
+
     case Chunk::Type_Custom:
 
       bytes_ += restore_binary_custom_data(_is, _bi.kernel()->_get_vprop(property_name_), header_.n_vertices_, _swap);
@@ -351,6 +376,19 @@ bool _OMReader_::read_binary_vertex_chunk(std::istream &_is, BaseImporter &_bi,
 
       break;
 
+    case Chunk::Type_Topology:
+    {
+      for (; vidx < header_.n_vertices_; ++vidx)
+      {
+        int halfedge_id;
+        bytes_ += restore( _is, halfedge_id, OMFormat::Chunk::Integer_Size(chunk_header_.bits_), _swap );
+
+        _bi.set_halfedge(VertexHandle(static_cast<int>(vidx)), HalfedgeHandle(halfedge_id));
+      }
+    }
+
+      break;
+
     default: // skip unknown chunks
     {
       omerr() << "Unknown chunk type ignored!\n";
@@ -376,34 +414,51 @@ bool _OMReader_::read_binary_face_chunk(std::istream &_is, BaseImporter &_bi, Op
   size_t fidx = 0;
   OpenMesh::Vec3f v3f;  // normal
   OpenMesh::Vec3uc v3uc; // rgb
+  OpenMesh::Attributes::StatusInfo status;
 
   switch (chunk_header_.type_) {
-    case Chunk::Type_Topology: {
-      BaseImporter::VHandles vhandles;
-      size_t nV = 0;
-      size_t vidx = 0;
-
-      switch (header_.mesh_) {
-        case 'T':
-          nV = 3;
-          break;
-        case 'Q':
-          nV = 4;
-          break;
-      }
+    case Chunk::Type_Topology:
+    {
+      if (header_.version_ < OMFormat::mk_version(2,0))
+      {
+        // add faces based on vertex indices
+        BaseImporter::VHandles vhandles;
+        size_t nV = 0;
+        size_t vidx = 0;
+
+        switch (header_.mesh_) {
+          case 'T':
+            nV = 3;
+            break;
+          case 'Q':
+            nV = 4;
+            break;
+        }
 
-      for (; fidx < header_.n_faces_; ++fidx) {
-        if (header_.mesh_ == 'P')
-          bytes_ += restore(_is, nV, Chunk::Integer_16, _swap);
+        for (; fidx < header_.n_faces_; ++fidx) {
+          if (header_.mesh_ == 'P')
+            bytes_ += restore(_is, nV, Chunk::Integer_16, _swap);
 
-        vhandles.clear();
-        for (size_t j = 0; j < nV; ++j) {
-          bytes_ += restore(_is, vidx, Chunk::Integer_Size(chunk_header_.bits_), _swap);
+          vhandles.clear();
+          for (size_t j = 0; j < nV; ++j) {
+            bytes_ += restore(_is, vidx, Chunk::Integer_Size(chunk_header_.bits_), _swap);
 
-          vhandles.push_back(VertexHandle(int(vidx)));
-        }
+            vhandles.push_back(VertexHandle(int(vidx)));
+          }
 
-        _bi.add_face(vhandles);
+          _bi.add_face(vhandles);
+        }
+      }
+      else
+      {
+        // add faces by simply setting an incident halfedge
+        for (; fidx < header_.n_faces_; ++fidx)
+        {
+          int halfedge_id;
+          bytes_ += restore( _is, halfedge_id, OMFormat::Chunk::Integer_Size(chunk_header_.bits_), _swap );
+
+          _bi.add_face(HalfedgeHandle(halfedge_id));
+        }
       }
     }
       break;
@@ -430,6 +485,19 @@ bool _OMReader_::read_binary_face_chunk(std::istream &_is, BaseImporter &_bi, Op
           _bi.set_color(FaceHandle(int(fidx)), v3uc);
       }
       break;
+    case Chunk::Type_Status:
+    {
+      assert( OMFormat::dimensions(chunk_header_) == 1);
+
+      fileOptions_ += Options::Status;
+
+      for (; fidx < header_.n_faces_ && !_is.eof(); ++fidx) {
+        bytes_ += restore(_is, status, _swap);
+        if (fileOptions_.face_has_status() && _opt.face_has_status())
+          _bi.set_status(FaceHandle(int(fidx)), status);
+      }
+      break;
+    }
 
     case Chunk::Type_Custom:
 
@@ -453,7 +521,7 @@ bool _OMReader_::read_binary_face_chunk(std::istream &_is, BaseImporter &_bi, Op
 
 //-----------------------------------------------------------------------------
 
-bool _OMReader_::read_binary_edge_chunk(std::istream &_is, BaseImporter &_bi, Options &/*_opt */, bool _swap) const
+bool _OMReader_::read_binary_edge_chunk(std::istream &_is, BaseImporter &_bi, Options &_opt, bool _swap) const
 {
   using OMFormat::Chunk;
 
@@ -461,6 +529,8 @@ bool _OMReader_::read_binary_edge_chunk(std::istream &_is, BaseImporter &_bi, Op
 
   size_t b = bytes_;
 
+  OpenMesh::Attributes::StatusInfo status;
+
   switch (chunk_header_.type_) {
     case Chunk::Type_Custom:
 
@@ -468,6 +538,20 @@ bool _OMReader_::read_binary_edge_chunk(std::istream &_is, BaseImporter &_bi, Op
 
       break;
 
+    case Chunk::Type_Status:
+    {
+      assert( OMFormat::dimensions(chunk_header_) == 1);
+
+      fileOptions_ += Options::Status;
+
+      for (size_t eidx = 0; eidx < header_.n_edges_ && !_is.eof(); ++eidx) {
+        bytes_ += restore(_is, status, _swap);
+        if (fileOptions_.edge_has_status() && _opt.edge_has_status())
+          _bi.set_status(EdgeHandle(int(eidx)), status);
+      }
+      break;
+    }
+
     default:
       // skip unknown type
       size_t size_of = OMFormat::chunk_data_size(header_, chunk_header_);
@@ -481,13 +565,14 @@ bool _OMReader_::read_binary_edge_chunk(std::istream &_is, BaseImporter &_bi, Op
 
 //-----------------------------------------------------------------------------
 
-bool _OMReader_::read_binary_halfedge_chunk(std::istream &_is, BaseImporter &_bi, Options &/* _opt */, bool _swap) const
+bool _OMReader_::read_binary_halfedge_chunk(std::istream &_is, BaseImporter &_bi, Options & _opt, bool _swap) const
 {
   using OMFormat::Chunk;
 
   assert( chunk_header_.entity_ == Chunk::Entity_Halfedge);
 
   size_t b = bytes_;
+  OpenMesh::Attributes::StatusInfo status;
 
   switch (chunk_header_.type_) {
     case Chunk::Type_Custom:
@@ -495,6 +580,55 @@ bool _OMReader_::read_binary_halfedge_chunk(std::istream &_is, BaseImporter &_bi
       bytes_ += restore_binary_custom_data(_is, _bi.kernel()->_get_hprop(property_name_), 2 * header_.n_edges_, _swap);
       break;