RadialLayout

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 custom center nodes using centerNodes.

Sample output of the layout algorithm for a tree with dendrogram layering, radial polyline edge routing and maximum child sector angle 360.

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 layeringStrategy.

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

The minimum distance between nodes of the same circle is specified using minimumNodeDistance. 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 layerSpacing. 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 minimumLayerDistance.

The RadialLayout also supports nodeTypes as a subordinate criterion for nodes of the same circle. More precisely, for nodes of the same circle (i.e., within the same layer), the algorithm prefers to place nodes of the same type next to each other if this does not induce additional crossings or conflicts with other constraints. Note that the algorithm uses an additional local optimization heuristic to improve the placement with respect to node types and, thus, does not guarantee optimal results. Furthermore, this additional step may increase the required runtime. The layer assignment is not affected by the node types.

The ordering of successor nodes can be specified by means of a mapper, see childOrder. This ordering criterion is stronger than the node types. This feature is especially suitable for tree-like graphs to sort child nodes.

This layout algorithm handles port placement constraints by applying the PortPlacementStage as a postprocessing step.

Layout Stages

This class provides a configurable pipeline that contains various ILayoutStages. Each ILayoutStage can incorporate preprocessing or postprocessing steps into the layout calculation to streamline the input graph and enhance the resulting layout. Additionally, custom ILayoutStages can be added and executed either before or after the predefined ones.

The following default ILayoutStages are included:

• PortPlacementStage
• GroupHidingStage
• ComponentLayout (disabled per default)
• GenericLabeling (disabled per default)
• SelfLoopRouter
• ParallelEdgeRouter
• TreeReductionStage (disabled per default)

With these layoutStages the layout algorithm is configured well, so they usually don't need to be changed.

Performance

The RadialLayout algorithm is a fast algorithm that is generally well-suited to handle even large graphs.

With disconnected graphs containing large unconnected components, it can be beneficial to change the component arrangement style of the used componentLayout from the default style PACKED_CIRCLE to the faster ROWS style.

With graphs containing a large number of edges, applying edgeBundling can cause the algorithm to take noticeably longer to arrive at a result.