mitkUndirectedGraph.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef _MITK_UndirectedGraph_H
#define _MITK_UndirectedGraph_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
    virtual void UpdateOutputInformation() override
    {
      if (this->GetSource())
        this->GetSource()->UpdateOutputInformation();
    }
    virtual void SetRequestedRegionToLargestPossibleRegion() override {}
    virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() override { return false; }
    virtual bool VerifyRequestedRegion() override { return true; }
    virtual void SetRequestedRegion(const itk::DataObject *data) 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(const UndirectedGraph<VertexType, EdgeType> &graph);
    virtual ~UndirectedGraph();

    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 /*  _MITK_UndirectedGraph_H */