add the ability to use a Visitor for a BGL graph using an overload of graph_traits

TODO : is_valid(mesh) does not compile on msvc. To be fixed

BGL/include/CGAL/boost/graph/visitor.h

@@ -0,0 +1,648 @@
+#ifndef CGAL_BOOST_GRAPH_VISITOR_H
+#define CGAL_BOOST_GRAPH_VISITOR_H
+
+#include <boost/graph/graph_traits.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/core/ref.hpp>
+
+namespace boost
+{
+  template<typename V, typename Graph>
+  struct boost::graph_traits<
+    boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> > >
+    : boost::graph_traits< Graph >
+  {
+    typedef boost::graph_traits<Graph> Base;
+    typedef typename Base::vertex_property_type vertex_property_type;
+  };
+
+  template<typename V, typename Graph>
+  struct boost::graph_traits<
+    boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> > const >
+    : boost::graph_traits< Graph >
+  {};
+
+  template<typename V, typename Graph, class PropertyTag>
+  struct property_map<
+      boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> >,
+      PropertyTag>
+      : public property_map<Graph, PropertyTag>
+  {};
+
+  template<typename V, typename Graph, class PropertyTag>
+  struct property_map<
+    const boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> >,
+    PropertyTag>
+    : public property_map<Graph, PropertyTag>
+  {};
+
+} // namespace boost
+
+namespace CGAL
+{
+template<typename V, typename Graph>
+boost::tuple<boost::reference_wrapper<V>,
+             boost::reference_wrapper<Graph> >
+make_graph_with_visitor(V& v, Graph& g)
+{
+  return boost::make_tuple(boost::ref(v), boost::ref(g));
+}
+
+template<typename Graph>
+class Visitor_base
+{
+public:
+  typedef typename boost::graph_traits<Graph> gt;
+  typedef typename gt::halfedge_descriptor halfedge_descriptor;
+  typedef typename gt::edge_descriptor edge_descriptor;
+  typedef typename gt::vertex_descriptor vertex_descriptor;
+
+
+};
+
+
+//// OVERLOADS FOR Visitor
+
+template<typename Graph>
+void num_vertices(Visitor_base<Graph>& w)
+{}
+template<typename Graph>
+void num_edges(Visitor_base<Graph>& w)
+{}
+template<typename Graph>
+void degree(typename boost::graph_traits<Graph>::vertex_descriptor v
+  , const Visitor_base<Graph>& w)
+{}
+template <class Graph>
+void out_degree(typename boost::graph_traits<Graph>::vertex_descriptor v
+  , const Visitor_base<Graph>& w)
+{}
+template <class Graph>
+void in_degree(typename boost::graph_traits<Graph>::vertex_descriptor v
+  , const Visitor_base<Graph>& w)
+{}
+template <class Graph>
+void source(typename boost::graph_traits<Graph>::edge_descriptor e
+  , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void target(typename boost::graph_traits<Graph>::edge_descriptor e
+  , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void edge(typename boost::graph_traits<Graph>::vertex_descriptor u
+        , typename boost::graph_traits<Graph>::vertex_descriptor v
+        , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+inline void vertices(const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+inline void edges(const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+inline void in_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
+                   , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+inline void out_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
+                    , const Visitor_base<Graph> & w)
+{}
+
+//
+// MutableHalfedgeGraph
+// 
+template <class Graph>
+void add_vertex(Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void add_vertex(const typename boost::graph_traits<Graph >::vertex_property_type& p
+               , Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void remove_vertex(typename boost::graph_traits< Graph >::vertex_descriptor v
+                 , Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void add_edge(Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void remove_edge(typename boost::graph_traits< Graph >::edge_descriptor e
+               , Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void set_target(typename boost::graph_traits< Graph >::halfedge_descriptor h1
+              , typename boost::graph_traits< Graph >::vertex_descriptor v
+              , Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void set_next(typename boost::graph_traits< Graph >::halfedge_descriptor h1
+            , typename boost::graph_traits< Graph >::halfedge_descriptor h2
+            , Visitor_base<Graph> & w)
+{}
+
+//
+// MutableFaceGraph 
+//
+template <class Graph>
+void add_face(Visitor_base<Graph> & w)
+{}
+template <class InputIterator, class Graph>
+void add_face(InputIterator begin, InputIterator end,
+              Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void remove_face(typename boost::graph_traits< Graph >::face_descriptor f
+               , Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void set_face(typename boost::graph_traits< Graph >::halfedge_descriptor h
+            , typename boost::graph_traits< Graph >::face_descriptor f
+            , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void set_halfedge(typename boost::graph_traits< Graph >::face_descriptor f
+                , typename boost::graph_traits< Graph >::halfedge_descriptor h
+                , Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void set_halfedge(typename boost::graph_traits< Graph >::vertex_descriptor v
+                , typename boost::graph_traits< Graph >::halfedge_descriptor h
+                , const Visitor_base<Graph> & w)
+{}
+
+//
+// HalfedgeGraph
+//
+template <class Graph>
+void edge(typename boost::graph_traits< Graph >::halfedge_descriptor h
+        , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void halfedge(typename boost::graph_traits< Graph >::edge_descriptor e
+            , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void halfedge(typename boost::graph_traits< Graph >::vertex_descriptor v
+            , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void halfedge(typename boost::graph_traits< Graph >::vertex_descriptor u
+            , typename boost::graph_traits< Graph >::vertex_descriptor v
+            , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void opposite(typename boost::graph_traits< Graph >::halfedge_descriptor h
+            , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void source(typename boost::graph_traits< Graph >::halfedge_descriptor h
+          , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void target(typename boost::graph_traits< Graph >::halfedge_descriptor h
+          , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void next(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
+        , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void prev(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
+        , const Visitor_base<Graph> & w)
+{}
+
+//
+// HalfedgeListGraph
+//
+template <class Graph>
+void halfedges(const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void num_halfedges(const Visitor_base<Graph> & w)
+{}
+
+// Graph
+template <class Graph>
+void face(typename boost::graph_traits< Graph >::halfedge_descriptor h
+        , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void halfedge(typename boost::graph_traits< Graph >::face_descriptor f
+            , const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void faces(const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void num_faces(const Visitor_base<Graph> & w)
+{}
+template <class Graph>
+void is_valid(const Visitor_base<Graph> & w, bool verbose = false)
+{}
+template <class Graph, class PropertyTag>
+void get(PropertyTag ptag, const Visitor_base<Graph>& w)
+{}
+
+
+//// OVERLOADS FOR TUPLE<Visitor, Graph>
+
+template <class Graph, class Visitor>
+typename boost::graph_traits<Graph>::vertices_size_type
+num_vertices(const boost::tuple<boost::reference_wrapper<Visitor>,
+                                boost::reference_wrapper<Graph> >& w)
+{
+  num_vertices(boost::unwrap_ref(w.get<0>()));
+  return num_vertices(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits<Graph>::edges_size_type
+num_edges(const boost::tuple<boost::reference_wrapper<Visitor>,
+                             boost::reference_wrapper<Graph> >& w)
+{
+  num_edges(boost::unwrap_ref(w.get<0>()));
+  return num_edges(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits<Graph>::degree_size_type
+degree(typename boost::graph_traits<Graph>::vertex_descriptor v
+     , const boost::tuple<boost::reference_wrapper<Visitor>,
+                          boost::reference_wrapper<Graph> >& w)
+{
+  degree(v, boost::unwrap_ref(w.get<0>()));
+  return degree(v, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits<Graph>::degree_size_type
+out_degree(typename boost::graph_traits<Graph>::vertex_descriptor v
+         , const boost::tuple<boost::reference_wrapper<Visitor>,
+                              boost::reference_wrapper<Graph> >& w)
+{
+  out_degree(v, boost::unwrap_ref(w.get<0>()));
+  return out_degree(v, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits<Graph>::degree_size_type
+in_degree(typename boost::graph_traits<Graph>::vertex_descriptor v
+        , const boost::tuple<boost::reference_wrapper<Visitor>,
+                             boost::reference_wrapper<Graph> >& w)
+{
+  in_degree(v, boost::unwrap_ref(w.get<0>()));
+  return in_degree(v, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits<Graph>::vertex_descriptor
+source(typename boost::graph_traits<Graph>::edge_descriptor e
+     , const boost::tuple<boost::reference_wrapper<Visitor>,
+                          boost::reference_wrapper<Graph> > & w)
+{
+  source(e, boost::unwrap_ref(w.get<0>()));
+  return source(e, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits<Graph>::vertex_descriptor
+target(typename boost::graph_traits<Graph>::edge_descriptor e
+     , const boost::tuple<boost::reference_wrapper<Visitor>,
+                          boost::reference_wrapper<Graph> > & w)
+{
+  target(e, boost::unwrap_ref(w.get<0>()));
+  return target(e, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+std::pair<typename boost::graph_traits<Graph>::edge_descriptor, bool>
+edge(typename boost::graph_traits<Graph>::vertex_descriptor u
+   , typename boost::graph_traits<Graph>::vertex_descriptor v
+   , const boost::tuple<boost::reference_wrapper<Visitor>,
+                        boost::reference_wrapper<Graph> > & w)
+{
+  return edge(u, v, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::vertex_iterator>
+vertices(const boost::tuple<boost::reference_wrapper<Visitor>,
+                            boost::reference_wrapper<Graph> >& w)
+{
+  return vertices(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::edge_iterator>
+edges(const boost::tuple<boost::reference_wrapper<Visitor>,
+                         boost::reference_wrapper<Graph> >& w)
+{
+  return edges(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::in_edge_iterator>
+in_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
+       , const boost::tuple<boost::reference_wrapper<Visitor>,
+                            boost::reference_wrapper<Graph> >& w)
+{
+  return in_edges(u, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::out_edge_iterator>
+out_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
+        , const boost::tuple<boost::reference_wrapper<Visitor>,
+                             boost::reference_wrapper<Graph> >& w)
+{
+  return out_edges(u, boost::unwrap_ref(w.get<1>()));
+}
+
+//
+// MutableHalfedgeGraph
+// 
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::vertex_descriptor
+add_vertex(boost::tuple<boost::reference_wrapper<Visitor>,
+                        boost::reference_wrapper<Graph> >& w)
+{
+  return add_vertex(boost::unwrap_ref(w.get<1>()));
+}
+
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::vertex_descriptor
+add_vertex(const typename boost::graph_traits<Graph >::vertex_property_type& p
+, boost::tuple<boost::reference_wrapper<Visitor>,
+               boost::reference_wrapper<Graph> >& w)
+{
+  return add_vertex(p, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+void
+remove_vertex(typename boost::graph_traits< Graph >::vertex_descriptor v
+, boost::tuple<boost::reference_wrapper<Visitor>,
+               boost::reference_wrapper<Graph> >& w)
+{
+  remove_vertex(v, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::edge_descriptor
+add_edge(boost::tuple<boost::reference_wrapper<Visitor>,
+                      boost::reference_wrapper<Graph> >& w)
+{
+  return add_edge(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+void
+remove_edge(typename boost::graph_traits< Graph >::edge_descriptor e
+, boost::tuple<boost::reference_wrapper<Visitor>,
+               boost::reference_wrapper<Graph> >& w)
+{
+  remove_edge(e, boost::unwrap_ref(w.get<1>()));
+}
+
+
+template <class Graph, class Visitor>
+void
+set_target(typename boost::graph_traits< Graph >::halfedge_descriptor h1
+, typename boost::graph_traits< Graph >::vertex_descriptor v
+, boost::tuple<boost::reference_wrapper<Visitor>,
+               boost::reference_wrapper<Graph> >& w)
+{
+  set_target(h1, v, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+void
+set_next(typename boost::graph_traits< Graph >::halfedge_descriptor h1
+       , typename boost::graph_traits< Graph >::halfedge_descriptor h2
+       , boost::tuple<boost::reference_wrapper<Visitor >,
+                      boost::reference_wrapper<Graph> >& w)
+{
+  set_next(h1, h2, boost::unwrap_ref(w.get<1>()));
+}
+
+//
+// MutableFaceGraph 
+//
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::face_descriptor
+add_face(boost::tuple<boost::reference_wrapper<Visitor>,
+boost::reference_wrapper<Graph> >& w)
+{
+  return add_face(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class InputIterator, class Graph, class Visitor>
+typename boost::graph_traits< Graph >::face_descriptor
+add_face(InputIterator begin,
+         InputIterator end,
+         boost::tuple<boost::reference_wrapper<Visitor>,
+         boost::reference_wrapper<Graph> >& w)
+{
+  return add_face(begin, end, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+void
+remove_face(typename boost::graph_traits< Graph >::face_descriptor f
+, boost::tuple<boost::reference_wrapper<Visitor>,
+boost::reference_wrapper<Graph> >& w)
+{
+  return remove_face(f, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+void
+set_face(typename boost::graph_traits< Graph >::halfedge_descriptor h
+, typename boost::graph_traits< Graph >::face_descriptor f
+, const boost::tuple<boost::reference_wrapper<Visitor>,
+boost::reference_wrapper<Graph> >& w)
+{
+  set_face(h, f, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+void
+set_halfedge(typename boost::graph_traits< Graph >::face_descriptor f
+, typename boost::graph_traits< Graph >::halfedge_descriptor h
+, boost::tuple<boost::reference_wrapper<Visitor>,
+boost::reference_wrapper<Graph> >& w)
+{
+  set_halfedge(f, h, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+void
+set_halfedge(typename boost::graph_traits< Graph >::vertex_descriptor v
+, typename boost::graph_traits< Graph >::halfedge_descriptor h
+, const boost::tuple<boost::reference_wrapper<Visitor>,
+boost::reference_wrapper<Graph> >& w)
+{
+  set_halfedge(v, h, boost::unwrap_ref(w.get<1>()));
+}
+
+
+//
+// HalfedgeGraph
+//
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::edge_descriptor
+edge(typename boost::graph_traits< Graph >::halfedge_descriptor h
+, const boost::tuple<boost::reference_wrapper<Visitor>,
+                     boost::reference_wrapper<Graph> >& w)
+{
+  return edge(h, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::halfedge_descriptor
+halfedge(typename boost::graph_traits< Graph >::edge_descriptor e
+, const boost::tuple<boost::reference_wrapper<Visitor>,
+                     boost::reference_wrapper<Graph> >& w)
+{
+  return halfedge(e, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::halfedge_descriptor
+halfedge(typename boost::graph_traits< Graph >::vertex_descriptor v
+, const boost::tuple<boost::reference_wrapper<Visitor>,
+                     boost::reference_wrapper<Graph> >& w)
+{
+  return halfedge(v, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+std::pair< typename boost::graph_traits< Graph >::halfedge_descriptor
+  , bool>
+  halfedge(typename boost::graph_traits< Graph >::vertex_descriptor u
+  , typename boost::graph_traits< Graph >::vertex_descriptor v
+  , const boost::tuple<boost::reference_wrapper<Visitor>,
+                       boost::reference_wrapper<Graph> >& w)
+{
+  return halfedge(u, v, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::halfedge_descriptor
+opposite(typename boost::graph_traits< Graph >::halfedge_descriptor h
+, const boost::tuple<boost::reference_wrapper<Visitor>,
+                      boost::reference_wrapper<Graph> >& w)
+{
+  return opposite(h, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::vertex_descriptor
+source(typename boost::graph_traits< Graph >::halfedge_descriptor h
+, const boost::tuple<boost::reference_wrapper<Visitor>,
+                     boost::reference_wrapper<Graph> >& w)
+{
+  return source(h, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::vertex_descriptor
+target(typename boost::graph_traits< Graph >::halfedge_descriptor h
+, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
+{
+  return target(h, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::halfedge_descriptor
+next(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
+, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
+{
+  return next(outedge, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::halfedge_descriptor
+prev(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
+, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
+{
+  return prev(outedge, boost::unwrap_ref(w.get<1>()));
+}
+
+
+//
+// HalfedgeListGraph
+//
+
+template <class Graph, class Visitor>
+CGAL::Iterator_range<typename boost::graph_traits< Graph >::halfedge_iterator>
+halfedges(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
+{
+  return halfedges(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::halfedges_size_type
+num_halfedges(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
+{
+  return num_halfedges(boost::unwrap_ref(w.get<1>()));
+}
+
+// Graph
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::face_descriptor
+face(typename boost::graph_traits< Graph >::halfedge_descriptor h
+, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
+{
+  return face(h, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits< Graph >::halfedge_descriptor
+halfedge(typename boost::graph_traits< Graph >::face_descriptor f
+, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
+{
+  return halfedge(f, boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::face_iterator >
+faces(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
+{
+  return faces(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+typename boost::graph_traits<Graph>::faces_size_type
+num_faces(const boost::tuple<boost::reference_wrapper<Visitor>,
+                             boost::reference_wrapper<Graph> >& w)
+{
+  return num_faces(boost::unwrap_ref(w.get<1>()));
+}
+
+template <class Graph, class Visitor>
+bool is_valid(const boost::tuple<boost::reference_wrapper<Visitor>,
+                                 boost::reference_wrapper<Graph> >& w
+              , bool verbose = false)
+{
+  Graph& g = boost::unwrap_ref(w.get<1>());
+  std::cout << typeid(g).name() << std::endl;
+  return is_valid(g, verbose);
+}
+
+template <class Graph, class PropertyTag, class Visitor>
+typename boost::property_map< Graph, PropertyTag >::type
+get(PropertyTag ptag,
+    const boost::tuple<boost::reference_wrapper<Visitor>,
+                       boost::reference_wrapper<Graph> >& w)
+{
+  return get(ptag, boost::unwrap_ref(w.get<1>()));
+}
+
+}//end namespace CGAL
+
+#endif //CGAL_BOOST_GRAPH_VISITOR_H

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/remesh_impl.h

@@ -12,6 +12,7 @@
 #include <CGAL/AABB_triangle_primitive.h>
 
 #include <CGAL/boost/graph/Euler_operations.h>
+#include <CGAL/boost/graph/visitor.h>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/foreach.hpp>
 
@@ -85,6 +86,22 @@ namespace internal {
 
   };
 
+  template<typename PolygonMesh>
+  class Status_map_visitor
+    : public Visitor_base<PolygonMesh>
+  {
+    typedef Visitor_base<PolygonMesh> Base;
+    typedef typename Base::halfedge_descriptor halfedge_descriptor;
+
+    std::map<halfedge_descriptor, Halfedge_status>& halfedge_status_map_;
+
+  public:
+    Status_map_visitor(std::map<halfedge_descriptor, Halfedge_status>& hsmap)
+      : halfedge_status_map_(hsmap)
+    {}
+
+  };
+
   template<typename PolygonMesh
          , typename VertexPointMap
          , typename GeomTraits
@@ -108,6 +125,8 @@ namespace internal {
     typedef CGAL::AABB_traits<GeomTraits, Primitive>               Traits;
     typedef CGAL::AABB_tree<Traits>                                AABB_tree;
 
+    typedef Status_map_visitor<PM> Status_visitor;
+
   public:
     Incremental_remesher(PolygonMesh& pmesh
                        , VertexPointMap& vpmap
@@ -377,6 +396,13 @@ namespace internal {
         boost::bimaps::multiset_of<double, std::less<double> > >  Boost_bimap;
       typedef typename Boost_bimap::value_type                    short_edge;
 
+      //Status_visitor visitor2(halfedge_status_map_);
+      //std::cout << "Valid : " 
+      //  << is_valid(mesh_)
+      //  << "\t"
+      //  << is_valid(CGAL::make_graph_with_visitor(visitor2, mesh_))
+      //  << std::endl;
+
 #ifdef CGAL_PMP_REMESHING_VERBOSE
       std::cout << "Collapse short edges (" << low << ", " << high << ")..."
                 << std::endl;
@@ -534,9 +560,12 @@ namespace internal {
         }//end if(collapse_ok)
       }
 
-      std::size_t n = PMP::remove_degenerate_faces(mesh_
+      Status_visitor visitor(halfedge_status_map_);
+      std::size_t n = PMP::remove_degenerate_faces(
+        CGAL::make_graph_with_visitor(visitor, mesh_)
         , PMP::parameters::vertex_point_map(vpmap_)
          .geom_traits(GeomTraits()));
+
       if (n > 0)
       {
         std::cout << "Warning : tags should maybe be fixed" << std::endl;
@@ -970,8 +999,6 @@ namespace internal {
     {
       typename std::map < halfedge_descriptor, Halfedge_status >::const_iterator
         it = halfedge_status_map_.find(h);
-      if (it == halfedge_status_map_.end())
-        std::cout << "stop " << std::endl;
       CGAL_assertion(it != halfedge_status_map_.end());
       return it->second;
     }