SimplexNodePlacer (yFiles-for-JavaFX-Complete-3.0 API)

java.lang.Object
- com.yworks.yfiles.layout.hierarchic.SimplexNodePlacer

All Implemented Interfaces:

INodePlacer
```
public class SimplexNodePlacer
extends Object
implements INodePlacer
```
This class is a INodePlacer implementation based on rank assignment.
The drawer works with integer values and rounds double values to integers using sophisticated quantizing.

Constructor Summary

Constructors
Constructor and Description

SimplexNodePlacer()

Constructors
Constructor and Description
`SimplexNodePlacer()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`assignLayerCoordinates(LayoutGraph graph, ILayoutDataProvider layoutDataProvider, ILayers layers)` Assigns preliminary y-coordinates for each layer of a hierarchic layout.
`protected void`	`assignNodesToSublayer(NodeList layerNodes, ILayoutDataProvider ldp, LayoutGraph graph, INodeMap lowerSublayer)` Assigns the nodes of a given layer to the corresponding upper/lower sublayer if `node compaction` is enabled.
`void`	`assignSequenceCoordinates(LayoutGraph graph, ILayoutDataProvider layoutDataProvider, ILayers layers, IDrawingDistanceCalculator drawingDistanceCalculator)` Determines the resulting x-coordinates of a hierarchic layout.
`GroupCompactionPolicy`	`getGroupCompactionStrategy()` Gets the strategy used for controlling the horizontal compactness of group nodes.
`protected double`	`getLayerAlignment(LayoutGraph graph, ILayoutDataProvider ldp, Node node, int layerIndex, double minLayerHeight)` Returns the alignment of the node with a specified layer.
`long`	`getMaximumDuration()` Gets the time limit (in milliseconds) set for the layout algorithm.
`protected double`	`getMinDistance(LayoutGraph graph, ILayer layer, Node predNode, Node succ)` Specifies the minimum allowed distance between two nodes of the same given layer.
`protected double`	`getMinimumLayerHeight(LayoutGraph graph, ILayoutDataProvider ldp, ILayer layer)` Returns the minimum height of a given `layer`.
`double`	`getMinimumSublayerDistance()` Gets the minimum distance between the upper and lower sublayer.
`double`	`getSwimLaneCrossingWeight()` Gets the relative weight of edges crossing a swimlane relative to edges that stay in their lane.
`boolean`	`isBarycenterModeEnabled()` Gets whether or not a barycenter drawing mode should be used.
`boolean`	`isBendReduction()` Gets whether or not an optimization step should be applied that tries to further reduce the number of bends.
`boolean`	`isEdgeStraighteningEnabled()` Gets whether or not a postprocessing step should be applied to reduce the number of bends.
`boolean`	`isExactPlacement()` Gets 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, ILayoutDataProvider provider, Node node, boolean inLayer)` Returns whether or not the given node should be treated as a node with fixed (given) coordinates.
`boolean`	`isFromSketchLayerAssignmentEnabled()` Gets 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()` Gets whether or not the `SimplexNodePlacer` tries to create a maximally compact horizontal layout at the cost of more bends.
`boolean`	`isLabelCompactionEnabled()` Gets whether or not the `SimplexNodePlacer` places labels in a more compact style.
`boolean`	`isLongSegmentBreakingEnabled()` Gets whether or not the `SimplexNodePlacer` should break long edge segments in favor of a more compact layout.
`boolean`	`isNodeCompaction()` Gets whether or not nodes should be placed in a more compact style with respect to layout width.
`void`	`setBarycenterModeEnabled(boolean value)` Sets whether or not a barycenter drawing mode should be used.
`void`	`setBendReduction(boolean value)` Sets whether or not an optimization step should be applied that tries to further reduce the number of bends.
`void`	`setEdgeStraighteningEnabled(boolean value)` Sets whether or not a postprocessing step should be applied to reduce the number of bends.
`void`	`setExactPlacement(boolean value)` Sets whether or not the `SimplexNodePlacer` enforces the placement of nodes at their exact current positions, even if this violates minimum distance constraints.
`void`	`setFromSketchLayerAssignmentEnabled(boolean value)` Sets 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(GroupCompactionPolicy value)` Sets the strategy used for controlling the horizontal compactness of group nodes.
`void`	`setHorizontalCompactionEnabled(boolean value)` Sets whether or not the `SimplexNodePlacer` tries to create a maximally compact horizontal layout at the cost of more bends.
`void`	`setLabelCompactionEnabled(boolean value)` Sets whether or not the `SimplexNodePlacer` places labels in a more compact style.
`void`	`setLongSegmentBreakingEnabled(boolean value)` Sets whether or not the `SimplexNodePlacer` should break long edge segments in favor of a more compact layout.
`void`	`setMaximumDuration(long value)` Sets the time limit (in milliseconds) set for the layout algorithm.
`void`	`setMinimumSublayerDistance(double value)` Sets the minimum distance between the upper and lower sublayer.
`void`	`setNodeCompaction(boolean value)` Sets whether or not nodes should be placed in a more compact style with respect to layout width.
`void`	`setSwimLaneCrossingWeight(double value)` Sets 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

- Constructor Detail
  - SimplexNodePlacer
```
public SimplexNodePlacer()
```
- Method Detail
  - assignLayerCoordinates
```
public void assignLayerCoordinates(LayoutGraph graph,
                                   ILayoutDataProvider layoutDataProvider,
                                   ILayers layers)
```
    Description copied from interface: INodePlacer
    
    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 INodePlacer
    
    Parameters:
    
    graph - the input graph
    
    layoutDataProvider - the ILayoutDataProvider containing information about the elements
    
    layers - the ILayers instance that will be calculated by this method
  - assignNodesToSublayer
```
protected void assignNodesToSublayer(NodeList layerNodes,
                                     ILayoutDataProvider ldp,
                                     LayoutGraph graph,
                                     INodeMap 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 INodeMap whose INodeMap.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 ILayoutDataProvider implementation which provides access to the INodeData and IEdgeData instances
    
    graph - the given graph
    
    lowerSublayer - the INodeMap holding sublayer information
    
    See Also:
    
    setNodeCompaction(boolean)
  - assignSequenceCoordinates
```
public void assignSequenceCoordinates(LayoutGraph graph,
                                      ILayoutDataProvider layoutDataProvider,
                                      ILayers layers,
                                      IDrawingDistanceCalculator drawingDistanceCalculator)
```
    Description copied from interface: INodePlacer
    
    Determines the resulting x-coordinates of a hierarchic layout.
    The minimum distance between each pair of nodes of the graph is determined by a IDrawingDistanceCalculator instance.
    
    Specified by:
    
    assignSequenceCoordinates in interface INodePlacer
    
    Parameters:
    
    graph - the input graph
    
    layoutDataProvider - the ILayoutDataProvider containing information about the elements
    
    layers - the ILayers instance that will be calculated by this method
    
    drawingDistanceCalculator - the given IDrawingDistanceCalculator instance
  - getGroupCompactionStrategy
```
public GroupCompactionPolicy getGroupCompactionStrategy()
```
    Gets the strategy used for controlling the horizontal compactness of group nodes.
    
    Default Value:
    The default value is GroupCompactionPolicy.NONE. No group compaction is performed.
    
    Returns:
    
    one of the predefined compaction strategies
    
    See Also:
    
    setGroupCompactionStrategy(GroupCompactionPolicy)
  - getLayerAlignment
```
protected double getLayerAlignment(LayoutGraph graph,
                                   ILayoutDataProvider ldp,
                                   Node node,
                                   int layerIndex,
                                   double minLayerHeight)
```
    Returns the alignment of the node with a specified layer.
    This callback method used by assignLayerCoordinates(LayoutGraph, ILayoutDataProvider, ILayers).
    
    Parameters:
    
    graph - the input graph
    
    ldp - the ILayoutDataProvider implementation which provides access to the INodeData and IEdgeData instances
    
    node - the given node
    
    layerIndex - the index of the layer
    
    minLayerHeight - the minimum height of the layer
  - getMaximumDuration
```
public long getMaximumDuration()
```
    Gets the time limit (in milliseconds) set for the layout algorithm.
    Values have to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the maximum duration is negative
    
    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.
    
    Returns:
    
    a non-negative value that specifies the time limit
    
    See Also:
    
    setMaximumDuration(long)
  - getMinDistance
```
protected double getMinDistance(LayoutGraph graph,
                                ILayer 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, ILayoutDataProvider, ILayers, IDrawingDistanceCalculator).
    
    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:
    
    IDrawingDistanceCalculator
  - getMinimumLayerHeight
```
protected double getMinimumLayerHeight(LayoutGraph graph,
                                       ILayoutDataProvider ldp,
                                       ILayer layer)
```
    Returns the minimum height of a given layer.
    This callback method is used by assignLayerCoordinates(LayoutGraph, ILayoutDataProvider, ILayers).
    
    Parameters:
    
    graph - the given graph
    
    ldp - the ILayoutDataProvider implementation which provides access to the INodeData and IEdgeData instances
    
    layer - the given ILayer object
    
    Returns:
    
    the minimum height
  - getMinimumSublayerDistance
```
public double getMinimumSublayerDistance()
```
    Gets 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 MinimumDistance.
    
    Values should be greater than 0.
    
    Throws:
    
    IllegalArgumentException - if minimum sublayer distance is negative
    
    This option is only considered if the node compaction is enabled.
    
    Default Value:
    The default value is 15.0d.
    
    Returns:
    
    the minimum distance
    
    See Also:
    
    setNodeCompaction(boolean), setMinimumSublayerDistance(double)
  - getSwimLaneCrossingWeight
```
public double getSwimLaneCrossingWeight()
```
    Gets 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.
    
    Throws:
    
    IllegalArgumentException - if the relative weight does not lie within [0,1]
    
    Default Value:
    The default value is 0.0d. The algorithm ignores edges crossing a swimlane border.
    
    Returns:
    
    a double value from [0,1]
    
    See Also:
    
    setSwimLaneCrossingWeight(double)
  - isBarycenterModeEnabled
```
public boolean isBarycenterModeEnabled()
```
    Gets 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.
    
    Default Value:
    The default value is false.
    
    Returns:
    
    true if a barycenter drawing mode is used, false otherwise
    
    See Also:
    
    setBarycenterModeEnabled(boolean)
  - isBendReduction
```
public boolean isBendReduction()
```
    Gets 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 MaximumDuration) the number of bends is not reduced.
    
    Default Value:
    The default value is true.
    
    Returns:
    
    true if the bend optimization step is applied, false otherwise
    
    See Also:
    
    setMaximumDuration(long), setBendReduction(boolean)
  - isEdgeStraighteningEnabled
```
public boolean isEdgeStraighteningEnabled()
```
    Gets 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 BarycenterModeEnabled and NodeCompaction are both disabled.
    
    Default Value:
    The default value is false. A postprocessing step to reduce the number of bends is not applied.
    
    Returns:
    
    true if the number of bends is reduced, false otherwise
    
    See Also:
    
    setEdgeStraighteningEnabled(boolean)
  - isExactPlacement
```
public boolean isExactPlacement()
```
    Gets 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.
    
    Returns:
    
    true if exact coordinates are enforced, false otherwise
    
    See Also:
    
    setExactPlacement(boolean)
  - isFixedNode
```
protected boolean isFixedNode(LayoutGraph graph,
                              ILayoutDataProvider 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(LayoutGraph, ILayoutDataProvider, ILayers) and assignSequenceCoordinates(LayoutGraph, ILayoutDataProvider, ILayers, IDrawingDistanceCalculator).
    
    If inLayer argument is true, this method is called from within the assignLayerCoordinates(LayoutGraph, ILayoutDataProvider, ILayers) method.
    
    Parameters:
    
    graph - the given graph
    
    provider - the ILayoutDataProvider implementation which provides access to the INodeData and IEdgeData 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
  - isFromSketchLayerAssignmentEnabled
```
public boolean isFromSketchLayerAssignmentEnabled()
```
    Gets 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.
    
    Returns:
    
    true if the current sketch is used, false otherwise
    
    See Also:
    
    setFromSketchLayerAssignmentEnabled(boolean)
  - isHorizontalCompactionEnabled
```
public boolean isHorizontalCompactionEnabled()
```
    Gets whether or not the SimplexNodePlacer tries to create a maximally compact horizontal layout at the cost of more bends.
    For best results, LongSegmentBreakingEnabled and LabelCompactionEnabled should also be enabled.
    
    Default Value:
    The default value is false.
    
    Returns:
    
    true if a maximally compact horizontal layout is created, false otherwise
    
    See Also:
    
    setLabelCompactionEnabled(boolean), setLongSegmentBreakingEnabled(boolean), setHorizontalCompactionEnabled(boolean)
  - isLabelCompactionEnabled
```
public boolean isLabelCompactionEnabled()
```
    Gets 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 IDrawingDistanceCalculators, see DrawingDistanceCalculator.
    
    Default Value:
    The default value is false.
    
    Returns:
    
    true if labels are placed compact, false otherwise
    
    See Also:
    
    setLabelCompactionEnabled(boolean)
  - isLongSegmentBreakingEnabled
```
public boolean isLongSegmentBreakingEnabled()
```
    Gets whether or not the SimplexNodePlacer should break long edge segments in favor of a more compact layout.
    
    Default Value:
    The default value is false. Long edges will not be broken.
    
    Returns:
    
    true if long edges are broken, false otherwise
    
    See Also:
    
    setLongSegmentBreakingEnabled(boolean)
  - isNodeCompaction
```
public boolean isNodeCompaction()
```
    Gets 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 IDrawingDistanceCalculators, see DrawingDistanceCalculator.
    
    Default Value:
    The default value is false. Nodes are not placed in a compact style.
    
    Returns:
    
    true if nodes are placed in a compact style, false otherwise
    
    See Also:
    
    setMinimumSublayerDistance(double), assignNodesToSublayer(NodeList, ILayoutDataProvider, LayoutGraph, INodeMap), setNodeCompaction(boolean)
  - setBarycenterModeEnabled
```
public void setBarycenterModeEnabled(boolean value)
```
    Sets 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.
    
    Default Value:
    The default value is false.
    
    Parameters:
    
    value - true if a barycenter drawing mode is used, false otherwise
    
    See Also:
    
    isBarycenterModeEnabled()
  - setBendReduction
```
public void setBendReduction(boolean value)
```
    Sets 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 MaximumDuration) the number of bends is not reduced.
    
    Default Value:
    The default value is true.
    
    Parameters:
    
    value - true if the bend optimization step is applied, false otherwise
    
    See Also:
    
    setMaximumDuration(long), isBendReduction()
  - setEdgeStraighteningEnabled
```
public void setEdgeStraighteningEnabled(boolean value)
```
    Sets 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 BarycenterModeEnabled and NodeCompaction are both disabled.
    
    Default Value:
    The default value is false. A postprocessing step to reduce the number of bends is not applied.
    
    Parameters:
    
    value - true if the number of bends is reduced, false otherwise
    
    See Also:
    
    isEdgeStraighteningEnabled()
  - setExactPlacement
```
public void setExactPlacement(boolean value)
```
    Sets 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:
    
    value - true if exact coordinates are enforced, false otherwise
    
    See Also:
    
    isExactPlacement()
  - setFromSketchLayerAssignmentEnabled
```
public void setFromSketchLayerAssignmentEnabled(boolean value)
```
    Sets 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:
    
    value - true if the current sketch is used, false otherwise
    
    See Also:
    
    isFromSketchLayerAssignmentEnabled()
  - setGroupCompactionStrategy
```
public void setGroupCompactionStrategy(GroupCompactionPolicy value)
```
    Sets the strategy used for controlling the horizontal compactness of group nodes.
    
    Default Value:
    The default value is GroupCompactionPolicy.NONE. No group compaction is performed.
    
    Parameters:
    
    value - one of the predefined compaction strategies
    
    See Also:
    
    getGroupCompactionStrategy()
  - setHorizontalCompactionEnabled
```
public void setHorizontalCompactionEnabled(boolean value)
```
    Sets whether or not the SimplexNodePlacer tries to create a maximally compact horizontal layout at the cost of more bends.
    For best results, LongSegmentBreakingEnabled and LabelCompactionEnabled should also be enabled.
    
    Default Value:
    The default value is false.
    
    Parameters:
    
    value - true if a maximally compact horizontal layout is created, false otherwise
    
    See Also:
    
    setLabelCompactionEnabled(boolean), setLongSegmentBreakingEnabled(boolean), isHorizontalCompactionEnabled()
  - setLabelCompactionEnabled
```
public void setLabelCompactionEnabled(boolean value)
```
    Sets 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 IDrawingDistanceCalculators, see DrawingDistanceCalculator.
    
    Default Value:
    The default value is false.
    
    Parameters:
    
    value - true if labels are placed compact, false otherwise
    
    See Also:
    
    isLabelCompactionEnabled()
  - setLongSegmentBreakingEnabled
```
public void setLongSegmentBreakingEnabled(boolean value)
```
    Sets whether or not the SimplexNodePlacer should break long edge segments in favor of a more compact layout.
    
    Default Value:
    The default value is false. Long edges will not be broken.
    
    Parameters:
    
    value - true if long edges are broken, false otherwise
    
    See Also:
    
    isLongSegmentBreakingEnabled()
  - setMaximumDuration
```
public void setMaximumDuration(long value)
```
    Sets the time limit (in milliseconds) set for the layout algorithm.
    Values have to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the maximum duration is negative
    
    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:
    
    value - a non-negative value that specifies the time limit
    
    See Also:
    
    getMaximumDuration()
  - setMinimumSublayerDistance
```
public void setMinimumSublayerDistance(double value)
```
    Sets 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 MinimumDistance.
    
    Values should be greater than 0.
    
    Throws:
    
    IllegalArgumentException - if minimum sublayer distance is negative
    
    This option is only considered if the node compaction is enabled.
    
    Default Value:
    The default value is 15.0d.
    
    Parameters:
    
    value - the minimum distance
    
    See Also:
    
    setNodeCompaction(boolean), getMinimumSublayerDistance()
  - setNodeCompaction
```
public void setNodeCompaction(boolean value)
```
    Sets 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 IDrawingDistanceCalculators, see DrawingDistanceCalculator.
    
    Default Value:
    The default value is false. Nodes are not placed in a compact style.
    
    Parameters:
    
    value - true if nodes are placed in a compact style, false otherwise
    
    See Also:
    
    setMinimumSublayerDistance(double), assignNodesToSublayer(NodeList, ILayoutDataProvider, LayoutGraph, INodeMap), isNodeCompaction()
  - setSwimLaneCrossingWeight
```
public void setSwimLaneCrossingWeight(double value)
```
    Sets 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.
    
    Throws:
    
    IllegalArgumentException - if the relative weight does not lie within [0,1]
    
    Default Value:
    The default value is 0.0d. The algorithm ignores edges crossing a swimlane border.
    
    Parameters:
    
    value - a double value from [0,1]
    
    See Also:
    
    getSwimLaneCrossingWeight()

Class SimplexNodePlacer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SimplexNodePlacer

Method Detail

assignLayerCoordinates

assignNodesToSublayer

assignSequenceCoordinates

getGroupCompactionStrategy

getLayerAlignment

getMaximumDuration

getMinDistance

getMinimumLayerHeight

getMinimumSublayerDistance

getSwimLaneCrossingWeight

isBarycenterModeEnabled

isBendReduction

isEdgeStraighteningEnabled

isExactPlacement

isFixedNode

isFromSketchLayerAssignmentEnabled

isHorizontalCompactionEnabled

isLabelCompactionEnabled

isLongSegmentBreakingEnabled

isNodeCompaction

setBarycenterModeEnabled

setBendReduction

setEdgeStraighteningEnabled

setExactPlacement

setFromSketchLayerAssignmentEnabled

setGroupCompactionStrategy

setHorizontalCompactionEnabled

setLabelCompactionEnabled

setLongSegmentBreakingEnabled

setMaximumDuration

setMinimumSublayerDistance

setNodeCompaction

setSwimLaneCrossingWeight