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

java.lang.Object
- com.yworks.yfiles.layout.MultiStageLayout
- - com.yworks.yfiles.layout.organic.OrganicLayout

All Implemented Interfaces:

ILayoutAlgorithm
```
public class OrganicLayout
extends MultiStageLayout
```
This layout algorithm arranges graphs in an organic fashion.

Layout Style
The organic layout style is characterized by a natural distribution of nodes that exhibits clusters and symmetric properties of the graph. Nodes are placed space-saving, close to their adjacent nodes. Edges maintain uniform lengths and are routed with straight-line segments without bends.

Organic diagrams are commonly used for visualizing relations in large networks for example in bioinformatics, enterprise networking, visualizing social networks, mesh visualization or system management.

Organic Layout obtained with default settings Organic Layout exhibiting symmetric properties
Concept
OrganicLayout uses a force-directed approach to place the nodes of the input graph. According to this approach, the graph is modeled as a physical system with appropriate forces acting on it. Nodes are considered as electrically charged particles with mutually repulsive forces. Edges are modeled as springs that attract adjacent nodes. A good diagram is obtained from an equilibrium state of the system, i.e., the nodes are rearranged based on the physical forces until the system reaches a (local) minimum of the sum of the forces.
Features

The ratio between the layout quality and the running time is conveniently adjustable. Another way to decrease the running time is to execute the layout algorithm multi-threaded.

This layout algorithm is able to consider a PartitionGrid structure. However, for common nodes (i.e. non-group nodes) it only considers single partition cells. Furthermore, the layout algorithm will throw a InvalidGraphStructureException if there is a partition grid and the descendants of a group node are assigned to different partition grid cells or if there are group nodes that are associated with a group node mode other than GroupNodeMode.NORMAL.

Although overlaps between edges and nodes are avoided, this layout algorithm doesn't guarantee that they won't appear in the resulting layout. To avoid overlaps, it is possible to route the edges afterwards using an edge routing algorithm, e.g., OrganicEdgeRouter.

The algorithm is also able to detect certain types of substructures in a graph (i.e., chains, stars, cycles and parallel structures) and arrange these structures with special-purpose layout styles. Using substructure styles ensures that the corrsponding structures are easily recognized in the graph.

Organic Layout without applying specific layout styles to substructures Organic Layout of the same graph applying specific layout styles to the detected substructures

Field Summary

Fields
Modifier and Type	Field and Description
`static NodeDpKey<Boolean>`	`AFFECTED_NODES_DPKEY` A `DataProvider` key for marking the nodes that are part of the relevant subset
`static EdgeDpKey<Double>`	`EDGE_DIRECTEDNESS_DPKEY` A `DataProvider` key for specifying the directedness of edges.
`static NodeDpKey<GroupNodeMode>`	`GROUP_NODE_MODE_DPKEY` A `DataProvider` key for assigning individual modes for all group nodes The modes specify how a group's content is handled and if it is resized during layout calculation.
`static EdgeDpKey<Double>`	`PREFERRED_EDGE_LENGTH_DPKEY` A `DataProvider` key for defining an individual preferred length for each edge

Constructor Summary

Constructors
Constructor and Description

OrganicLayout()
Creates a new OrganicLayout instance with default settings.

Constructors
Constructor and Description
`OrganicLayout()` Creates a new `OrganicLayout` instance with default settings.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyLayout(LayoutGraph graph)` Calculates an organic arrangement of the graph.
`void`	`applyLayoutCore(LayoutGraph graph)` Calculates an organic arrangement of the graph.
`protected void`	`configureComponentLayout(LayoutGraph graph, ComponentLayout layouter)` Configures the given `ComponentLayout` to take fixed nodes in components into account.
`protected void`	`disposeComponentLayout(LayoutGraph graph, ComponentLayout layouter)` Disposes of the `ComponentLayout` instance.
`ChainSubstructureStyle`	`getChainSubstructureStyle()` Gets the style specifier for chain substructures.
`double`	`getClusteringQuality()` Gets the quality measure of the clustering algorithm.
`double`	`getCompactnessFactor()` Gets the compactness factor for the layout algorithm.
`CycleSubstructureStyle`	`getCycleSubstructureStyle()` Gets the style specifier for cycle substructures.
`IGroupBoundsCalculator`	`getGroupBoundsCalculator()` Gets the `IGroupBoundsCalculator` instance used for calculating the size of group nodes.
`double`	`getGroupNodeCompactness()` Gets the compactness of group nodes.
`long`	`getMaximumDuration()` Gets the maximum duration in milliseconds that this layout algorithm is allowed to run.
`double`	`getMinimumNodeDistance()` Gets the minimum node distance that this algorithm should enforce between all pairs of nodes.
`OutputRestriction`	`getOutputRestriction()` Gets the area restriction for the result of the layout algorithm.
`ParallelSubstructureStyle`	`getParallelSubstructureStyle()` Gets the style specifier for parallel substructures.
`double`	`getPreferredEdgeLength()` Gets the default preferred edge length.
`double`	`getPreferredMinimumNodeToEdgeDistance()` Gets the minimum preferred distance between nodes and edges when node-edge overlaps are not allowed.
`double`	`getQualityTimeRatio()` Gets the ratio of layout quality versus running time.
`Scope`	`getScope()` Gets the scope that determines which nodes are placed by this algorithm.
`StarSubstructureStyle`	`getStarSubstructureStyle()` Gets the style specifier for star substructures.
`boolean`	`isAutomaticGroupNodeCompaction()` Gets whether or not group nodes are compacted automatically.
`boolean`	`isAvoidingNodeEdgeOverlapsEnabled()` Gets whether or not the layout algorithm tries to avoid node/edge overlaps.
`boolean`	`isConsiderNodeSizes()` Gets whether or not to consider node sizes during layout calculation.
`boolean`	`isDeterministicModeEnabled()` Gets whether or not the deterministic mode of this algorithm is enabled.
`boolean`	`isMultiThreadingAllowed()` Gets whether or not the layout algorithm may use multi-threading to reduce the running time.
`boolean`	`isNodeClusteringEnabled()` Gets whether or not a clustering algorithm should be applied to the input graph.
`boolean`	`isNodeLabelConsiderationEnabled()` Gets whether or not to reserve space for node labels during layout calculation.
`boolean`	`isNodeOverlapsAllowed()` Gets whether or not overlaps between nodes are allowed.
`boolean`	`isSmartComponentLayoutEnabled()` Gets whether or not this instance should configure the `ComponentLayout` to respect subsets of nodes.
`void`	`setAutomaticGroupNodeCompaction(boolean value)` Sets whether or not group nodes are compacted automatically.
`void`	`setAvoidingNodeEdgeOverlapsEnabled(boolean value)` Sets whether or not the layout algorithm tries to avoid node/edge overlaps.
`void`	`setChainSubstructureStyle(ChainSubstructureStyle value)` Sets the style specifier for chain substructures.
`void`	`setClusteringQuality(double value)` Sets the quality measure of the clustering algorithm.
`void`	`setCompactnessFactor(double value)` Sets the compactness factor for the layout algorithm.
`void`	`setConsiderNodeSizes(boolean value)` Sets whether or not to consider node sizes during layout calculation.
`void`	`setCycleSubstructureStyle(CycleSubstructureStyle value)` Sets the style specifier for cycle substructures.
`void`	`setDeterministicModeEnabled(boolean value)` Sets whether or not the deterministic mode of this algorithm is enabled.
`void`	`setGroupBoundsCalculator(IGroupBoundsCalculator value)` Sets the `IGroupBoundsCalculator` instance used for calculating the size of group nodes.
`void`	`setGroupNodeCompactness(double value)` Sets the compactness of group nodes.
`void`	`setMaximumDuration(long value)` Sets the maximum duration in milliseconds that this layout algorithm is allowed to run.
`void`	`setMinimumNodeDistance(double value)` Sets the minimum node distance that this algorithm should enforce between all pairs of nodes.
`void`	`setMultiThreadingAllowed(boolean value)` Sets whether or not the layout algorithm may use multi-threading to reduce the running time.
`void`	`setNodeClusteringEnabled(boolean value)` Sets whether or not a clustering algorithm should be applied to the input graph.
`void`	`setNodeLabelConsiderationEnabled(boolean value)` Sets whether or not to reserve space for node labels during layout calculation.
`void`	`setNodeOverlapsAllowed(boolean value)` Sets whether or not overlaps between nodes are allowed.
`void`	`setOrientationLayoutEnabled(boolean value)` Sets whether or not the `ILayoutStage` that modifies the orientation of the layout is activated.
`void`	`setOutputRestriction(OutputRestriction value)` Sets the area restriction for the result of the layout algorithm.
`void`	`setParallelSubstructureStyle(ParallelSubstructureStyle value)` Sets the style specifier for parallel substructures.
`void`	`setPreferredEdgeLength(double value)` Sets the default preferred edge length.
`void`	`setPreferredMinimumNodeToEdgeDistance(double value)` Sets the minimum preferred distance between nodes and edges when node-edge overlaps are not allowed.
`void`	`setQualityTimeRatio(double value)` Sets the ratio of layout quality versus running time.
`void`	`setScope(Scope value)` Sets the scope that determines which nodes are placed by this algorithm.
`void`	`setSmartComponentLayoutEnabled(boolean value)` Sets whether or not this instance should configure the `ComponentLayout` to respect subsets of nodes.
`void`	`setStarSubstructureStyle(StarSubstructureStyle value)` Sets the style specifier for star substructures.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - AFFECTED_NODES_DPKEY
```
public static final NodeDpKey<Boolean> AFFECTED_NODES_DPKEY
```
    A DataProvider key for marking the nodes that are part of the relevant subset
    
    The specified subset is only considered if the scope is set to Scope.SUBSET or Scope.MAINLY_SUBSET.
    
    See Also:
    
    setScope(Scope)
  - EDGE_DIRECTEDNESS_DPKEY
```
public static final EdgeDpKey<Double> EDGE_DIRECTEDNESS_DPKEY
```
    A DataProvider key for specifying the directedness of edges.
    Generally, the organic layout algorithm doesn't consider the edge direction. Nevertheless, this IDataProvider allows the user to specify hints on the directedness of edges. More precisely, a value of 1 indicates that the edge should be considered to be directed from source to target, a value of -1 that it is directed from target to source, and a value of 0 means that it is undirected.
    
    Currently, the specified values are only considered during the detection of special substructures, see ChainSubstructureStyle, CycleSubstructureStyle, ParallelSubstructureStyle and StarSubstructureStyle.
    
    If no IDataProvider is registered with this key, the algorithm assumes that all edges are undirected.
  - GROUP_NODE_MODE_DPKEY
```
public static final NodeDpKey<GroupNodeMode> GROUP_NODE_MODE_DPKEY
```
    A DataProvider key for assigning individual modes for all group nodes
    The modes specify how a group's content is handled and if it is resized during layout calculation.
  - PREFERRED_EDGE_LENGTH_DPKEY
```
public static final EdgeDpKey<Double> PREFERRED_EDGE_LENGTH_DPKEY
```
    A DataProvider key for defining an individual preferred length for each edge
- Constructor Detail
  - OrganicLayout
```
public OrganicLayout()
```
    Creates a new OrganicLayout instance with default settings.
- Method Detail
  - applyLayout
```
public void applyLayout(LayoutGraph graph)
```
    Calculates an organic arrangement of the graph.
    In contrast to applyLayoutCore(LayoutGraph), graph and layouter are prepared for an independent layout run.
    
    Specified by:
    
    applyLayout in interface ILayoutAlgorithm
    
    Overrides:
    
    applyLayout in class MultiStageLayout
    
    The given graph will not be copied during the layout process and the layout will be immediately applied to the given graph.
    
    Parameters:
    
    graph - the input graph
    
    See Also:
    
    MultiStageLayout.appendStage(ILayoutStage), MultiStageLayout.prependStage(ILayoutStage), MultiStageLayout.applyLayoutCore(LayoutGraph)
  - applyLayoutCore
```
public void applyLayoutCore(LayoutGraph graph)
```
    Calculates an organic arrangement of the graph.
    In contrast to applyLayout(LayoutGraph), graph and algorithm are not prepared specifically. This method should only be called directly when using OrganicLayout as a ILayoutStage.
    
    Specified by:
    
    applyLayoutCore in class MultiStageLayout
    
    The given graph will not be copied during the layout process and the layout will be immediately applied to the given graph.
    
    Parameters:
    
    graph - the input graph
  - configureComponentLayout
```
protected void configureComponentLayout(LayoutGraph graph,
                                        ComponentLayout layouter)
```
    Configures the given ComponentLayout to take fixed nodes in components into account.
    Components that contain fixed nodes will not be rearranged.
    
    This method is called by applyLayout(LayoutGraph) before the actual layout is calculated. It may be overridden in order to manually configure the ComponentLayout.
    
    Everything that is added to the graph or the ComponentLayout needs to be removed in disposeComponentLayout(LayoutGraph, ComponentLayout).
    
    Parameters:
    
    graph - the input graph
    
    layouter - the ComponentLayout instance to reconfigure
    
    See Also:
    
    setSmartComponentLayoutEnabled(boolean)
  - disposeComponentLayout
```
protected void disposeComponentLayout(LayoutGraph graph,
                                      ComponentLayout layouter)
```
    Disposes of the ComponentLayout instance.
    This method is called by applyLayout(LayoutGraph) after the actual layout is calculated. It may be overridden in order to revert a custom configuration made in configureComponentLayout(LayoutGraph, ComponentLayout).
    
    Everything that was added to the graph or to the ComponentLayout in configureComponentLayout(LayoutGraph, ComponentLayout) needs to be removed here.
    
    Parameters:
    
    graph - the input graph
    
    layouter - the ComponentLayout to reset
    
    See Also:
    
    setSmartComponentLayoutEnabled(boolean)
  - getChainSubstructureStyle
```
public ChainSubstructureStyle getChainSubstructureStyle()
```
    Gets the style specifier for chain substructures.
    A chain is a simple edge path where the degree of the nodes is less than or equal to 2.
    
    Throws:
    
    IllegalArgumentException - if the given style is unknown
    
    If a IDataProvider is registered with key EDGE_DIRECTEDNESS_DPKEY, all edges of the chain must have the same direction.
    
    If the algorithm only considers a subset of nodes, only these nodes may be contained in a substructure.
    
    Default Value:
    The default value is ChainSubstructureStyle.NONE
    
    Returns:
    
    one of the predefined styles for chain substructures
    
    See Also:
    
    setScope(Scope), EDGE_DIRECTEDNESS_DPKEY, setChainSubstructureStyle(ChainSubstructureStyle)
  - getClusteringQuality
```
public double getClusteringQuality()
```
    Gets the quality measure of the clustering algorithm.
    The higher the value, the higher the clustering quality.
    
    The value needs to lie in [0,1].
    
    Throws:
    
    IllegalArgumentException - if the specified quality measure is outside the interval [0,1]
    
    The expected running time of the clustering algorithm increases with the quality measure. The running time does not depend on the specified maximum duration.
    
    The clustering quality only has an effect if automatic clustering is enabled.
    
    Default Value:
    The default value is 1.
    
    Returns:
    
    a value from interval [0,1]
    
    See Also:
    
    setNodeClusteringEnabled(boolean), setMaximumDuration(long), setClusteringQuality(double)
  - getCompactnessFactor
```
public double getCompactnessFactor()
```
    Gets the compactness factor for the layout algorithm.
    Smaller values result in less compact drawings, greater values result in more compact drawings.
    
    The compactness value needs to lie in [0,1].
    
    Throws:
    
    IllegalArgumentException - if the specified value is outside the interval [0,1]
    
    Default Value:
    The default value is 0.5.
    
    Returns:
    
    the compactness value in [0,1]
    
    See Also:
    
    setCompactnessFactor(double)
  - getCycleSubstructureStyle
```
public CycleSubstructureStyle getCycleSubstructureStyle()
```
    Gets the style specifier for cycle substructures.
    A cycle is a simple edge path where the first and last node are identical. The algorithm only considers cycles where the number of edges connecting nodes of the cycle with the remaining nodes is less than or equal to 2.
    
    Throws:
    
    IllegalArgumentException - if the given style is unknown
    
    If a IDataProvider is registered with key EDGE_DIRECTEDNESS_DPKEY, all edges of the cycle must have the same direction.
    
    If the algorithm only considers a subset of nodes, only these nodes may be contained in a substructure.
    
    Default Value:
    The default value is CycleSubstructureStyle.NONE
    
    Returns:
    
    one of the predefined styles for cycle substructures
    
    See Also:
    
    setScope(Scope), EDGE_DIRECTEDNESS_DPKEY, setCycleSubstructureStyle(CycleSubstructureStyle)
  - getGroupBoundsCalculator
```
public IGroupBoundsCalculator getGroupBoundsCalculator()
```
    Gets the IGroupBoundsCalculator instance used for calculating the size of group nodes.
    
    Throws:
    
    IllegalArgumentException - if the specified IGroupBoundsCalculator is null
    
    The specified IGroupBoundsCalculator is not applied to empty group nodes (i.e. group nodes without children). Such group nodes will not be resized by the algorithm even if that leads to a violation of the minimum group node size specified by GroupingKeys.MINIMUM_NODE_SIZE_DPKEY.
    
    Default Value:
    The default value is MinimumSizeGroupBoundsCalculator
    
    Returns:
    
    the IGroupBoundsCalculator instance
    
    See Also:
    
    setGroupBoundsCalculator(IGroupBoundsCalculator)
  - getGroupNodeCompactness
```
public double getGroupNodeCompactness()
```
    Gets the compactness of group nodes.
    The compactness ranges from 0 to 1 where 0 results in group nodes not affecting the overall layout too much while 1 forces nodes in the same group to be clustered tightly.
    
    The values need to lie in [0,1].
    
    Throws:
    
    IllegalArgumentException - if specified compactness value is outside the interval [0,1]
    
    The specified value is only considered if automatic group node compaction is disabled and if there is no PartitionGrid structure.
    
    Default Value:
    The default value is 0.4.
    
    Returns:
    
    groupNodeCompactness the compactness value for group nodes
    
    See Also:
    
    setAutomaticGroupNodeCompaction(boolean), setGroupNodeCompactness(double)
  - getMaximumDuration
```
public long getMaximumDuration()
```
    Gets the maximum duration in milliseconds that this layout algorithm is allowed to run.
    The duration needs to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the specified duration has a negative value
    
    This is a soft limit. When it is reached, the layout algorithm may take some additional time to finish.
    
    Default Value:
    The default value is 30000.
    
    Returns:
    
    a non-negative duration in milliseconds
    
    See Also:
    
    setMaximumDuration(long)
  - getMinimumNodeDistance
```
public double getMinimumNodeDistance()
```
    Gets the minimum node distance that this algorithm should enforce between all pairs of nodes.
    The minimum node distance needs to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the specified minimum node distance is negative
    
    If node overlaps are allowed, the specified minimum node distance will be ignored.
    
    Default Value:
    The default value is 0.
    
    Returns:
    
    a non-negative minimum distance between nodes that are not connected by an edge
    
    See Also:
    
    setNodeOverlapsAllowed(boolean), setMinimumNodeDistance(double)
  - getOutputRestriction
```
public OutputRestriction getOutputRestriction()
```
    Gets the area restriction for the result of the layout algorithm.
    
    If option NodeOverlapsAllowed is disabled, the restriction area might be violated when node overlaps get resolved in a post-processing step.
    
    Default Value:
    The default value is OutputRestriction.NONE
    
    Returns:
    
    the OutputRestriction
    
    See Also:
    
    setOutputRestriction(OutputRestriction)
  - getParallelSubstructureStyle
```
public ParallelSubstructureStyle getParallelSubstructureStyle()
```
    Gets the style specifier for parallel substructures.
    A parallel structure consists of a set of nodes (called the inner nodes) such that all nodes have degree two and are connected to the same pair of neighbors (called the outer nodes).
    
    Throws:
    
    IllegalArgumentException - if the given style is unknown
    
    If a IDataProvider is registered with key EDGE_DIRECTEDNESS_DPKEY, all edges of the parallel structure must have the same direction.
    
    If the algorithm only considers a subset of nodes, only these nodes may be contained in a substructure.
    
    Default Value:
    The default value is ParallelSubstructureStyle.NONE
    
    Returns:
    
    one of the predefined styles for parallel substructures
    
    See Also:
    
    setScope(Scope), EDGE_DIRECTEDNESS_DPKEY, setParallelSubstructureStyle(ParallelSubstructureStyle)
  - getPreferredEdgeLength
```
public double getPreferredEdgeLength()
```
    Gets the default preferred edge length.
    If there is no specific preferred edge length assigned to an edge, this default preferred edge length is used.
    
    The preferred edge length needs to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the specified edge length is negative
    
    If the option NodeOverlapsAllowed is disabled, the preferred edge length may be violated because then the nodes are moved in a post-processing step to resolve overlaps.
    
    Default Value:
    The default value is 40.
    
    Returns:
    
    a non-negative edge length
    
    See Also:
    
    PREFERRED_EDGE_LENGTH_DPKEY, setPreferredEdgeLength(double)
  - getPreferredMinimumNodeToEdgeDistance
```
public double getPreferredMinimumNodeToEdgeDistance()
```
    Gets the minimum preferred distance between nodes and edges when node-edge overlaps are not allowed.
    The minimum preferred distance needs to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the specified distance is negative
    
    The algorithm doesn't guarantee that the specified minimum value is always maintained.
    
    This value has an effect only if node-edge overlaps are not allowed.
    
    Default Value:
    The default value is 40.
    
    Returns:
    
    a non-negative minimum preferred distance
    
    See Also:
    
    setPreferredMinimumNodeToEdgeDistance(double)
  - getQualityTimeRatio
```
public double getQualityTimeRatio()
```
    Gets the ratio of layout quality versus running time.
    The larger the ratio, the better the quality of the resulting layout but the longer it may take to perform the layout calculation.
    
    The value needs to lie within [0,1].
    
    Throws:
    
    IllegalArgumentException - if the specified ratio is outside the interval [0,1]
    
    Default Value:
    The default value is 0.6.
    
    Returns:
    
    a value between 0.0 (low quality, fast) and 1.0 (high quality, slow)
    
    See Also:
    
    setQualityTimeRatio(double)
  - getScope
```
public Scope getScope()
```
    Gets the scope that determines which nodes are placed by this algorithm.
    
    Throws:
    
    IllegalArgumentException - if the given scope is unknown
    
    When using scopes that consider only a subset of the nodes, this subset needs to be marked using a IDataProvider registered with key AFFECTED_NODES_DPKEY. If this IDataProvider is missing, all nodes will be arranged.
    
    Default Value:
    The default value is Scope.ALL
    
    Returns:
    
    one of the predefined scopes
    
    See Also:
    
    AFFECTED_NODES_DPKEY, setScope(Scope)
  - getStarSubstructureStyle
```
public StarSubstructureStyle getStarSubstructureStyle()
```
    Gets the style specifier for star substructures.
    A star consists of a set of degree one nodes that are all connected to the same node (called the root of the star).
    
    Throws:
    
    IllegalArgumentException - if the given style is unknown
    
    If a IDataProvider is registered with key EDGE_DIRECTEDNESS_DPKEY, all edges of the star must have the same direction.
    
    If the algorithm only considers a subset of nodes, only these nodes may be contained in a substructure.
    
    Default Value:
    The default value is StarSubstructureStyle.NONE
    
    Returns:
    
    one of the predefined styles for star substructures
    
    See Also:
    
    setScope(Scope), EDGE_DIRECTEDNESS_DPKEY, setStarSubstructureStyle(StarSubstructureStyle)
  - isAutomaticGroupNodeCompaction
```
public boolean isAutomaticGroupNodeCompaction()
```
    Gets whether or not group nodes are compacted automatically.
    When enabled, the compactness factor is determined automatically, i.e. it only depends on the general compactness specified by option CompactnessFactor.
    
    If this option is enabled, the value specified by option GroupNodeCompactness is ignored.
    
    Default Value:
    The default value is true. Automatic group node compaction is enabled.
    
    Returns:
    
    true if automatic group node compaction is enabled, false otherwise
    
    See Also:
    
    setGroupNodeCompactness(double), setCompactnessFactor(double), setAutomaticGroupNodeCompaction(boolean)
  - isAvoidingNodeEdgeOverlapsEnabled
```
public boolean isAvoidingNodeEdgeOverlapsEnabled()
```
    Gets whether or not the layout algorithm tries to avoid node/edge overlaps.
    
    The current implementation does not guarantee the non-existence of overlaps but tries to avoid them. Furthermore, the post-processing step that removes node overlaps ignores node/edge overlaps, i.e., the number of node/edge overlaps may increase if option NodeOverlapsAllowed is disabled.
    
    Default Value:
    The default value is false. Overlaps between nodes and edges are not avoided.
    
    Returns:
    
    true if the layout algorithm tries to avoid node/edge overlaps, false otherwise
    
    See Also:
    
    setNodeOverlapsAllowed(boolean), setAvoidingNodeEdgeOverlapsEnabled(boolean)
  - isConsiderNodeSizes
```
public boolean isConsiderNodeSizes()
```
    Gets whether or not to consider node sizes during layout calculation.
    If this option is enabled, the circumcircles of the nodes are used. If it is disabled, points will be used instead.
    
    This option doesn't affect the minimum node distance property.
    
    Default Value:
    The default value is false. Points will be used for modeling the nodes.
    
    Returns:
    
    true if the sizes of nodes are considered, false otherwise
    
    See Also:
    
    setConsiderNodeSizes(boolean)
  - isDeterministicModeEnabled
```
public boolean isDeterministicModeEnabled()
```
    Gets whether or not the deterministic mode of this algorithm is enabled.
    In deterministic mode, the layout algorithm will yield the same results if the exact same input and same settings are given as input.
    
    Default Value:
    The default value is false. The layout algorithm works deterministically.
    
    Returns:
    
    true if this algorithm works deterministically, false otherwise
    
    See Also:
    
    setDeterministicModeEnabled(boolean)
  - isMultiThreadingAllowed
```
public boolean isMultiThreadingAllowed()
```
    Gets whether or not the layout algorithm may use multi-threading to reduce the running time.
    
    Default Value:
    The default value is false. Multi-threading is disabled.
    
    Returns:
    
    true if multi-threading is used, false otherwise
    
    See Also:
    
    setMultiThreadingAllowed(boolean)
  - isNodeClusteringEnabled
```
public boolean isNodeClusteringEnabled()
```
    Gets whether or not a clustering algorithm should be applied to the input graph.
    When this option is enabled, the following steps are performed during the layout:
    1. A clustering algorithm is applied to the input graph.
    2. All nodes of the same cluster are put into a newly created group node.
    3. The layout is applied to the modified graph.
    4. Group nodes denoting clusters (inserted during step 2) are removed.
    The user can also specify customized clusters by defining appropriate groups.
    The running time of the clustering algorithm does not depend on the specified maximum duration.
    
    Default Value:
    The default value is false. Automatic clustering is disabled.
    
    Returns:
    
    true if a clustering algorithm is used, false otherwise
    
    See Also:
    
    setMaximumDuration(long), setNodeClusteringEnabled(boolean)
  - isNodeLabelConsiderationEnabled
```
public boolean isNodeLabelConsiderationEnabled()
```
    Gets whether or not to reserve space for node labels during layout calculation.
    
    Note that this option only works correctly if the layout orientation is set to LayoutOrientation.TOP_TO_BOTTOM (which is the default). Changing the layout orientation for an undirected layout algorithm like the OrganicLayout doesn't make sense.
    
    Enabling this setting overrides the value of ConsiderNodeSizes, i.e. node sizes are always considered.
    
    Default Value:
    The default value is false. Node labels are not considered.
    
    Returns:
    
    true if the labels of nodes are taken into account, false otherwise
    
    See Also:
    
    setNodeLabelConsiderationEnabled(boolean)
  - isNodeOverlapsAllowed
```
public boolean isNodeOverlapsAllowed()
```
    Gets whether or not overlaps between nodes are allowed.
    
    When disabled, a post-processing step is added that resolves node overlaps considering the specified minimum node distance. This procedure may affect other options like output restrictions and edge distances.
    
    If only a subset of nodes is considered in the layout algorithm, there might be some overlapping nodes even if this option is disabled.
    
    Default Value:
    The default value is false. Node overlaps are not allowed.
    
    Returns:
    
    true if node overlaps are allowed, false otherwise
    
    See Also:
    
    setMinimumNodeDistance(double), setScope(Scope), setNodeOverlapsAllowed(boolean)
  - isSmartComponentLayoutEnabled
```
public boolean isSmartComponentLayoutEnabled()
```
    Gets whether or not this instance should configure the ComponentLayout to respect subsets of nodes.
    When only a subset of nodes is placed by the layout algorithm, the fixed nodes will keep their locations even if they reside in different components.
    
    This option is only considered if Scope.SUBSET or Scope.MAINLY_SUBSET is used.
    
    Default Value:
    The default value is false. Smart component layout is disabled.
    
    Returns:
    
    true if ComponentLayout should be configured for subsets, false otherwise
    
    See Also:
    
    MultiStageLayout.setComponentLayoutEnabled(boolean), MultiStageLayout.getComponentLayout(), getScope(), setSmartComponentLayoutEnabled(boolean)
  - setAutomaticGroupNodeCompaction
```
public void setAutomaticGroupNodeCompaction(boolean value)
```
    Sets whether or not group nodes are compacted automatically.
    When enabled, the compactness factor is determined automatically, i.e. it only depends on the general compactness specified by option CompactnessFactor.
    
    If this option is enabled, the value specified by option GroupNodeCompactness is ignored.
    
    Default Value:
    The default value is true. Automatic group node compaction is enabled.
    
    Parameters:
    
    value - true if automatic group node compaction is enabled, false otherwise
    
    See Also:
    
    setGroupNodeCompactness(double), setCompactnessFactor(double), isAutomaticGroupNodeCompaction()
  - setAvoidingNodeEdgeOverlapsEnabled
```
public void setAvoidingNodeEdgeOverlapsEnabled(boolean value)
```
    Sets whether or not the layout algorithm tries to avoid node/edge overlaps.
    
    The current implementation does not guarantee the non-existence of overlaps but tries to avoid them. Furthermore, the post-processing step that removes node overlaps ignores node/edge overlaps, i.e., the number of node/edge overlaps may increase if option NodeOverlapsAllowed is disabled.
    
    Default Value:
    The default value is false. Overlaps between nodes and edges are not avoided.
    
    Parameters:
    
    value - true if the layout algorithm tries to avoid node/edge overlaps, false otherwise
    
    See Also:
    
    setNodeOverlapsAllowed(boolean), isAvoidingNodeEdgeOverlapsEnabled()
  - setChainSubstructureStyle
```
public void setChainSubstructureStyle(ChainSubstructureStyle value)
```
    Sets the style specifier for chain substructures.
    A chain is a simple edge path where the degree of the nodes is less than or equal to 2.
    
    Throws:
    
    IllegalArgumentException - if the given style is unknown
    
    If a IDataProvider is registered with key EDGE_DIRECTEDNESS_DPKEY, all edges of the chain must have the same direction.
    
    If the algorithm only considers a subset of nodes, only these nodes may be contained in a substructure.
    
    Default Value:
    The default value is ChainSubstructureStyle.NONE
    
    Parameters:
    
    value - one of the predefined styles for chain substructures
    
    See Also:
    
    setScope(Scope), EDGE_DIRECTEDNESS_DPKEY, getChainSubstructureStyle()
  - setClusteringQuality
```
public void setClusteringQuality(double value)
```
    Sets the quality measure of the clustering algorithm.
    The higher the value, the higher the clustering quality.
    
    The value needs to lie in [0,1].
    
    Throws:
    
    IllegalArgumentException - if the specified quality measure is outside the interval [0,1]
    
    The expected running time of the clustering algorithm increases with the quality measure. The running time does not depend on the specified maximum duration.
    
    The clustering quality only has an effect if automatic clustering is enabled.
    
    Default Value:
    The default value is 1.
    
    Parameters:
    
    value - a value from interval [0,1]
    
    See Also:
    
    setNodeClusteringEnabled(boolean), setMaximumDuration(long), getClusteringQuality()
  - setCompactnessFactor
```
public void setCompactnessFactor(double value)
```
    Sets the compactness factor for the layout algorithm.
    Smaller values result in less compact drawings, greater values result in more compact drawings.
    
    The compactness value needs to lie in [0,1].
    
    Throws:
    
    IllegalArgumentException - if the specified value is outside the interval [0,1]
    
    Default Value:
    The default value is 0.5.
    
    Parameters:
    
    value - the compactness value in [0,1]
    
    See Also:
    
    getCompactnessFactor()
  - setConsiderNodeSizes
```
public void setConsiderNodeSizes(boolean value)
```
    Sets whether or not to consider node sizes during layout calculation.
    If this option is enabled, the circumcircles of the nodes are used. If it is disabled, points will be used instead.
    
    This option doesn't affect the minimum node distance property.
    
    Default Value:
    The default value is false. Points will be used for modeling the nodes.
    
    Parameters:
    
    value - true if the sizes of nodes are considered, false otherwise
    
    See Also:
    
    isConsiderNodeSizes()
  - setCycleSubstructureStyle
```
public void setCycleSubstructureStyle(CycleSubstructureStyle value)
```
    Sets the style specifier for cycle substructures.
    A cycle is a simple edge path where the first and last node are identical. The algorithm only considers cycles where the number of edges connecting nodes of the cycle with the remaining nodes is less than or equal to 2.
    
    Throws:
    
    IllegalArgumentException - if the given style is unknown
    
    If a IDataProvider is registered with key EDGE_DIRECTEDNESS_DPKEY, all edges of the cycle must have the same direction.
    
    If the algorithm only considers a subset of nodes, only these nodes may be contained in a substructure.
    
    Default Value:
    The default value is CycleSubstructureStyle.NONE
    
    Parameters:
    
    value - one of the predefined styles for cycle substructures
    
    See Also:
    
    setScope(Scope), EDGE_DIRECTEDNESS_DPKEY, getCycleSubstructureStyle()
  - setDeterministicModeEnabled
```
public void setDeterministicModeEnabled(boolean value)
```
    Sets whether or not the deterministic mode of this algorithm is enabled.
    In deterministic mode, the layout algorithm will yield the same results if the exact same input and same settings are given as input.
    
    Default Value:
    The default value is false. The layout algorithm works deterministically.
    
    Parameters:
    
    value - true if this algorithm works deterministically, false otherwise
    
    See Also:
    
    isDeterministicModeEnabled()
  - setGroupBoundsCalculator
```
public void setGroupBoundsCalculator(IGroupBoundsCalculator value)
```
    Sets the IGroupBoundsCalculator instance used for calculating the size of group nodes.
    
    Throws:
    
    IllegalArgumentException - if the specified IGroupBoundsCalculator is null
    
    The specified IGroupBoundsCalculator is not applied to empty group nodes (i.e. group nodes without children). Such group nodes will not be resized by the algorithm even if that leads to a violation of the minimum group node size specified by GroupingKeys.MINIMUM_NODE_SIZE_DPKEY.
    
    Default Value:
    The default value is MinimumSizeGroupBoundsCalculator
    
    Parameters:
    
    value - the IGroupBoundsCalculator instance
    
    See Also:
    
    getGroupBoundsCalculator()
  - setGroupNodeCompactness
```
public void setGroupNodeCompactness(double value)
```
    Sets the compactness of group nodes.
    The compactness ranges from 0 to 1 where 0 results in group nodes not affecting the overall layout too much while 1 forces nodes in the same group to be clustered tightly.
    
    The values need to lie in [0,1].
    
    Throws:
    
    IllegalArgumentException - if specified compactness value is outside the interval [0,1]
    
    The specified value is only considered if automatic group node compaction is disabled and if there is no PartitionGrid structure.
    
    Default Value:
    The default value is 0.4.
    
    Parameters:
    
    value - groupNodeCompactness the compactness value for group nodes
    
    See Also:
    
    setAutomaticGroupNodeCompaction(boolean), getGroupNodeCompactness()
  - setMaximumDuration
```
public void setMaximumDuration(long value)
```
    Sets the maximum duration in milliseconds that this layout algorithm is allowed to run.
    The duration needs to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the specified duration has a negative value
    
    This is a soft limit. When it is reached, the layout algorithm may take some additional time to finish.
    
    Default Value:
    The default value is 30000.
    
    Parameters:
    
    value - a non-negative duration in milliseconds
    
    See Also:
    
    getMaximumDuration()
  - setMinimumNodeDistance
```
public void setMinimumNodeDistance(double value)
```
    Sets the minimum node distance that this algorithm should enforce between all pairs of nodes.
    The minimum node distance needs to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the specified minimum node distance is negative
    
    If node overlaps are allowed, the specified minimum node distance will be ignored.
    
    Default Value:
    The default value is 0.
    
    Parameters:
    
    value - a non-negative minimum distance between nodes that are not connected by an edge
    
    See Also:
    
    setNodeOverlapsAllowed(boolean), getMinimumNodeDistance()
  - setMultiThreadingAllowed
```
public void setMultiThreadingAllowed(boolean value)
```
    Sets whether or not the layout algorithm may use multi-threading to reduce the running time.
    
    Default Value:
    The default value is false. Multi-threading is disabled.
    
    Parameters:
    
    value - true if multi-threading is used, false otherwise
    
    See Also:
    
    isMultiThreadingAllowed()
  - setNodeClusteringEnabled
```
public void setNodeClusteringEnabled(boolean value)
```
    Sets whether or not a clustering algorithm should be applied to the input graph.
    When this option is enabled, the following steps are performed during the layout:
    1. A clustering algorithm is applied to the input graph.
    2. All nodes of the same cluster are put into a newly created group node.
    3. The layout is applied to the modified graph.
    4. Group nodes denoting clusters (inserted during step 2) are removed.
    The user can also specify customized clusters by defining appropriate groups.
    The running time of the clustering algorithm does not depend on the specified maximum duration.
    
    Default Value:
    The default value is false. Automatic clustering is disabled.
    
    Parameters:
    
    value - true if a clustering algorithm is used, false otherwise
    
    See Also:
    
    setMaximumDuration(long), isNodeClusteringEnabled()
  - setNodeLabelConsiderationEnabled
```
public void setNodeLabelConsiderationEnabled(boolean value)
```
    Sets whether or not to reserve space for node labels during layout calculation.
    
    Note that this option only works correctly if the layout orientation is set to LayoutOrientation.TOP_TO_BOTTOM (which is the default). Changing the layout orientation for an undirected layout algorithm like the OrganicLayout doesn't make sense.
    
    Enabling this setting overrides the value of ConsiderNodeSizes, i.e. node sizes are always considered.
    
    Default Value:
    The default value is false. Node labels are not considered.
    
    Parameters:
    
    value - true if the labels of nodes are taken into account, false otherwise
    
    See Also:
    
    isNodeLabelConsiderationEnabled()
  - setNodeOverlapsAllowed
```
public void setNodeOverlapsAllowed(boolean value)
```
    Sets whether or not overlaps between nodes are allowed.
    
    When disabled, a post-processing step is added that resolves node overlaps considering the specified minimum node distance. This procedure may affect other options like output restrictions and edge distances.
    
    If only a subset of nodes is considered in the layout algorithm, there might be some overlapping nodes even if this option is disabled.
    
    Default Value:
    The default value is false. Node overlaps are not allowed.
    
    Parameters:
    
    value - true if node overlaps are allowed, false otherwise
    
    See Also:
    
    setMinimumNodeDistance(double), setScope(Scope), isNodeOverlapsAllowed()
  - setOrientationLayoutEnabled
```
public void setOrientationLayoutEnabled(boolean value)
```
    Sets whether or not the ILayoutStage that modifies the orientation of the layout is activated.
    
    Overrides:
    
    setOrientationLayoutEnabled in class MultiStageLayout
    
    If the current layout orientation is LayoutOrientation.TOP_TO_BOTTOM, the orientation of the layout will not be modified.
    
    Based on the undirected layout style, disabling OrientationLayout has no significant effect.
    
    Default Value:
    The default value is true. The orientation ILayoutStage is activated.
    
    Parameters:
    
    value - true if the stage that modifies the orientation is activated, false otherwise
    
    See Also:
    
    MultiStageLayout.isOrientationLayoutEnabled(), MultiStageLayout.setOrientationLayout(com.yworks.yfiles.layout.ILayoutStage), MultiStageLayout.setLayoutOrientation(com.yworks.yfiles.layout.LayoutOrientation), OrientationLayout
  - setOutputRestriction
```
public void setOutputRestriction(OutputRestriction value)
```
    Sets the area restriction for the result of the layout algorithm.
    
    If option NodeOverlapsAllowed is disabled, the restriction area might be violated when node overlaps get resolved in a post-processing step.
    
    Default Value:
    The default value is OutputRestriction.NONE
    
    Parameters:
    
    value - the OutputRestriction
    
    See Also:
    
    getOutputRestriction()
  - setParallelSubstructureStyle
```
public void setParallelSubstructureStyle(ParallelSubstructureStyle value)
```
    Sets the style specifier for parallel substructures.
    A parallel structure consists of a set of nodes (called the inner nodes) such that all nodes have degree two and are connected to the same pair of neighbors (called the outer nodes).
    
    Throws:
    
    IllegalArgumentException - if the given style is unknown
    
    If a IDataProvider is registered with key EDGE_DIRECTEDNESS_DPKEY, all edges of the parallel structure must have the same direction.
    
    If the algorithm only considers a subset of nodes, only these nodes may be contained in a substructure.
    
    Default Value:
    The default value is ParallelSubstructureStyle.NONE
    
    Parameters:
    
    value - one of the predefined styles for parallel substructures
    
    See Also:
    
    setScope(Scope), EDGE_DIRECTEDNESS_DPKEY, getParallelSubstructureStyle()
  - setPreferredEdgeLength
```
public void setPreferredEdgeLength(double value)
```
    Sets the default preferred edge length.
    If there is no specific preferred edge length assigned to an edge, this default preferred edge length is used.
    
    The preferred edge length needs to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the specified edge length is negative
    
    If the option NodeOverlapsAllowed is disabled, the preferred edge length may be violated because then the nodes are moved in a post-processing step to resolve overlaps.
    
    Default Value:
    The default value is 40.
    
    Parameters:
    
    value - a non-negative edge length
    
    See Also:
    
    PREFERRED_EDGE_LENGTH_DPKEY, getPreferredEdgeLength()
  - setPreferredMinimumNodeToEdgeDistance
```
public void setPreferredMinimumNodeToEdgeDistance(double value)
```
    Sets the minimum preferred distance between nodes and edges when node-edge overlaps are not allowed.
    The minimum preferred distance needs to be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the specified distance is negative
    
    The algorithm doesn't guarantee that the specified minimum value is always maintained.
    
    This value has an effect only if node-edge overlaps are not allowed.
    
    Default Value:
    The default value is 40.
    
    Parameters:
    
    value - a non-negative minimum preferred distance
    
    See Also:
    
    getPreferredMinimumNodeToEdgeDistance()
  - setQualityTimeRatio
```
public void setQualityTimeRatio(double value)
```
    Sets the ratio of layout quality versus running time.
    The larger the ratio, the better the quality of the resulting layout but the longer it may take to perform the layout calculation.
    
    The value needs to lie within [0,1].
    
    Throws:
    
    IllegalArgumentException - if the specified ratio is outside the interval [0,1]
    
    Default Value:
    The default value is 0.6.
    
    Parameters:
    
    value - a value between 0.0 (low quality, fast) and 1.0 (high quality, slow)
    
    See Also:
    
    getQualityTimeRatio()
  - setScope
```
public void setScope(Scope value)
```
    Sets the scope that determines which nodes are placed by this algorithm.
    
    Throws:
    
    IllegalArgumentException - if the given scope is unknown
    
    When using scopes that consider only a subset of the nodes, this subset needs to be marked using a IDataProvider registered with key AFFECTED_NODES_DPKEY. If this IDataProvider is missing, all nodes will be arranged.
    
    Default Value:
    The default value is Scope.ALL
    
    Parameters:
    
    value - one of the predefined scopes
    
    See Also:
    
    AFFECTED_NODES_DPKEY, getScope()
  - setSmartComponentLayoutEnabled
```
public void setSmartComponentLayoutEnabled(boolean value)
```
    Sets whether or not this instance should configure the ComponentLayout to respect subsets of nodes.
    When only a subset of nodes is placed by the layout algorithm, the fixed nodes will keep their locations even if they reside in different components.
    
    This option is only considered if Scope.SUBSET or Scope.MAINLY_SUBSET is used.
    
    Default Value:
    The default value is false. Smart component layout is disabled.
    
    Parameters:
    
    value - true if ComponentLayout should be configured for subsets, false otherwise
    
    See Also:
    
    MultiStageLayout.setComponentLayoutEnabled(boolean), MultiStageLayout.getComponentLayout(), getScope(), isSmartComponentLayoutEnabled()
  - setStarSubstructureStyle
```
public void setStarSubstructureStyle(StarSubstructureStyle value)
```
    Sets the style specifier for star substructures.
    A star consists of a set of degree one nodes that are all connected to the same node (called the root of the star).
    
    Throws:
    
    IllegalArgumentException - if the given style is unknown
    
    If a IDataProvider is registered with key EDGE_DIRECTEDNESS_DPKEY, all edges of the star must have the same direction.
    
    If the algorithm only considers a subset of nodes, only these nodes may be contained in a substructure.
    
    Default Value:
    The default value is StarSubstructureStyle.NONE
    
    Parameters:
    
    value - one of the predefined styles for star substructures
    
    See Also:
    
    setScope(Scope), EDGE_DIRECTEDNESS_DPKEY, getStarSubstructureStyle()

Class OrganicLayout

Layout Style

Concept

Features

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.yworks.yfiles.layout.MultiStageLayout

Methods inherited from class java.lang.Object

Field Detail

AFFECTED_NODES_DPKEY

EDGE_DIRECTEDNESS_DPKEY

GROUP_NODE_MODE_DPKEY

PREFERRED_EDGE_LENGTH_DPKEY

Constructor Detail

OrganicLayout

Method Detail

applyLayout

applyLayoutCore

configureComponentLayout

disposeComponentLayout

getChainSubstructureStyle

getClusteringQuality

getCompactnessFactor

getCycleSubstructureStyle

getGroupBoundsCalculator

getGroupNodeCompactness

getMaximumDuration

getMinimumNodeDistance

getOutputRestriction

getParallelSubstructureStyle

getPreferredEdgeLength

getPreferredMinimumNodeToEdgeDistance

getQualityTimeRatio

getScope

getStarSubstructureStyle

isAutomaticGroupNodeCompaction

isAvoidingNodeEdgeOverlapsEnabled

isConsiderNodeSizes

isDeterministicModeEnabled

isMultiThreadingAllowed

isNodeClusteringEnabled

isNodeLabelConsiderationEnabled

isNodeOverlapsAllowed

isSmartComponentLayoutEnabled

setAutomaticGroupNodeCompaction

setAvoidingNodeEdgeOverlapsEnabled

setChainSubstructureStyle

setClusteringQuality

setCompactnessFactor

setConsiderNodeSizes

setCycleSubstructureStyle

setDeterministicModeEnabled

setGroupBoundsCalculator

setGroupNodeCompactness

setMaximumDuration

setMinimumNodeDistance

setMultiThreadingAllowed

setNodeClusteringEnabled

setNodeLabelConsiderationEnabled

setNodeOverlapsAllowed

setOrientationLayoutEnabled

setOutputRestriction

setParallelSubstructureStyle

setPreferredEdgeLength

setPreferredMinimumNodeToEdgeDistance

setQualityTimeRatio

setScope

setSmartComponentLayoutEnabled

setStarSubstructureStyle