Search this API

y.layout.hierarchic.incremental
Class SimplexNodePlacer

java.lang.Object
  extended by 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 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.

 
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.

 
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

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