C

TransitiveEdges

Show Usages
Calculates the transitive edges that connect the visibleNodes in the specified graph.
Inheritance Hierarchy

Remarks

The algorithm suggests a transitive edge between two visible nodes if:

  • there is a (directed/undirected) path between the nodes using only invisible nodes as intermediate nodes
  • and there is not already an edge between the two nodes

yFiles for HTML supports other algorithms related to transitivity:

  • TransitiveClosure – calculates the transitive closure of a graph, i.e. the edges that would have to be added that the set of edges defines the reachability relation in the graph
  • TransitiveReduction – calculates the transitive reduction of a graph, i.e. the edges that are unnecessary to only ensure that the same reachability relation is represented

Other than TransitiveClosure, this algorithm only suggests edges for nodes which are indirectly connected via nodes which are hidden, i.e. not visible.

This can be useful to simplify graphs where unimportant nodes are removed but the (indirect) connections between the important nodes should be kept:

Examples

Calculating the transitive edges between the selected nodes.
// calculate the transitive edges between the selected nodes
const algorithm = new TransitiveEdges({
  visibleNodes: graphComponent.selection.nodes,
})
// run the algorithm
const result = algorithm.run(graph)

// add the edges
for (const edge of result.edgesToAdd) {
  graph.createEdge(edge.source, edge.target, edgeStyle)
}

See Also

Developer's Guide

API

addTransitiveEdges

Members

No filters for this type

Constructors

TransitiveEdges

()

Parameters

Properties

directed

: boolean
Gets or sets a boolean that specifies whether the graph is directed.
Default is false.
final

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 transitive edges of a subset of the graph
// prepare the chain detection algorithm
const algorithm = new TransitiveEdges({
  // 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 the edges
for (const edge of result.edgesToAdd) {
  graph.createEdge(edge.source, edge.target, edgeStyle)
}

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 transitive edges of a subset of the graph
// prepare the chain detection algorithm
const algorithm = new TransitiveEdges({
  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 the edges
for (const edge of result.edgesToAdd) {
  graph.createEdge(edge.source, edge.target, edgeStyle)
}

visibleNodes

: ItemCollection<INode>
Gets or sets a collection of nodes to start from.
conversionfinal

Methods

run

(graph: IGraph): TransitiveEdgesResult
Calculates the transitive edges that connect the visibleNodes in the specified graph.
The algorithm suggests a transitive edge between two visible nodes if:
  • there is a (directed/undirected) path between the nodes using only invisible nodes as intermediate nodes
  • and there is not already an edge between the two nodes
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 original graph that contains both the visible and invisible nodes

Return Value

TransitiveEdgesResult
A TransitiveEdgesResult containing placeholders for edges that can be inserted to obtain the transitive closure of graph.

Throws

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

Examples

Calculating the transitive edges between the selected nodes.
// calculate the transitive edges between the selected nodes
const algorithm = new TransitiveEdges({
  visibleNodes: graphComponent.selection.nodes,
})
// run the algorithm
const result = algorithm.run(graph)

// add the edges
for (const edge of result.edgesToAdd) {
  graph.createEdge(edge.source, edge.target, edgeStyle)
}