org.graphstream.algorithm
Class BetweennessCentrality

java.lang.Object
  org.graphstream.algorithm.BetweennessCentrality

All Implemented Interfaces:

Algorithm

public class BetweennessCentrality
extends Object
implements Algorithm

Compute the "betweenness" centrality of each vertex of a given graph.

The betweenness centrality counts how many shortest paths between each pair of nodes of the graph pass by a node. It does it for all nodes of the graph.

Usage

This algorithm, by default, stores the centrality values for each edge inside the "Cb" attribute. You can change this attribute name at construction time.

This algorithm does not accept multi-graphs (p-graphs with p>1) yet.

This algorithm does not take into account edge direction yet.

By default the weight attribute name is "weight", you can activate the weights using setWeighted(). You can change the weight attribute name using the dedicated constructor or the setWeightAttributeName(String) method. This method implicitly enable weights in the computation. Use setUnweighted() to disable weights.

The result of the computation is stored on each node inside the "Cb" attribute. You can change the name of this attribute using the dedicated constructor or the setCentralityAttributeName(String) method.

As the computing of centrality can take a lot of time, you can provide a progress 'callback' to get notified each time the algorithm finished processing a node (however the centrality values are usable only when the algorithm finished). See the registerProgressIndicator(Progress) method.

Complexity

By default the algorithm performs on a graph considered as not weighted with complexity O(nm). You can specify that the graph edges contain weights in which case the algorithm complexity is O(nm + n^2 log n).

Example

                Graph graph = new SingleGraph("Betweenness Test");
                
                //    E----D  AB=1, BC=5, CD=3, DE=2, BE=6, EA=4  
                //   /|    |  Cb(A)=4
                //  / |    |  Cb(B)=2
                // A  |    |  Cb(C)=0
                //  \ |    |  Cb(D)=2
                //   \|    |  Cb(E)=4
                //    B----C
                
                Node A = graph.addNode("A");
                Node B = graph.addNode("B");
                Node E = graph.addNode("E");
                Node C = graph.addNode("C");
                Node D = graph.addNode("D");

                graph.addEdge("AB", "A", "B");
                graph.addEdge("BE", "B", "E");
                graph.addEdge("BC", "B", "C");
                graph.addEdge("ED", "E", "D");
                graph.addEdge("CD", "C", "D");
                graph.addEdge("AE", "A", "E");
                
                bcb.setWeight(A, B, 1);
                bcb.setWeight(B, E, 6);
                bcb.setWeight(B, C, 5);
                bcb.setWeight(E, D, 2);
                bcb.setWeight(C, D, 3);
                bcb.setWeight(A, E, 4);

                BetweennessCentrality bcb = new BetweennessCentrality();
                bcb.setWeightAttributeName("weight");
                bcb.init(graph);
                bcb.compute();
                
                System.out.println("A="+ graph.getNode("A").getAttribute("Cb"));
                System.out.println("B="+ graph.getNode("B").getAttribute("Cb"));
                System.out.println("C="+ graph.getNode("C").getAttribute("Cb"));
                System.out.println("D="+ graph.getNode("D").getAttribute("Cb"));
                System.out.println("E="+ graph.getNode("E").getAttribute("Cb"));
 

Reference

This is based on the algorithm described in "A Faster Algorithm for Betweenness Centrality", Ulrik Brandes, Journal of Mathematical Sociology, 2001, and in "On variants of shortest-path betweenness centrality and their generic computation", of the same author, 2008.

Scientific Reference :

A Faster Algorithm for Betweenness Centrality, Ulrik Brandes, Journal of Mathematical Sociology, 2001, 25:2, pp. 163 - 177", "DOI: 10.1080/0022250X.2001.9990249", On variants of shortest-path betweenness centrality and their generic computation, Ulrik Brandes, Social Networks, vol 30:2", pp. 136 - 145, 2008, issn 0378-8733, "DOI: 10.1016/j.socnet.2007.11.001".

Nested Class Summary

static interface

BetweennessCentrality.Progress Interface allowing to be notified of the algorithm progress.

Constructor Summary

BetweennessCentrality()
New centrality algorithm that will perform as if the graph was unweighted.

BetweennessCentrality(String centralityAttributeName)
New centrality algorithm that will perform as if the graph was unweighted.

BetweennessCentrality(String centralityAttributeName, String weightAttributeName)
New centrality algorithm that will perform on a weighted graph, taking the weight of each edge in the given weightAttributeName.

Method Summary

void	betweennessCentrality(org.graphstream.graph.Graph graph) Compute the betweenness centrality on the given graph for each node.
double	centrality(org.graphstream.graph.Node node) The centrality value of the given node.
void	compute() Compute the betweenness centrality on the given graph for each node.
String	getCentralityAttributeName() Name of the attribute used to store centrality values on nodes.
String	getWeightAttributeName() Name of the attribute used to retrieve weights on edges.
void	init(org.graphstream.graph.Graph graph) Setup the algorithm to work on the given graph.
void	registerProgressIndicator(BetweennessCentrality.Progress progress) Specify an interface to call in order to indicate the algorithm progress.
void	setCentrality(org.graphstream.graph.Node node, double centrality) Set the centrality of the given node.
void	setCentralityAttributeName(String centralityAttributeName) Specify the name of the attribute used to store the computed centrality values for each node.
void	setUnweighted() Consider all the edges to have the weight.
void	setWeight(org.graphstream.graph.Node from, org.graphstream.graph.Node to, double weight) Set the weight of the edge between 'from' and 'to'.
void	setWeightAttributeName(String weightAttributeName) Specify the name of the weight attribute to retrieve edge attributes.
void	setWeighted() Consider the edges to have a weight.
double	weight(org.graphstream.graph.Node from, org.graphstream.graph.Node to) The weight of the edge between 'from' and 'to'.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BetweennessCentrality

public BetweennessCentrality()

New centrality algorithm that will perform as if the graph was unweighted. By default the centrality will be stored in a "Cb" attribute on each node.

BetweennessCentrality

public BetweennessCentrality(String centralityAttributeName)

New centrality algorithm that will perform as if the graph was unweighted. The centrality for each node will be stored in an attribute whose name is specified by the centralityAttributeName argument.

Parameters:

centralityAttributeName - The name of the attribute used to store the result of the algorithm on each node.

BetweennessCentrality

public BetweennessCentrality(String centralityAttributeName,
                             String weightAttributeName)

New centrality algorithm that will perform on a weighted graph, taking the weight of each edge in the given weightAttributeName. The result of the algorithm is stored for each node using the given centralityAttributeName. If an edge has no weight attribute, it is considered as having a weight of one.

Parameters:

centralityAttributeName - Name to use to store the centrality results on each node.

weightAttributeName - Name to use to retrieve the edge weights.

Method Detail

getWeightAttributeName

public String getWeightAttributeName()

Name of the attribute used to retrieve weights on edges.

getCentralityAttributeName

public String getCentralityAttributeName()

Name of the attribute used to store centrality values on nodes.

setWeightAttributeName

public void setWeightAttributeName(String weightAttributeName)

Specify the name of the weight attribute to retrieve edge attributes. This automatically set the algorithm to perform on the graph as if it was weighted.

setWeighted

public void setWeighted()

Consider the edges to have a weight. By default the weight is stored in a "weight" attribute. You can change this attribute using setWeightAttributeName(String). If an edge has no weight the value 1.0 is used.

setUnweighted

public void setUnweighted()

Consider all the edges to have the weight.

setCentralityAttributeName

public void setCentralityAttributeName(String centralityAttributeName)

Specify the name of the attribute used to store the computed centrality values for each node.

registerProgressIndicator

public void registerProgressIndicator(BetweennessCentrality.Progress progress)

Specify an interface to call in order to indicate the algorithm progress. Pass null to remove the progress indicator. The progress indicator will be called regularly to indicate the computation progress.

init

public void init(org.graphstream.graph.Graph graph)

Setup the algorithm to work on the given graph.

Specified by:

init in interface Algorithm

Parameters:

graph - The graph this algorithm is using.

compute

public void compute()

Compute the betweenness centrality on the given graph for each node. The result is by default stored in the "Cb" attribute on each node.

Specified by:

compute in interface Algorithm

See Also:

Algorithm.init(Graph)

betweennessCentrality

public void betweennessCentrality(org.graphstream.graph.Graph graph)

Compute the betweenness centrality on the given graph for each node. This method is equivalent to a call in sequence to the two methods init(Graph) then compute().

centrality

public double centrality(org.graphstream.graph.Node node)

The centrality value of the given node.

Parameters:

node - Extract the centrality of this node.

Returns:

The centrality value.

setCentrality

public void setCentrality(org.graphstream.graph.Node node,
                          double centrality)

Set the centrality of the given node.

Parameters:

node - The node to modify.

centrality - The centrality to store on the node.

setWeight

public void setWeight(org.graphstream.graph.Node from,
                      org.graphstream.graph.Node to,
                      double weight)

Set the weight of the edge between 'from' and 'to'.

Parameters:

from - The source node.

to - The target node.

weight - The weight to store on the edge between 'from' and 'to'.

weight

public double weight(org.graphstream.graph.Node from,
                     org.graphstream.graph.Node to)

The weight of the edge between 'from' and 'to'.

Parameters:

from - The origin node.

to - The target node.

Returns:

The weight on the edge between 'form' and 'to'.