C

DegreeCentrality

Show Usages
Computes the degree centrality for the nodes of a given graph.
Inheritance Hierarchy

Remarks

Degree centrality is the number of the incoming, outgoing, or overall edges incident to a node (measures incoming, outgoing, and overall degree).

If both considerIncomingEdges and considerOutgoingEdges are false, an InvalidOperationError is thrown.

Other Centrality Measures

yFiles for HTML supports a number of other centrality measures:

Complexity

O(|V|)

Examples

const result = new DegreeCentrality().run(graph)

// add node labels for centrality values
// and adjust node size according to centrality
result.normalizedNodeCentrality.forEach((entry) => {
  const node = entry.key
  const centrality = entry.value
  graph.addLabel(node, `${centrality}`)
  graph.setNodeLayout(
    node,
    new Rect(node.layout.center, new Size(centrality, centrality)),
  )
})

See Also

Developer's Guide

API

degreeCentrality

Members

No filters for this type

Constructors

DegreeCentrality

()
Creates a new instance.

Parameters

Properties

considerIncomingEdges

: boolean
Gets or sets a value indicating whether incoming edges contribute to the centrality values of their target nodes.

If both considerIncomingEdges and considerOutgoingEdges are false, an InvalidOperationError is thrown.

Default is false.

final

Property Value

true if the incoming edges should be considered, false otherwise.

See Also

Developer's Guide

considerOutgoingEdges

: boolean
Gets or sets a value indicating whether outgoing edges contribute to the centrality values of their source nodes.

If both considerIncomingEdges and considerOutgoingEdges are false, an InvalidOperationError is thrown.

Default is true.

final

Property Value

true if the incoming edges should be considered, false otherwise.

subgraphEdges

: ItemCollection<IEdge>
Gets or sets the collection of edges which define a subset of the graph for the algorithms to work on.

If nothing is set, all edges of the graph will be processed.

If only the excludes are set, all edges in the graph except those provided in the excludes are processed.

Note that edges which start or end at nodes which are not in the subgraphNodes are automatically not considered by the algorithm.

ItemCollection<T> instances may be shared among algorithm instances and will be (re-)evaluated upon (re-)execution of the algorithm.

The edges provided here must be part of the graph which is passed to the run method.
conversionfinal

Examples

Calculating the degree centrality on a subset of the graph
// configure the algorithm
const algorithm = new DegreeCentrality({
  // Ignore edges without target arrow heads
  subgraphEdges: {
    excludes: (edge: IEdge): boolean =>
      edge.style instanceof PolylineEdgeStyle &&
      edge.style.targetArrow instanceof Arrow &&
      edge.style.targetArrow.type === ArrowType.NONE,
  },
})
// run the algorithm
const result = algorithm.run(graph)
// add node labels for centrality values
// and adjust node size according to centrality
result.normalizedNodeCentrality.forEach((entry) => {
  const node = entry.key
  const centrality = entry.value
  graph.addLabel(node, `${centrality}`)
  graph.setNodeLayout(
    node,
    new Rect(node.layout.center, new Size(centrality, centrality)),
  )
})

subgraphNodes

: ItemCollection<INode>
Gets or sets the collection of nodes which define a subset of the graph for the algorithms to work on.

If nothing is set, all nodes of the graph will be processed.

If only the excludes are set, all nodes in the graph except those provided in the excludes are processed.

ItemCollection<T> instances may be shared among algorithm instances and will be (re-)evaluated upon (re-)execution of the algorithm.

The nodes provided here must be part of the graph which is passed to the run method.
conversionfinal

Examples

Calculating the degree centrality on a subset of the graph
// configure the algorithm
const algorithm = new DegreeCentrality({
  subgraphNodes: {
    // only consider elliptical nodes in the graph
    includes: (node: INode): boolean =>
      node.style instanceof ShapeNodeStyle &&
      node.style.shape === ShapeNodeShape.ELLIPSE,
    // but ignore the first node, regardless of its shape
    excludes: graph.nodes.first()!,
  },
})
// run the algorithm
const result = algorithm.run(graph)
// add node labels for centrality values
// and adjust node size according to centrality
result.normalizedNodeCentrality.forEach((entry) => {
  const node = entry.key
  const centrality = entry.value
  graph.addLabel(node, `${centrality}`)
  graph.setNodeLayout(
    node,
    new Rect(node.layout.center, new Size(centrality, centrality)),
  )
})

Methods

run

(graph: IGraph): DegreeCentralityResult
Computes the degree centrality for the nodes of a given graph.
The result obtained from this algorithm is a snapshot which is no longer valid once the graph has changed, e.g. by adding or removing nodes or edges.
final

Parameters

graph: IGraph
The input graph to run the algorithm on.

Return Value

DegreeCentralityResult
A DegreeCentralityResult from which the calculated centrality values can be obtained.

Throws

Exception ({ name: 'InvalidOperationError' })
If the algorithm can't create a valid result due to an invalid graph structure or wrongly configured properties.

Complexity

O(|V|)