mlGraphToBoostUndirectedGraph.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2012, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_GRAPH_TO_BOOST_UNDIRECTED_GRAPH_H
#define ML_GRAPH_TO_BOOST_UNDIRECTED_GRAPH_H
 
 
 
// Include dll-specific settings.
#include "MLGraphUtilitiesSystem.h"
 
#include <iterator>
#include <boost/version.hpp>
#include <boost/config.hpp>
#include <boost/operators.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>
#include <boost/property_map/property_map.hpp>
 
#include "mlGraphComponents.h"
 
 
ML_START_NAMESPACE
 
// Following classes are inherited from Graph to define different types for a existing
// Graph object. Since the boost graph library defines the Graph properties via traits
// it is necessary to match different runtime states to different types.
// It will be necessary to cast a current Graph object to a pointer of one of the
// derived classes and use this pointer with the boost library
 
class MLGRAPHUTILITIES_EXPORT UndirectedGraph : public Graph {};
 
ML_END_NAMESPACE
 
 
 
//
// Functions and traits for the plain ml::Graph class
//
 
class ml_ug_out_edge_iterator;
 
 
 
typedef ml::UndirectedGraph* ml_undirected_graph_ptr;
 
namespace boost {
 
// forward declaration of an undirected edge
class ml_ug_edge;
 
 // typedef const UndirectedVesselGraph* ml_const_uv_graph_ptr;
 
 
  // already defined by directed graph
  struct ml_undirected_graph_traversal_tag :
    public virtual incidence_graph_tag,     // Graph is of type IncidenceGraph
    public virtual vertex_list_graph_tag    // Graph is of type VertexList
 { };
 
 
  template <> struct graph_traits<ml_undirected_graph_ptr> {
 
    // --- typedefs for boost::Graph ---
 
    typedef ml::VesselNode* vertex_descriptor;
 
    typedef ml_ug_edge edge_descriptor;
 
    typedef undirected_tag directed_category;
 
    typedef allow_parallel_edge_tag edge_parallel_category;
 
    typedef ml_undirected_graph_traversal_tag traversal_category;
 
    // --- typedefs for boost::IncidenceGraph  ---
 
    typedef long degree_size_type;
 
    // An out-edge iterator for a vertex v provides access to the out-edges of the vertex. As such,
    // the value type of an out-edge iterator is the edge descriptor type of its graph.
    typedef  ml_ug_out_edge_iterator out_edge_iterator;
 
    // --- typedefs for boost::VertexListGraph  ---
 
    typedef ml::Graph::NodeIterator vertex_iterator;
 
    typedef long vertices_size_type;
 
    // to do: add missing functions/traits for other boost graph models
    /*
    typedef void in_edge_iterator;
    typedef sgb_adj_iterator adjacency_iterator;
    typedef void edge_iterator;
    typedef long edge_size_type;
    */
  };
 
 
 
} // namespace boost
 
 
namespace boost {
 
  class ml_ug_edge
  {
    typedef ml_ug_edge self;
 
    public:
 
 
    ml_ug_edge() : _vertex(nullptr), _edge(nullptr) {};
    ml_ug_edge(ml::VesselNode* vertex, ml::VesselEdge* edge) : _vertex(vertex), _edge(edge) {};
 
 
    // source is always vertex
    ml::VesselNode* source() {
      return _vertex;
    };
 
    // target is not _vertex
    ml::VesselNode* target() {
      if (_edge->isPred(_vertex))
      {
        return _edge->succNode();
      }
      return _edge->predNode();
    };
 
    double weight() const { return _edge->getWeight(); };
 
    friend bool operator==(const self& a, const self& b ) {
      return a._edge == b._edge;
    }
 
    friend bool operator!=(const self& a, const self& b ) {
      return !(a == b);
    }
 
    protected:
    ml::VesselNode* _vertex;
    ml::VesselEdge* _edge;
  };
 
} // namespace boost
 
class ml_ug_out_edge_iterator : public boost::forward_iterator_helper<
                                            ml_ug_out_edge_iterator,  // operand type
                                            boost::ml_ug_edge,        // value type
                                            std::ptrdiff_t,        // difference type
                                            boost::ml_ug_edge*,       // pointer type
                                            boost::ml_ug_edge>        // reference type
{
 
typedef ml_ug_out_edge_iterator self;
 
public:
 
  ml_ug_out_edge_iterator() : _vertex(nullptr) {}
 
  ml_ug_out_edge_iterator(ml::VesselNode* vertex,
                       std::vector<ml::VesselEdge*>::iterator edgeIter)
  :_vertex(vertex)
  ,_edgeIter(edgeIter)
  {}
 
  boost::ml_ug_edge operator*() { return boost::ml_ug_edge(_vertex, *_edgeIter); }
 
  self& operator++()
  {
    ++_edgeIter;
    return *this;
  }
 
  friend bool operator==(const self& x, const self& y) {
    return x._edgeIter == y._edgeIter; }
 
protected:
  ml::VesselNode* _vertex;
  std::vector<ml::VesselEdge*>::iterator _edgeIter;
};
 
 
namespace boost {
 
  // --- functions required by boost::IncidenceGraph  ---
 
 
  inline boost::graph_traits<ml_undirected_graph_ptr>::vertex_descriptor
  source(graph_traits<ml_undirected_graph_ptr>::edge_descriptor e,
         const ml_undirected_graph_ptr)
  {
    return e.source();
  }
 
  inline boost::graph_traits<ml_undirected_graph_ptr>::vertex_descriptor
  target(graph_traits<ml_undirected_graph_ptr>::edge_descriptor e,
         const ml_undirected_graph_ptr)
  {
    return e.target();
  }
 
  inline std::pair<boost::graph_traits<ml_undirected_graph_ptr>::out_edge_iterator,
                   boost::graph_traits<ml_undirected_graph_ptr>::out_edge_iterator>
  out_edges(boost::graph_traits<ml_undirected_graph_ptr>::vertex_descriptor vertex,
            const ml_undirected_graph_ptr)
  {
    return std::make_pair(
      boost::graph_traits<ml_undirected_graph_ptr>::out_edge_iterator(vertex, vertex->edges()->begin()),
      boost::graph_traits<ml_undirected_graph_ptr>::out_edge_iterator(vertex, vertex->edges()->end()) );
  }
 
 
  inline boost::graph_traits<ml_undirected_graph_ptr>::degree_size_type
  out_degree(boost::graph_traits<ml_undirected_graph_ptr>::vertex_descriptor vertex,
             const ml_undirected_graph_ptr )
  {
    return static_cast<boost::graph_traits<ml_undirected_graph_ptr>::degree_size_type>(vertex->getEdgeNum());
  }
 
 
  // --- functions required by boost::VertexListGraph ---
 
  inline std::pair<boost::graph_traits<ml_undirected_graph_ptr>::vertex_iterator,
                   boost::graph_traits<ml_undirected_graph_ptr>::vertex_iterator>
  vertices(ml_undirected_graph_ptr g)
  {
    return std::make_pair( g->beginNode(),
                           g->endNode() );
  }
 
  inline boost::graph_traits<ml_undirected_graph_ptr>::vertices_size_type
  num_vertices(const ml_undirected_graph_ptr g)
  {
    return static_cast<long> (g->numNodes());
  }
 
 
  inline boost::graph_traits<ml_undirected_graph_ptr>::vertex_descriptor
  vertex(boost::graph_traits<ml_undirected_graph_ptr>::degree_size_type arrayIndex, const ml_undirected_graph_ptr g)
  {
    return g->getNode(arrayIndex);
  }
 
  // --- Property maps ---
  // put_get_helper<class Reference, class LvaluePropertyMap> is a helper template which
  // automatically generates the put() and get() functions for a property map
 
  // already defined by directed graph
  class ml_ug_vertex_id_map : public boost::put_get_helper<unsigned int, ml_ug_vertex_id_map>
  {
    public:
      // readonly property
      typedef boost::readable_property_map_tag category;
 
      // vertex index is of type long
      typedef unsigned int value_type;
      typedef unsigned int reference;
 
      // key = Vertex
      typedef ml::VesselNode* key_type;
 
      ml_ug_vertex_id_map() : _g(nullptr) {}
      ml_ug_vertex_id_map(ml_undirected_graph_ptr g) : _g(g) {}
      unsigned int operator[](ml::VesselNode* vertex) const {  return static_cast<unsigned int>(_g->getIndex(vertex)); }
 
    protected:
      ml_undirected_graph_ptr _g;
  };
 
  inline ml_ug_vertex_id_map get(vertex_index_t, ml_undirected_graph_ptr g)
  {
    return ml_ug_vertex_id_map(g);
  }
 
  // --- Property Map Traits classes ---
  template<>
  struct property_map<ml_undirected_graph_ptr, vertex_index_t>
  {
    typedef ml_ug_vertex_id_map type;
    typedef ml_ug_vertex_id_map const_type;
  };
 
 
  //
  class ml_ug_edge_weight_map : public boost::put_get_helper<double, ml_ug_edge_weight_map>
  {
    public:
       // readonly property
      typedef boost::lvalue_property_map_tag category;
 
      // vertex index is of type long
      typedef double value_type;
      typedef double const& reference;
 
      // key = edge
      typedef  boost::ml_ug_edge key_type;
 
      value_type operator[](boost::ml_ug_edge edge) const {
        //std::cout << "edge.getWeight() = " << edge.getWeight() << std::endl;
        return edge.weight();
      }
  };
 
  inline ml_ug_edge_weight_map get(edge_weight_t, ml_undirected_graph_ptr)
  {
    return ml_ug_edge_weight_map();
  }
 
  // --- Property Map Traits classes ---
  template<>
  struct property_map<ml_undirected_graph_ptr, edge_weight_t>
  {
    typedef ml_ug_edge_weight_map type;
    typedef ml_ug_edge_weight_map const_type;
  };
 
 
} // namespace boost
 
#endif