y.layout.hierarchic.incremental
Class SimplexNodePlacer

java.lang.Object
  y.layout.hierarchic.incremental.SimplexNodePlacer

All Implemented Interfaces:

NodePlacer

public class SimplexNodePlacer
extends java.lang.Object
implements NodePlacer

This class is a NodePlacer implementation based on rank assignment.

The drawer works with integer values and rounds double values to integers using sophisticated quantizing.

Field Summary

static int	GROUP_COMPACTION_MAX A strategy specifying maximal horizontal group compaction.
static int	GROUP_COMPACTION_NONE A strategy specifying no horizontal group compaction.

Constructor Summary

SimplexNodePlacer()

Method Summary

void	assignLayerCoordinates(LayoutGraph graph, LayoutDataProvider layoutDataProvider, Layers layers) Assigns preliminary y-coordinates for each layer of a hierarchic layout.
protected void	assignNodesToSublayer(NodeList layerNodes, LayoutDataProvider ldp, LayoutGraph graph, NodeMap lowerSublayer) Assigns the nodes of a given layer to the corresponding upper/lower sublayer if node compaction is enabled.
void	assignSequenceCoordinates(LayoutGraph graph, LayoutDataProvider layoutDataProvider, Layers layers, DrawingDistanceCalculator drawingDistanceCalculator) Determines the resulting x-coordinates of a hierarchic layout.
int	getGroupCompactionStrategy() Specifies the strategy used for controlling the horizontal compactness of group nodes.
protected double	getLayerAlignment(LayoutGraph graph, LayoutDataProvider ldp, Node node, int layerIndex, double minLayerHeight) Returns the alignment of the node with a specified layer.
long	getMaximalDuration() Returns the time limit (in milliseconds) set for the layout algorithm.
protected double	getMinDistance(LayoutGraph graph, Layer layer, Node predNode, Node succ) Specifies the minimum allowed distance between two nodes of the same given layer.
protected double	getMinimumLayerHeight(LayoutGraph graph, LayoutDataProvider ldp, Layer layer) Returns the minimum height of a given layer.
double	getMinimumSublayerDistance() Returns the minimum distance between the upper and lower sublayer.
double	getSwimLaneCrossingWeight() Returns the relative weight of edges crossing a swimlane relative to edges that stay in their lane.
boolean	isBaryCenterModeEnabled() Returns whether or not a barycenter drawing mode should be used.
boolean	isBendReductionEnabled() Returns whether or not an optimization step should be applied that tries to further reduce the number of bends.
boolean	isBreakLongSegmentsEnabled() Returns whether or not the SimplexNodePlacer should break long edge segments in favor of a potentially more compact layout.
boolean	isEdgeStraighteningOptimizationEnabled() Returns whether or not a postprocessing step should be applied to reduce the number of bends.
boolean	isExactPlacementEnforced() Returns whether or not the SimplexNodePlacer enforces the placement of nodes at their exact current positions, even if this violates minimum distance constraints.
protected boolean	isFixedNode(LayoutGraph graph, LayoutDataProvider provider, Node node, boolean inLayer) Returns whether or not the given node should be treated as a node with fixed (given) coordinates.
boolean	isFromSketchLayerAssignment() Returns whether or not the SimplexNodePlacer should try to use the coordinates given from the current sketch for the determination of the layer coordinates.
boolean	isHorizontalCompactionEnabled() Returns whether or not the SimplexNodePlacer tries to create a maximally compact horizontal layout at the cost of more bends.
boolean	isLabelCompactionEnabled() Returns whether or not the SimplexNodePlacer places labels in a more compact style.
boolean	isNodeCompactionEnabled() Returns whether or not nodes should be placed in a more compact style with respect to layout width.
void	setBaryCenterModeEnabled(boolean enabled) Specifies whether or not a barycenter drawing mode should be used.
void	setBendReductionEnabled(boolean bendReductionEnabled) Specifies whether or not an optimization step should be applied that tries to further reduce the number of bends.
void	setBreakLongSegmentsEnabled(boolean breakLongSegmentsEnabled) Specifies whether or not the SimplexNodePlacer should break long edge segments in favor of a potentially more compact layout.
void	setEdgeStraighteningOptimizationEnabled(boolean edgeStraighteningOptimizationEnabled) Specifies whether or not a postprocessing step should be applied to reduce the number of bends.
void	setExactPlacementEnforced(boolean exactPlacementEnforced) Specifies whether or not the SimplexNodePlacer enforces the placement of nodes at their exact current positions, even if this violates minimum distance constraints.
void	setFromSketchLayerAssignment(boolean fromSketchLayerAssignment) Specifies whether or not the SimplexNodePlacer should try to use the coordinates given from the current sketch for the determination of the layer coordinates.
void	setGroupCompactionStrategy(int groupCompactionStrategy) Specifies the strategy used for controlling the horizontal compactness of group nodes.
void	setHorizontalCompactionEnabled(boolean horizontalCompactionEnabled) Specifies whether or not the SimplexNodePlacer tries to create a maximally compact horizontal layout at the cost of more bends.
void	setLabelCompactionEnabled(boolean labelCompactionEnabled) Specifies whether or not the SimplexNodePlacer places labels in a more compact style.
void	setMaximalDuration(long maximalDuration) Specifies the time limit (in milliseconds) set for the layout algorithm.
void	setMinimumSublayerDistance(double minimumSublayerDistance) Specifies the minimum distance between the upper and lower sublayer.
void	setNodeCompactionEnabled(boolean nodeCompactionEnabled) Specifies whether or not nodes should be placed in a more compact style with respect to layout width.
void	setSwimLaneCrossingWeight(double weight) Specifies the relative weight of edges crossing a swimlane relative to edges that stay in their lane.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

GROUP_COMPACTION_NONE

public static final int GROUP_COMPACTION_NONE

A strategy specifying no horizontal group compaction.

This means that group node contents will occupy nearly the same horizontal positions as when not grouped at all.

See Also:

setGroupCompactionStrategy(int), Constant Field Values

Sample Graph:

GROUP_COMPACTION_MAX

public static final int GROUP_COMPACTION_MAX

A strategy specifying maximal horizontal group compaction.

This means that the node placer will try to minimize the horizontally occupied space for a group node.

To obtain compact groups you should additionally disable option setBendReductionEnabled(boolean).

See Also:

setGroupCompactionStrategy(int), Constant Field Values

Sample Graph:

Constructor Detail

SimplexNodePlacer

public SimplexNodePlacer()

Method Detail

isNodeCompactionEnabled

public boolean isNodeCompactionEnabled()

Returns whether or not nodes should be placed in a more compact style with respect to layout width.

If enabled, the algorithm may place the nodes of a layer in a stacked style (horizontally interleaving), i.e., it splits the layer into an upper and lower sublayer and places adjacent nodes into different sublayers if this reduces the width of the layer.

Enabling this option increases the required layout height.

This option does not work with customized DrawingDistanceCalculators, see HierarchicLayouter.setDrawingDistanceCalculator(DrawingDistanceCalculator).

Returns:

true if nodes are placed in a compact style, false otherwise

See Also:

setNodeCompactionEnabled(boolean), setMinimumSublayerDistance(double), assignNodesToSublayer(y.base.NodeList, LayoutDataProvider, y.layout.LayoutGraph, y.base.NodeMap)

setNodeCompactionEnabled

public void setNodeCompactionEnabled(boolean nodeCompactionEnabled)

Specifies whether or not nodes should be placed in a more compact style with respect to layout width.

If enabled, the algorithm may place the nodes of a layer in a stacked style (horizontally interleaving), i.e., it splits the layer into an upper and lower sublayer and places adjacent nodes into different sublayers if this reduces the width of the layer.

Enabling this option increases the required layout height.

This option does not work with customized DrawingDistanceCalculators, see HierarchicLayouter.setDrawingDistanceCalculator(DrawingDistanceCalculator).

Default Value:

The default value is false. Nodes are not placed in a compact style.

Parameters:

nodeCompactionEnabled - true if nodes should be placed in a compact style, false otherwise

See Also:

setMinimumSublayerDistance(double), assignNodesToSublayer(y.base.NodeList, LayoutDataProvider, y.layout.LayoutGraph, y.base.NodeMap)

Sample Graphs:

false

true

getMinimumSublayerDistance

public double getMinimumSublayerDistance()

Returns the minimum distance between the upper and lower sublayer.

A too small distance value may prevent adjacent nodes from being placed in a stacked style (horizontally interleaving) because the vertical distance between these nodes must be greater than or equal to the value specified by NodeLayoutDescriptor.getMinimumDistance().

Values should be greater than 0.

This option is only considered if the node compaction is enabled.

Returns:

the minimum distance

See Also:

setMinimumSublayerDistance(double), setNodeCompactionEnabled(boolean)

setMinimumSublayerDistance

public void setMinimumSublayerDistance(double minimumSublayerDistance)

Specifies the minimum distance between the upper and lower sublayer.

A too small distance value may prevent adjacent nodes from being placed in a stacked style (horizontally interleaving) because the vertical distance between these nodes must be greater than or equal to the value specified by NodeLayoutDescriptor.getMinimumDistance().

Values should be greater than 0.

This option is only considered if the node compaction is enabled.

Default Value:

The default value is 15.0d.

Parameters:

minimumSublayerDistance - the minimum distance

Throws:

java.lang.IllegalArgumentException - if minimum sublayer distance is negative

See Also:

setNodeCompactionEnabled(boolean)

Sample Graphs:

Minimum distance 15.0d

Minimum distance 100.0d

isLabelCompactionEnabled

public boolean isLabelCompactionEnabled()

Returns whether or not the SimplexNodePlacer places labels in a more compact style.

If this option is enabled the algorithm tries to place adjacent label elements in a stacked style, i.e., horizontally interleaving.

This option has no effect with customized DrawingDistanceCalculators, see HierarchicLayouter.setDrawingDistanceCalculator(DrawingDistanceCalculator).

Returns:

true if labels are placed compact, false otherwise

setLabelCompactionEnabled

public void setLabelCompactionEnabled(boolean labelCompactionEnabled)

Specifies whether or not the SimplexNodePlacer places labels in a more compact style.

If this option is enabled the algorithm tries to place adjacent label elements in a stacked style, i.e., horizontally interleaving.

This option has no effect with customized DrawingDistanceCalculators, see HierarchicLayouter.setDrawingDistanceCalculator(DrawingDistanceCalculator).

Default Value:

The default value is false.

Parameters:

labelCompactionEnabled - true if labels should be placed compact, false otherwise

isBendReductionEnabled

public boolean isBendReductionEnabled()

Returns whether or not an optimization step should be applied that tries to further reduce the number of bends.

Using this option may increase the running time of the layout algorithm. If the running time exceeds the maximum duration (see setMaximalDuration(long)) the number of bends is not reduced.

Returns:

true if the bend optimization step is applied, false otherwise

See Also:

setBendReductionEnabled(boolean), setMaximalDuration(long)

setBendReductionEnabled

public void setBendReductionEnabled(boolean bendReductionEnabled)

Specifies whether or not an optimization step should be applied that tries to further reduce the number of bends.

Using this option may increase the running time of the layout algorithm. If the running time exceeds the maximum duration (see setMaximalDuration(long)) the number of bends is not reduced.

Default Value:

The default value is true.

Parameters:

bendReductionEnabled - true if the bend optimization step should be applied, false otherwise

See Also:

setMaximalDuration(long)

isHorizontalCompactionEnabled

public boolean isHorizontalCompactionEnabled()

Returns whether or not the SimplexNodePlacer tries to create a maximally compact horizontal layout at the cost of more bends.

For best results, setBreakLongSegmentsEnabled(boolean) and setLabelCompactionEnabled(boolean) should also be enabled.

Returns:

true if a maximally compact horizontal layout is created, false otherwise

See Also:

isHorizontalCompactionEnabled(), setLabelCompactionEnabled(boolean), setBreakLongSegmentsEnabled(boolean)

setHorizontalCompactionEnabled

public void setHorizontalCompactionEnabled(boolean horizontalCompactionEnabled)

Specifies whether or not the SimplexNodePlacer tries to create a maximally compact horizontal layout at the cost of more bends.

For best results, setBreakLongSegmentsEnabled(boolean) and setLabelCompactionEnabled(boolean) should also be enabled.

Default Value:

The default value is false.

Parameters:

horizontalCompactionEnabled - true if a maximally compact horizontal layout should be created, false otherwise

See Also:

isHorizontalCompactionEnabled(), setLabelCompactionEnabled(boolean), setBreakLongSegmentsEnabled(boolean)

isEdgeStraighteningOptimizationEnabled

public boolean isEdgeStraighteningOptimizationEnabled()

Returns whether or not a postprocessing step should be applied to reduce the number of bends.

Furthermore, enabling this option may violate some minimum distances specified by the user and the edge distribution is no longer uniform.

This option is only considered if option setBaryCenterModeEnabled(boolean) and setNodeCompactionEnabled(boolean) are both disabled.

Returns:

true if the number of bends is reduced, false otherwise

See Also:

setEdgeStraighteningOptimizationEnabled(boolean)

setEdgeStraighteningOptimizationEnabled

public void setEdgeStraighteningOptimizationEnabled(boolean edgeStraighteningOptimizationEnabled)

Specifies whether or not a postprocessing step should be applied to reduce the number of bends.

Furthermore, enabling this option may violate some minimum distances specified by the user and the edge distribution is no longer uniform.

This option is only considered if option setBaryCenterModeEnabled(boolean) and setNodeCompactionEnabled(boolean) are both disabled.

Default Value:

The default value is false. A postprocessing step to reduce the number of bends is not applied.

Parameters:

edgeStraighteningOptimizationEnabled - true if the number of bends should be reduced, false otherwise

Sample Graphs:

false

true

getGroupCompactionStrategy

public int getGroupCompactionStrategy()

Specifies the strategy used for controlling the horizontal compactness of group nodes.

To obtain compact groups you should additionally disable option setBendReductionEnabled(boolean).

Returns:

one of the predefined compaction strategies

See Also:

setGroupCompactionStrategy(int)

setGroupCompactionStrategy

public void setGroupCompactionStrategy(int groupCompactionStrategy)

Specifies the strategy used for controlling the horizontal compactness of group nodes.

To obtain compact groups you should additionally disable option setBendReductionEnabled(boolean).

Default Value:

The default value is GROUP_COMPACTION_NONE. No group compaction is performed.

Parameters:

groupCompactionStrategy - one of the predefined compaction strategies

isExactPlacementEnforced

public boolean isExactPlacementEnforced()

Returns whether or not the SimplexNodePlacer enforces the placement of nodes at their exact current positions, even if this violates minimum distance constraints.

Returns:

true if exact coordinates are enforced, false otherwise

See Also:

setExactPlacementEnforced(boolean)

setExactPlacementEnforced

public void setExactPlacementEnforced(boolean exactPlacementEnforced)

Specifies whether or not the SimplexNodePlacer enforces the placement of nodes at their exact current positions, even if this violates minimum distance constraints.

Default Value:

The default value is true.

Parameters:

exactPlacementEnforced - true if exact coordinates should be enforced, false otherwise

isFromSketchLayerAssignment

public boolean isFromSketchLayerAssignment()

Returns whether or not the SimplexNodePlacer should try to use the coordinates given from the current sketch for the determination of the layer coordinates.

Returns:

true if the current sketch is used, false otherwise

See Also:

setFromSketchLayerAssignment(boolean)

setFromSketchLayerAssignment

public void setFromSketchLayerAssignment(boolean fromSketchLayerAssignment)

Specifies whether or not the SimplexNodePlacer should try to use the coordinates given from the current sketch for the determination of the layer coordinates.

Default Value:

The default value is true.

Parameters:

fromSketchLayerAssignment - true if the current sketch should be used, false otherwise

Sample Graphs:

Initial Graph

false

true

getMaximalDuration

public long getMaximalDuration()

Returns the time limit (in milliseconds) set for the layout algorithm.

Values have to be greater than or equal to 0.

Restricting the maximum duration may result in a lower layout quality. Furthermore, the real runtime may exceed the maximum duration since the layout algorithm still has to find a valid solution.

Returns:

a non-negative value that specifies the time limit

See Also:

setMaximalDuration(long)

setMaximalDuration

public void setMaximalDuration(long maximalDuration)

Specifies the time limit (in milliseconds) set for the layout algorithm.

Values have to be greater than or equal to 0.

Restricting the maximum duration may result in a lower layout quality. Furthermore, the real runtime may exceed the maximum duration since the layout algorithm still has to find a valid solution.

Default Value:

The default value is Long.MAX_VALUE. The layout algorithm runs unrestricted.

Parameters:

maximalDuration - a non-negative value that specifies the time limit

Throws:

java.lang.IllegalArgumentException - if the maximum duration is negative

setSwimLaneCrossingWeight

public void setSwimLaneCrossingWeight(double weight)

Specifies the relative weight of edges crossing a swimlane relative to edges that stay in their lane. Higher values lead to more compact drawings but may cause additional bends.

Values should lie within [0,1] interval.

Default Value:

The default value is 0.0d. The algorithm ignores edges crossing a swimlane border.

Parameters:

weight - a double value from [0,1]

Throws:

java.lang.IllegalArgumentException - if the relative weight does not lie within [0,1]

Sample Graphs:

Crossing weight 0.0d

Crossing weight 1.0d

getSwimLaneCrossingWeight

public double getSwimLaneCrossingWeight()

Returns the relative weight of edges crossing a swimlane relative to edges that stay in their lane. Higher values lead to more compact drawings but may cause additional bends.

Values should lie within [0,1] interval.

Returns:

a double value from [0,1]

See Also:

setSwimLaneCrossingWeight(double)

setBaryCenterModeEnabled

public void setBaryCenterModeEnabled(boolean enabled)

Specifies whether or not a barycenter drawing mode should be used.

If this mode is enabled the resulting drawing is likely to have more bends, but may be more symmetric.

Disabling option setBendReductionEnabled(boolean) may produce more symmetric results.

Default Value:

The default value is true.

Parameters:

enabled - true if a barycenter drawing mode should be used, false otherwise

Sample Graphs:

false

true

isBaryCenterModeEnabled

public boolean isBaryCenterModeEnabled()

Returns whether or not a barycenter drawing mode should be used.

If this mode is enabled the resulting drawing is likely to have more bends, but may be more symmetric.

Disabling option setBendReductionEnabled(boolean) may produce more symmetric results.

Returns:

true if a barycenter drawing mode is used, false otherwise

See Also:

setBaryCenterModeEnabled(boolean)

assignLayerCoordinates

public void assignLayerCoordinates(LayoutGraph graph,
                                   LayoutDataProvider layoutDataProvider,
                                   Layers layers)

Description copied from interface: NodePlacer

Assigns preliminary y-coordinates for each layer of a hierarchic layout.

The distance between two layers will be adjusted later by the edge routing algorithm. This method is responsible for assigning the relative positions of the nodes within each layer.

Specified by:

assignLayerCoordinates in interface NodePlacer

Parameters:

graph - the input graph

layoutDataProvider - the LayoutDataProvider containing information about the elements

layers - the Layers instance that will be calculated by this method

assignNodesToSublayer

protected void assignNodesToSublayer(NodeList layerNodes,
                                     LayoutDataProvider ldp,
                                     LayoutGraph graph,
                                     NodeMap lowerSublayer)

Assigns the nodes of a given layer to the corresponding upper/lower sublayer if node compaction is enabled.

Information about sublayers is given by a NodeMap whose NodeMap.getBool(Object) method has to return true for each node that should be placed in the lower sublayer (values are set by this method).

Parameters:

layerNodes - a list of all @link y.layout.hierarchic.incremental.NodeData#TYPE_NORMAL normal nodes} of a layer

ldp - the LayoutDataProvider implementation which provides access to the NodeData and EdgeData instances

graph - the given graph

lowerSublayer - the NodeMap holding sublayer information

See Also:

setNodeCompactionEnabled(boolean)

isFixedNode

protected boolean isFixedNode(LayoutGraph graph,
                              LayoutDataProvider provider,
                              Node node,
                              boolean inLayer)

Returns whether or not the given node should be treated as a node with fixed (given) coordinates.

This callback method is used by both assignLayerCoordinates(y.layout.LayoutGraph,LayoutDataProvider,Layers) and assignSequenceCoordinates(y.layout.LayoutGraph,LayoutDataProvider,Layers,DrawingDistanceCalculator).

If inLayer argument is true, this method is called from within the assignLayerCoordinates(y.layout.LayoutGraph,LayoutDataProvider,Layers) method.

Parameters:

graph - the given graph

provider - the LayoutDataProvider implementation which provides access to the NodeData and EdgeData instances

node - the given node

inLayer - true if the layer coordinate of the node is queried, false if the sequence coordinate is queried

Returns:

true if the node should be treated as fixed, false otherwise

getMinimumLayerHeight

protected double getMinimumLayerHeight(LayoutGraph graph,
                                       LayoutDataProvider ldp,
                                       Layer layer)

Returns the minimum height of a given layer.

This callback method is used by assignLayerCoordinates(LayoutGraph,LayoutDataProvider,Layers).

Parameters:

graph - the given graph

ldp - the LayoutDataProvider implementation which provides access to the NodeData and EdgeData instances

layer - the given Layer object

Returns:

the minimum height

getLayerAlignment

protected double getLayerAlignment(LayoutGraph graph,
                                   LayoutDataProvider ldp,
                                   Node node,
                                   int layerIndex,
                                   double minLayerHeight)

Returns the alignment of the node with a specified layer.

This callback method is used by assignLayerCoordinates(LayoutGraph,LayoutDataProvider,Layers).

Parameters:

graph - the input graph

ldp - the LayoutDataProvider implementation which provides access to the NodeData and EdgeData instances

node - the given node

layerIndex - the index of the layer

minLayerHeight - the minimum height of the layer

assignSequenceCoordinates

public void assignSequenceCoordinates(LayoutGraph graph,
                                      LayoutDataProvider layoutDataProvider,
                                      Layers layers,
                                      DrawingDistanceCalculator drawingDistanceCalculator)

Description copied from interface: NodePlacer

Determines the resulting x-coordinates of a hierarchic layout.

The minimum distance between each pair of nodes of the graph is determined by a DrawingDistanceCalculator instance.

Specified by:

assignSequenceCoordinates in interface NodePlacer

Parameters:

graph - the input graph

layoutDataProvider - the LayoutDataProvider containing information about the elements

layers - the Layers instance that will be calculated by this method

drawingDistanceCalculator - the given DrawingDistanceCalculator instance

getMinDistance

protected double getMinDistance(LayoutGraph graph,
                                Layer layer,
                                Node predNode,
                                Node succ)

Specifies the minimum allowed distance between two nodes of the same given layer.

This callback method is used by assignSequenceCoordinates(LayoutGraph, LayoutDataProvider, Layers, DrawingDistanceCalculator).

Parameters:

graph - the graph that contains the nodes

layer - the layer that contains the nodes

predNode - the node to the left of the other one, may be null to indicate a border line

succ - the node to the right of the other one, may be null to indicate a border line

Returns:

the minimum distance allowed between those two nodes ( >=0 )

See Also:

DrawingDistanceCalculator

isBreakLongSegmentsEnabled

public boolean isBreakLongSegmentsEnabled()

Returns whether or not the SimplexNodePlacer should break long edge segments in favor of a potentially more compact layout.

A long edge is an edge that spans multiple layers. For each layer, a dummy node is necessary to model the edge path from source to target.

• Not breaking such edges means that there is a constraint that enforces the alignment of all these dummy nodes (same x-coordinate). This favors straight edge paths.
• Breaking an edge means that the dummy nodes are not necessarily aligned, but additional bends can be generated if that leads to a horizontally more compact layout result.

It is not guaranteed that enabling this setting leads to more compact results. The effect highly depends on the actual input and other algorithm settings. Breaking up the segments might still not allow to make the layout horizontally more compact.

Enabling this setting will in general negatively affect the performance, which might be considerable at least for larger graphs.

Returns:

true if long edges are broken, false otherwise

See Also:

setBreakLongSegmentsEnabled(boolean)

setBreakLongSegmentsEnabled

public void setBreakLongSegmentsEnabled(boolean breakLongSegmentsEnabled)

Specifies whether or not the SimplexNodePlacer should break long edge segments in favor of a potentially more compact layout.

A long edge is an edge that spans multiple layers. For each layer, a dummy node is necessary to model the edge path from source to target.

• Not breaking such edges means that there is a constraint that enforces the alignment of all these dummy nodes (same x-coordinate). This favors straight edge paths.
• Breaking an edge means that the dummy nodes are not necessarily aligned, but additional bends can be generated if that leads to a horizontally more compact layout result.

It is not guaranteed that enabling this setting leads to more compact results. The effect highly depends on the actual input and other algorithm settings. Breaking up the segments might still not allow to make the layout horizontally more compact.

Enabling this setting will in general negatively affect the performance, which might be considerable at least for larger graphs.

Default Value:

The default value is false. Long edges will not be broken, in favor of straight edge paths and better performance.

Parameters:

breakLongSegmentsEnabled - true if long edges should be broken, false otherwise