Search this API

y.layout.radial
Class RadialLayouter

java.lang.Object
  extended by y.layout.CanonicMultiStageLayouter
      extended by y.layout.radial.RadialLayouter
All Implemented Interfaces:
Layouter

public class RadialLayouter
extends CanonicMultiStageLayouter

This layout algorithm arranges graphs in a radial fashion.

Layout Style

The nodes are distributed into circles (layers) around a common center based on predefined layering strategies. Some potential applications include visualization of social networks, data clustering and bioinformatics.


Sample output of the layout algorithm with default settings and one center node


Sample output of the layout algorithm with straight-line edges and five center nodes using CENTER_NODES_POLICY_SELECTED_NODES policy

Concept

The layout algorithm creates a virtual tree structure for the input graph whose root node is placed in the center of the circles. All children of a tree node are placed on a higher layer (i.e. on a circle of larger radius) than their parent. A sector is calculated for each node such that the sector of each child node in the virtual tree is a sub-sector of its parent's sector. The radii of the circles are calculated based on the sizes of the sectors required to accommodate each whole subtree.

Features

There are different center nodes policies that can be applied in order to determine the nodes that will be placed in the center (single center node) or on the innermost circle (more than one center node). The distribution of the nodes to the circles is specified by a layering strategy.

The edges are routed based on the edge routing strategy. Note that the edge routing cannot always prevent node-edge overlaps.

The minimum distance between nodes of the same circle is specified using setMinimalNodeToNodeDistance(double). If there are too many nodes assigned to a circle, the radius of the particular circle will be increased until all nodes fit onto it.

The distance between consecutive layers is specified using setLayerSpacing(double). The radii of the circles are a multiple of this spacing value. If the layer spacing is 0, the radii are chosen such that all nodes fit on their corresponding circles. A minimum layer distance is specified by setMinimalLayerDistance(double).

 

Nested Class Summary
static class RadialLayouter.NodeInfo
          Info object used for retrieving information about each node from the layout algorithm.
 
Field Summary
static byte CENTER_NODES_POLICY_CENTRALITY
          Specifier for a center nodes policy which chooses the node with the highest centrality as center node.
static byte CENTER_NODES_POLICY_DIRECTED
          Specifier for a center nodes policy which chooses all nodes with in-degree equal to 0 as center nodes.
static byte CENTER_NODES_POLICY_SELECTED_NODES
          Specifier for a center nodes policy which uses center nodes specified by the user.
static byte CENTER_NODES_POLICY_WEIGHTED_CENTRALITY
          Specifier for a center nodes policy which chooses the node with the highest weighted centrality as center node.
static byte EDGE_ROUTING_STRATEGY_ARC
          Specifier for an edge routing strategy that will route edges as arcs.
static byte EDGE_ROUTING_STRATEGY_POLYLINE
          Specifier for an edge routing strategy that will route edges with polyline segments from source to target with one bend on each spanned circle.
static java.lang.Object LAYER_ID_DPKEY
          A DataProvider key for providing user-defined layer/circle IDs.
static byte LAYERING_STRATEGY_BFS
          Specifier for a layering strategy that uses breadth first search (BFS) to determine a layering for the graph.
static byte LAYERING_STRATEGY_HIERARCHICAL
          Specifier for a layering strategy that uses an optimal hierarchical layering strategy.
static byte LAYERING_STRATEGY_USER_DEFINED
          Specifier for a layering strategy that uses a custom, user-defined layer/circle assignment.
static java.lang.Object NODE_INFO_DPKEY
          A DataAcceptor key for publishing the circle ID and sector data For each node, the ID of the circle and data regarding the circular sector on which it was placed will be stored.
 
Fields inherited from interface y.layout.Layouter
EDGE_ID_DPKEY, NODE_ID_DPKEY, SELECTED_EDGES, SELECTED_NODES
 
Constructor Summary
RadialLayouter()
          Creates a new RadialLayouter instance with the default settings.
 
Method Summary
 boolean canLayoutCore(LayoutGraph graph)
          Accepts all general graphs.
protected  NodeList determineCenter(LayoutGraph graph)
          Determines the center nodes of the graph according to the selected center node policy.
 void doLayoutCore(LayoutGraph graph)
          Calculates a radial arrangement for the given graph.
 java.lang.Object getCenterNodesDpKey()
          Returns the DataProvider key used for looking up the selected nodes that should be placed in the center.
 byte getCenterNodesPolicy()
          Returns the policy that determines which nodes are selected as roots of the (virtual) tree for the layout process and are set in the center of the circles.
 EdgeBundling getEdgeBundling()
          Returns the EdgeBundling instance that defines the settings of the edge bundling feature.
 byte getEdgeRoutingStrategy()
          Returns the edge routing strategy.
 byte getLayeringStrategy()
          Returns the layering strategy that determines how nodes are distributed into different layers.
 double getLayerSpacing()
          Returns the spacing between two consecutive circles (layers).
 double getMaximalChildSectorAngle()
          Returns the maximum sector angle around a node within which the node's children will be placed.
 double getMinimalBendAngle()
          Returns the minimum bend angle (in degrees) between two adjacent edge segments.
 double getMinimalLayerDistance()
          Returns the minimum distance between two circles.
 double getMinimalNodeToNodeDistance()
          Returns the minimum distance between two neighboring nodes of the same circle.
protected  double getNodeDiameter(LayoutGraph graph, Node node)
          Returns the diameter of the circular space around the center of a given node that should be reserved in order to place the node.
 boolean isConsiderNodeLabelsEnabled()
          Returns whether or not node labels are taken into account when calculating node positions.
 void setCenterNodesDpKey(java.lang.Object centerNodesDpKey)
          Specifies the DataProvider key used for looking up the selected nodes that should be placed in the center.
 void setCenterNodesPolicy(byte policy)
          Specifies the policy that determines which nodes are selected as roots of the (virtual) tree for the layout process and are placed in the center of the circles.
 void setConsiderNodeLabelsEnabled(boolean handleNodeLabels)
          Specifies whether or not node labels are taken into account when calculating node positions.
 void setEdgeRoutingStrategy(byte edgeRoutingStrategy)
          Specifies the edge routing strategy.
 void setLayeringStrategy(byte layeringStrategy)
          Specifies the layering strategy that determines how nodes are distributed into different layers.
 void setLayerSpacing(double layerSpacing)
          Specifies the spacing between two consecutive circles (layers).
 void setMaximalChildSectorAngle(double maximalChildSectorAngle)
          Specifies the maximum angle (in degrees) of the sector around a node on which its children will be placed.
 void setMinimalBendAngle(double minimalBendAngle)
          Specifies the minimum bend angle (in degrees) between two adjacent edge segments.
 void setMinimalLayerDistance(double minimalLayerDistance)
          Specifies the minimum distance between two circles.
 void setMinimalNodeToNodeDistance(double minimalNodeToNodeDistance)
          Specifies the minimum distance between two neighboring nodes of the same circle.
 void setOrientationLayouterEnabled(boolean enabled)
          Specifies whether or not the LayoutStage that modifies the orientation of the layout is activated.
 
Methods inherited from class y.layout.CanonicMultiStageLayouter
appendStage, calcLayout, calcLayout, canLayout, checkGroupNodeSize, checkNodeSize, doLayout, doLayout, enableOnlyCore, getComponentLayouter, getGroupNodeHider, getLabelLayouter, getLayoutOrientation, getOrientationLayouter, getParallelEdgeLayouter, getSelfLoopLayouter, getSubgraphLayouter, isComponentLayouterEnabled, isGroupNodeHidingEnabled, isLabelLayouterEnabled, isOrientationLayouterEnabled, isParallelEdgeLayouterEnabled, isSelfLoopLayouterEnabled, isSubgraphLayouterEnabled, prependStage, removeStage, setComponentLayouter, setComponentLayouterEnabled, setGroupNodeHider, setGroupNodeHidingEnabled, setLabelLayouter, setLabelLayouterEnabled, setLayoutOrientation, setOrientationLayouter, setParallelEdgeLayouter, setParallelEdgeLayouterEnabled, setSelfLoopLayouter, setSelfLoopLayouterEnabled, setSubgraphLayouter, setSubgraphLayouterEnabled
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

NODE_INFO_DPKEY

public static final java.lang.Object NODE_INFO_DPKEY
A DataAcceptor key for publishing the circle ID and sector data

For each node, the ID of the circle and data regarding the circular sector on which it was placed will be stored.

 
If no DataProvider is registered with this key, information about circle ID and sector data will be dropped.
 
The layout algorithm will not take into account any settings that are initially specified by a RadialLayouter.NodeInfo provided by the DataProvider registered with this key. It is only intended to publish information after the layout has been calculated.

CENTER_NODES_POLICY_DIRECTED

public static final byte CENTER_NODES_POLICY_DIRECTED
Specifier for a center nodes policy which chooses all nodes with in-degree equal to 0 as center nodes. If no node with this property is present, an arbitrary node will be selected.

See Also:
getCenterNodesPolicy(), Trees.getRoot(Graph), Constant Field Values
Sample Graph:

The center node is marked

CENTER_NODES_POLICY_CENTRALITY

public static final byte CENTER_NODES_POLICY_CENTRALITY
Specifier for a center nodes policy which chooses the node with the highest centrality as center node.

See Also:
getCenterNodesPolicy(), Trees.getCenterRoot(Graph), Constant Field Values
Sample Graph:

The center node is marked

CENTER_NODES_POLICY_WEIGHTED_CENTRALITY

public static final byte CENTER_NODES_POLICY_WEIGHTED_CENTRALITY
Specifier for a center nodes policy which chooses the node with the highest weighted centrality as center node.

See Also:
getCenterNodesPolicy(), Trees.getWeightedCenterNode(Graph), Constant Field Values
Sample Graph:

The center node is marked

CENTER_NODES_POLICY_SELECTED_NODES

public static final byte CENTER_NODES_POLICY_SELECTED_NODES
Specifier for a center nodes policy which uses center nodes specified by the user. The center nodes have to be specified using a DataProvider registered with the according key. The DataProvider returns true for nodes that should be placed in the center.

If there exists more than one center node, they will be placed on the innermost circle while the center position stays empty.

See Also:
getCenterNodesPolicy(), getCenterNodesDpKey(), Constant Field Values
Sample Graph:

The center nodes are marked

LAYERING_STRATEGY_BFS

public static final byte LAYERING_STRATEGY_BFS
Specifier for a layering strategy that uses breadth first search (BFS) to determine a layering for the graph. All edges will span at most one layer in the resulting drawing. Edges between nodes that belong to the same layer are possible.

See Also:
setLayeringStrategy(byte), Constant Field Values
Sample Graph:

The center node is marked

LAYERING_STRATEGY_HIERARCHICAL

public static final byte LAYERING_STRATEGY_HIERARCHICAL
Specifier for a layering strategy that uses an optimal hierarchical layering strategy. The layer distance of an edge is the absolute difference between the layer numbers of its source and target node. Layer assignment will be done such that the overall sum of the layer distances of all edges in the layout is minimal.

See Also:
setLayeringStrategy(byte), Constant Field Values
Sample Graph:

The center node is marked

LAYERING_STRATEGY_USER_DEFINED

public static final byte LAYERING_STRATEGY_USER_DEFINED
Specifier for a layering strategy that uses a custom, user-defined layer/circle assignment.

The nodes' layer/circle assignment must be provided by a DataProvider registered with the input graph with the key LAYER_ID_DPKEY. If no data is provided and this strategy is selected, then the algorithm will throw an exception.

Using this strategy, the center nodes (nodes on the innermost circle) are not determined by the specified center nodes policy anymore. Instead, the nodes with the smallest given ID (i.e. 0) are part of the center nodes.

 
If applying this strategy, the getCenterNodesPolicy() is ignored.
See Also:
setLayeringStrategy(byte), LAYER_ID_DPKEY, Constant Field Values

LAYER_ID_DPKEY

public static final java.lang.Object LAYER_ID_DPKEY
A DataProvider key for providing user-defined layer/circle IDs.

The DataProvider registered with this key provides for each node the layer/circle ID to which it belongs. Nodes with the same ID are placed on the same circle while the circles are sorted according to their IDs such that a smaller ID means that the circle has a smaller radius and is closer to the center of the radial layout.

When providing user-defined IDs, the center nodes (nodes on the innermost circle) are not determined by the specified center nodes policy anymore. Instead, the nodes with the smallest given ID (i.e. 0) define the set of center nodes.

 
This user-defined IDs are only considered if strategy LAYERING_STRATEGY_USER_DEFINED is specified.
See Also:
LAYERING_STRATEGY_USER_DEFINED

EDGE_ROUTING_STRATEGY_POLYLINE

public static final byte EDGE_ROUTING_STRATEGY_POLYLINE
Specifier for an edge routing strategy that will route edges with polyline segments from source to target with one bend on each spanned circle.

See Also:
setEdgeRoutingStrategy(byte), Constant Field Values
Sample Graph:

EDGE_ROUTING_STRATEGY_ARC

public static final byte EDGE_ROUTING_STRATEGY_ARC
Specifier for an edge routing strategy that will route edges as arcs. The source and target of an edge as well as one bend on each spanned circle are used as main control points. An easing function is applied in order to calculate additional control points between the polar coordinates of the main control points.

See Also:
setEdgeRoutingStrategy(byte), Constant Field Values
Sample Graph:
Constructor Detail

RadialLayouter

public RadialLayouter()
Creates a new RadialLayouter instance with the default settings.

Method Detail

setMinimalNodeToNodeDistance

public void setMinimalNodeToNodeDistance(double minimalNodeToNodeDistance)
Specifies the minimum distance between two neighboring nodes of the same circle.

Default Value:
The default value is 10.
Parameters:
minimalNodeToNodeDistance - a non-negative distance
Throws:
java.lang.IllegalArgumentException - if the given minimum distance is negative
Sample Graphs:

Node distance 10

Node distance 100

getMinimalNodeToNodeDistance

public double getMinimalNodeToNodeDistance()
Returns the minimum distance between two neighboring nodes of the same circle.

Returns:
a non-negative distance
See Also:
setMinimalNodeToNodeDistance(double)

getLayerSpacing

public double getLayerSpacing()
Returns the spacing between two consecutive circles (layers).

The spacing is a non-negative value, where 0 means that no spacing is considered.

The radius of each circle will be a multiple of this value.

Returns:
the spacing value
See Also:
setLayerSpacing(double)

setLayerSpacing

public void setLayerSpacing(double layerSpacing)
Specifies the spacing between two consecutive circles (layers).

The spacing is a non-negative value, where 0 means that no spacing is considered.

The radius of each circle will be a multiple of this value.

Default Value:
The default value is 25.
Parameters:
layerSpacing - the spacing value
Throws:
java.lang.IllegalArgumentException - if the spacing value is negative
Sample Graphs:

Layer spacing 25

Layer spacing 100

getMinimalLayerDistance

public double getMinimalLayerDistance()
Returns the minimum distance between two circles.

Returns:
the non-negative distance between two circles
See Also:
setMinimalLayerDistance(double)

setMinimalLayerDistance

public void setMinimalLayerDistance(double minimalLayerDistance)
Specifies the minimum distance between two circles.

Default Value:
The default value is 100.
Parameters:
minimalLayerDistance - the non-negative distance between two circles
Throws:
java.lang.IllegalArgumentException - if the minimum layer distance is negative
Sample Graphs:

Minimum layer distance 100

Minimum layer distance 200

getMaximalChildSectorAngle

public double getMaximalChildSectorAngle()
Returns the maximum sector angle around a node within which the node's children will be placed.

Based on the location of a given node, the sector of its children that lie on the next outer layer is described by this angle. The vertex of the angle is located in the center of the node while its sides point away from the inner circles. The child nodes are placed inside this angle. If there is not enough space, the radius of the child circle is increased.

Returns:
the maximum sector angle in degrees from the interval [0,360]
See Also:
setMaximalChildSectorAngle(double)

setMaximalChildSectorAngle

public void setMaximalChildSectorAngle(double maximalChildSectorAngle)
Specifies the maximum angle (in degrees) of the sector around a node on which its children will be placed.

Based on the location of a given node, the sector of its children that lie on the next outer layer is described by this angle. The vertex of the angle is located in the center of the node while its sides point away from the inner circles. The child nodes are placed inside this angle. If there is not enough space, the radius of the child circle is increased.

Default Value:
The default value is 180.
Parameters:
maximalChildSectorAngle - the maximum sector angle in degrees from the interval [0,360]
Throws:
java.lang.IllegalArgumentException - if the sector angle is negative or greater than 360 degrees
Sample Graphs:

Maximum sector angle 90

Maximum sector angle 180

Maximum sector angle 360

getMinimalBendAngle

public double getMinimalBendAngle()
Returns the minimum bend angle (in degrees) between two adjacent edge segments.

The minimum bend angle is defined to be a value between 0 and 90 degrees.

 
Increasing this value reduces the number of bends such that the edge path becomes less smooth.
Returns:
an angle from the interval [0,90]
See Also:
setMinimalBendAngle(double)

setMinimalBendAngle

public void setMinimalBendAngle(double minimalBendAngle)
Specifies the minimum bend angle (in degrees) between two adjacent edge segments.

The minimum bend angle is defined to be a value between 0 and 90 degrees.

 
Increasing this value reduces the number of bends such that the edge path becomes less smooth.
Default Value:
The default value is 5.
Parameters:
minimalBendAngle - an angle from the interval [0,90]
Throws:
java.lang.IllegalArgumentException - if the given minimum bend angle is negative or greater than 90
Sample Graphs:

Minimum bend angle 1

Minimum bend angle 20

setCenterNodesPolicy

public void setCenterNodesPolicy(byte policy)
Specifies the policy that determines which nodes are selected as roots of the (virtual) tree for the layout process and are placed in the center of the circles.

 
This policy is ignored if the layers (i.e. circles) are specified manually by using strategy LAYERING_STRATEGY_USER_DEFINED. Instead, the nodes with the smallest provided layer/circle ID determine the center nodes.
Default Value:
The default value is CENTER_NODES_POLICY_WEIGHTED_CENTRALITY. The node determined using weighted centrality is placed in the center.
Parameters:
policy - one of the predefined center node policies
Throws:
java.lang.IllegalArgumentException - if an invalid center node policy is given

getCenterNodesPolicy

public byte getCenterNodesPolicy()
Returns the policy that determines which nodes are selected as roots of the (virtual) tree for the layout process and are set in the center of the circles.

 
This policy is ignored if the layers (i.e. circles) are specified manually by using strategy LAYERING_STRATEGY_USER_DEFINED. Instead, the nodes with the smallest provided layer/circle ID determine the center nodes.
Returns:
one of the predefined center node policies
See Also:
setCenterNodesPolicy(byte)

getCenterNodesDpKey

public java.lang.Object getCenterNodesDpKey()
Returns the DataProvider key used for looking up the selected nodes that should be placed in the center.

 
This option will only take effect if center node policy is set to CENTER_NODES_POLICY_SELECTED_NODES.
Returns:
the DataProvider key for the selection of center nodes
See Also:
setCenterNodesDpKey(Object)

setCenterNodesDpKey

public void setCenterNodesDpKey(java.lang.Object centerNodesDpKey)
Specifies the DataProvider key used for looking up the selected nodes that should be placed in the center.

 
This option will only take effect if center node policy is set to CENTER_NODES_POLICY_SELECTED_NODES.
Default Value:
The default value is Layouter.SELECTED_NODES. The selected nodes are placed in the center.
Parameters:
centerNodesDpKey - the DataProvider key for the selection of center nodes
Throws:
java.lang.IllegalArgumentException - if the specified key is null
See Also:
getCenterNodesDpKey()

getLayeringStrategy

public byte getLayeringStrategy()
Returns the layering strategy that determines how nodes are distributed into different layers. All nodes of a given layer will be placed on the same circle.

Returns:
one of the predefined layering strategies
See Also:
setLayeringStrategy(byte)

setLayeringStrategy

public void setLayeringStrategy(byte layeringStrategy)
Specifies the layering strategy that determines how nodes are distributed into different layers. All nodes of one layer will be placed on the same circle.

Default Value:
The default value is LAYERING_STRATEGY_BFS. The layers are determined using BFS.
Parameters:
layeringStrategy - one of the predefined layering strategies
Throws:
java.lang.IllegalArgumentException - if an invalid layering strategy is set

getEdgeRoutingStrategy

public byte getEdgeRoutingStrategy()
Returns the edge routing strategy.

 
The edge routing cannot always prevent node-edge overlaps.
Returns:
the edge routing strategy
See Also:
setEdgeRoutingStrategy(byte)

setEdgeRoutingStrategy

public void setEdgeRoutingStrategy(byte edgeRoutingStrategy)
Specifies the edge routing strategy.

 
The edge routing cannot always prevent node-edge overlaps.
Default Value:
The default value is EDGE_ROUTING_STRATEGY_ARC. The edges will be routed as arcs.
Parameters:
edgeRoutingStrategy - the edge routing strategy
Throws:
java.lang.IllegalArgumentException - if an invalid edge routing strategy is set

isConsiderNodeLabelsEnabled

public boolean isConsiderNodeLabelsEnabled()
Returns whether or not node labels are taken into account when calculating node positions. Thereby, possible node/node label or node label/node label overlaps are prevented.

 
This option only works correctly if the layout orientation is set to LayoutOrientation.TOP_TO_BOTTOM (which is the default). Changing the layout orientation for an undirected layout algorithm like the RadialLayouter doesn't make sense.
Returns:
true if node labels are considered, false otherwise
See Also:
setConsiderNodeLabelsEnabled(boolean)

setConsiderNodeLabelsEnabled

public void setConsiderNodeLabelsEnabled(boolean handleNodeLabels)
Specifies whether or not node labels are taken into account when calculating node positions. Thereby, possible node/node label or node label/node label overlaps are prevented.

 
This option only works correctly if the layout orientation is set to LayoutOrientation.TOP_TO_BOTTOM (which is the default). Changing the layout orientation for an undirected layout algorithm like the RadialLayouter doesn't make sense.
Default Value:
The default value is false. Node labels are not considered.
Parameters:
handleNodeLabels - true if labels should be considered, false otherwise
Sample Graphs:

false

true

setOrientationLayouterEnabled

public void setOrientationLayouterEnabled(boolean enabled)
Specifies whether or not the LayoutStage that modifies the orientation of the layout is activated.

Overrides:
setOrientationLayouterEnabled in class CanonicMultiStageLayouter
 
If the current layout orientation is LayoutOrientation.TOP_TO_BOTTOM, the orientation of the layout will not be modified.
 
Based on the undirected layout style, disabling OrientationLayouter has no significant effect.
Default Value:
The default value is true. The orientation LayoutStage is activated.
Parameters:
enabled - true if the stage that modifies the orientation is activated, false otherwise
See Also:
CanonicMultiStageLayouter.isOrientationLayouterEnabled(), CanonicMultiStageLayouter.setOrientationLayouter(y.layout.LayoutStage), CanonicMultiStageLayouter.setLayoutOrientation(byte), OrientationLayouter

canLayoutCore

public boolean canLayoutCore(LayoutGraph graph)
Accepts all general graphs.

Specified by:
canLayoutCore in class CanonicMultiStageLayouter
Parameters:
graph - the input graph
Returns:
true for all kinds of graphs

doLayoutCore

public void doLayoutCore(LayoutGraph graph)
Calculates a radial arrangement for the given graph.

Specified by:
doLayoutCore in class CanonicMultiStageLayouter
Parameters:
graph - the input graph

determineCenter

protected NodeList determineCenter(LayoutGraph graph)
Determines the center nodes of the graph according to the selected center node policy.

This method may be overridden to introduce a custom policy that selects center nodes.

Parameters:
graph - the input graph
Returns:
a list of center nodes of the given graph
See Also:
getCenterNodesPolicy(), setCenterNodesPolicy(byte)

getNodeDiameter

protected double getNodeDiameter(LayoutGraph graph,
                                 Node node)
Returns the diameter of the circular space around the center of a given node that should be reserved in order to place the node.

This value describes the circular area that a given node requires in order to be arranged on its own circle without overlapping with other nodes of the same layer. By default, this value equals to the actual diameter of the given node extended by minimum node to node distance. In this manner, nodes maintain enough distance from the remaining nodes.

This method may be overridden to reserve more or different amounts of space around each node of the graph.

Parameters:
graph - the input graph
node - the given node
Returns:
the circular space reserved for the given node

getEdgeBundling

public EdgeBundling getEdgeBundling()
Returns the EdgeBundling instance that defines the settings of the edge bundling feature.

The specified EdgeBundling defines global bundling properties. Settings for individual edges can be defined by assigning an EdgeBundleDescriptor to an edge using a DataProvider registered with key EdgeBundling.EDGE_BUNDLE_DESCRIPTOR_DPKEY.

 
To enable bundling for all edges, set a default bundle descriptor which has bundling enabled.
 
Edge bundling may be of low quality if the virtual tree is not drawn planar, i.e., there exist tree-edges that cross each other. This is more likely to occur if hierarchic layering strategy is selected.
Returns:
the EdgeBundling instance defining the edge bundling setup

© Copyright 2000-2021,
yWorks GmbH.
All rights reserved.