mitkUndirectedGraph.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkUndirectedGraph_h
#define mitkUndirectedGraph_h
 
#include <mitkBaseData.h>
 
#ifndef Q_MOC_RUN
#include <boost/graph/adjacency_list.hpp>
#endif
 
/* definition of basic boost::graph properties */
enum vertex_properties_t
{
  vertex_properties
};
enum edge_properties_t
{
  edge_properties
};
 
namespace boost
{
  BOOST_INSTALL_PROPERTY(vertex, properties);
  BOOST_INSTALL_PROPERTY(edge, properties);
}
 
namespace mitk
{
  template <class TVertex, class TEdge>
  class UndirectedGraph : public BaseData
  {
  public:
    //--- Typedefs ---//
 
    typedef TVertex VertexType;
    typedef TEdge EdgeType;
    typedef boost::adjacency_list<boost::listS,
                                  boost::vecS,
                                  boost::undirectedS, // undirected graph
                                  boost::property<vertex_properties_t, VertexType>,
                                  boost::property<edge_properties_t, EdgeType>>
      GraphType;
 
    /* a bunch of graph-specific typedefs */
    typedef typename boost::graph_traits<GraphType>::vertex_descriptor VertexDescriptorType;
    typedef typename boost::graph_traits<GraphType>::edge_descriptor EdgeDescriptorType;
 
    typedef typename boost::graph_traits<GraphType>::vertex_iterator VertexIteratorType;
    typedef typename boost::graph_traits<GraphType>::edge_iterator EdgeIteratorType;
    typedef typename boost::graph_traits<GraphType>::adjacency_iterator AdjacenyIteratorType;
    typedef typename boost::graph_traits<GraphType>::out_edge_iterator OutEdgeIteratorType;
    typedef typename boost::graph_traits<GraphType>::in_edge_iterator InEdgeIteratorType;
 
    //--- Macros ---//
    mitkClassMacro(UndirectedGraph, BaseData);
    itkNewMacro(Self);
 
    // virtual methods that need to be implemented
    void UpdateOutputInformation() override
    {
      if (this->GetSource())
        this->GetSource()->UpdateOutputInformation();
    }
    void SetRequestedRegionToLargestPossibleRegion() override {}
    bool RequestedRegionIsOutsideOfTheBufferedRegion() override { return false; }
    bool VerifyRequestedRegion() override { return true; }
    void SetRequestedRegion(const itk::DataObject *) override {}
    VertexDescriptorType AddVertex(const VertexType &vertexData);
 
    void RemoveVertex(const VertexDescriptorType &vertex);
 
    VertexType GetVertex(const VertexDescriptorType &vertex);
 
    void SetVertex(const VertexDescriptorType &vertex, const VertexType &vertexData);
 
    VertexDescriptorType GetVertexDescriptor(const VertexType &vertexData) const;
 
    EdgeDescriptorType AddEdge(const VertexDescriptorType &vertexA,
                               const VertexDescriptorType &vertexB,
                               const EdgeType &edgeData);
 
    void RemoveEdge(const EdgeDescriptorType &edge);
 
    EdgeType GetEdge(const EdgeDescriptorType &edge);
 
    void SetEdge(const EdgeDescriptorType &edge, const EdgeType &edgeData);
 
    EdgeDescriptorType GetEdgeDescriptor(const EdgeType &edgeData) const;
 
    std::pair<VertexType, VertexType> GetVerticesOfAnEdge(const EdgeDescriptorType &edge) const;
 
    EdgeDescriptorType GetEdgeDescriptorByVerices(const VertexDescriptorType &vertexA,
                                                  const VertexDescriptorType &vertexB) const;
 
    std::vector<EdgeType> GetAllEdgesOfAVertex(const VertexDescriptorType &vertex) const;
 
    int GetNumberOfVertices() const;
 
    int GetNumberOfEdges() const;
 
    std::vector<VertexType> GetVectorOfAllVertices() const;
 
    std::vector<EdgeType> GetVectorOfAllEdges() const;
 
    void Clear() override;
 
    const GraphType &GetGraph() const;
 
    UndirectedGraph<VertexType, EdgeType> &operator=(const UndirectedGraph<VertexType, EdgeType> &rhs);
 
  protected:
    UndirectedGraph();
    ~UndirectedGraph() override;
 
    GraphType m_Graph;
 
  private:
    VertexType &properties(const VertexDescriptorType &vertex);
    const VertexType &properties(const VertexDescriptorType &vertex) const;
    EdgeType &properties(const EdgeDescriptorType &edge);
    const EdgeType &properties(const EdgeDescriptorType &edge) const;
  };
 
} // namespace mitk
 
#include "mitkUndirectedGraph.txx"
 
#endif