y.layout.radial
Class RadialLayouter

java.lang.Object
  y.layout.CanonicMultiStageLayouter
      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, NODE_TYPE_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