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

java.lang.Object
- com.yworks.yfiles.layout.AbstractLayoutStage
- - com.yworks.yfiles.layout.router.polyline.EdgeRouter

All Implemented Interfaces:

ILayoutAlgorithm, ILayoutStage
```
public class EdgeRouter
extends AbstractLayoutStage
```
This edge routing algorithm applies polyline routes to the edges of the graph.

Layout Style
Edges are normally routed in an orthogonal fashion, i.e., they only consist of horizontal and vertical segments. There is also a routing style in which, between horizontal and vertical segments, additional segments with other slopes are inserted.

During the routing process, the positions of the nodes are considered to be fixed and the routing algorithm will not modify their locations or their sizes in any way.

The edge routing algorithm can be applied wherever it is needed to route the edges as polyline or orthogonal segments without crossing any nodes, while keeping the positions of the nodes in the diagram fixed. Some potential applications include electric circuit design, floor planning and navigation maps.

Sample output of the edge routing algorithm with default settings Sample output of the edge routing algorithm with polyline routing and grouped edges Sample output of the edge routing algorithm with polyline routing and group nodes
Concept
The edge routing algorithm basically performs three (four) steps to achieve an orthogonal (polyline) edge routing.
1. Creating a IPartition which divides the area of the graph area into several PartitionCells.
2. Finding the shortest/cheapest paths for all edges through the IPartition using PathSearch.
3. Assigning coordinates to the segments of the edges based on the paths that were calculated before with ChannelBasedPathRouting.
4. Inserting non-orthogonal segments where horizontal and vertical segments meet (only if polyline routing is enabled).
The first two steps are customizable. IGraphPartitionExtensions are able to influence how the IPartition is created. They add PartitionCells and/or mark them for adding costs later in the process. The currently used partition extensions can be dropped or extended by custom implementations.

For example, the extension 'Node Partition' adds a PartitionCell to the IPartition for each node and marks it as belonging to a node. During PathSearch, the extension 'Node Crossing' recognizes these PartitionCells and adds costs that penalizes crossing a node. The edge will be routed around the nodes.

PathSearchExtensions influence the PathSearch by adding costs for traversing PartitionCells or narrowing their intervals to allow a less expensive traversal of a PartitionCell. The currently used partition extensions can be dropped or extended by custom implementations.

Using EdgeLayoutDescriptors, it is possible to add individual layout settings like routing styles to edges. They are registered with the graph with key EDGE_LAYOUT_DESCRIPTOR_DPKEY. If no descriptor is provided for an edge, a default edge layout descriptor is used as fallback value.

Features

The routing algorithm supports two approaches to connect edges on a specific side or even on an exact location to a node. PortConstraints define a single constraint for the ports of an edge. To realize more complex port restrictions, several PortCandidates or PortCandidateSets can be assigned to edges or nodes. If an edge with registered PortCandidates connects to nodes with PortCandidateSets, the edge router will try to match both collections in order to find an appropriate port. In case there is no matching port candidate, a PortCandidate specified for the edge is preferred. Since their simultaneous existence at the same node may be ambiguous, it is not recommended to use a combination of PortConstraints and PortCandidates in the same diagram.

Edges can be grouped so that they share common segments at the beginning or end of their routes. Although a graph may contain source and target grouped edges, an edge can only either be part of a source or a target group. Edge groups are specified using IDataProviders that provide the same ID object for all edges in the same group. Those IDataProviders are registered with the graph with key PortConstraintKeys.SOURCE_GROUP_ID_DPKEY for source groups or key PortConstraintKeys.TARGET_GROUP_ID_DPKEY for target groups.
An edge can either be source or target grouped but not both at the same time.

Field Summary

Fields
Modifier and Type	Field and Description
`static EdgeDpKey<EdgeLayoutDescriptor>`	`EDGE_LAYOUT_DESCRIPTOR_DPKEY` A `DataProvider` key for specifying individual edge layout information If this `IDataProvider` does not contain an `EdgeLayoutDescriptor` for an edge, then the layout algorithm will use the `default descriptor`.
`static ILabelLayoutDpKey<Double>`	`LABEL_CROSSING_PENALTY_FACTOR_DPKEY` A `DataProvider` key for weighting the costs for crossing each label individually If the factor for a label is `0` then it is allowed to cross it.

Constructor Summary

Constructors
Constructor and Description
`EdgeRouter()` Creates a new `EdgeRouter` instance with an optional `core layout algorithm`.
`EdgeRouter(ILayoutAlgorithm core)` Creates a new `EdgeRouter` instance with an optional `core layout algorithm`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyLayout(LayoutGraph graph)` Performs the routing of the edges of the input graph.
`protected void`	`checkNodeSize(LayoutGraph g)` Checks the sizes of the nodes to be non-zero.
`protected void`	`cleanUpGraphPartition(GraphPartition partition)` Removes all registered `IGraphPartitionExtension`s from a given `GraphPartition` instance.
`protected void`	`configureGraphPartition(GraphPartition partition)` Adds all registered `IGraphPartitionExtension`s instances to a given `GraphPartition` instance.
`protected void`	`configurePathSearch(PathSearch pathSearch)` Adds all registered `PathSearchExtension`s to a given `PathSearch` instance.
`protected PathSearchConfiguration`	`createConfiguration(LayoutGraph graph, GroupingSupport grouping)` Creates a `PathSearchConfiguration` that is used during the path searching process.
`protected Comparator<Object>`	`createDefaultEdgeOrderComparator(LayoutGraph graph, PathSearchConfiguration configuration)` Creates a default `Comparator` instance to determine the order of the edges according to which they will be routed.
`protected GraphPartition`	`createGraphPartition(IObstaclePartition decomposition)` Creates a `GraphPartition` instance that divides the area of the graph into several rectangles.
`protected DynamicObstacleDecomposition`	`createObstacleDecomposition()` Creates a `DynamicObstacleDecomposition` that is used by the `GraphPartition` to divide the graph area in rectangles.
`protected ChannelBasedPathRouting`	`createPathRouting()` Creates a `ChannelBasedPathRouting` instance that routes the edges using pre-calculated `Path` objects.
`protected PathSearch`	`createPathSearch()` Creates a `PathSearch` instance that finds the paths of the edges through the `GraphPartition`.
`protected PathSearchContext`	`createPathSearchContext(PathSearch pathSearch, PathSearchConfiguration configuration)` Creates a `PathSearchContext` that provides context information for the path searching algorithm.
`Object`	`getAffectedEdgesDpKey()` Gets the `IDataProvider` key to look up the selection state of the edges.
`Object`	`getAffectedNodesDpKey()` Gets the `IDataProvider` key to look up the selection state of the nodes.
`EdgeLayoutDescriptor`	`getDefaultEdgeLayoutDescriptor()` Gets the `EdgeLayoutDescriptor` instance used for all those edges that do not have a specific edge layout descriptor assigned.
`Comparator<Object>`	`getEdgeComparator()` Gets a custom `Comparator` to define the processing order of the edges.
`protected EdgeLayoutDescriptor`	`getEdgeLayoutDescriptor(Edge edge)` Returns the `EdgeLayoutDescriptor` instance for a given edge that is provided by a `IDataProvider` which is registered with the graph with key `EDGE_LAYOUT_DESCRIPTOR_DPKEY`.
`Grid`	`getGrid()` Gets the `Grid` instance on which the routing algorithm places the orthogonal segments.
`long`	`getMaximumDuration()` Gets the time limit (in milliseconds) set for the edge routing algorithm.
`double`	`getMaximumPolylineSegmentRatio()` Gets the maximum ratio between the horizontal/vertical part of a segment and the (non-orthogonal) polyline part.
`double`	`getMinimumNodeToEdgeDistance()` Gets the minimum distance between edges and node bounds.
`GraphPartition`	`getPartition()` Gets the `GraphPartition` instance used during the routing process.
`double`	`getPreferredPolylineSegmentLength()` Gets the preferred length of (non-orthogonal) polyline segments.
`List<Object>`	`getRegisteredPartitionExtensions()` Gets a list of all registered `IGraphPartitionExtension`s.
`List<Object>`	`getRegisteredPathSearchExtensions()` Gets a list of all registered `PathSearchExtension`s.
`Scope`	`getScope()` Gets a (sub-)set of edges that shall be routed.
`protected boolean`	`isAffected(Edge edge, Graph graph)` Returns whether or not a given edge is selected.
`boolean`	`isEdgeLabelConsiderationEnabled()` Gets whether or not the routing algorithm considers as obstacles the edge labels that do not belong to the (sub-)set of edges to be routed when calculating the edge routes.
`boolean`	`isIgnoringInnerNodeLabelsEnabled()` Gets whether or not this routing algorithm ignores node labels that are inside the bounds of their owner as obstacles for edge routes.
`boolean`	`isNodeLabelConsiderationEnabled()` Gets whether or not the routing algorithm considers the labels of the nodes as obstacles when calculating the edge routes to avoid overlaps.
`boolean`	`isPolylineRoutingEnabled()` Gets whether or not the routing algorithm will route the edges of the graph with (non-orthogonal) polyline segments.
`boolean`	`isReroutingEnabled()` Gets whether or not the routing algorithm uses an additional step to reroute the edges that are considered to have the worst paths.
`void`	`setAffectedEdgesDpKey(Object value)` Sets the `IDataProvider` key to look up the selection state of the edges.
`void`	`setAffectedNodesDpKey(Object value)` Sets the `IDataProvider` key to look up the selection state of the nodes.
`void`	`setEdgeComparator(Comparator<Object> value)` Sets a custom `Comparator` to define the processing order of the edges.
`void`	`setEdgeLabelConsiderationEnabled(boolean value)` Sets whether or not the routing algorithm considers as obstacles the edge labels that do not belong to the (sub-)set of edges to be routed when calculating the edge routes.
`void`	`setGrid(Grid value)` Sets the `Grid` instance on which the routing algorithm places the orthogonal segments.
`void`	`setIgnoringInnerNodeLabelsEnabled(boolean value)` Sets whether or not this routing algorithm ignores node labels that are inside the bounds of their owner as obstacles for edge routes.
`void`	`setMaximumDuration(long value)` Sets the time limit (in milliseconds) set for the edge routing algorithm.
`void`	`setMaximumPolylineSegmentRatio(double value)` Sets the maximum ratio between the horizontal/vertical part of a segment and the (non-orthogonal) polyline part.
`void`	`setMinimumNodeToEdgeDistance(double value)` Sets the minimum distance between edges and node bounds.
`void`	`setNodeLabelConsiderationEnabled(boolean value)` Sets whether or not the routing algorithm considers the labels of the nodes as obstacles when calculating the edge routes to avoid overlaps.
`void`	`setPolylineRoutingEnabled(boolean value)` Sets whether or not the routing algorithm will route the edges of the graph with (non-orthogonal) polyline segments.
`void`	`setPreferredPolylineSegmentLength(double value)` Sets the preferred length of (non-orthogonal) polyline segments.
`void`	`setReroutingEnabled(boolean value)` Sets whether or not the routing algorithm uses an additional step to reroute the edges that are considered to have the worst paths.
`void`	`setScope(Scope value)` Sets a (sub-)set of edges that shall be routed.

Methods inherited from class com.yworks.yfiles.layout.AbstractLayoutStage
applyLayoutCore, getCoreLayout, setCoreLayout

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

- Field Detail
  - EDGE_LAYOUT_DESCRIPTOR_DPKEY
```
public static final EdgeDpKey<EdgeLayoutDescriptor> EDGE_LAYOUT_DESCRIPTOR_DPKEY
```
    A DataProvider key for specifying individual edge layout information
    If this IDataProvider does not contain an EdgeLayoutDescriptor for an edge, then the layout algorithm will use the default descriptor.
    
    See Also:
    
    getDefaultEdgeLayoutDescriptor()
  - LABEL_CROSSING_PENALTY_FACTOR_DPKEY
```
public static final ILabelLayoutDpKey<Double> LABEL_CROSSING_PENALTY_FACTOR_DPKEY
```
    A DataProvider key for weighting the costs for crossing each label individually
    If the factor for a label is 0 then it is allowed to cross it. Very important labels should get a high factor.
    
    This factor is multiplied by the basic penalty arising when an edge must cross a node label or an edge label in order to determine the final costs arising when this label is crossed.
    
    See Also:
    
    getDefaultEdgeLayoutDescriptor(), EdgeLayoutDescriptor.getPenaltySettings()
- Constructor Detail
  - EdgeRouter
```
public EdgeRouter()
```
    Creates a new EdgeRouter instance with an optional core layout algorithm.
  - EdgeRouter
```
public EdgeRouter(ILayoutAlgorithm core)
```
    Creates a new EdgeRouter instance with an optional core layout algorithm.
    
    Parameters:
    
    core - The core layout algorithm.
- Method Detail
  - applyLayout
```
public void applyLayout(LayoutGraph graph)
```
    Performs the routing of the edges of the input graph.
    This method also prepares the graph for the edge routing process.
    
    Specified by:
    
    applyLayout in interface ILayoutAlgorithm
    
    Specified by:
    
    applyLayout in class AbstractLayoutStage
    
    The given graph will not be copied during the edge routing process and the result will be immediately applied to the input graph.
    
    Parameters:
    
    graph - the input graph
  - checkNodeSize
```
protected void checkNodeSize(LayoutGraph g)
```
    Checks the sizes of the nodes to be non-zero.
    
    Parameters:
    
    g - The graph to check.
  - cleanUpGraphPartition
```
protected void cleanUpGraphPartition(GraphPartition partition)
```
    Removes all registered IGraphPartitionExtensions from a given GraphPartition instance.
    This method is called by applyLayout(LayoutGraph) after the edge routes are calculated. It may be overridden in order to provide a custom implementation for cleaning up a GraphPartition instance.
    
    Parameters:
    
    partition - the given GraphPartition instance
    
    See Also:
    
    configureGraphPartition(GraphPartition), getRegisteredPartitionExtensions()
  - configureGraphPartition
```
protected void configureGraphPartition(GraphPartition partition)
```
    Adds all registered IGraphPartitionExtensions instances to a given GraphPartition instance.
    This method is called by applyLayout(LayoutGraph) before the edge routes are calculated. It may be overridden in order to adjust the configuration of the GraphPartition instance.
    
    Parameters:
    
    partition - the given GraphPartition instance
    
    See Also:
    
    getRegisteredPartitionExtensions(), cleanUpGraphPartition(GraphPartition)
  - configurePathSearch
```
protected void configurePathSearch(PathSearch pathSearch)
```
    Adds all registered PathSearchExtensions to a given PathSearch instance.
    This method is called by applyLayout(LayoutGraph) before the edge routes are calculated. It may be overridden in order to adjust the configuration of a PathSearch instance.
    
    Parameters:
    
    pathSearch - a PathSearch instance
    
    See Also:
    
    createPathSearch(), getRegisteredPathSearchExtensions()
  - createConfiguration
```
protected PathSearchConfiguration createConfiguration(LayoutGraph graph,
                                                      GroupingSupport grouping)
```
    Creates a PathSearchConfiguration that is used during the path searching process.
    This method is called by applyLayout(LayoutGraph) before the edge routes are calculated. It may be overridden in order to create a new PathSearchConfiguration object with custom configuration.
    
    Parameters:
    
    graph - the input graph
    
    grouping - the grouping structure of the graph
    
    Returns:
    
    a PathSearchConfiguration instance
  - createDefaultEdgeOrderComparator
```
protected Comparator<Object> createDefaultEdgeOrderComparator(LayoutGraph graph,
                                                              PathSearchConfiguration configuration)
```
    Creates a default Comparator instance to determine the order of the edges according to which they will be routed.
    This method is called by applyLayout(LayoutGraph) before the edge routes are calculated. It may be overridden in order to create a new Comparator object with a custom configuration.
    
    By default, this method returns an instance of the default implementation.
    
    Parameters:
    
    graph - the input graph
    
    configuration - the given configuration for the path searching process
    
    Returns:
    
    a Comparator instance
  - createGraphPartition
```
protected GraphPartition createGraphPartition(IObstaclePartition decomposition)
```
    Creates a GraphPartition instance that divides the area of the graph into several rectangles.
    This implementation creates a GraphPartition using the current IObstaclePartition instance.
    
    This method is called by applyLayout(LayoutGraph) before the edge routes are calculated. It may be overridden in order to create a new GraphPartition object with a custom configuration.
    
    Parameters:
    
    decomposition - the current IObstaclePartition
    
    Returns:
    
    a GraphPartition instance
    
    See Also:
    
    configureGraphPartition(GraphPartition), getRegisteredPartitionExtensions()
  - createObstacleDecomposition
```
protected DynamicObstacleDecomposition createObstacleDecomposition()
```
    Creates a DynamicObstacleDecomposition that is used by the GraphPartition to divide the graph area in rectangles.
    This method is called by applyLayout(LayoutGraph) before the edge routes are calculated. It may be overridden in order to create a new DynamicObstacleDecomposition object with custom configuration.
    
    Returns:
    
    a DynamicObstacleDecomposition instance
    
    See Also:
    
    createGraphPartition(IObstaclePartition)
  - createPathRouting
```
protected ChannelBasedPathRouting createPathRouting()
```
    Creates a ChannelBasedPathRouting instance that routes the edges using pre-calculated Path objects.
    This method is called by applyLayout(LayoutGraph) before the edge routes are calculated. It may be overridden in order to create a new ChannelBasedPathRouting object with custom configuration.
    
    Returns:
    
    a ChannelBasedPathRouting instance
  - createPathSearch
```
protected PathSearch createPathSearch()
```
    Creates a PathSearch instance that finds the paths of the edges through the GraphPartition.
    This method may be overridden in order to create a new PathSearch object with custom configuration.
    
    Returns:
    
    a PathSearch instance
    
    See Also:
    
    configurePathSearch(PathSearch), getRegisteredPathSearchExtensions()
  - createPathSearchContext
```
protected PathSearchContext createPathSearchContext(PathSearch pathSearch,
                                                    PathSearchConfiguration configuration)
```
    Creates a PathSearchContext that provides context information for the path searching algorithm.
    This method is called by applyLayout(LayoutGraph) before the edge routes are calculated. It may be overridden in order to create a new PathSearchContext object with custom configuration.
    
    Parameters:
    
    pathSearch - a given PathSearch instance
    
    configuration - a given configuration for the path searching process
    
    Returns:
    
    a PathSearchContext instance
  - getAffectedEdgesDpKey
```
public Object getAffectedEdgesDpKey()
```
    Gets the IDataProvider key to look up the selection state of the edges.
    If the scope is set to Scope.ROUTE_AFFECTED_EDGES, only the selected edges will be routed, while all other edges will be considered to have fixed routes.
    
    Throws:
    
    IllegalArgumentException - if the specified IDataProvider key is null
    
    Default Value:
    The default value is LayoutKeys.AFFECTED_EDGES_DPKEY
    
    Returns:
    
    the IDataProvider key for the edge selection
    
    See Also:
    
    setScope(Scope), setAffectedEdgesDpKey(Object)
  - getAffectedNodesDpKey
```
public Object getAffectedNodesDpKey()
```
    Gets the IDataProvider key to look up the selection state of the nodes.
    If the scope is set to Scope.ROUTE_EDGES_AT_AFFECTED_NODES, only the edges that are incident to selected nodes will be routed, while all other edges will be considered to have fixed routes.
    
    Throws:
    
    IllegalArgumentException - if the specified IDataProvider key is null
    
    Default Value:
    The default value is LayoutKeys.AFFECTED_NODES_DPKEY
    
    Returns:
    
    the IDataProvider key for the node selection
    
    See Also:
    
    setScope(Scope), setAffectedNodesDpKey(Object)
  - getDefaultEdgeLayoutDescriptor
```
public EdgeLayoutDescriptor getDefaultEdgeLayoutDescriptor()
```
    Gets the EdgeLayoutDescriptor instance used for all those edges that do not have a specific edge layout descriptor assigned.
    
    Returns:
    
    the default EdgeLayoutDescriptor
    
    See Also:
    
    EDGE_LAYOUT_DESCRIPTOR_DPKEY
  - getEdgeComparator
```
public Comparator<Object> getEdgeComparator()
```
    Gets a custom Comparator to define the processing order of the edges.
    
    The processing order may affect the quality of the individual edge paths. When routing an edge, only the paths of the already routed edges and of the fixed edges (that will not be routed at all) can be considered. Therefore, edges that are processed first have to consider less other edge paths than the edges that are processed later, which might have to use less optimal alternative paths.
    
    Default Value:
    The default value is Comparator. The comparator returned by EdgeComparator.
    
    Returns:
    
    the current Comparator instance
    
    See Also:
    
    createDefaultEdgeOrderComparator(LayoutGraph, PathSearchConfiguration), setEdgeComparator(Comparator)
  - getEdgeLayoutDescriptor
```
protected EdgeLayoutDescriptor getEdgeLayoutDescriptor(Edge edge)
```
    Returns the EdgeLayoutDescriptor instance for a given edge that is provided by a IDataProvider which is registered with the graph with key EDGE_LAYOUT_DESCRIPTOR_DPKEY.
    For all those edges that do not have a specific layout descriptor assigned, the default layout descriptor returned by DefaultEdgeLayoutDescriptor will be assigned.
    
    This method may be overridden in order to create an EdgeLayoutDescriptor with custom configuration.
    
    Parameters:
    
    edge - the given edge
    
    Returns:
    
    the current EdgeLayoutDescriptor instance for a given edge
    
    See Also:
    
    getDefaultEdgeLayoutDescriptor(), EDGE_LAYOUT_DESCRIPTOR_DPKEY
  - getGrid
```
public Grid getGrid()
```
    Gets the Grid instance on which the routing algorithm places the orthogonal segments.
    
    Default Value:
    The default value is null. No grid is specified.
    
    Returns:
    
    the Grid instance
    
    See Also:
    
    setGrid(Grid)
  - getMaximumDuration
```
public long getMaximumDuration()
```
    Gets the time limit (in milliseconds) set for the edge routing algorithm.
    The maximum duration has 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 edge routing algorithm still has to find a valid solution.
    
    Default Value:
    The default value is Long.MAX_VALUE. The edge routing algorithm runs unrestricted.
    
    Returns:
    
    a non-negative integer value
    
    See Also:
    
    setMaximumDuration(long)
  - getMaximumPolylineSegmentRatio
```
public double getMaximumPolylineSegmentRatio()
```
    Gets the maximum ratio between the horizontal/vertical part of a segment and the (non-orthogonal) polyline part.
    When polyline segments are added to an edge path, corners between horizontal and vertical segments are cut and replaced by the new segment. This ratio describes the cutting points on a segment. If it is zero, the route stays orthogonal. The value cannot be larger than 0.5 because there may be another polyline segment at the other side of the segment. For long orthogonal segments the length of the polyline segment is determined by the value returned by PreferredPolylineSegmentLength.
    
    The maximum polyline segment ratio must be between 0 and 0.5.
    
    Throws:
    
    IllegalArgumentException - if the maximum segment length is negative or greater than 0.5
    
    Default Value:
    The default value is 0.3.
    
    Returns:
    
    the maximum polyline segment ratio
    
    See Also:
    
    setMaximumPolylineSegmentRatio(double)
  - getMinimumNodeToEdgeDistance
```
public double getMinimumNodeToEdgeDistance()
```
    Gets the minimum distance between edges and node bounds.
    The minimum distance should have a non-negative value.
    
    Throws:
    
    IllegalArgumentException - if the minimum node-to-edge distance is negative
    
    Default Value:
    The default value is 10.
    
    Returns:
    
    the non-negative minimum distance
    
    See Also:
    
    PenaltySettings.getMinimumNodeToEdgeDistancePenalty(), setMinimumNodeToEdgeDistance(double)
  - getPartition
```
public GraphPartition getPartition()
```
    Gets the GraphPartition instance used during the routing process.
    
    If the routing process is not running, null will be returned.
    
    Returns:
    
    the current GraphPartition instance
  - getPreferredPolylineSegmentLength
```
public double getPreferredPolylineSegmentLength()
```
    Gets the preferred length of (non-orthogonal) polyline segments.
    If there is not enough space to use this preferred length, polyline segments may also be shorter.
    
    The preferred length of (non-orthogonal) polyline segments has to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the preferred polyline segment length is negative
    
    This restriction applies only if polyline routing is enabled.
    
    Default Value:
    The default value is 30.
    
    Returns:
    
    the preferred length of (non-orthogonal) polyline segments
    
    See Also:
    
    getMaximumPolylineSegmentRatio(), setPreferredPolylineSegmentLength(double)
  - getRegisteredPartitionExtensions
```
public List<Object> getRegisteredPartitionExtensions()
```
    Gets a list of all registered IGraphPartitionExtensions.
    IGraphPartitionExtensions can be added to a GraphPartition in order to create new Obstacles or can be removed from a GraphPartition instance.
    
    By default, the following IGraphPartitionExtensions are registered with a given GraphPartition instance:
    - Minimum Node To Edge Distance Partition
    - Node Partition
    - Partition Grid Partition
    - Node Label Partition
    - Edge Label Partition
    - Fixed Edges Partition
    - External Strong Port Restriction Partition
    Returns:
    
    a list containing all registered IGraphPartitionExtensions
    
    See Also:
    
    createGraphPartition(IObstaclePartition), configureGraphPartition(GraphPartition)
  - getRegisteredPathSearchExtensions
```
public List<Object> getRegisteredPathSearchExtensions()
```
    Gets a list of all registered PathSearchExtensions.
    PathSearchExtensions can be added to a PathSearch instance in order to influence the path searching process or can be removed from a PathSearch instance.
    
    By default, the following PathSearchExtensions are registered with a PathSearch instance:
    - Fixed Grouped Edges
    - Node Crossing
    - Minimum Node To Edge Distance
    - Group Node Crossing
    - Minimum Group Node To Edge Distance
    - Node Label Crossing
    - Edge Label Crossing
    - Bends In Node To Edge Distance
    - Bend
    - Monotonic Route
    - Edge Length
    - Partition Grid
    - Port Restriction
    - Edge Grouping
    - Minimum Node Corner Distance
    - Interval Based Crossing
    - Minimum Edge To Edge Distance And Grid
    - Minimum First Last Segment Length
    - Intersecting Source And Target
    Returns:
    
    a list containing all registered PathSearchExtensions
    
    See Also:
    
    createPathSearch(), configurePathSearch(PathSearch)
  - getScope
```
public Scope getScope()
```
    Gets a (sub-)set of edges that shall be routed.
    
    Throws:
    
    IllegalArgumentException - if the given scope is unknown
    
    Default Value:
    The default value is Scope.ROUTE_ALL_EDGES
    
    Returns:
    
    one of the default scope values
    
    See Also:
    
    getAffectedEdgesDpKey(), setScope(Scope)
  - isAffected
```
protected boolean isAffected(Edge edge,
                             Graph graph)
```
    Returns whether or not a given edge is selected.
    If all the edges of the graph will be routed by EdgeRouter, i.e., the scope is set to Scope.ROUTE_ALL_EDGES, this utility method returns true for all edges.
    
    This method may be overridden in order to determine differently whether or not a given edge is considered to be selected.
    
    Parameters:
    
    edge - the given edge
    
    graph - the input graph
    
    Returns:
    
    true if the given edge is selected, false otherwise
  - isEdgeLabelConsiderationEnabled
```
public boolean isEdgeLabelConsiderationEnabled()
```
    Gets whether or not the routing algorithm considers as obstacles the edge labels that do not belong to the (sub-)set of edges to be routed when calculating the edge routes.
    
    This option takes effect only if Scope is set to Scope.ROUTE_AFFECTED_EDGES and a IDataProvider instance with the key AffectedEdgesDpKey is registered with the graph.
    
    Default Value:
    The default value is false. Edge labels are not considered.
    
    Returns:
    
    true if edge labels are considered, false otherwise
    
    See Also:
    
    setScope(Scope), setAffectedEdgesDpKey(Object), PenaltySettings.getNodeLabelCrossingPenalty(), setEdgeLabelConsiderationEnabled(boolean)
  - isIgnoringInnerNodeLabelsEnabled
```
public boolean isIgnoringInnerNodeLabelsEnabled()
```
    Gets whether or not this routing algorithm ignores node labels that are inside the bounds of their owner as obstacles for edge routes.
    
    This setting can be applied only if node labels are considered and is especially useful in order to ignore inner node labels of group nodes.
    
    Default Value:
    The default value is false. Node labels that are inside the bounds of their owner are not ignored.
    
    Returns:
    
    true if the routing algorithm ignores inner node labels, false otherwise
    
    See Also:
    
    isNodeLabelConsiderationEnabled(), PenaltySettings.getNodeLabelCrossingPenalty(), LABEL_CROSSING_PENALTY_FACTOR_DPKEY, setIgnoringInnerNodeLabelsEnabled(boolean)
  - isNodeLabelConsiderationEnabled
```
public boolean isNodeLabelConsiderationEnabled()
```
    Gets whether or not the routing algorithm considers the labels of the nodes as obstacles when calculating the edge routes to avoid overlaps.
    
    This option takes effect only if Scope is set to Scope.ROUTE_EDGES_AT_AFFECTED_NODES and a IDataProvider instance with the key AffectedNodesDpKey is registered with the graph.
    
    Default Value:
    The default value is false. Node labels are not considered.
    
    Returns:
    
    true if the node labels are considered, false otherwise
    
    See Also:
    
    PenaltySettings.getNodeLabelCrossingPenalty(), setNodeLabelConsiderationEnabled(boolean)
  - isPolylineRoutingEnabled
```
public boolean isPolylineRoutingEnabled()
```
    Gets whether or not the routing algorithm will route the edges of the graph with (non-orthogonal) polyline segments.
    
    Default Value:
    The default value is false. The polyline edge routing is disabled.
    
    Returns:
    
    true if the routing algorithm creates (non-orthogonal) polyline segments, false otherwise
    
    See Also:
    
    getPreferredPolylineSegmentLength(), getMaximumPolylineSegmentRatio(), setPolylineRoutingEnabled(boolean)
  - isReroutingEnabled
```
public boolean isReroutingEnabled()
```
    Gets whether or not the routing algorithm uses an additional step to reroute the edges that are considered to have the worst paths.
    
    The rerouting step will only be applied if the maximum duration has not been exceeded yet.
    
    Default Value:
    The default value is false. The rerouting step will not be performed.
    
    Returns:
    
    true if the rerouting step will be performed, false otherwise
    
    See Also:
    
    setReroutingEnabled(boolean)
  - setAffectedEdgesDpKey
```
public void setAffectedEdgesDpKey(Object value)
```
    Sets the IDataProvider key to look up the selection state of the edges.
    If the scope is set to Scope.ROUTE_AFFECTED_EDGES, only the selected edges will be routed, while all other edges will be considered to have fixed routes.
    
    Throws:
    
    IllegalArgumentException - if the specified IDataProvider key is null
    
    Default Value:
    The default value is LayoutKeys.AFFECTED_EDGES_DPKEY
    
    Parameters:
    
    value - the IDataProvider key for the edge selection
    
    See Also:
    
    setScope(Scope), getAffectedEdgesDpKey()
  - setAffectedNodesDpKey
```
public void setAffectedNodesDpKey(Object value)
```
    Sets the IDataProvider key to look up the selection state of the nodes.
    If the scope is set to Scope.ROUTE_EDGES_AT_AFFECTED_NODES, only the edges that are incident to selected nodes will be routed, while all other edges will be considered to have fixed routes.
    
    Throws:
    
    IllegalArgumentException - if the specified IDataProvider key is null
    
    Default Value:
    The default value is LayoutKeys.AFFECTED_NODES_DPKEY
    
    Parameters:
    
    value - the IDataProvider key for the node selection
    
    See Also:
    
    setScope(Scope), getAffectedNodesDpKey()
  - setEdgeComparator
```
public void setEdgeComparator(Comparator<Object> value)
```
    Sets a custom Comparator to define the processing order of the edges.
    
    The processing order may affect the quality of the individual edge paths. When routing an edge, only the paths of the already routed edges and of the fixed edges (that will not be routed at all) can be considered. Therefore, edges that are processed first have to consider less other edge paths than the edges that are processed later, which might have to use less optimal alternative paths.
    
    Default Value:
    The default value is Comparator. The comparator returned by EdgeComparator.
    
    Parameters:
    
    value - the current Comparator instance
    
    See Also:
    
    createDefaultEdgeOrderComparator(LayoutGraph, PathSearchConfiguration), getEdgeComparator()
  - setEdgeLabelConsiderationEnabled
```
public void setEdgeLabelConsiderationEnabled(boolean value)
```
    Sets whether or not the routing algorithm considers as obstacles the edge labels that do not belong to the (sub-)set of edges to be routed when calculating the edge routes.
    
    This option takes effect only if Scope is set to Scope.ROUTE_AFFECTED_EDGES and a IDataProvider instance with the key AffectedEdgesDpKey is registered with the graph.
    
    Default Value:
    The default value is false. Edge labels are not considered.
    
    Parameters:
    
    value - true if edge labels are considered, false otherwise
    
    See Also:
    
    setScope(Scope), setAffectedEdgesDpKey(Object), PenaltySettings.getNodeLabelCrossingPenalty(), isEdgeLabelConsiderationEnabled()
  - setGrid
```
public void setGrid(Grid value)
```
    Sets the Grid instance on which the routing algorithm places the orthogonal segments.
    
    Default Value:
    The default value is null. No grid is specified.
    
    Parameters:
    
    value - the Grid instance
    
    See Also:
    
    getGrid()
  - setIgnoringInnerNodeLabelsEnabled
```
public void setIgnoringInnerNodeLabelsEnabled(boolean value)
```
    Sets whether or not this routing algorithm ignores node labels that are inside the bounds of their owner as obstacles for edge routes.
    
    This setting can be applied only if node labels are considered and is especially useful in order to ignore inner node labels of group nodes.
    
    Default Value:
    The default value is false. Node labels that are inside the bounds of their owner are not ignored.
    
    Parameters:
    
    value - true if the routing algorithm ignores inner node labels, false otherwise
    
    See Also:
    
    isNodeLabelConsiderationEnabled(), PenaltySettings.getNodeLabelCrossingPenalty(), LABEL_CROSSING_PENALTY_FACTOR_DPKEY, isIgnoringInnerNodeLabelsEnabled()
  - setMaximumDuration
```
public void setMaximumDuration(long value)
```
    Sets the time limit (in milliseconds) set for the edge routing algorithm.
    The maximum duration has 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 edge routing algorithm still has to find a valid solution.
    
    Default Value:
    The default value is Long.MAX_VALUE. The edge routing algorithm runs unrestricted.
    
    Parameters:
    
    value - a non-negative integer value
    
    See Also:
    
    getMaximumDuration()
  - setMaximumPolylineSegmentRatio
```
public void setMaximumPolylineSegmentRatio(double value)
```
    Sets the maximum ratio between the horizontal/vertical part of a segment and the (non-orthogonal) polyline part.
    When polyline segments are added to an edge path, corners between horizontal and vertical segments are cut and replaced by the new segment. This ratio describes the cutting points on a segment. If it is zero, the route stays orthogonal. The value cannot be larger than 0.5 because there may be another polyline segment at the other side of the segment. For long orthogonal segments the length of the polyline segment is determined by the value returned by PreferredPolylineSegmentLength.
    
    The maximum polyline segment ratio must be between 0 and 0.5.
    
    Throws:
    
    IllegalArgumentException - if the maximum segment length is negative or greater than 0.5
    
    Default Value:
    The default value is 0.3.
    
    Parameters:
    
    value - the maximum polyline segment ratio
    
    See Also:
    
    getMaximumPolylineSegmentRatio()
  - setMinimumNodeToEdgeDistance
```
public void setMinimumNodeToEdgeDistance(double value)
```
    Sets the minimum distance between edges and node bounds.
    The minimum distance should have a non-negative value.
    
    Throws:
    
    IllegalArgumentException - if the minimum node-to-edge distance is negative
    
    Default Value:
    The default value is 10.
    
    Parameters:
    
    value - the non-negative minimum distance
    
    See Also:
    
    PenaltySettings.getMinimumNodeToEdgeDistancePenalty(), getMinimumNodeToEdgeDistance()
  - setNodeLabelConsiderationEnabled
```
public void setNodeLabelConsiderationEnabled(boolean value)
```
    Sets whether or not the routing algorithm considers the labels of the nodes as obstacles when calculating the edge routes to avoid overlaps.
    
    This option takes effect only if Scope is set to Scope.ROUTE_EDGES_AT_AFFECTED_NODES and a IDataProvider instance with the key AffectedNodesDpKey is registered with the graph.
    
    Default Value:
    The default value is false. Node labels are not considered.
    
    Parameters:
    
    value - true if the node labels are considered, false otherwise
    
    See Also:
    
    PenaltySettings.getNodeLabelCrossingPenalty(), isNodeLabelConsiderationEnabled()
  - setPolylineRoutingEnabled
```
public void setPolylineRoutingEnabled(boolean value)
```
    Sets whether or not the routing algorithm will route the edges of the graph with (non-orthogonal) polyline segments.
    
    Default Value:
    The default value is false. The polyline edge routing is disabled.
    
    Parameters:
    
    value - true if the routing algorithm creates (non-orthogonal) polyline segments, false otherwise
    
    See Also:
    
    getPreferredPolylineSegmentLength(), getMaximumPolylineSegmentRatio(), isPolylineRoutingEnabled()
  - setPreferredPolylineSegmentLength
```
public void setPreferredPolylineSegmentLength(double value)
```
    Sets the preferred length of (non-orthogonal) polyline segments.
    If there is not enough space to use this preferred length, polyline segments may also be shorter.
    
    The preferred length of (non-orthogonal) polyline segments has to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the preferred polyline segment length is negative
    
    This restriction applies only if polyline routing is enabled.
    
    Default Value:
    The default value is 30.
    
    Parameters:
    
    value - the preferred length of (non-orthogonal) polyline segments
    
    See Also:
    
    getMaximumPolylineSegmentRatio(), getPreferredPolylineSegmentLength()
  - setReroutingEnabled
```
public void setReroutingEnabled(boolean value)
```
    Sets whether or not the routing algorithm uses an additional step to reroute the edges that are considered to have the worst paths.
    
    The rerouting step will only be applied if the maximum duration has not been exceeded yet.
    
    Default Value:
    The default value is false. The rerouting step will not be performed.
    
    Parameters:
    
    value - true if the rerouting step will be performed, false otherwise
    
    See Also:
    
    isReroutingEnabled()
  - setScope
```
public void setScope(Scope value)
```
    Sets a (sub-)set of edges that shall be routed.
    
    Throws:
    
    IllegalArgumentException - if the given scope is unknown
    
    Default Value:
    The default value is Scope.ROUTE_ALL_EDGES
    
    Parameters:
    
    value - one of the default scope values
    
    See Also:
    
    getAffectedEdgesDpKey(), getScope()

Class EdgeRouter

Layout Style

Concept

Features

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

EDGE_LAYOUT_DESCRIPTOR_DPKEY

LABEL_CROSSING_PENALTY_FACTOR_DPKEY

Constructor Detail

EdgeRouter

EdgeRouter

Method Detail

applyLayout

checkNodeSize

cleanUpGraphPartition

configureGraphPartition

configurePathSearch

createConfiguration

createDefaultEdgeOrderComparator

createGraphPartition

createObstacleDecomposition

createPathRouting

createPathSearch

createPathSearchContext

getAffectedEdgesDpKey

getAffectedNodesDpKey

getDefaultEdgeLayoutDescriptor

getEdgeComparator

getEdgeLayoutDescriptor

getGrid

getMaximumDuration

getMaximumPolylineSegmentRatio

getMinimumNodeToEdgeDistance

getPartition

getPreferredPolylineSegmentLength

getRegisteredPartitionExtensions

getRegisteredPathSearchExtensions

getScope

isAffected

isEdgeLabelConsiderationEnabled

isIgnoringInnerNodeLabelsEnabled

isNodeLabelConsiderationEnabled

isPolylineRoutingEnabled

isReroutingEnabled

setAffectedEdgesDpKey

setAffectedNodesDpKey

setEdgeComparator

setEdgeLabelConsiderationEnabled

setGrid

setIgnoringInnerNodeLabelsEnabled

setMaximumDuration

setMaximumPolylineSegmentRatio

setMinimumNodeToEdgeDistance

setNodeLabelConsiderationEnabled

setPolylineRoutingEnabled

setPreferredPolylineSegmentLength

setReroutingEnabled

setScope