Calculates the transitive edges that connect the visibleNodes in the specified graph.
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
@PRODUCT@ 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
// 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)
}Type Details
- yFiles module
- view-layout-bridge
See Also
Sample Graphs
Constructors
Parameters
A map of options to pass to the method.
- visibleNodes - ItemCollection<INode>
- A collection of nodes to start from. This option either sets the value directly or recursively sets properties to the instance of the visibleNodes property on the created object.
- directed - boolean
- A boolean that specifies whether the graph is directed. This option sets the directed property on the created object.
- subgraphNodes - ItemCollection<INode>
- The collection of nodes which define a subset of the graph for the algorithms to work on. This option either sets the value directly or recursively sets properties to the instance of the subgraphNodes property on the created object.
- subgraphEdges - ItemCollection<IEdge>
- The collection of edges which define a subset of the graph for the algorithms to work on. This option either sets the value directly or recursively sets properties to the instance of the subgraphEdges property on the created object.
Properties
Gets or sets the collection of edges which define a subset of the graph for the algorithms to work on.
Remarks
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.
Examples
// 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)
}Gets or sets the collection of nodes which define a subset of the graph for the algorithms to work on.
Remarks
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.
Examples
// 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)
}Gets or sets a collection of nodes to start from.
Methods
Calculates the transitive edges that connect the visibleNodes in the specified graph.
Remarks
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
Parameters
A map of options to pass to the method.
- graph - IGraph
- the original graph that contains both the visible and invisible nodes
Returns
- ↪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
// 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)
}