DigitalSurfaceBoostGraphInterface.h

 
#pragma once
 
#if defined(DigitalSurfaceBoostGraphInterface_RECURSES)
#error Recursive header files inclusion detected in DigitalSurfaceBoostGraphInterface.h
#else // defined(DigitalSurfaceBoostGraphInterface_RECURSES)
 
#define DigitalSurfaceBoostGraphInterface_RECURSES
 
#if !defined DigitalSurfaceBoostGraphInterface_h
 
#define DigitalSurfaceBoostGraphInterface_h
 
// Inclusions
#include <iostream>
#include <vector>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>
#include <boost/property_map/property_map.hpp>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/topology/DigitalSurface.h"
 
 
// The interface to the Boost Graph should be defined in namespace boost.
namespace boost
{
 
  template < class TDigitalSurfaceContainer >
  struct graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > > 
  {
    typedef DGtal::DigitalSurface< TDigitalSurfaceContainer > Adapted;
    typedef undirected_tag directed_category;
    typedef DigitalSurface_graph_traversal_category traversal_category;
    typedef disallow_parallel_edge_tag edge_parallel_category;
 
    typedef typename Adapted::Size vertices_size_type;
    typedef typename Adapted::Size edges_size_type;
    typedef typename Adapted::Size degree_size_type;
 
    typedef typename Adapted::Vertex Vertex;
    typedef Vertex vertex_descriptor;
    typedef typename Adapted::Arc Arc;
    typedef Arc edge_descriptor;
    typedef typename Adapted::ConstIterator vertex_iterator;
 
    typedef std::vector< vertex_descriptor > AdjacentVertexContainer;
    typedef typename Adapted::ArcRange OutEdgeContainer;
 
 
    static
    inline 
    vertex_descriptor null_vertex() 
    {
      return vertex_descriptor( 0 );
    }
 
    class adjacency_iterator 
      : public iterator_facade< adjacency_iterator,
                                Vertex,
                                bidirectional_traversal_tag,
                                const Vertex & >
    {
    public:
      inline
      adjacency_iterator() 
        : myIterator(), myVertices( 0 ) {}
      inline
      adjacency_iterator( typename AdjacentVertexContainer::const_iterator it,
                          const DGtal::CountedPtr< AdjacentVertexContainer > & vertices )
        : myIterator( it ), myVertices( vertices ) {}
    private:
      inline
      const Vertex & dereference() const 
      {
        ASSERT( myIterator != myVertices->end() );
        return *myIterator; 
      }
 
      inline
      bool equal(const adjacency_iterator& other) const
      {
        bool thisAtEnd = ( myIterator == myVertices->end() );
        bool otherAtEnd = ( other.myIterator == other.myVertices->end() );
        if ( thisAtEnd || otherAtEnd ) return thisAtEnd && otherAtEnd;
        else return *myIterator == *other.myIterator; 
      }
 
      inline
      void increment() { ++myIterator; }
      inline
      void decrement() { --myIterator; }
 
      typename AdjacentVertexContainer::const_iterator myIterator;
      DGtal::CountedPtr< AdjacentVertexContainer > myVertices;
 
      friend class iterator_core_access;
    }; // end class adjacency_iterator 
 
    class out_edge_iterator 
      : public iterator_facade< out_edge_iterator,
                                Arc,
                                bidirectional_traversal_tag,
                                const Arc & >
    {
    public:
      inline
      out_edge_iterator() 
        : myIterator(), myOutEdges( 0 ) {}
      inline
      out_edge_iterator( typename OutEdgeContainer::const_iterator it,
                         const DGtal::CountedPtr< OutEdgeContainer > & out_edges )
        : myIterator( it ), myOutEdges( out_edges ) {}
    private:
      inline
      const Arc & dereference() const
      { 
        ASSERT( myIterator != myOutEdges->end() );
        return *myIterator; 
      }
 
      inline
      bool equal(const out_edge_iterator & other) const
      {
        bool thisAtEnd = ( myIterator == myOutEdges->end() );
        bool otherAtEnd = ( other.myIterator == other.myOutEdges->end() );
        if ( thisAtEnd || otherAtEnd ) return thisAtEnd && otherAtEnd;
        else return *myIterator == *other.myIterator; 
      }
 
      inline
      void increment() { ++myIterator; }
      inline
      void decrement() { --myIterator; }
 
      typename OutEdgeContainer::const_iterator myIterator;
      DGtal::CountedPtr< OutEdgeContainer > myOutEdges;
 
      friend class iterator_core_access;
    }; // end class out_edge_iterator
 
    class edge_iterator 
      : public iterator_facade< edge_iterator,
                                Arc,
                                forward_traversal_tag,
                                const Arc & >
    {
    public:
      edge_iterator();
      edge_iterator( ConstAlias<Adapted> graph,
                     const vertex_iterator & itB, const vertex_iterator & itE );
 
    private:
      const Arc & dereference() const;
      bool equal(const edge_iterator & other) const;
      void increment();
 
      const Adapted* myGraph;
      std::pair< vertex_iterator, vertex_iterator > myVertexRange;
      std::pair< out_edge_iterator, out_edge_iterator > myOutEdgeRange;
 
      friend class iterator_core_access;
    }; // end class out_edge_iterator
 
  }; // end struct graph_traits< >
 
  // template < class TDigitalSurfaceContainer, typename TPropertyTag >
  // struct property_map< DGtal::DigitalSurface< TDigitalSurfaceContainer >, TPropertyTag >
  // {
    
  // }; 
 
 
  // Functions for the boost graph interface to DigitalSurface<TDigitalSurfaceContainer>.
 
  template < class TDigitalSurfaceContainer >
  inline 
  typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::vertex_descriptor
  source( typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edge_descriptor edge,
          const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf )
  {
    return digSurf.tail( edge );
  }
  template < class TDigitalSurfaceContainer >
  inline 
  typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::vertex_descriptor
  target( typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edge_descriptor edge,
          const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf )
  {
    return digSurf.head( edge );
  }
  
  template < class TDigitalSurfaceContainer >
  std::pair<
    typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::vertex_iterator,
    typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::vertex_iterator 
    >
  vertices( const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf );
 
  template < class TDigitalSurfaceContainer >
  inline 
  typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::vertices_size_type
  num_vertices( const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf )
  {
    return digSurf.size();
  }
  
  template < class TDigitalSurfaceContainer >
  inline 
  std::pair<
    typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::adjacency_iterator,
    typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::adjacency_iterator 
    >
  adjacent_vertices( typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::vertex_descriptor u,
                     const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf )
  {
    typedef typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >
      ::adjacency_iterator Iterator;
    typedef typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >
      ::AdjacentVertexContainer Container;
    DGtal::CountedPtr<Container> ptrAdjVertices( new Container );
    std::back_insert_iterator< Container > outIt = std::back_inserter( *ptrAdjVertices );
    digSurf.writeNeighbors( outIt, u );
    return std::make_pair( Iterator( ptrAdjVertices->begin(), ptrAdjVertices ),
                           Iterator( ptrAdjVertices->end(), ptrAdjVertices ) );
  }
 
 
  template < class TDigitalSurfaceContainer >
  inline 
  std::pair<
    typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::out_edge_iterator,
    typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::out_edge_iterator 
    >
  out_edges( typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::vertex_descriptor u,
             const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf )
  {
    typedef typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >
      ::out_edge_iterator Iterator;
    typedef typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >
      ::OutEdgeContainer Container;
    DGtal::CountedPtr<Container> ptrOutEdges( new Container( digSurf.outArcs( u ) ) );
    return std::make_pair( Iterator( ptrOutEdges->begin(), ptrOutEdges ),
                           Iterator( ptrOutEdges->end(), ptrOutEdges ) );
  }
 
  template < class TDigitalSurfaceContainer >
  inline 
  typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::degree_size_type
  out_degree( typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::vertex_descriptor u,
              const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf )
  {
    return digSurf.degree( u );
  }
 
  template < class TDigitalSurfaceContainer >
  inline 
  std::pair<
    typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edge_iterator,
    typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edge_iterator 
    >
  edges( const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf )
  {
    typedef typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edge_iterator
      edge_iterator;
    return std::make_pair( edge_iterator( digSurf, digSurf.begin(), digSurf.end() ),
                           edge_iterator( digSurf, digSurf.end(), digSurf.end() ) );
  }
 
  template < class TDigitalSurfaceContainer >
  inline 
  typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edges_size_type
  num_edges( const DGtal::DigitalSurface< TDigitalSurfaceContainer > & digSurf )
  {
    typedef typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edge_iterator
      edge_iterator;
    typedef typename graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edges_size_type
      edges_size_type;
    edges_size_type nbEdges = 0;
    for ( std::pair< edge_iterator, edge_iterator > ve = boost::edges( digSurf );
          ve.first != ve.second; ++ve.first ) 
      ++nbEdges;
    return nbEdges;
  }
 
  
} // namespace Boost
 
 
// Includes inline functions.
#include "DGtal/graph/DigitalSurfaceBoostGraphInterface.ih"
 
//                                                                           //
 
#endif // !defined DigitalSurfaceBoostGraphInterface_h
 
#undef DigitalSurfaceBoostGraphInterface_RECURSES
#endif // else defined(DigitalSurfaceBoostGraphInterface_RECURSES)