y.layout.router
Class OrganicEdgeRouter

java.lang.Object
  y.layout.router.OrganicEdgeRouter

All Implemented Interfaces:

Layouter, LayoutStage

public class OrganicEdgeRouter
extends Object
implements LayoutStage

This algorithm routes edges using an organic-like layout approach and style. It is implemented as a LayoutStage so that it can easily be appended to another stage, by setting the other stage as the core of this one. Note that this algorithm only works correctly if it is guaranteed that nodes are at least approximately twice as far away from each other as the minimal edge distance, which has been set for this algorithm. This can be achieved by using the createNodeEnlargementStage() layout stage in combination with a stage that removes node overlaps as the core of this layouter.

Here is a sample output of the router using as input a straight-line drawing created by SmartOrganicLayouter:

Field Summary

static Object

ROUTE_EDGE_DPKEY Use this key to provide the algorithm with boolean values for each edge, specifying the ones which should be rerouted.

Fields inherited from interface y.layout.Layouter

EDGE_ID_DPKEY, NODE_ID_DPKEY, SELECTED_EDGES, SELECTED_NODES

Constructor Summary

OrganicEdgeRouter()
Creates a new instance of OrganicEdgeRouter with an initial minimal distance of 10.

OrganicEdgeRouter(double minNodeDistance)
Creates a new instance of OrganicEdgeRouter using the given initial minimal distance

Method Summary

boolean	canLayout(LayoutGraph graph) Returns true iff the given graph can be laid out by this algorithm.
protected void	checkGroupNodeSize(GraphLayout layout, Object node) This method throws an IllegalArgumentException if the width/height of the given group node object is zero.
protected void	checkNodeSize(GraphLayout layout, Object node) This method throws an IllegalArgumentException if the width/height of the given node object is zero.
LayoutStage	createNodeEnlargementStage() This will return a layout stage which can be given a core layouter, which itself should assure that the nodes do not overlap.
void	doLayout(LayoutGraph graph) Main layout routine that assigns new layout information to the given graph.
Layouter	getCoreLayouter() Returns the core layouter.
double	getMinimalDistance() Returns the minimal distance between nodes and non-incident edges.
boolean	isEdgeNodeOverlapAllowed() Returns whether or not edge-node overlaps are allowed.
boolean	isRoutingAll() Returns whether edges should be rerouted even if they do not obey all constraints initially.
boolean	isUsingBends() Returns whether given bend coordinates are taken into account when determining initial bend positions.
void	setCoreLayouter(Layouter l) Sets the core layouter.
void	setEdgeNodeOverlapAllowed(boolean edgeNodeOverlapAllowed) Enabling this option often leads to better results if the createNodeEnlargementStage() LayoutStage is not used (e.g. because the nodes are not allowed to move) and the distances between some nodes are small.
void	setMinimalDistance(double minimalDistance) Specifies the minimal distance the algorithm should guarantee between nodes and non-incident edges.
void	setRoutingAll(boolean routingAll) Specifies whether edges should be rerouted even if they do not obey all constraints initially.
void	setUsingBends(boolean usingBends) Specifies whether given bend coordinates are taken into account when determining initial bend positions.

Methods inherited from class java.lang.Object

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

Field Detail

ROUTE_EDGE_DPKEY

public static final Object ROUTE_EDGE_DPKEY

Use this key to provide the algorithm with boolean values for each edge, specifying the ones which should be rerouted.

Constructor Detail

OrganicEdgeRouter

public OrganicEdgeRouter()

Creates a new instance of OrganicEdgeRouter with an initial minimal distance of 10.

OrganicEdgeRouter

public OrganicEdgeRouter(double minNodeDistance)

Creates a new instance of OrganicEdgeRouter using the given initial minimal distance

Method Detail

canLayout

public boolean canLayout(LayoutGraph graph)

Description copied from interface: Layouter

Returns true iff the given graph can be laid out by this algorithm. Calling doLayout with the given graph as its argument will only success if this method returns true.

Specified by:

canLayout in interface Layouter

isEdgeNodeOverlapAllowed

public boolean isEdgeNodeOverlapAllowed()

Returns whether or not edge-node overlaps are allowed. Enabling this option often leads to better results if the createNodeEnlargementStage() LayoutStage is not used (e.g. because the nodes are not allowed to move) and the distances between some nodes are small. However enabling this option may produce edge-node overlaps. Furthermore, the minimal distance (set with setMinimalDistance(double) cannot always be maintained in that case.

Returns:

true if edge-node overlaps are allowed.

See Also:

setEdgeNodeOverlapAllowed(boolean), createNodeEnlargementStage(), setMinimalDistance(double)

setEdgeNodeOverlapAllowed

public void setEdgeNodeOverlapAllowed(boolean edgeNodeOverlapAllowed)

Enabling this option often leads to better results if the createNodeEnlargementStage() LayoutStage is not used (e.g. because the nodes are not allowed to move) and the distances between some nodes are small. However enabling this option may produce edge-node overlaps. Furthermore, the minimal distance (set with setMinimalDistance(double)) cannot always be maintained in that case.

Parameters:

edgeNodeOverlapAllowed - true if edge-node overlaps should be allowed.

See Also:

isEdgeNodeOverlapAllowed(), createNodeEnlargementStage(), setMinimalDistance(double)

doLayout

public void doLayout(LayoutGraph graph)

Description copied from interface: Layouter

Main layout routine that assigns new layout information to the given graph.

Specified by:

doLayout in interface Layouter

checkNodeSize

protected void checkNodeSize(GraphLayout layout,
                             Object node)
                      throws IllegalArgumentException

This method throws an IllegalArgumentException if the width/height of the given node object is zero. It is called by the doLayout(LayoutGraph) method for each node object in the input graph.

Throws:

IllegalArgumentException - thrown if the width/height of the node object is zero.

Parameters:

layout - a graph layout object.

node - the node object to test.

See Also:

checkGroupNodeSize(GraphLayout,Object)

checkGroupNodeSize

protected void checkGroupNodeSize(GraphLayout layout,
                                  Object node)
                           throws IllegalArgumentException

This method throws an IllegalArgumentException if the width/height of the given group node object is zero. It is called by the doLayout(LayoutGraph) method for each group node object in the input graph.

Throws:

IllegalArgumentException - thrown if the width/height of the group node object is zero.

Parameters:

layout - a graph layout object.

node - the group node object to test.

See Also:

checkNodeSize(GraphLayout,Object)

getCoreLayouter

public Layouter getCoreLayouter()

Returns the core layouter.

Specified by:

getCoreLayouter in interface LayoutStage

setCoreLayouter

public void setCoreLayouter(Layouter l)

Sets the core layouter.

Specified by:

setCoreLayouter in interface LayoutStage

getMinimalDistance

public double getMinimalDistance()

Returns the minimal distance between nodes and non-incident edges.

setMinimalDistance

public void setMinimalDistance(double minimalDistance)

Specifies the minimal distance the algorithm should guarantee between nodes and non-incident edges. Values should be larger than 10.

isUsingBends

public boolean isUsingBends()

Returns whether given bend coordinates are taken into account when determining initial bend positions.

setUsingBends

public void setUsingBends(boolean usingBends)

Specifies whether given bend coordinates are taken into account when determining initial bend positions.

isRoutingAll

public boolean isRoutingAll()

Returns whether edges should be rerouted even if they do not obey all constraints initially. This flag is initially set to false so that if edges that do not intersect with other nodes will not be rerouted by this algorithm.

setRoutingAll

public void setRoutingAll(boolean routingAll)

Specifies whether edges should be rerouted even if they do not obey all constraints initially. This flag is initially set to false so that if edges that do not intersect with other nodes will not be rerouted by this algorithm.

createNodeEnlargementStage

public LayoutStage createNodeEnlargementStage()

This will return a layout stage which can be given a core layouter, which itself should assure that the nodes do not overlap. This ensures that OrganicEdgeRouter has enough empty space for routing edges. This could for example look like the following snippet:

 RemoveOverlapsLayoutStage rmos = new RemoveOverlapsLayoutStage(0);
 LayoutStage nodeEnlarger = router.createNodeEnlargementStage();
 final CompositeLayoutStage cls = new CompositeLayoutStage();
 cls.appendStage(nodeEnlarger);
 cls.appendStage(new BendConverter());
 cls.appendStage(rmos);

 OrganicEdgeRouter oer = new OrganicEdgeRouter();
 oer.setCoreLayouter(cls);
 oer.doLayout(myGraph);