Package org.jungrapht.visualization.layout.algorithms

Class EdgeAwareTreeLayoutAlgorithm<V,E>

java.lang.Object

org.jungrapht.visualization.layout.algorithms.AbstractLayoutAlgorithm<V>

org.jungrapht.visualization.layout.algorithms.AbstractTreeLayoutAlgorithm<V>

org.jungrapht.visualization.layout.algorithms.TreeLayoutAlgorithm<V>

org.jungrapht.visualization.layout.algorithms.EdgeAwareTreeLayoutAlgorithm<V,E>

All Implemented Interfaces:

Consumer<Function<V,Rectangle>>, EdgeAwareLayoutAlgorithm<V,E>, EdgePredicated<E>, EdgeSorting<E>, LayoutAlgorithm<V>, TreeLayout<V>, AfterRunnable, VertexBoundsFunctionConsumer<V>, VertexPredicated<V>, VertexSorting<V>

Direct Known Subclasses:

RadialEdgeAwareTreeLayoutAlgorithm

public class EdgeAwareTreeLayoutAlgorithm<V,E>
extends TreeLayoutAlgorithm<V>
implements TreeLayout<V>, EdgeAwareLayoutAlgorithm<V,E>, EdgeSorting<E>, EdgePredicated<E>, VertexSorting<V>, VertexPredicated<V>

A TreeLayoutAlgorithm that can evaluate Comparator and Predicate for both edges and vertices.

During graph traversal (for tree layout) the Comparators may be spcified to help order the traversal to favor certain edges or vertices. Similarly, the Predicates may be used to help follow a desired path to a vertex when multiple alternatives appear in the graph.

Author:

Tom Nelson

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	EdgeAwareTreeLayoutAlgorithm.Builder<V,E,T extends EdgeAwareTreeLayoutAlgorithm<V,E>,B extends EdgeAwareTreeLayoutAlgorithm.Builder<V,E,T,B>>	a Builder to create a configured instance of an EdgeAwareTreeLayoutAlgorithm

Nested classes/interfaces inherited from interface org.jungrapht.visualization.layout.algorithms.LayoutAlgorithm

LayoutAlgorithm.NoOp<V>

Field Summary

Fields

Modifier and Type	Field	Description
protected boolean	alignFavoredEdges
protected Comparator<E>	edgeComparator	a Comparator to sort edges
protected Predicate<E>	edgePredicate	a Predicate to filter edges
protected Comparator<V>	vertexComparator	a Comparator to sort vertices
protected Predicate<V>	vertexPredicate	a Predicate to filter vertices

Fields inherited from class org.jungrapht.visualization.layout.algorithms.AbstractTreeLayoutAlgorithm

baseBounds, correctOverlap, defaultRootPredicate, expandLayout, horizontalVertexSpacing, neighborCache, rootComparator, rootPredicate, vertexBoundsFunction, verticalVertexSpacing, visitedVertices

Fields inherited from class org.jungrapht.visualization.layout.algorithms.AbstractLayoutAlgorithm

after

Fields inherited from interface org.jungrapht.visualization.layout.algorithms.TreeLayout

TREE_LAYOUT_HORIZONTAL_SPACING, TREE_LAYOUT_VERTICAL_SPACING

Constructor Summary

Constructors

Modifier	Constructor	Description
	EdgeAwareTreeLayoutAlgorithm()
protected	EdgeAwareTreeLayoutAlgorithm(EdgeAwareTreeLayoutAlgorithm.Builder<V,E,?,?> builder)	Create an instance with the passed builder parameters

Method Summary

Modifier and Type	Method	Description
protected Set<V>	alignBuildTree(LayoutModel<V> layoutModel)	After the tree is configured, visit all of the vertices that are on favored edges and adjust their position to the left side of their children's bounding box.
protected Set<V>	buildTree(LayoutModel<V> layoutModel)
protected void	buildTree(LayoutModel<V> layoutModel, V vertex, int x, int y, Set<V> seen)	Build the tree (position the vertices) starting at the passed vertex and then descending recursively into its child vertices
protected int	calculateHeight(LayoutModel<V> layoutModel, V vertex, Set<V> seen)	Calculate the overall height of the subtree rooted at the passed vertex.
protected int	calculateWidth(LayoutModel<V> layoutModel, V vertex, Set<V> seen)	Calculate the overall width of the subtree rooted at the passed vertex.
static <V,E> EdgeAwareTreeLayoutAlgorithm.Builder<V,E,?,?>	edgeAwareBuilder()
void	setEdgeComparator(Comparator<E> edgeComparator)
void	setEdgePredicate(Predicate<E> edgePredicate)
void	setVertexComparator(Comparator<V> vertexComparator)
void	setVertexPredicate(Predicate<V> vertexPredicate)

Methods inherited from class org.jungrapht.visualization.layout.algorithms.TreeLayoutAlgorithm

builder, calculateHeight, calculateWidth, constrained, getBaseBounds, getCenter, getInitialPosition, getSpanningTree, merge, visit

Methods inherited from class org.jungrapht.visualization.layout.algorithms.AbstractTreeLayoutAlgorithm

adjustToFill, expandToFill, moveVerticesThatOverlapVerticalEdges, setRootComparator, setRootPredicate, setVertexBoundsFunction

Methods inherited from class org.jungrapht.visualization.layout.algorithms.AbstractLayoutAlgorithm

computeAverageVertexDimension, computeLayoutExtent, expandToFill, runAfter, setAfter

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.jungrapht.visualization.layout.algorithms.util.AfterRunnable

runAfter, setAfter

Methods inherited from interface java.util.function.Consumer

andThen

Methods inherited from interface org.jungrapht.visualization.layout.algorithms.EdgeAwareLayoutAlgorithm

visit

Methods inherited from interface org.jungrapht.visualization.layout.algorithms.LayoutAlgorithm

cancel, constrained

Methods inherited from interface org.jungrapht.visualization.layout.algorithms.TreeLayout

getBaseBounds, setRootComparator, setRootPredicate

Methods inherited from interface org.jungrapht.visualization.layout.algorithms.util.VertexBoundsFunctionConsumer

accept, setVertexBoundsFunction

Field Detail

vertexPredicate

protected Predicate<V> vertexPredicate

a Predicate to filter vertices

edgePredicate

protected Predicate<E> edgePredicate

a Predicate to filter edges

vertexComparator

protected Comparator<V> vertexComparator

a Comparator to sort vertices

edgeComparator

protected Comparator<E> edgeComparator

a Comparator to sort edges

alignFavoredEdges

protected boolean alignFavoredEdges

Constructor Detail

EdgeAwareTreeLayoutAlgorithm

public EdgeAwareTreeLayoutAlgorithm()

EdgeAwareTreeLayoutAlgorithm

protected EdgeAwareTreeLayoutAlgorithm(EdgeAwareTreeLayoutAlgorithm.Builder<V,E,?,?> builder)

Create an instance with the passed builder parameters

Parameters:

builder - the configuration

Method Detail

edgeAwareBuilder

public static <V,E> EdgeAwareTreeLayoutAlgorithm.Builder<V,E,?,?> edgeAwareBuilder()

Type Parameters:

V - vertex type

E - edge type

Returns:

a Builder ready to configure

setVertexPredicate

public void setVertexPredicate(Predicate<V> vertexPredicate)

Specified by:

setVertexPredicate in interface VertexPredicated<V>

Parameters:

vertexPredicate - parameter to set

setEdgePredicate

public void setEdgePredicate(Predicate<E> edgePredicate)

Specified by:

setEdgePredicate in interface EdgePredicated<V>

Parameters:

edgePredicate - parameter to set

setVertexComparator

public void setVertexComparator(Comparator<V> vertexComparator)

Specified by:

setVertexComparator in interface VertexSorting<V>

Parameters:

vertexComparator - parameter to set

setEdgeComparator

public void setEdgeComparator(Comparator<E> edgeComparator)

Specified by:

setEdgeComparator in interface EdgeSorting<V>

Parameters:

edgeComparator - parameter to set

buildTree

protected Set<V> buildTree(LayoutModel<V> layoutModel)

Overrides:

buildTree in class TreeLayoutAlgorithm<V>

Parameters:

layoutModel - the model to hold vertex positions

Returns:

the roots vertices of the tree

buildTree

protected void buildTree(LayoutModel<V> layoutModel,
                         V vertex,
                         int x,
                         int y,
                         Set<V> seen)

Build the tree (position the vertices) starting at the passed vertex and then descending recursively into its child vertices

Overrides:

buildTree in class TreeLayoutAlgorithm<V>

Parameters:

layoutModel - the LayoutModel to hold the vertex positions

vertex - the vertex to place in position

x - the x position

y - the y position

seen - a set of vertices that were already 'seen' (and placed in the layoutModel)

calculateWidth

protected int calculateWidth(LayoutModel<V> layoutModel,
                             V vertex,
                             Set<V> seen)

Calculate the overall width of the subtree rooted at the passed vertex. The edgePredicate is used to keep favored edges together. For example, if a non-favored edge provides a vertex sooner than its favored edge, the non-favored edge path will be deferred until the favored edge provides the same vertex. This prevents edges that span from one tree to another from 'stealing' a subtree that we would prefer to keep together on its favored edge path

Overrides:

calculateWidth in class TreeLayoutAlgorithm<V>

Parameters:

layoutModel - the source of the Graph and its vertices

vertex - the vertex at the top of the current subtree

seen - a set of vertices that were already counted

Returns:

the overall width of the subtree rooted at the passed vertex

calculateHeight

protected int calculateHeight(LayoutModel<V> layoutModel,
                              V vertex,
                              Set<V> seen)

Calculate the overall height of the subtree rooted at the passed vertex. The edgePredicate is used to keep favored edges together. For example, if a non-favored edge provides a vertex sooner than its favored edge, the non-favored edge path will be deferred until the favored edge provides the same vertex. This prevents edges that span from one tree to another from 'stealing' a subtree that we would prefer to keep together on its favored edge path

Overrides:

calculateHeight in class TreeLayoutAlgorithm<V>

Parameters:

layoutModel - the source of the Graph and its vertices

vertex - the vertex at the top of the current subtree

seen - a set of vertices that were already counted

Returns:

the overall height of the subtree rooted at the passed vertex

alignBuildTree

protected Set<V> alignBuildTree(LayoutModel<V> layoutModel)

After the tree is configured, visit all of the vertices that are on favored edges and adjust their position to the left side of their children's bounding box. This helps provide a more linear path for favored edge endpoints

Parameters:

layoutModel - the source of the graph and its vertices

Returns:

the Set of root vertices