Determines the minimal distance between nodes that reside in adjacent layers.

Determines the minimal distance between adjacent nodes that reside in the same layer.

Determines the distance between adjacent pairs of horizontal edge segments, and between horizontal edge segments and nodes.

Determines the minimal length of the first segment in an orthogonal edge routing. This applies to the routing of self-loops, same-layer edges, and orthogonal inter-layer edge routing.

Sets the maximal duration of the layout process in milliseconds. The maximal duration is a soft bound, which may be exceeded in case essential parts of the layout calculation are still missing. Most likely the layout quality will increase with a longer calculation period. In most cases the layouter will consume the complete time assigned to it.

Determines the main layout orientation. The layouter tries to arrange nodes in such a way that all edges point in the main layout direction.

Influences the horizontal spacing between nodes, the number of bends of the edges, and the overall balance of the layout.

Figure 5.21, “Different hierarchic layout styles” displays the effect of using different layout styles. There is a tradeoff involved between the straightness of edge paths and the compactness of the diagram.

Figure 5.21. Different hierarchic layout styles

POLYLINE	PENDULUM	LINEAR_SEGMENTS

SIMPLEX	MEDIAN_SIMPLEX

Determines the edge routing style.

Figure 5.22, “Different routing styles and different edge path realizers” below shows the effect of different routing styles available for class HierarchicLayouter.

Figure 5.22. Different routing styles and different edge path realizers

ROUTE_POLYLINE using PolyLineEdgeRealizer.	ROUTE_ORTHOGONAL using PolyLineEdgeRealizer.

ROUTE_ORTHOGONAL using PolyLineEdgeRealizer and setSmoothedBends() feature.	ROUTE_ORTHOGONAL using BezierEdgeRealizer.

If enabled, all edges that do not point in the main layout direction will be routed as back-loops. Back-loops start at the bottom side of their source node, then turn around 180 degrees, go upward, then turn around 180 degrees again and finally connect to the upper side of their target node.

Class ConstraintLayerer is an implementation of the Layerer interface that enables user-defined constrained layering. Nodes can be restricted to be placed either

The remaining nodes, that have no constraints defined, are processed by the core layerer that is set with ConstraintLayerer. By default, the core layerer uses the Tight Tree heuristic.

Figure 5.23, “Constrained hierarchical layering” shows a resulting hierarchical layout where nodes with an absolute constraint specified for them are placed in the topmost layer (note the emphasis on these nodes). Normally, i.e., when no constraints are specified, these nodes are placed in the very center of the graph as can be observed in the original hierarchical layout.

Figure 5.23. Constrained hierarchical layering

Original hierarchical layout.	Resulting hierarchical layout where the constrained nodes are placed in the topmost layer.

Example 5.19, “Setting the core layerer for ConstraintLayerer” presents how hierarchical layout is set up for constrained layer assignment where the previously configured Layerer implementation is used as ConstraintLayerer's core layerer. Nodes that have no constraints defined will be placed according to the layering strategy of this Layerer.

// Instantiate hierarchical layout and, in particular, configure the layerer.
HierarchicLayouter hl = new HierarchicLayouter();
hl.setLayeringStrategy(HierarchicLayouter.LAYERING_HIERARCHICAL_DOWNSHIFT);
// Instantiate a ConstraintLayerer.
ConstraintLayerer cl = new ConstraintLayerer();
// Set the previously configured layerer as ConstraintLayerer's core layerer.
cl.setCoreLayerer(hl.getLayerer());
// Set the ConstraintLayerer as the new layerer for hierarchical layout.
hl.setLayerer(cl);

To express both absolute and relative constraints, ConstraintLayerer offers a so-called "constraint factory" which provides the methods for specifying constraints for the nodes of a graph. API Excerpt 5.6, “Getter method for ConstraintFactory” shows the static getter method for the constraint factory.

// Getter for the constraint factory.
static ConstraintFactory createConstraintFactory(Graph graph)

The returned constraint factory is specific for the graph given at instantiation. API Excerpt 5.7, “ConstraintFactory methods for specifying constraints” lists the methods that allow to define both absolute and relative constraints for nodes.

// Absolute constraints.
void addPlaceNodeAtTopConstraint(Node n)
void addPlaceNodeAtBottomConstraint(Node n)

// Constraints relative to a given reference node.
void addPlaceNodeInSameLayerConstraint(Node reference, Node sameLayer)
void addPlaceNodeAboveConstraint(Node reference, Node above)
void addPlaceNodeBelowConstraint(Node reference, Node below)

Using class ConstraintLayerer in a hierarchical layout and defining constraints for the nodes of a graph is demonstrated in the tutorial demo application ConstraintLayererDemo.java.

Determines the strategy used to find a better node ordering within a layer.

If enabled, a postprocessing further reduces the number of edge crossings. The postprocessing step can be rather time consuming. This feature is disabled by default. It is advisable to activate this processing step for high quality layout results.

If enabled, a postprocessing step tries to eliminate all false edge crossings. A false edge crossing is an edge crossing between two edges that share a common terminal node.

The hierarchic layout algorithm can be configured to obey port constraints. Using port constraints for both ends of each edge in the graph it is possible to specify at which side of the source and target node an edge path must connect. This feature is supported for all different kinds of edges: ordinary edges, self-loops, and same layer edges.

The algorithm can be instructed to place each port at either the North, East, South, or West side of the node, or to choose the most appropriate side itself.

Figure 5.24. Constraint on which side edges should connect to nodes

Opposed to "Weak Port Constraints," using "Strong Port Constraints" it is possible to not only specify the side of the node at which an edge must connect to it, but also the exact port position.

Both strong and weak port constraints can be mixed easily in the drawing. Strong port constraints are supported by all three types of edges.

Figure 5.25, “Constraint at which exact points edges should connect to nodes” demonstrates strong port constraints (the rather "odd" port positions have been set to be "strong").

Figure 5.25. Constraint at which exact points edges should connect to nodes

A special feature of the hierarchical layout algorithm is its ability to group multiple ports (edge end points) together to be anchored at the same location. This can be specified for both source ports and target ports.

Edges that belong to the same group at a specific end will additionally be routed in bus-style, i.e., if multiple edges start or end at the same layer and belong to the same group, even if they do not share the same node at that end point, they will be merged together in a bus structure in that layer.

This highly versatile configuration policy can be used to specify different interesting edge routing behaviors. Some of them are shown in Figure 5.26, “Multiple different edge group configurations resulting in bus style edge routings”.

Figure 5.26. Multiple different edge group configurations resulting in bus style edge routings

The hierarchical layout algorithm allows to bundle nodes within a layer to a so-called "packed block" of nodes. A packed block will always be placed as an inseparable unit on the layer. Note that this will only influence nodes that lie in the same layer. Figure 5.27, “Packed blocks” shows three packed blocks on different layers of the graph. In the figure, the blocks are emphasized both by an enclosing rectangle and also by different node colors.

Figure 5.27. Packed blocks

To specify the packed block a node should be put into, a data provider holding such supplemental layout data can be bound to the graph. The data provider is expected to be registered with the graph using key GROUP_KEY. Note that in the absence of the data provider no packed blocks are created.

Besides the general labeling support as described in the section called “General Labeling”, which is available with all yFiles layout algorithms, the hierarchical layout algorithm additionally features integrated labeling. Integrated labeling is available for edge labels, they are taken into consideration when determining both node placement and edge path generation. With this strategy it is guaranteed that no edge label will overlap other objects in the diagram.

Figure 5.28. Automatic edge labeling methods

General edge labeling as a postprocessing step. Labels may overlap other objects.	Edge labeling as part of main layout procedure. Labels only overlap their associated edges.

To specify size and preferred placement of edge labels when using integrated labeling, a data provider holding such supplemental layout data must be bound to the graph. The data provider is expected to be registered with the graph using key EDGE_LABEL_LAYOUT_KEY.

Enabling integrated labeling with HierarchicLayouter and using the services of class LabelLayoutTranslator to conveniently have such a data provider created and bound to the graph is described in the section called “Integrated Labeling”.