diff --git a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.cpp b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.cpp
index 913f12ab41..6150e1beca 100644
--- a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.cpp
@@ -1,650 +1,689 @@
 
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkConnectomicsNetwork.h"
 #include <boost/graph/clustering_coefficient.hpp>
 #include <boost/graph/betweenness_centrality.hpp>
 
 /* Constructor and Destructor */
 mitk::ConnectomicsNetwork::ConnectomicsNetwork()
 : m_IsModified( false )
 {
 }
 
 mitk::ConnectomicsNetwork::~ConnectomicsNetwork()
 {
 }
 
 /* Wrapper methods */
 
 bool mitk::ConnectomicsNetwork::EdgeExists(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB ) const
 {
   return boost::edge(vertexA, vertexB, m_Network ).second;
 }
 
 void mitk::ConnectomicsNetwork::IncreaseEdgeWeight(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB )
 {
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight++;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::AddEdge(
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexB
                                         )
 {
   AddEdge(vertexA, vertexB, m_Network[ vertexA ].id, m_Network[ vertexB ].id );
 }
 
 void mitk::ConnectomicsNetwork::AddEdge(
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexB,
                                         int sourceID, int targetID, int weight )
 {
   boost::add_edge( vertexA, vertexB, m_Network );
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].sourceId = sourceID;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].targetId = targetID;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight = weight;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].edge_weight = 1.0;
 
   SetIsModified( true );
 }
 
 mitk::ConnectomicsNetwork::VertexDescriptorType mitk::ConnectomicsNetwork::AddVertex( int id )
 {
   VertexDescriptorType vertex = boost::add_vertex( m_Network );
   m_Network[vertex].id = id;
 
   SetIsModified( true );
 
   return vertex;
 }
 
 void mitk::ConnectomicsNetwork::SetLabel(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::string inLabel )
 {
   m_Network[vertex].label = inLabel;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::SetCoordinates(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::vector< float > inCoordinates )
 {
   m_Network[vertex].coordinates = inCoordinates;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::clear()
 {
   m_Network.clear();
 
   SetIsModified( true );
 }
 
 /* Superclass methods, that need to be implemented */
 void mitk::ConnectomicsNetwork::UpdateOutputInformation()
 {
 
 }
 void mitk::ConnectomicsNetwork::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool mitk::ConnectomicsNetwork::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 bool mitk::ConnectomicsNetwork::VerifyRequestedRegion()
 {
   return true;
 }
 void mitk::ConnectomicsNetwork::SetRequestedRegion( itk::DataObject *data )
 {
 
 }
 
 
 
 std::vector< mitk::ConnectomicsNetwork::NetworkNode >
 mitk::ConnectomicsNetwork::GetVectorOfAllNodes() const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   std::vector< NetworkNode > vectorOfNodes;
 
   for ( ; iterator != end; ++iterator)
   {
     NetworkNode tempNode;
 
     // the value of an iterator is a descriptor
     tempNode = m_Network[ *iterator ];
 
     vectorOfNodes.push_back( tempNode );
   }
 
   return vectorOfNodes;
 }
 
 std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
 mitk::ConnectomicsNetwork::GetVectorOfAllVertexDescriptors() const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   std::vector< VertexDescriptorType > vectorOfDescriptors;
 
   for ( ; iterator != end; ++iterator)
   {
     vectorOfDescriptors.push_back( *iterator );
   }
 
   return vectorOfDescriptors;
 }
 
 std::vector< std::pair<
 std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode >
 , mitk::ConnectomicsNetwork::NetworkEdge > >
 mitk::ConnectomicsNetwork::GetVectorOfAllEdges() const
 {
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   std::vector<
     std::pair<
     std::pair< NetworkNode, NetworkNode >
     , NetworkEdge
     >
   > vectorOfEdges;
 
   for ( ; iterator != end; ++iterator)
   {
     NetworkNode sourceNode, targetNode;
     NetworkEdge tempEdge;
 
     // the value of an iterator is a descriptor
     tempEdge = m_Network[ *iterator ];
     sourceNode = m_Network[ boost::source( *iterator, m_Network ) ];
     targetNode = m_Network[ boost::target( *iterator, m_Network ) ];
 
     std::pair< NetworkNode, NetworkNode > nodePair( sourceNode, targetNode );
     std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > edgePair( nodePair, tempEdge);
     vectorOfEdges.push_back( edgePair );
   }
 
   return vectorOfEdges;
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfVertices() const
 {
   return boost::num_vertices( m_Network );
 }
 
-int mitk::ConnectomicsNetwork::GetNumberOfEdges()
+int mitk::ConnectomicsNetwork::GetNumberOfEdges() const
 {
   return boost::num_edges( m_Network );
 }
 
 int mitk::ConnectomicsNetwork::GetMaximumWeight() const
 {
   int maxWeight( 0 );
 
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   for ( ; iterator != end; ++iterator)
   {
     int tempWeight;
 
     // the value of an iterator is a descriptor
     tempWeight = m_Network[ *iterator ].weight;
 
     if( tempWeight > maxWeight )
     {
       maxWeight = tempWeight;
     }
   }
 
   return maxWeight;
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfSelfLoops()
 {
   int noOfSelfLoops( 0 );
 
   std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > >
     edgeVector =  GetVectorOfAllEdges();
 
   for( int index = 0; index < edgeVector.size() ; index++ )
   {
     double sourceX, sourceY, sourceZ, targetX, targetY, targetZ;
 
     sourceX = edgeVector[ index ].first.first.coordinates[0] ;
     sourceY = edgeVector[ index ].first.first.coordinates[1] ;
     sourceZ = edgeVector[ index ].first.first.coordinates[2] ;
     targetX = edgeVector[ index ].first.second.coordinates[0] ;
     targetY = edgeVector[ index ].first.second.coordinates[1] ;
     targetZ = edgeVector[ index ].first.second.coordinates[2] ;
 
     // if the coordinates are the same
     if(
       sourceX > ( targetX - 0.01 ) &&
       sourceX < ( targetX + 0.01 ) &&
       sourceY > ( targetY - 0.01 ) &&
       sourceY < ( targetY + 0.01 ) &&
       sourceZ > ( targetZ - 0.01 ) &&
       sourceZ < ( targetZ + 0.01 )
       )
     {
       noOfSelfLoops++;
     }
   }
 
   return noOfSelfLoops;
 }
 
 double mitk::ConnectomicsNetwork::GetAverageDegree()
 {
   double vertices = (double) GetNumberOfVertices();
   double edges = (double) GetNumberOfEdges();
 
   return ( ( edges * 2.0 ) / vertices );
 }
 
 double mitk::ConnectomicsNetwork::GetConnectionDensity()
 {
   double vertices = (double) GetNumberOfVertices();
   double edges = (double) GetNumberOfEdges();
   double numberOfPossibleEdges = vertices * ( vertices - 1 ) / 2 ;
 
   return ( edges / numberOfPossibleEdges );
 }
 
 std::vector< int > mitk::ConnectomicsNetwork::GetDegreeOfNodes( ) const
 {
   std::vector< int > vectorOfDegree;
 
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie( iterator, end ) = boost::vertices( m_Network );
 
   vectorOfDegree.resize( this->GetNumberOfVertices() );
 
   for ( ; iterator != end; ++iterator)
   {
     // the value of an iterator is a descriptor
     vectorOfDegree[ m_Network[ *iterator ].id ] = GetVectorOfAdjacentNodes( *iterator ).size();
   }
   return vectorOfDegree;
 }
 
 std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
 mitk::ConnectomicsNetwork::GetVectorOfAdjacentNodes( mitk::ConnectomicsNetwork::VertexDescriptorType vertex ) const
 {
   std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType > vectorOfAdjacentNodes;
 
   boost::graph_traits<NetworkType>::adjacency_iterator adjIter, adjEnd;
 
   boost::tie( adjIter, adjEnd ) = boost::adjacent_vertices( vertex, m_Network);
 
   for ( ; adjIter != adjEnd; ++adjIter)
   {
     vectorOfAdjacentNodes.push_back( *adjIter );
   }
 
   return vectorOfAdjacentNodes;
 }
 
 int mitk::ConnectomicsNetwork::GetMaximumDegree() const
 {
   int maximumDegree( 0 );
 
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
 
   for( int index( 0 ); index < vectorOfDegree.size(); ++index )
   {
     if( maximumDegree < vectorOfDegree[ index ] )
     {
       maximumDegree = vectorOfDegree[ index ];
     }
   }
 
   return maximumDegree;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetLocalClusteringCoefficients( ) const
 {
   std::vector< double > vectorOfClusteringCoefficients;
 
   typedef boost::graph_traits<NetworkType>::vertex_iterator vertexIter;
 
   vectorOfClusteringCoefficients.resize( this->GetNumberOfVertices() );
 
   std::pair<vertexIter, vertexIter> vertexPair;
 
   //for every vertex calculate the clustering coefficient
   for (vertexPair = vertices(m_Network); vertexPair.first != vertexPair.second; ++vertexPair.first)
   {
     vectorOfClusteringCoefficients[ m_Network[ *vertexPair.first ].id ] =
       boost::clustering_coefficient(m_Network,*vertexPair.first) ;
   }
 
   return vectorOfClusteringCoefficients;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetClusteringCoefficientsByDegree( )
 {
   std::vector< double > vectorOfClusteringCoefficients = GetLocalClusteringCoefficients();
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
 
   std::vector< double > vectorOfClusteringCoefficientsByDegree;
   vectorOfClusteringCoefficientsByDegree.resize( GetMaximumDegree() + 1, 0 );
 
   // c_{mean}(k) = frac{1}_{N_{k}} sum_{i in Y(k)} c_{i}
   // where N_{k} is the number of vertices of degree k
   // Y(k) is the set of vertices of degree k
   // c_{i} is the local clustering coefficient of vertex i
   for( int degree( 0 ); degree < vectorOfClusteringCoefficientsByDegree.size(); ++degree )
   {
     vectorOfClusteringCoefficientsByDegree[ degree ] = 0;
     int n_k( 0 );
     for( int index( 0 ); index < vectorOfDegree.size(); ++index )
     {
       if( degree == vectorOfDegree[ index ] )
       {// if in Y( degree )
         vectorOfClusteringCoefficientsByDegree[ degree ] += vectorOfClusteringCoefficients[ index ];
         n_k++;
       }
     }
     if( n_k != 0 )
     {
       vectorOfClusteringCoefficientsByDegree[ degree ] =
         vectorOfClusteringCoefficientsByDegree[ degree ] / n_k;
     }
   }
 
   return vectorOfClusteringCoefficientsByDegree;
 }
 
 double mitk::ConnectomicsNetwork::GetGlobalClusteringCoefficient( )
 {
   double globalClusteringCoefficient( 0.0 );
 
   std::vector< double > vectorOfClusteringCoefficientsByDegree = GetClusteringCoefficientsByDegree();
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
   std::vector< int > degreeDistribution;
   degreeDistribution.resize( vectorOfClusteringCoefficientsByDegree.size(), 0 );
 
   int normalizationParameter( 0 );
 
   for( int index( 0 ); index < vectorOfDegree.size(); ++index )
   {
     degreeDistribution[ vectorOfDegree[ index ] ]++;
     normalizationParameter++;
   }
   // c_{mean} = sum_{k} P_{k} c_{mean}(k)
   // where P_{k} is the degree distribution
   // k is the degree
   for( int degree( 0 ); degree < degreeDistribution.size(); ++degree )
   {
     globalClusteringCoefficient +=
       degreeDistribution[ degree ] / ( (double) normalizationParameter)
       * vectorOfClusteringCoefficientsByDegree[ degree ];
   }
 
   return globalClusteringCoefficient;
 }
 
 mitk::ConnectomicsNetwork::NetworkType* mitk::ConnectomicsNetwork::GetBoostGraph()
 {
   return &m_Network;
 }
 
 
 bool mitk::ConnectomicsNetwork::GetIsModified() const
 {
   return m_IsModified;
 }
 
 
 void mitk::ConnectomicsNetwork::SetIsModified( bool value)
 {
   m_IsModified = value;
 }
 
 
 mitk::ConnectomicsNetwork::NetworkNode mitk::ConnectomicsNetwork::GetNode( VertexDescriptorType vertex ) const
 {
   return m_Network[ vertex ];
 }
 
 
 mitk::ConnectomicsNetwork::NetworkEdge mitk::ConnectomicsNetwork::GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const
 {
   return m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ];
 }
 
 void mitk::ConnectomicsNetwork::UpdateBounds( )
 {
   float min = itk::NumericTraits<float>::min();
   float max = itk::NumericTraits<float>::max();
   float bounds[] = {max, min, max, min, max, min};
 
   std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = this->GetVectorOfAllNodes();
 
   if( nodeVector.size() == 0 )
   {
     bounds[0] = 0;
     bounds[1] = 1;
     bounds[2] = 0;
     bounds[3] = 1;
     bounds[4] = 0;
     bounds[5] = 1;
   }
 
   // for each direction, make certain the point is in between
   for( int index(0), end(nodeVector.size()) ; index < end; index++ )
   {
     for( int direction(0); direction < nodeVector.at( index ).coordinates.size(); direction++ )
     {
       if( nodeVector.at( index ).coordinates.at(direction) < bounds[ 2 * direction ]  )
       {
         bounds[ 2 * direction ] = nodeVector.at( index ).coordinates.at(direction);
       }
 
       if( nodeVector.at( index ).coordinates.at(direction) > bounds[ 2 * direction + 1]  )
       {
         bounds[ 2 * direction + 1] = nodeVector.at( index ).coordinates.at(direction);
       }
     }
   }
 
 
   // provide some border margin
   for(int i=0; i<=4; i+=2)
   {
     bounds[i] -=10;
   }
 
   for(int i=1; i<=5; i+=2)
   {
     bounds[i] +=10;
   }
 
   this->GetGeometry()->SetFloatBounds(bounds);
   this->GetTimeSlicedGeometry()->UpdateInformation();
 }
 
 void mitk::ConnectomicsNetwork::PruneUnconnectedSingleNodes()
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // set to true if iterators are invalidated by deleting a vertex
   bool vertexHasBeenRemoved( true );
 
   // if no vertex has been removed in the last loop, we are done
   while( vertexHasBeenRemoved )
   {
     vertexHasBeenRemoved = false;
     // sets iterator to start and end to end
     boost::tie(iterator, end) = boost::vertices( m_Network );
 
     for ( ; iterator != end && !vertexHasBeenRemoved; ++iterator)
     {
       // If the node has no adjacent vertices it should be deleted
       if( GetVectorOfAdjacentNodes( *iterator ).size() == 0 )
       {
         vertexHasBeenRemoved = true;
         // this invalidates all iterators
         boost::remove_vertex( *iterator, m_Network );
       }
     }
   }
 
   UpdateIDs();
 }
 
 void mitk::ConnectomicsNetwork::UpdateIDs()
 {
   boost::graph_traits<NetworkType>::vertex_iterator v_i, v_end;
   boost::graph_traits<NetworkType>::edge_iterator e_i, e_end;
 
   // update node ids
   boost::tie( v_i, v_end ) = boost::vertices( m_Network );
 
   for ( ; v_i != v_end; ++v_i)
   {
     m_Network[*v_i].id = *v_i;
   }
 
   // update edge information
   boost::tie(e_i, e_end) = boost::edges( m_Network );
 
   for ( ; e_i != e_end; ++e_i)
   {
     m_Network[ *e_i ].sourceId = m_Network[ boost::source( *e_i, m_Network ) ].id;
     m_Network[ *e_i ].targetId = m_Network[ boost::target( *e_i, m_Network ) ].id;
   }
   this->SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::PruneEdgesBelowWeight( int targetWeight )
 {
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // set to true if iterators are invalidated by deleting a vertex
   bool edgeHasBeenRemoved( true );
 
   // if no vertex has been removed in the last loop, we are done
   while( edgeHasBeenRemoved )
   {
     edgeHasBeenRemoved = false;
     // sets iterator to start and end to end
     boost::tie(iterator, end) = boost::edges( m_Network );
 
     for ( ; iterator != end && !edgeHasBeenRemoved; ++iterator)
     {
       // If the node has no adjacent edges it should be deleted
       if( m_Network[ *iterator ].weight < targetWeight )
       {
         edgeHasBeenRemoved = true;
         // this invalidates all iterators
         boost::remove_edge( *iterator, m_Network );
       }
     }
   }
 
   // this will remove any nodes which, after deleting edges are now
   // unconnected, also this calls UpdateIDs()
   PruneUnconnectedSingleNodes();
 }
 
-std::vector< double > mitk::ConnectomicsNetwork::GetBetweennessVector() const
+std::vector< double > mitk::ConnectomicsNetwork::GetNodeBetweennessVector() const
 {
   std::vector< double > betweennessVector;
 
   betweennessVector.clear();
   betweennessVector.resize( this->GetNumberOfVertices() );
 
   boost::brandes_betweenness_centrality(
     m_Network,
     boost::centrality_map(
     boost::make_iterator_property_map( betweennessVector.begin(), boost::get( &NetworkNode::id, m_Network ), double() )
     ).vertex_index_map( boost::get( &NetworkNode::id, m_Network ) )
     );
 
   return betweennessVector;
 }
 
+std::vector< double > mitk::ConnectomicsNetwork::GetEdgeBetweennessVector() const
+{
+  // std::map used for convenient initialization
+  typedef std::map<EdgeDescriptorType, int> EdgeIndexStdMap;
+  EdgeIndexStdMap stdEdgeIndex;
+  // associative property map needed for iterator property map-wrapper
+  typedef boost::associative_property_map< EdgeIndexStdMap > EdgeIndexMap;
+  EdgeIndexMap edgeIndex(stdEdgeIndex);
+
+  boost::graph_traits<NetworkType>::edge_iterator iterator, end;
+
+  // sets iterator to start end end to end
+  boost::tie(iterator, end) = boost::edges( m_Network );
+
+  int i(0);
+  for ( ; iterator != end; ++iterator, ++i)
+  {
+    stdEdgeIndex.insert(std::pair< EdgeDescriptorType, int >( *iterator, i));
+  }
+
+  // Define EdgeCentralityMap
+  std::vector< double > edgeBetweennessVector(boost::num_edges( m_Network ), 0.0);
+  // Create the external property map
+  boost::iterator_property_map< std::vector< double >::iterator, EdgeIndexMap >
+    e_centrality_map(edgeBetweennessVector.begin(), edgeIndex);
+
+  // Define VertexCentralityMap
+  typedef boost::property_map< NetworkType, boost::vertex_index_t>::type VertexIndexMap;
+  VertexIndexMap vertexIndex = get(boost::vertex_index, m_Network );
+  std::vector< double > betweennessVector(boost::num_vertices( m_Network ), 0.0);
+  // Create the external property map
+  boost::iterator_property_map< std::vector< double >::iterator, VertexIndexMap >
+    v_centrality_map(betweennessVector.begin(), vertexIndex);
+
+  boost::brandes_betweenness_centrality( m_Network, v_centrality_map, e_centrality_map );
+
+  return edgeBetweennessVector;
+}
+
 std::vector< double > mitk::ConnectomicsNetwork::GetShortestDistanceVectorFromLabel( std::string targetLabel ) const
 {
   std::vector< VertexDescriptorType > predecessorMap( boost::num_vertices( m_Network ) );
   int numberOfNodes( boost::num_vertices( m_Network ) );
 
   std::vector< double > distanceMatrix;
   distanceMatrix.resize( numberOfNodes );
 
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
   {
     ++iterator;
   }
 
   if( iterator == end )
   {
     MITK_WARN << "Label not found";
     return distanceMatrix;
   }
 
   boost::dijkstra_shortest_paths(m_Network, *iterator, boost::predecessor_map(&predecessorMap[ 0 ]).distance_map(&distanceMatrix[ 0 ]).weight_map( boost::get( &NetworkEdge::edge_weight ,m_Network ) ) ) ;
 
   return distanceMatrix;
 }
 
 bool mitk::ConnectomicsNetwork::CheckForLabel( std::string targetLabel ) const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
   {
     ++iterator;
   }
 
   if( iterator == end )
   {
     return false;
   }
 
   return true;
 }
diff --git a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.h b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.h
index 60a0383f8f..0c919e1db8 100644
--- a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.h
+++ b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.h
@@ -1,224 +1,227 @@
 
 /*===================================================================
 
 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_ConnectomicsNetwork_H
 #define _MITK_ConnectomicsNetwork_H
 
 #include "MitkDiffusionImagingExports.h"
 
 #include "mitkBaseData.h"
 
 #include <boost/graph/adjacency_list.hpp>
 
 namespace mitk {
 
   /**
   * \brief Connectomics Network Class
   *
   * This class is designed to represent a connectomics network (brain network). It encapsulates a
   * boost adjacency list and provides additional capabilities. The information contained in the nodes and edges is:
   *
   * Network Node:
   * <ul>
   *  <li> int ID - The id of the node
   *  <li> string label - The label of the node, this can be any string, such as an anatomical label
   *  <li> vector<float> coordinates - The coordinates the node should be displayed at
   * </ul>
   *
   * Network Edge:
   * <ul>
   *  <li> int sourceId - The Id of the source node
   *  <li> int targetId - The Id of the target node
   *  <li> int weight - Weight of the edge as int (used for counting fibers)
   *  <li> double edge_weight - Used for boost and algorithms, should be between 0 and 1
   * </ul>
   */
   class MitkDiffusionImaging_EXPORT ConnectomicsNetwork : public BaseData
   {
   public:
     /** Structs for the graph */
 
     /** The Node */
     struct NetworkNode
     {
       int id;
       std::string label;
       std::vector< float > coordinates;
     };
 
     /** The Edge */
     struct NetworkEdge
     {
       int sourceId;
       int targetId;
       int weight; // For now the number of times it was present
       double edge_weight; // For boost, currently set to 1 by default for unweighted calculations
     };
 
     /** Typedefs **/
     //typedef boost::adjacency_list< boost::listS, boost::listS, boost::undirectedS, NetworkNode, NetworkEdge > NetworkType;
     typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, NetworkNode, NetworkEdge > NetworkType;
     typedef boost::graph_traits<NetworkType>::vertex_descriptor VertexDescriptorType;
     typedef boost::graph_traits<NetworkType>::edge_descriptor EdgeDescriptorType;
 
     // virtual methods that need to be implemented
     virtual void UpdateOutputInformation();
     virtual void SetRequestedRegionToLargestPossibleRegion();
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
     virtual bool VerifyRequestedRegion();
     virtual void SetRequestedRegion( itk::DataObject *data );
 
 
     // Macros
     mitkClassMacro( ConnectomicsNetwork, BaseData );
     itkNewMacro( Self );
 
     ////////////////// Interface ///////////////////
     /** return whether an edge exists between the two given vertices */
     bool EdgeExists( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const;
 
     /** increase the weight of an edge between the two given vertices */
     void IncreaseEdgeWeight( VertexDescriptorType vertexA, VertexDescriptorType vertexB );
 
     /** add an edge between two given vertices */
     void AddEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB);
 
     /** add an edge between two given vertices ( with a specific weight ) */
     void AddEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB, int sourceID, int targetID, int weight = 1 );
 
     /** add a vertex with a specified id */
     VertexDescriptorType AddVertex( int id);
 
     /** set the label of a vertex */
     void SetLabel( VertexDescriptorType vertex, std::string inLabel );
 
     /** set the coordinates of a vertex */
     void SetCoordinates( VertexDescriptorType vertex, std::vector< float > inCoordinates );
 
     /** clear the graph */
     void clear();
 
     /** return the node struct for a given node descriptor */
     NetworkNode GetNode( VertexDescriptorType vertex ) const;
 
     /** return the edge struct for two given node descriptors */
     NetworkEdge GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const;
 
     /** get vector containing all the nodes of the network */
     std::vector< NetworkNode > GetVectorOfAllNodes() const;
 
     /** get vector containing all the vertex descriptors of the network */
     std::vector< VertexDescriptorType > GetVectorOfAllVertexDescriptors() const;
 
     /** get vector containing the descriptors of nodes adjacent to the vertex denoted by the given descriptor  */
     std::vector< VertexDescriptorType > GetVectorOfAdjacentNodes( VertexDescriptorType vertex ) const;
 
     /** get vector containing all the edges of the network and the connected nodes */
     std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > > GetVectorOfAllEdges() const;
 
     /** get overall number of vertices in the network */
     int GetNumberOfVertices() const;
 
     /** get overall number of edges in the network */
-    int GetNumberOfEdges();
+    int GetNumberOfEdges() const;
 
     /** get number of vertices, that are connected to themselves */
     int GetNumberOfSelfLoops();
 
     /** get number of vertices, that are connected to themselves */
     double GetAverageDegree();
 
     /** get number of edges divided by number of possible edges */
     double GetConnectionDensity();
 
     /** Get the maximum weight of all edges */
     int GetMaximumWeight() const;
 
     /** Get a vector in the format vector[ vertexID ] = degree */
     std::vector< int > GetDegreeOfNodes( ) const;
 
     /** Get the maximum degree of all nodes */
     int GetMaximumDegree() const;
 
     /** Get a vector in the format vector[ vertexID ] = clustering coefficient */
     std::vector< double > GetLocalClusteringCoefficients( ) const;
 
     /** Get a vector in the format vector[ degree ] = average clustering coefficient */
     std::vector< double > GetClusteringCoefficientsByDegree( );
 
     /** Get the global clustering coefficient */
     double GetGlobalClusteringCoefficient( );
 
     /** Get the betweenness centrality for each vertex in form of a vector of length (number vertices)*/
-    std::vector< double > GetBetweennessVector() const;
+    std::vector< double > GetNodeBetweennessVector() const;
+
+    /** Get the betweenness centrality for each edge in form of a vector of length (number edges)*/
+    std::vector< double > GetEdgeBetweennessVector() const;
 
     /** Check whether a vertex with the specified label exists*/
     bool CheckForLabel( std::string targetLabel ) const;
 
     /** Get the shortest distance from a specified vertex to all other vertices in form of a vector of length (number vertices)*/
     std::vector< double > GetShortestDistanceVectorFromLabel( std::string targetLabel ) const;
 
     /** Access boost graph directly */
     NetworkType* GetBoostGraph();
 
     /** Get the modified flag */
     bool GetIsModified() const;
 
     /** Set the modified flag */
     void SetIsModified( bool );
 
     /** Update the bounds of the geometry to fit the network */
     void UpdateBounds( );
 
     /** Remove nodes not connected to any other node */
     void PruneUnconnectedSingleNodes();
 
     /** Remove edges below the specified weight
       *
       * targetWeight is the number of connecting fibers
       *
       * This will remove unconnected nodes after removal
       */
     void PruneEdgesBelowWeight( int targetWeight );
 
   protected:
     ConnectomicsNetwork();
     virtual ~ConnectomicsNetwork();
 
     /** This function will relabel all vertices and edges in a continuous manner
       *
       * Mainly important after removing vertices, to make sure that the ids run continuously from
       * 0 to number of vertices - 1 and edge target and source ids match the corresponding node.
       */
     void UpdateIDs();
 
     NetworkType m_Network;
 
     /// Flag which indicates whether the network has been modified since the last check
     ///
     /// mainly for rendering purposes
 
     bool m_IsModified;
 
   private:
 
   };
 
 } // namespace mitk
 
 #endif /*  _MITK_ConnectomicsNetwork_H */
diff --git a/Modules/DiffusionImaging/Rendering/mitkConnectomicsNetworkMapper3D.cpp b/Modules/DiffusionImaging/Rendering/mitkConnectomicsNetworkMapper3D.cpp
index 1e966ebe91..2ad0475379 100644
--- a/Modules/DiffusionImaging/Rendering/mitkConnectomicsNetworkMapper3D.cpp
+++ b/Modules/DiffusionImaging/Rendering/mitkConnectomicsNetworkMapper3D.cpp
@@ -1,620 +1,632 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkConnectomicsNetworkMapper3D.h"
 
 #include <vtkMutableUndirectedGraph.h>
 #include "vtkGraphLayout.h"
 #include <vtkPoints.h>
 #include "vtkGraphToPolyData.h"
 #include <vtkPassThroughLayoutStrategy.h>
 #include "vtkGlyph3D.h"
 #include "vtkGlyphSource2D.h"
 
 #include "mitkConnectomicsRenderingProperties.h"
 #include "mitkConnectomicsRenderingSchemeProperty.h"
 #include "mitkConnectomicsRenderingEdgeFilteringProperty.h"
 #include "mitkConnectomicsRenderingNodeFilteringProperty.h"
 #include "mitkConnectomicsRenderingNodeColorParameterProperty.h"
 #include "mitkConnectomicsRenderingNodeRadiusParameterProperty.h"
 #include "mitkConnectomicsRenderingEdgeColorParameterProperty.h"
 #include "mitkConnectomicsRenderingEdgeRadiusParameterProperty.h"
 #include "mitkConnectomicsRenderingNodeThresholdParameterProperty.h"
 #include "mitkConnectomicsRenderingEdgeThresholdParameterProperty.h"
 
 #include <algorithm>
 
 mitk::ConnectomicsNetworkMapper3D::ConnectomicsNetworkMapper3D()
 {
   m_NetworkAssembly = vtkPropAssembly::New();
 
 }
 
 mitk::ConnectomicsNetworkMapper3D:: ~ConnectomicsNetworkMapper3D()
 {
   m_NetworkAssembly->Delete();
 
 }
 
 void mitk::ConnectomicsNetworkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
   if( this->GetInput() == NULL )
   {
     return;
   }
 
   bool propertiesHaveChanged = this->PropertiesChanged();
 
   if( this->GetInput()->GetIsModified( ) || propertiesHaveChanged )
   {
     GenerateData();
   }
 }
 
 void mitk::ConnectomicsNetworkMapper3D::GenerateData()
 {
   m_NetworkAssembly->Delete();
   m_NetworkAssembly = vtkPropAssembly::New();
 
   // Here is the part where a graph is given and converted to points and connections between points...
   std::vector< mitk::ConnectomicsNetwork::NetworkNode > vectorOfNodes = this->GetInput()->GetVectorOfAllNodes();
   std::vector< std::pair<
     std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode >
     , mitk::ConnectomicsNetwork::NetworkEdge > >  vectorOfEdges = this->GetInput()->GetVectorOfAllEdges();
 
   // Decide on the style of rendering due to property
 
   if( m_ChosenRenderingScheme == connectomicsRenderingMITKScheme )
   {
     mitk::Point3D tempWorldPoint, tempCNFGeometryPoint;
 
     //////////////////////Prepare coloring and radius////////////
 
     std::vector< double > vectorOfNodeRadiusParameterValues;
     vectorOfNodeRadiusParameterValues.resize( vectorOfNodes.size() );
     double maxNodeRadiusParameterValue( FillNodeParameterVector( &vectorOfNodeRadiusParameterValues, m_NodeRadiusParameter ) );
 
     std::vector< double > vectorOfNodeColorParameterValues;
     vectorOfNodeColorParameterValues.resize( vectorOfNodes.size() );
     double maxNodeColorParameterValue( FillNodeParameterVector( &vectorOfNodeColorParameterValues, m_NodeColorParameter ) );
 
     std::vector< double > vectorOfEdgeRadiusParameterValues;
     vectorOfEdgeRadiusParameterValues.resize( vectorOfEdges.size() );
     double maxEdgeRadiusParameterValue( FillEdgeParameterVector( &vectorOfEdgeRadiusParameterValues, m_EdgeRadiusParameter ) );
 
     std::vector< double > vectorOfEdgeColorParameterValues;
     vectorOfEdgeColorParameterValues.resize( vectorOfEdges.size() );
     double maxEdgeColorParameterValue( FillEdgeParameterVector( &vectorOfEdgeColorParameterValues, m_EdgeColorParameter ) );
 
     //////////////////////Create Spheres/////////////////////////
     for(unsigned int i = 0; i < vectorOfNodes.size(); i++)
     {
       vtkSmartPointer<vtkSphereSource> sphereSource =
         vtkSmartPointer<vtkSphereSource>::New();
 
       for(unsigned int dimension = 0; dimension < 3; dimension++)
       {
         tempCNFGeometryPoint.SetElement( dimension , vectorOfNodes[i].coordinates[dimension] );
       }
 
       this->GetData()->GetGeometry()->IndexToWorld( tempCNFGeometryPoint, tempWorldPoint );
 
       sphereSource->SetCenter( tempWorldPoint[0] , tempWorldPoint[1], tempWorldPoint[2] );
 
       // determine radius
       double radiusFactor = vectorOfNodeRadiusParameterValues[i] / maxNodeRadiusParameterValue;
 
       double radius = m_NodeRadiusStart + ( m_NodeRadiusEnd - m_NodeRadiusStart) * radiusFactor;
       sphereSource->SetRadius( radius );
 
       vtkSmartPointer<vtkPolyDataMapper> mapper =
         vtkSmartPointer<vtkPolyDataMapper>::New();
       mapper->SetInput(sphereSource->GetOutput());
 
       vtkSmartPointer<vtkActor> actor =
         vtkSmartPointer<vtkActor>::New();
       actor->SetMapper(mapper);
 
       // determine color
       double colorFactor = vectorOfNodeColorParameterValues[i] / maxNodeColorParameterValue;
 
       double redStart = m_NodeColorStart.GetElement( 0 );
       double greenStart = m_NodeColorStart.GetElement( 1 );
       double blueStart = m_NodeColorStart.GetElement( 2 );
       double redEnd = m_NodeColorEnd.GetElement( 0 );
       double greenEnd = m_NodeColorEnd.GetElement( 1 );
       double blueEnd = m_NodeColorEnd.GetElement( 2 );
 
       double red = redStart + ( redEnd - redStart ) * colorFactor;
       double green = greenStart + ( greenEnd - greenStart ) * colorFactor;
       double blue = blueStart + ( blueEnd - blueStart ) * colorFactor;
 
       actor->GetProperty()->SetColor( red, green, blue);
 
       m_NetworkAssembly->AddPart(actor);
     }
 
     //////////////////////Create Tubes/////////////////////////
 
     double maxWeight = (double) this->GetInput()->GetMaximumWeight();
 
     for(unsigned int i = 0; i < vectorOfEdges.size(); i++)
     {
 
       vtkSmartPointer<vtkLineSource> lineSource =
         vtkSmartPointer<vtkLineSource>::New();
 
       for(unsigned int dimension = 0; dimension < 3; dimension++)
       {
         tempCNFGeometryPoint[ dimension ] = vectorOfEdges[i].first.first.coordinates[dimension];
       }
 
       this->GetData()->GetGeometry()->IndexToWorld( tempCNFGeometryPoint, tempWorldPoint );
 
       lineSource->SetPoint1(tempWorldPoint[0], tempWorldPoint[1],tempWorldPoint[2]  );
 
       for(unsigned int dimension = 0; dimension < 3; dimension++)
       {
         tempCNFGeometryPoint[ dimension ] = vectorOfEdges[i].first.second.coordinates[dimension];
       }
 
       this->GetData()->GetGeometry()->IndexToWorld( tempCNFGeometryPoint, tempWorldPoint );
 
       lineSource->SetPoint2(tempWorldPoint[0], tempWorldPoint[1], tempWorldPoint[2] );
 
       vtkSmartPointer<vtkTubeFilter> tubes = vtkSmartPointer<vtkTubeFilter>::New();
       tubes->SetInput( lineSource->GetOutput() );
       tubes->SetNumberOfSides( 12 );
 
       // determine radius
       double radiusFactor = vectorOfEdgeRadiusParameterValues[i] / maxEdgeRadiusParameterValue;
 
       double radius = m_EdgeRadiusStart + ( m_EdgeRadiusEnd - m_EdgeRadiusStart) * radiusFactor;
       tubes->SetRadius( radius );
 
       // originally we used a logarithmic scaling,
       // double radiusFactor = 1.0 + ((double) vectorOfEdges[i].second.weight) / 10.0 ;
       // tubes->SetRadius( std::log10( radiusFactor ) );
 
       vtkSmartPointer<vtkPolyDataMapper> mapper2 =
         vtkSmartPointer<vtkPolyDataMapper>::New();
       mapper2->SetInput( tubes->GetOutput() );
 
       vtkSmartPointer<vtkActor> actor =
         vtkSmartPointer<vtkActor>::New();
       actor->SetMapper(mapper2);
 
       // determine color
       double colorFactor = vectorOfEdgeColorParameterValues[i] / maxEdgeColorParameterValue;
 
       double redStart = m_EdgeColorStart.GetElement( 0 );
       double greenStart = m_EdgeColorStart.GetElement( 1 );
       double blueStart = m_EdgeColorStart.GetElement( 2 );
       double redEnd = m_EdgeColorEnd.GetElement( 0 );
       double greenEnd = m_EdgeColorEnd.GetElement( 1 );
       double blueEnd = m_EdgeColorEnd.GetElement( 2 );
 
       double red = redStart + ( redEnd - redStart ) * colorFactor;
       double green = greenStart + ( greenEnd - greenStart ) * colorFactor;
       double blue = blueStart + ( blueEnd - blueStart ) * colorFactor;
 
       actor->GetProperty()->SetColor( red, green, blue);
 
       m_NetworkAssembly->AddPart(actor);
 
     }
   }
   else if( m_ChosenRenderingScheme == connectomicsRenderingVTKScheme )
   {
     vtkSmartPointer<vtkMutableUndirectedGraph> graph =
       vtkSmartPointer<vtkMutableUndirectedGraph>::New();
 
     std::vector< vtkIdType > networkToVTKvector;
     networkToVTKvector.resize(vectorOfNodes.size());
 
     for(unsigned int i = 0; i < vectorOfNodes.size(); i++)
     {
       networkToVTKvector[vectorOfNodes[i].id] = graph->AddVertex();
     }
 
     for(unsigned int i = 0; i < vectorOfEdges.size(); i++)
     {
       graph->AddEdge(networkToVTKvector[vectorOfEdges[i].first.first.id], networkToVTKvector[vectorOfEdges[i].first.second.id]);
     }
 
     vtkSmartPointer<vtkPoints> points =
       vtkSmartPointer<vtkPoints>::New();
     for(unsigned int i = 0; i < vectorOfNodes.size(); i++)
     {
       double x = vectorOfNodes[i].coordinates[0];
       double y = vectorOfNodes[i].coordinates[1];
       double z = vectorOfNodes[i].coordinates[2];
       points->InsertNextPoint( x, y, z);
     }
 
     graph->SetPoints(points);
 
     vtkGraphLayout* layout = vtkGraphLayout::New();
     layout->SetInput(graph);
     layout->SetLayoutStrategy(vtkPassThroughLayoutStrategy::New());
 
     vtkGraphToPolyData* graphToPoly = vtkGraphToPolyData::New();
     graphToPoly->SetInputConnection(layout->GetOutputPort());
 
     // Create the standard VTK polydata mapper and actor
     // for the connections (edges) in the tree.
     vtkPolyDataMapper* edgeMapper = vtkPolyDataMapper::New();
     edgeMapper->SetInputConnection(graphToPoly->GetOutputPort());
     vtkActor* edgeActor = vtkActor::New();
     edgeActor->SetMapper(edgeMapper);
     edgeActor->GetProperty()->SetColor(0.0, 0.5, 1.0);
 
     // Glyph the points of the tree polydata to create
     // VTK_VERTEX cells at each vertex in the tree.
     vtkGlyph3D* vertGlyph = vtkGlyph3D::New();
     vertGlyph->SetInputConnection(0, graphToPoly->GetOutputPort());
     vtkGlyphSource2D* glyphSource = vtkGlyphSource2D::New();
     glyphSource->SetGlyphTypeToVertex();
     vertGlyph->SetInputConnection(1, glyphSource->GetOutputPort());
 
     // Create a mapper for the vertices, and tell the mapper
     // to use the specified color array.
     vtkPolyDataMapper* vertMapper = vtkPolyDataMapper::New();
     vertMapper->SetInputConnection(vertGlyph->GetOutputPort());
     /*if (colorArray)
     {
     vertMapper->SetScalarModeToUsePointFieldData();
     vertMapper->SelectColorArray(colorArray);
     vertMapper->SetScalarRange(colorRange);
     }*/
 
     // Create an actor for the vertices.  Move the actor forward
     // in the z direction so it is drawn on top of the edge actor.
     vtkActor* vertActor = vtkActor::New();
     vertActor->SetMapper(vertMapper);
     vertActor->GetProperty()->SetPointSize(5);
     vertActor->SetPosition(0, 0, 0.001);
 
     m_NetworkAssembly->AddPart(edgeActor);
     m_NetworkAssembly->AddPart(vertActor);
   }
 
   (static_cast<mitk::ConnectomicsNetwork * > ( GetData() ) )->SetIsModified( false );
 }
 
 const mitk::ConnectomicsNetwork* mitk::ConnectomicsNetworkMapper3D::GetInput()
 {
 
   return static_cast<const mitk::ConnectomicsNetwork * > ( GetData() );
 }
 
 void mitk::ConnectomicsNetworkMapper3D::SetDefaultProperties(DataNode* node, BaseRenderer* renderer , bool overwrite)
 {
   // Initialize enumeration properties
 
   mitk::ConnectomicsRenderingSchemeProperty::Pointer connectomicsRenderingScheme =
     mitk::ConnectomicsRenderingSchemeProperty::New();
   mitk::ConnectomicsRenderingEdgeFilteringProperty::Pointer connectomicsRenderingEdgeFiltering =
     mitk::ConnectomicsRenderingEdgeFilteringProperty::New();
   mitk::ConnectomicsRenderingNodeFilteringProperty::Pointer connectomicsRenderingNodeFiltering =
      mitk::ConnectomicsRenderingNodeFilteringProperty::New();
 
    mitk::ConnectomicsRenderingNodeColorParameterProperty::Pointer  connectomicsRenderingNodeGradientColorParameter =
     mitk::ConnectomicsRenderingNodeColorParameterProperty::New();
   mitk::ConnectomicsRenderingNodeRadiusParameterProperty::Pointer connectomicsRenderingNodeRadiusParameter =
     mitk::ConnectomicsRenderingNodeRadiusParameterProperty::New();
   mitk::ConnectomicsRenderingEdgeColorParameterProperty::Pointer connectomicsRenderingEdgeGradientColorParameter =
     mitk::ConnectomicsRenderingEdgeColorParameterProperty::New();
   mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::Pointer connectomicsRenderingEdgeRadiusParameter =
     mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::New();
 
   mitk::ConnectomicsRenderingNodeThresholdParameterProperty::Pointer connectomicsRenderingNodeThresholdParameter =
     mitk::ConnectomicsRenderingNodeThresholdParameterProperty::New();
   mitk::ConnectomicsRenderingEdgeThresholdParameterProperty::Pointer connectomicsRenderingEdgeThresholdParameter =
     mitk::ConnectomicsRenderingEdgeThresholdParameterProperty::New();
 
   // set the properties
   node->AddProperty( connectomicsRenderingSchemePropertyName.c_str(),
     connectomicsRenderingScheme, renderer, overwrite );
 
   node->AddProperty( connectomicsRenderingEdgeFilteringPropertyName.c_str(),
     connectomicsRenderingEdgeFiltering, renderer, overwrite );
   node->AddProperty( connectomicsRenderingEdgeThresholdFilterParameterName.c_str(),
     connectomicsRenderingEdgeThresholdParameter, renderer, overwrite );
   node->AddProperty( connectomicsRenderingEdgeThresholdFilterThresholdName.c_str(),
     connectomicsRenderingEdgeThresholdFilterThresholdDefault, renderer, overwrite );
 
   node->AddProperty( connectomicsRenderingNodeFilteringPropertyName.c_str(),
     connectomicsRenderingNodeFiltering, renderer, overwrite );
   node->AddProperty( connectomicsRenderingNodeThresholdFilterParameterName.c_str(),
     connectomicsRenderingNodeThresholdParameter, renderer, overwrite );
   node->AddProperty( connectomicsRenderingNodeThresholdFilterThresholdName.c_str(),
     connectomicsRenderingNodeThresholdFilterThresholdDefault, renderer, overwrite );
 
   node->AddProperty( connectomicsRenderingNodeGradientStartColorName.c_str(),
     connectomicsRenderingNodeGradientStartColorDefault, renderer, overwrite );
   node->AddProperty( connectomicsRenderingNodeGradientEndColorName.c_str(),
     connectomicsRenderingNodeGradientEndColorDefault, renderer, overwrite );
   node->AddProperty( connectomicsRenderingNodeGradientColorParameterName.c_str(),
     connectomicsRenderingNodeGradientColorParameter, renderer, overwrite );
 
   node->AddProperty( connectomicsRenderingNodeRadiusStartName.c_str(),
     connectomicsRenderingNodeRadiusStartDefault, renderer, overwrite );
   node->AddProperty( connectomicsRenderingNodeRadiusEndName.c_str(),
     connectomicsRenderingNodeRadiusEndDefault, renderer, overwrite );
   node->AddProperty( connectomicsRenderingNodeRadiusParameterName.c_str(),
     connectomicsRenderingNodeRadiusParameter, renderer, overwrite );
 
   node->AddProperty( connectomicsRenderingNodeChosenNodeName.c_str(),
     connectomicsRenderingNodeChosenNodeDefault, renderer, overwrite );
 
   node->AddProperty( connectomicsRenderingEdgeGradientStartColorName.c_str(),
     connectomicsRenderingEdgeGradientStartColorDefault, renderer, overwrite );
   node->AddProperty( connectomicsRenderingEdgeGradientEndColorName.c_str(),
     connectomicsRenderingEdgeGradientEndColorDefault, renderer, overwrite );
   node->AddProperty( connectomicsRenderingEdgeGradientColorParameterName.c_str(),
     connectomicsRenderingEdgeGradientColorParameter, renderer, overwrite );
 
   node->AddProperty( connectomicsRenderingEdgeRadiusStartName.c_str(),
     connectomicsRenderingEdgeRadiusStartDefault, renderer, overwrite );
   node->AddProperty( connectomicsRenderingEdgeRadiusEndName.c_str(),
     connectomicsRenderingEdgeRadiusEndDefault, renderer, overwrite );
   node->AddProperty( connectomicsRenderingEdgeRadiusParameterName.c_str(),
     connectomicsRenderingEdgeRadiusParameter, renderer, overwrite );
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 void mitk::ConnectomicsNetworkMapper3D::ApplyProperties(mitk::BaseRenderer* renderer)
 {
   //TODO: implement
 
 }
 
 void mitk::ConnectomicsNetworkMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *mapper)
 {
   //TODO: implement
 
 }
 
 void mitk::ConnectomicsNetworkMapper3D::UpdateVtkObjects()
 {
   //TODO: implement
 }
 
 vtkProp* mitk::ConnectomicsNetworkMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
 
   return m_NetworkAssembly;
 
 }
 
 bool mitk::ConnectomicsNetworkMapper3D::PropertiesChanged()
 {
   mitk::ConnectomicsRenderingSchemeProperty * renderingScheme =
     static_cast< mitk::ConnectomicsRenderingSchemeProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingSchemePropertyName.c_str() ) );
   mitk::ConnectomicsRenderingEdgeFilteringProperty * edgeFilter =
     static_cast< mitk::ConnectomicsRenderingEdgeFilteringProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingEdgeFilteringPropertyName.c_str() ) );
   mitk::FloatProperty * edgeThreshold = static_cast< mitk::FloatProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingEdgeThresholdFilterThresholdName.c_str() ) );
   mitk::ConnectomicsRenderingNodeFilteringProperty * nodeFilter =
     static_cast< mitk::ConnectomicsRenderingNodeFilteringProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeFilteringPropertyName.c_str() ) );
   mitk::FloatProperty * nodeThreshold = static_cast< mitk::FloatProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeThresholdFilterThresholdName.c_str() ) );
   mitk::ColorProperty * nodeColorStart = static_cast< mitk::ColorProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeGradientStartColorName.c_str() ) );
   mitk::ColorProperty * nodeColorEnd = static_cast< mitk::ColorProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeGradientEndColorName.c_str() ) );
   mitk::FloatProperty * nodeRadiusStart = static_cast< mitk::FloatProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeRadiusStartName.c_str() ) );
   mitk::FloatProperty * nodeRadiusEnd = static_cast< mitk::FloatProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeRadiusEndName.c_str() ) );
   mitk::StringProperty * chosenNode = static_cast< mitk::StringProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeChosenNodeName.c_str() ) );
   mitk::ColorProperty * edgeColorStart = static_cast< mitk::ColorProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingEdgeGradientStartColorName.c_str() ) );
   mitk::ColorProperty * edgeColorEnd  = static_cast< mitk::ColorProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingEdgeGradientEndColorName.c_str() ) );
   mitk::FloatProperty * edgeRadiusStart = static_cast< mitk::FloatProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingEdgeRadiusStartName.c_str() ) );
   mitk::FloatProperty * edgeRadiusEnd = static_cast< mitk::FloatProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingEdgeRadiusEndName.c_str() ) );
   mitk::ConnectomicsRenderingNodeColorParameterProperty *  nodeColorParameter =
     static_cast< mitk::ConnectomicsRenderingNodeColorParameterProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeGradientColorParameterName.c_str() ) );
   mitk::ConnectomicsRenderingNodeRadiusParameterProperty * nodeRadiusParameter =
     static_cast< mitk::ConnectomicsRenderingNodeRadiusParameterProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingNodeRadiusParameterName.c_str() ) );
   mitk::ConnectomicsRenderingEdgeColorParameterProperty * edgeColorParameter =
     static_cast< mitk::ConnectomicsRenderingEdgeColorParameterProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingEdgeGradientColorParameterName.c_str() ) );
   mitk::ConnectomicsRenderingEdgeRadiusParameterProperty * edgeRadiusParameter =
     static_cast< mitk::ConnectomicsRenderingEdgeRadiusParameterProperty * > (
     this->GetDataNode()->GetProperty( connectomicsRenderingEdgeRadiusParameterName.c_str() ) );
 
   if(
     m_ChosenRenderingScheme != renderingScheme->GetValueAsString() ||
     m_ChosenEdgeFilter != edgeFilter->GetValueAsString() ||
     m_EdgeThreshold != edgeThreshold->GetValue() ||
     m_ChosenNodeFilter != nodeFilter->GetValueAsString() ||
     m_NodeThreshold != nodeThreshold->GetValue() ||
     m_NodeColorStart != nodeColorStart->GetValue() ||
     m_NodeColorEnd != nodeColorEnd->GetValue() ||
     m_NodeRadiusStart != nodeRadiusStart->GetValue() ||
     m_NodeRadiusEnd != nodeRadiusEnd->GetValue() ||
     m_ChosenNodeLabel != chosenNode->GetValueAsString() ||
     m_EdgeColorStart != edgeColorStart->GetValue() ||
     m_EdgeColorEnd != edgeColorEnd->GetValue() ||
     m_EdgeRadiusStart != edgeRadiusStart->GetValue() ||
     m_EdgeRadiusEnd != edgeRadiusEnd->GetValue() ||
     m_NodeColorParameter != nodeColorParameter->GetValueAsString() ||
     m_NodeRadiusParameter != nodeRadiusParameter->GetValueAsString() ||
     m_EdgeColorParameter != edgeColorParameter->GetValueAsString() ||
     m_EdgeRadiusParameter != edgeRadiusParameter->GetValueAsString()
     )
   {
     m_ChosenRenderingScheme = renderingScheme->GetValueAsString();
     m_ChosenEdgeFilter = edgeFilter->GetValueAsString();
     m_EdgeThreshold = edgeThreshold->GetValue();
     m_ChosenNodeFilter = nodeFilter->GetValueAsString();
     m_NodeThreshold = nodeThreshold->GetValue();
     m_NodeColorStart = nodeColorStart->GetValue();
     m_NodeColorEnd = nodeColorEnd->GetValue();
     m_NodeRadiusStart = nodeRadiusStart->GetValue();
     m_NodeRadiusEnd = nodeRadiusEnd->GetValue();
     m_ChosenNodeLabel = chosenNode->GetValueAsString();
     m_EdgeColorStart = edgeColorStart->GetValue();
     m_EdgeColorEnd = edgeColorEnd->GetValue();
     m_EdgeRadiusStart = edgeRadiusStart->GetValue();
     m_EdgeRadiusEnd = edgeRadiusEnd->GetValue();
     m_NodeColorParameter = nodeColorParameter->GetValueAsString();
     m_NodeRadiusParameter = nodeRadiusParameter->GetValueAsString();
     m_EdgeColorParameter = edgeColorParameter->GetValueAsString();
     m_EdgeRadiusParameter = edgeRadiusParameter->GetValueAsString();
 
     return true;
   }
 
   return false;
 
 }
 
 double mitk::ConnectomicsNetworkMapper3D::FillNodeParameterVector( std::vector< double > * parameterVector, std::string parameterName )
 {
   int end( parameterVector->size() );
 
   // constant parameter - uniform style
   if( parameterName == connectomicsRenderingNodeParameterConstant )
   {
     for(int index(0); index < end; index++)
     {
       parameterVector->at( index ) = 1.0;
     }
     return 1.0;
   }
 
   double maximum( 0.0 );
 
   // using the degree as parameter
   if( parameterName == connectomicsRenderingNodeParameterDegree )
   {
     std::vector< int > vectorOfDegree = this->GetInput()->GetDegreeOfNodes();
     for(int index(0); index < end; index++)
     {
       parameterVector->at( index ) = vectorOfDegree[ index ];
     }
 
     maximum = *std::max_element( parameterVector->begin(), parameterVector->end() );
   }
 
   // using betweenness centrality as parameter
   if( parameterName == connectomicsRenderingNodeParameterBetweenness )
   {
-    std::vector< double > vectorOfBetweenness = this->GetInput()->GetBetweennessVector();
+    std::vector< double > vectorOfBetweenness = this->GetInput()->GetNodeBetweennessVector();
     for(int index(0); index < end; index++)
     {
       parameterVector->at( index ) = vectorOfBetweenness[index];
     }
     maximum = *std::max_element( parameterVector->begin(), parameterVector->end() );
   }
 
   // using clustering coefficient as parameter
   if( parameterName == connectomicsRenderingNodeParameterClustering )
   {
     const std::vector< double > vectorOfClustering = this->GetInput()->GetLocalClusteringCoefficients();
     for(int index(0); index < end; index++)
     {
       parameterVector->at( index ) = vectorOfClustering[index];
     }
     maximum = *std::max_element( parameterVector->begin(), parameterVector->end() );
   }
 
   // using distance to a specific node as parameter
   if( parameterName == connectomicsRenderingNodeParameterColoringShortestPath )
   {
     bool labelFound( this->GetInput()->CheckForLabel( m_ChosenNodeLabel ) );
     // check whether the chosen node is valid
     if( !labelFound )
     {
       MITK_WARN << "Node chosen for rendering is not valid.";
       for(int index(0); index < end; index++)
       {
         parameterVector->at( index ) = 1.0;
       }
       return 1.0;
     }
     else
     {
       const std::vector< double > distanceVector = this->GetInput()->GetShortestDistanceVectorFromLabel( m_ChosenNodeLabel );
       for(int index(0); index < end; index++)
       {
         parameterVector->at( index ) = distanceVector[index];
       }
       maximum = *std::max_element( parameterVector->begin(), parameterVector->end() );
     }
   }
 
   // if the maximum is nearly zero
   if( std::abs( maximum ) < mitk::eps )
   {
     maximum = 1.0;
   }
 
   return maximum;
 }
 
 double mitk::ConnectomicsNetworkMapper3D::FillEdgeParameterVector( std::vector< double > * parameterVector, std::string parameterName )
 {
     int end( parameterVector->size() );
 
   // constant parameter - uniform style
   if( parameterName == connectomicsRenderingEdgeParameterConstant )
   {
     for(int index(0); index < end; index++)
     {
       parameterVector->at( index ) = 1.0;
     }
     return 1.0;
   }
 
   double maximum( 0.0 );
 
   // using the weight as parameter
   if( parameterName == connectomicsRenderingEdgeParameterWeight )
   {
     std::vector< std::pair<
       std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode >
       , mitk::ConnectomicsNetwork::NetworkEdge > >  vectorOfEdges = this->GetInput()->GetVectorOfAllEdges();
 
     for(int index(0); index < end; index++)
     {
       parameterVector->at( index ) = vectorOfEdges[ index ].second.weight;
     }
 
     maximum = *std::max_element( parameterVector->begin(), parameterVector->end() );
   }
 
+  // using the edge centrality as parameter
+  if( parameterName == connectomicsRenderingEdgeParameterCentrality )
+  {
+    const std::vector< double > vectorOfCentrality = this->GetInput()->GetEdgeBetweennessVector();
+    for(int index(0); index < end; index++)
+    {
+      parameterVector->at( index ) = vectorOfCentrality[index];
+    }
+
+    maximum = *std::max_element( parameterVector->begin(), parameterVector->end() );
+  }
+
   // if the maximum is nearly zero
   if( std::abs( maximum ) < mitk::eps )
   {
     maximum = 1.0;
   }
 
   return maximum;
 }
diff --git a/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingEdgeColorParameterProperty.cpp b/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingEdgeColorParameterProperty.cpp
index 518426ec63..8dc1881b2b 100644
--- a/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingEdgeColorParameterProperty.cpp
+++ b/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingEdgeColorParameterProperty.cpp
@@ -1,68 +1,70 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkConnectomicsRenderingEdgeColorParameterProperty.h"
 #include "mitkConnectomicsRenderingProperties.h"
 
 #define EDGE_COLOR_CONSTANT 0
 #define EDGE_COLOR_WEIGHT 1
+#define EDGE_COLOR_CENTRALITY 2
 
 mitk::ConnectomicsRenderingEdgeColorParameterProperty::ConnectomicsRenderingEdgeColorParameterProperty( )
 {
   AddRenderingEdgeColorParameters();
   SetValue( EDGE_COLOR_CONSTANT );
 }
 
 
 mitk::ConnectomicsRenderingEdgeColorParameterProperty::ConnectomicsRenderingEdgeColorParameterProperty( const IdType& value )
 {
   AddRenderingEdgeColorParameters();
   if ( IsValidEnumerationValue( value ) )
   {
     SetValue( value ) ;
   }
   else
   {
     SetValue( EDGE_COLOR_CONSTANT );
   }
 }
 
 mitk::ConnectomicsRenderingEdgeColorParameterProperty::ConnectomicsRenderingEdgeColorParameterProperty( const std::string& value )
 {
   AddRenderingEdgeColorParameters();
   if ( IsValidEnumerationValue( value ) )
   {
     SetValue( value );
   }
   else
   {
     SetValue( EDGE_COLOR_CONSTANT );
   }
 }
 
 
 
 void mitk::ConnectomicsRenderingEdgeColorParameterProperty::AddRenderingEdgeColorParameters()
 {
   AddEnum( connectomicsRenderingEdgeParameterConstant , EDGE_COLOR_CONSTANT );
   AddEnum( connectomicsRenderingEdgeParameterWeight , EDGE_COLOR_WEIGHT );
+  AddEnum( connectomicsRenderingEdgeParameterCentrality , EDGE_COLOR_CENTRALITY );
 }
 
 
 bool mitk::ConnectomicsRenderingEdgeColorParameterProperty::AddEnum( const std::string& name, const IdType& id )
 {
   return Superclass::AddEnum( name, id );
 }
diff --git a/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingEdgeRadiusParameterProperty.cpp b/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingEdgeRadiusParameterProperty.cpp
index 2215ea8546..c71385669a 100644
--- a/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingEdgeRadiusParameterProperty.cpp
+++ b/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingEdgeRadiusParameterProperty.cpp
@@ -1,68 +1,70 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkConnectomicsRenderingEdgeRadiusParameterProperty.h"
 #include "mitkConnectomicsRenderingProperties.h"
 
 #define EDGE_RADIUS_CONSTANT 0
 #define EDGE_RADIUS_WEIGHT 1
+#define EDGE_RADIUS_CENTRALITY 2
 
 mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::ConnectomicsRenderingEdgeRadiusParameterProperty( )
 {
   AddRenderingEdgeRadiusParameters();
   SetValue( EDGE_RADIUS_CONSTANT );
 }
 
 
 mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::ConnectomicsRenderingEdgeRadiusParameterProperty( const IdType& value )
 {
   AddRenderingEdgeRadiusParameters();
   if ( IsValidEnumerationValue( value ) )
   {
     SetValue( value ) ;
   }
   else
   {
     SetValue( EDGE_RADIUS_CONSTANT );
   }
 }
 
 mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::ConnectomicsRenderingEdgeRadiusParameterProperty( const std::string& value )
 {
   AddRenderingEdgeRadiusParameters();
   if ( IsValidEnumerationValue( value ) )
   {
     SetValue( value );
   }
   else
   {
     SetValue( EDGE_RADIUS_CONSTANT );
   }
 }
 
 
 
 void mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::AddRenderingEdgeRadiusParameters()
 {
   AddEnum( connectomicsRenderingEdgeParameterConstant , EDGE_RADIUS_CONSTANT );
   AddEnum( connectomicsRenderingEdgeParameterWeight , EDGE_RADIUS_WEIGHT );
+  AddEnum( connectomicsRenderingEdgeParameterCentrality , EDGE_RADIUS_CENTRALITY );
 }
 
 
 bool mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::AddEnum( const std::string& name, const IdType& id )
 {
   return Superclass::AddEnum( name, id );
 }
diff --git a/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingProperties.h b/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingProperties.h
index 41de729339..1ac8e5d82b 100644
--- a/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingProperties.h
+++ b/Modules/DiffusionImaging/Rendering/mitkConnectomicsRenderingProperties.h
@@ -1,323 +1,328 @@
 /*===================================================================
 
 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 ConnectomicsRenderingProperties_H_HEADER_INCLUDED
 #define ConnectomicsRenderingProperties_H_HEADER_INCLUDED
 
 #include <string.h>
 #include "mitkproperties.h"
 #include "mitkStringProperty.h"
 #include "mitkEnumerationProperty.h"
 #include "mitkColorProperty.h"
 
 namespace mitk {
 
   /** \file mitkConnectomicsRenderingProperties.h
    * \brief This file defines the rendering properties available for connectomics networks in MITK.
    *
    * This file collects and explains the properties which can be used to modify the visualisation
    * of connectomics networks.
    */
 
   // Switching between rendering modes
   /**
    * \brief Define the rendering scheme to be used.
    *
    * Currently there are two possible rendering schemes in MITK.
    * <ol>
    *  <li> The VTK Graph Layout
    *  <li> The MITK Connectomics Visualisation - Default
    * </ol>
    *
    * The VTK Graph Layout is faster than the MITK Connectomics Visualisation, but provides less features
    * and settings.
    */
    const std::string connectomicsRenderingSchemePropertyName = "Connectomics.Rendering.Scheme";
 
    /**
     * \brief Much faster but less features.
     */
    const std::string connectomicsRenderingVTKScheme = "VTK Graph Layout";
 
    /**
     * \brief Slower but with several visualisation options.
     */
    const std::string connectomicsRenderingMITKScheme = "MITK Connectomics Visualisation";
 
    // All options below are only for the MITK Connectomics Visualisation scheme
 
    ////////////////////////////////////////
    // Filtering Options
    ////////////////////////////////////////
 
    /** \brief Edge filter option
     *
     * This option controls the filtering of edges for visualization purposes. Edges filtered out will not be shown, but still included in calculations.
     *
     * Currently there these options:
     * <ol>
     *  <li> No Edge Filtering - Default
     *  <li> Shortest Path to Node
     *  <li> Thresholding
     * </ol>
     *
     */
     const std::string connectomicsRenderingEdgeFilteringPropertyName = "Connectomics.Rendering.Edges.Filtering";
 
    /**
     * \brief Do not filter edges
     */
    const std::string connectomicsRenderingEdgeNoFilter = "No Edge Filtering";
 
    /**
     * \brief Only show edges which are part of a shortest path to the selected node from any other node
     */
    const std::string connectomicsRenderingEdgeShortestPathFilter = "Shortest Path to Node";
 
    /**
     * \brief Show only edges above a certain parameter threshold
     */
    const std::string connectomicsRenderingEdgeThresholdFilter = "Thresholding";
 
    /**
     * \brief Parameter to be thresholded
     */
    const std::string connectomicsRenderingEdgeThresholdFilterParameterName = "Connectomics.Rendering.Edges.Filtering.ThresholdParameter";
 
    /**
     * \brief Threshold
     */
    const std::string connectomicsRenderingEdgeThresholdFilterThresholdName = "Connectomics.Rendering.Edges.Filtering.Threshold";
 
     /** \brief Node filter option
     *
     * This option controls the filtering of nodes for visualization purposes. Nodes filtered out will not be shown, but still included in calculations.
     *
     * Currently there these options:
     * <ol>
     *  <li> No Node Filtering - Default
     *  <li> Thresholding
     * </ol>
     *
     */
     const std::string connectomicsRenderingNodeFilteringPropertyName = "Connectomics.Rendering.Nodes.Filtering";
 
    /**
     * \brief Do not filter nodes
     */
    const std::string connectomicsRenderingNodeNoFilter = "No Node Filtering";
 
    /**
     * \brief Only show nodes above a certain parameter threshold
     */
    const std::string connectomicsRenderingNodeThresholdingFilter = "Thresholding";
 
       /**
     * \brief Parameter to be thresholded
     */
    const std::string connectomicsRenderingNodeThresholdFilterParameterName = "Connectomics.Rendering.Nodes.Filtering.ThresholdParameter";
 
    /**
     * \brief Threshold
     */
    const std::string connectomicsRenderingNodeThresholdFilterThresholdName = "Connectomics.Rendering.Nodes.Filtering.Threshold";
 
    // Default values
    const mitk::StringProperty::Pointer connectomicsRenderingEdgeThresholdFilterParameterDefault =
      mitk::StringProperty::New( "" );
    const  mitk::FloatProperty::Pointer connectomicsRenderingEdgeThresholdFilterThresholdDefault =
      mitk::FloatProperty::New( 1.0 );
 
    const mitk::StringProperty::Pointer connectomicsRenderingNodeThresholdFilterParameterDefault =
      mitk::StringProperty::New( "" );
    const  mitk::FloatProperty::Pointer connectomicsRenderingNodeThresholdFilterThresholdDefault =
      mitk::FloatProperty::New( 1.0 );
 
    ////////////////////////////////////////
    // Node Options
    ////////////////////////////////////////
 
    // Color gradient
     /**
     * \brief Start Color
     *
     * The start color that will be used for gradient creation
     */
    const std::string connectomicsRenderingNodeGradientStartColorName = "Connectomics.Rendering.Nodes.Gradient.StartColor";
 
     /**
     * \brief End Color
     *
     * The end color that will be used for gradient creation
     */
    const std::string connectomicsRenderingNodeGradientEndColorName = "Connectomics.Rendering.Nodes.Gradient.EndColor";
 
     /**
     * \brief Color parameter
     *
     * This parameter will be used to select the color of the node.
     */
    const std::string connectomicsRenderingNodeGradientColorParameterName = "Connectomics.Rendering.Nodes.Gradient.Parameter";
 
    /**
     * \brief The chosen node label
     *
     * This node will be used for any visualisation requiring a specific node
     */
    const std::string connectomicsRenderingNodeChosenNodeName = "Connectomics.Rendering.Nodes.ChosenNode";
 
   // Radius
     /**
     * \brief Start Radius
     *
     * The start radius that will be used
     */
    const std::string connectomicsRenderingNodeRadiusStartName = "Connectomics.Rendering.Nodes.Radius.Start";
 
     /**
     * \brief End Radius
     *
     * The end radius that will be used
     */
    const std::string connectomicsRenderingNodeRadiusEndName = "Connectomics.Rendering.Nodes.Radius.End";
 
     /**
     * \brief Radius parameter
     *
     * This parameter will be used to select the radius of the node.
     */
    const std::string connectomicsRenderingNodeRadiusParameterName = "Connectomics.Rendering.Nodes.Radius.Parameter";
 
    // Possible parameters
    /**
     * \brief Using the node degree as parameter
     */
    const std::string connectomicsRenderingNodeParameterDegree = "Degree";
 
    /**
     * \brief Using the node betweenness as parameter
     */
    const std::string connectomicsRenderingNodeParameterBetweenness = "Betweenness centrality";
 
    /**
     * \brief Using the node clustering coefficient as parameter
     */
    const std::string connectomicsRenderingNodeParameterClustering = "Clustering coefficient";
 
    /**
     * \brief Color nodes by shortest path length to a chosen node
     */
    const std::string connectomicsRenderingNodeParameterColoringShortestPath = "Shortest Path Steps";
 
    /**
     * \brief Constant
     *
     * The node property will be constant.
     */
    const std::string connectomicsRenderingNodeParameterConstant = "Constant";
 
    // Default values
    const mitk::StringProperty::Pointer connectomicsRenderingNodeChosenNodeDefault =
      mitk::StringProperty::New("");
 
    const mitk::ColorProperty::Pointer connectomicsRenderingNodeGradientStartColorDefault =
      mitk::ColorProperty::New(0.0f, 0.0f, 1.0f);
    const mitk::ColorProperty::Pointer connectomicsRenderingNodeGradientEndColorDefault =
      mitk::ColorProperty::New(0.0f, 1.0f, 0.0f);
 
    const  mitk::FloatProperty::Pointer connectomicsRenderingNodeRadiusStartDefault =
      mitk::FloatProperty::New( 1.0 );
    const  mitk::FloatProperty::Pointer connectomicsRenderingNodeRadiusEndDefault =
      mitk::FloatProperty::New( 1.0 );
 
    ////////////////////////////////////////
    // Edge Options
    ////////////////////////////////////////
 
 
    // Color gradient
     /**
     * \brief Start Color
     *
     * The start color that will be used for gradient creation
     */
    const std::string connectomicsRenderingEdgeGradientStartColorName = "Connectomics.Rendering.Edges.Gradient.StartColor";
 
     /**
     * \brief End Color
     *
     * The end color that will be used for gradient creation
     */
    const std::string connectomicsRenderingEdgeGradientEndColorName = "Connectomics.Rendering.Edges.Gradient.EndColor";
 
     /**
     * \brief Color parameter
     *
     * This parameter will be used to select the color of the edge.
     */
    const std::string connectomicsRenderingEdgeGradientColorParameterName = "Connectomics.Rendering.Edges.Gradient.Parameter";
 
   // Radius
     /**
     * \brief Start Radius
     *
     * The start radius that will be used
     */
    const std::string connectomicsRenderingEdgeRadiusStartName = "Connectomics.Rendering.Edges.Radius.Start";
 
     /**
     * \brief End Radius
     *
     * The end radius that will be used
     */
    const std::string connectomicsRenderingEdgeRadiusEndName = "Connectomics.Rendering.Edges.Radius.End";
 
     /**
     * \brief Radius parameter
     *
     * This parameter will be used to select the radius of the edge.
     */
    const std::string connectomicsRenderingEdgeRadiusParameterName = "Connectomics.Rendering.Edges.Radius.Parameter";
 
    // Possible parameters
    /**
     * \brief Using the weight as parameter
     */
    const std::string connectomicsRenderingEdgeParameterWeight = "Weight";
 
+   /**
+    * \brief Using the edge centrality as parameter
+    */
+   const std::string connectomicsRenderingEdgeParameterCentrality = "Edge betweenness centrality";
+
     /**
     * \brief Constant
     *
     * The edge property will be constant.
     */
    const std::string connectomicsRenderingEdgeParameterConstant = "Constant";
 
    // Default values
    const mitk::ColorProperty::Pointer connectomicsRenderingEdgeGradientStartColorDefault =
      mitk::ColorProperty::New(0.8f, 0.0f, 0.6f);
    const mitk::ColorProperty::Pointer connectomicsRenderingEdgeGradientEndColorDefault =
      mitk::ColorProperty::New(0.0f, 0.8f, 0.2f);
 
    const  mitk::FloatProperty::Pointer connectomicsRenderingEdgeRadiusStartDefault =
      mitk::FloatProperty::New( 0.1 );
    const  mitk::FloatProperty::Pointer connectomicsRenderingEdgeRadiusEndDefault =
      mitk::FloatProperty::New( 0.4 );
 
 } // namespace mitk
 
 
 #endif /* ConnectomicsRenderingProperties_H_HEADER_INCLUDED */