com.yworks.yfiles.layout

Class LayoutGraphUtilities

java.lang.Object

com.yworks.yfiles.layout.LayoutGraphUtilities

public final class LayoutGraphUtilities
extends Object

The LayoutGraphUtilities provides several helper and utility functions for LayoutGraph and the layout algorithms.

See Also:

LayoutGraph

Method Summary

Modifier and Type	Method and Description
static void	alignNodeLayouts(LayoutGraph graph, NodeList nodes, Node referenceNode, boolean vertical, NodeAlignment mode) Aligns the specified nodes either vertically or horizontally according to the specified node alignment mode.
static YDimension	arrangeRectangleGrid(Rectangle2D[] rectangles, Rectangle2D finalRect, double aspectRatio) Reassigns the bounds of the rectangles in a grid to fit in a large rectangle with an aspect ratio close to the specified aspect ratio.
static int	arrangeRectangleMultiRows(Rectangle2D[] rectangles, Rectangle2D finalRect, double preferredWidth, double preferredHeight, boolean compaction, MultiRowConstraint constraintMode) Reassigns the bounds of the rectangles in multiple rows to fit the preferred width and height.
static int	arrangeRectangleMultiRows(Rectangle2D[] rectangles, Rectangle2D finalRect, double preferredWidth, double preferredHeight, boolean compaction, MultiRowConstraint constraintMode, RowAlignment alignment) Reassigns the bounds of the rectangles in multiple rows to fit the preferred width and height.
static int	arrangeRectangleRows(Rectangle2D[] rectangles, Rectangle2D finalRect, double aspectRatio) Reassigns the bounds of the rectangles to fit in a large rectangle with an aspect ratio close to the specified aspect ratio.
static int	arrangeRectangleRows(Rectangle2D[] rectangles, Rectangle2D finalRect, double aspectRatio, RowAlignment alignment) Reassigns the bounds of the rectangles to fit in a large rectangle with an aspect ratio close to the specified aspect ratio.
static void	assignReverseLayout(LayoutGraph graph, Edge edge1, Edge edge2) Applies the reversed layout of the first edge to the second edge.
static boolean	autoFlipBox(YOrientedRectangle rect) Flips the orientation of a given rectangle, if its up vector points downward (upY> 0).
static void	clipEdgeOnBounds(LayoutGraph graph, Edge edge) Clips the path of the given edge on the bounding box of the source and target points.
static YPointPath	clipEdgePathOnBounds(IEdgeLayout edge, INodeLayout source, INodeLayout target) Returns the path of an edge clipped on insets of the bounding box of the source and target node.
static YPointPath	clipEdgePathOnBounds(IEdgeLayout edge, INodeLayout source, INodeLayout target, double inset) Returns the path of an edge clipped on insets of the bounding box of the source and target node.
static YPointPath	clipEdgePathOnBounds(LayoutGraph graph, Edge edge) Returns the path of an edge clipped on the bounding box of the source and target node.
static void	clipEdgesOnBounds(LayoutGraph graph) Clips the path of all edges in the graph on the bounding box of their source and target points.
static YPointPath	clipPathOnBounds(YPointPath path, YRectangle sourceBox, YRectangle targetBox) Returns the path of a given edge path clipped on the given bounding boxes of the source and target node.
static EdgeFlow	determineEdgeFlowDirection(LayoutGraph graph, IDataProvider considerEdges) Determines the main direction of the edge flow by analyzing the current layout of the graph.
static String	edgeLayoutString(LayoutGraph graph, Edge edge) Returns a String representation of the path of the given edge.
static Rectangle2D	getBoundingBox(LayoutGraph graph, Edge edge) Returns the bounding box of the given edge.
static Rectangle2D	getBoundingBox(LayoutGraph graph, IEdgeCursor edges) Returns the bounding box of the edges accessible through the given cursor.
static Rectangle2D	getBoundingBox(LayoutGraph graph, INodeCursor nodes) Returns the bounding box of the nodes accessible through the given cursor.
static Rectangle2D	getBoundingBox(LayoutGraph graph, INodeCursor nodes, IEdgeCursor edges) Returns the bounding box of the nodes and edges accessible through the given cursors.
static Rectangle2D	getBoundingBox(LayoutGraph graph, INodeCursor nodes, IEdgeCursor edges, boolean includeLabels) Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels and edge labels.
static Rectangle2D	getBoundingBox(LayoutGraph graph, INodeCursor nodes, IEdgeCursor edges, boolean includeNodeLabels, boolean includeEdgeLabels) Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels or edge labels.
static Rectangle2D	getBoundingBox(LayoutGraph graph, INodeCursor nodes, IEdgeCursor edges, boolean includeNodeLabels, boolean includeEdgeLabels, boolean includeHalos) Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels, edge labels or NodeHalos.
static Rectangle2D	getBoundingBox(LayoutGraph graph, Node node) Returns the bounding box of the given node.
static ILabelLayoutFactory	getLabelFactory(LayoutGraph graph) Returns the ILabelLayoutFactory for the given graph.
static YPoint	getLabelPlacement(IEdgeLabelLayoutModel model, YDimension labelSize, IEdgeLayout edgeLayout, INodeLayout sourceLayout, INodeLayout targetLayout, Object param) Returns the upper-left corner of the paraxial bounding box of the given edge label as encoded by the specified model parameter.
static YPoint	getLabelPlacement(INodeLabelLayoutModel model, YDimension labelSize, INodeLayout nodeLayout, Object param) Returns the upper-left corner of the paraxial bounding box of the given node label as encoded by the specified model parameter.
static double	getNodeDistance(LayoutGraph graph, Node node1, Node node2) Returns the distance between the centers of the two given nodes.
static String	getNodePositions(LayoutGraph graph) Returns a String representation of all node positions in the graph.
static double	getPathLength(LayoutGraph graph, Edge edge) Returns the length of the path of the given edge.
static boolean	isEdgeOutsideNodes(IEdgeLayout edge, INodeLayout source, INodeLayout target, double halo) Checks whether or not the path of an edge is outside the bounding box of the source and target node, considering the given halo.
static boolean	isEdgeOutsideNodes(LayoutGraph graph, Edge edge) Checks whether or not the path of an edge is outside the bounding box of the source and target node.
static boolean	isUsingOctilinearEdgeRoutes(LayoutGraph graph, IDataProvider considerEdges) Determines whether or not most of the edges of the graph are routed octilinear.
static boolean	isUsingOrthogonalEdgeRoutes(LayoutGraph graph, IDataProvider considerEdges) Determines whether or not most of the edges of the graph are routed orthogonally.
static void	moveEdge(LayoutGraph graph, Edge edge, double dx, double dy) Moves all control points of the given edge by the vector (dx,dy).
static void	moveEdges(LayoutGraph graph, IEdgeCursor edges, double dx, double dy) Moves the control points of all edges accessible through the given IEdgeCursor by the vector (dx,dy).
static void	moveNode(LayoutGraph graph, Node node, double dx, double dy) Moves the given node by the vector (dx,dy).
static void	moveNodes(LayoutGraph graph, INodeCursor nodes, double dx, double dy) Moves all nodes accessible through the given INodeCursor by the vector (dx,dy).
static void	moveSubgraph(LayoutGraph graph, IEdgeCursor edges, double dx, double dy) Moves the subgraph induced by the edges accessible through the given IEdgeCursor by the vector (dx,dy).
static void	moveSubgraph(LayoutGraph graph, INodeCursor nodes, double dx, double dy) Moves the subgraph induced by the nodes accessible through the given INodeCursor by the vector (dx,dy).
static boolean	pathIntersectsRect(LayoutGraph graph, Edge edge, Rectangle2D rect) Checks whether or not the path of the given edge intersects the interior of a given rectangular area.
static void	removeDuplicateBends(LayoutGraph graph) Removes successive bends that have the same coordinates from all edges in the graph.
static void	removeDuplicateBends(LayoutGraph graph, Edge edge) Removes successive bends that have the same coordinates from the given edge.
static void	resetPath(LayoutGraph graph, Edge edge) Assigns a trivial path which has no control points to the specified edge.
static void	resetPath(LayoutGraph graph, Edge edge, boolean resetPorts) Assigns a trivial path which has no control points to the specified edge.
static void	resetPaths(LayoutGraph graph) Assigns a trivial path which has no control points to all edges in the specified graph.
static void	resetPaths(LayoutGraph graph, boolean resetPorts) Assigns a trivial path which has no control points to all edges in the specified graph.
static void	resetPorts(LayoutGraph graph) Sets the ports of all edges in the graph to the center of the nodes.
static void	reverseEdgeLayout(IEdgeLayout el) Reverses the layout of an edge.
static void	roundEdgeLayout(LayoutGraph graph, Edge edge) Rounds the locations of the control points and ports of the given edge to integer values.
static void	roundLayout(LayoutGraph graph) Rounds coordinates and sizes in the layout of an entire graph to integer values.
static void	roundNodeLayout(LayoutGraph graph, Node node) Rounds the location and size of the given node to integer values.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge1, Edge edge2, double lineDistance) Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge1, Edge edge2, double lineDistance, boolean joinEnds) Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge1, Edge edge2, double lineDistance, boolean joinEnds, double absJoinDist) Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge1, Edge edge2, double lineDistance, boolean joinEnds, double absJoinDist, double relJoinDist) Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance, boolean adjustE1) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance, boolean adjustE1, boolean joinEnds) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance, boolean adjustE1, boolean joinEnds, double absJoinDist) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance, boolean adjustE1, boolean joinEnds, double absJoinDist, double relJoinDist) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	routeSelfLoop(LayoutGraph graph, Edge edge) Routes a self-loop.

Methods inherited from class java.lang.Object

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

Method Detail

alignNodeLayouts

public static final void alignNodeLayouts(LayoutGraph graph,
                                          NodeList nodes,
                                          Node referenceNode,
                                          boolean vertical,
                                          NodeAlignment mode)

Aligns the specified nodes either vertically or horizontally according to the specified node alignment mode.

For vertical arrangements, nodes are either top-aligned, center-aligned, bottom-aligned, or vertically distributed.

For horizontal arrangements, nodes are either left-aligned, center-aligned, right-aligned, or horizontally distributed.

In this context, distributed means that the specified nodes are placed in such a way that the projections of their bounds onto the vertical or horizontal coordinate axis do not overlap. For example, after vertically distributing nodes, (n1.y + n1.height) <= n2.y for two consecutively placed nodes n1 and n2.

Parameters:

graph - the graph that contains the specified nodes

nodes - the subset of the specified graph's nodes that is arranged

referenceNode - if null, the common coordinate for aligning the specified nodes is calculated as the the vertical minimum (top-aligned), the vertical center, the vertical maximum (bottom-aligned), the horizontal minimum (left-aligned), the horizontal center, or the horizontal maximum (right-aligned) of the bounds of the specified nodes; otherwise the appropriate coordinate of the given reference node's bounds is used as common coordinate for aligning the specified nodes. The reference node is ignored when distributing nodes.

vertical - true if nodes should be aligned (or distributed) according to their y-coordinates; otherwise nodes are aligned (or distributed) according to their x-coordinates.

mode - one of the valid alignment modes

arrangeRectangleGrid

public static final YDimension arrangeRectangleGrid(Rectangle2D[] rectangles,
                                                    Rectangle2D finalRect,
                                                    double aspectRatio)

Reassigns the bounds of the rectangles in a grid to fit in a large rectangle with an aspect ratio close to the specified aspect ratio.

The aspect ratio must be greater than 0.

Throws:

IllegalArgumentException - if the given aspect ratio is less than or equal to zero

Parameters:

rectangles - the rectangles whose coordinates will be modified

finalRect - the exact dimension will be placed in this rectangle

aspectRatio - the preferred aspect ratio of the grid

Returns:

the dimension of the grid

arrangeRectangleMultiRows

public static final int arrangeRectangleMultiRows(Rectangle2D[] rectangles,
                                                  Rectangle2D finalRect,
                                                  double preferredWidth,
                                                  double preferredHeight,
                                                  boolean compaction,
                                                  MultiRowConstraint constraintMode)

Reassigns the bounds of the rectangles in multiple rows to fit the preferred width and height.

The rectangles will be placed within this bound, arranged in rows, where each row may be split into more sub-rows. This often leads to more compact results than provided by the procedure used in arrangeRectangleRows(Rectangle2D[], Rectangle2D, double, RowAlignment). A row will be subdivided into more rows, if two successive rectangles to be placed in the row could be placed stacked within this row without making the row larger in height.

The preferred width and height should be greater than 0, otherwise the nodes are not arranged.

Parameters:

rectangles - the rectangles to arrange (coordinates will be assigned)

finalRect - the exact resulting dimension will be stored in this rectangle

preferredWidth - the preferred width of the result rectangle

preferredHeight - the preferred height of the result rectangle

compaction - true if the algorithm tries to always minimize the resulting dimension, whilst respecting the given constraints, false otherwise

constraintMode - the width or height constraints to consider

Returns:

the number of rows used

See Also:

arrangeRectangleMultiRows(Rectangle2D[], Rectangle2D, double, double, boolean, MultiRowConstraint, RowAlignment)

arrangeRectangleMultiRows

public static final int arrangeRectangleMultiRows(Rectangle2D[] rectangles,
                                                  Rectangle2D finalRect,
                                                  double preferredWidth,
                                                  double preferredHeight,
                                                  boolean compaction,
                                                  MultiRowConstraint constraintMode,
                                                  RowAlignment alignment)

Reassigns the bounds of the rectangles in multiple rows to fit the preferred width and height.

The rectangles will be placed within this bound, arranged in rows, where each row may be split into more sub-rows. This often leads to more compact results than provided by the procedure used in arrangeRectangleRows(Rectangle2D[], Rectangle2D, double, RowAlignment). A row will be subdivided into more rows, if two successive rectangles to be placed in the row could be placed stacked within this row without making the row larger in height.

The preferred width and height should be greater than 0, otherwise the nodes are not arranged.

Parameters:

rectangles - the rectangles to arrange (coordinates will be assigned)

finalRect - the exact resulting dimension will be stored in this rectangle

preferredWidth - the preferred width of the result rectangle

preferredHeight - the preferred height of the result rectangle

compaction - true if the algorithm tries to always minimize the resulting dimension, whilst respecting the given constraints, false otherwise

constraintMode - the width or height constraints to consider

alignment - the alignment inside a row

Returns:

the number of rows used

See Also:

arrangeRectangleMultiRows(Rectangle2D[], Rectangle2D, double, double, boolean, MultiRowConstraint, RowAlignment)

arrangeRectangleRows

public static final int arrangeRectangleRows(Rectangle2D[] rectangles,
                                             Rectangle2D finalRect,
                                             double aspectRatio)

Reassigns the bounds of the rectangles to fit in a large rectangle with an aspect ratio close to the specified aspect ratio.

This is achieved by arranging the rectangles in rows.

The aspect ratio must be greater than 0.

Throws:

IllegalArgumentException - if the aspect ratio is 0 or less

Parameters:

rectangles - the rectangles whose coordinates will be modified

finalRect - the exact dimension of the resulting rectangle

aspectRatio - the preferred aspect ratio of the resulting rectangle

Returns:

the number of used rows

arrangeRectangleRows

public static final int arrangeRectangleRows(Rectangle2D[] rectangles,
                                             Rectangle2D finalRect,
                                             double aspectRatio,
                                             RowAlignment alignment)

Reassigns the bounds of the rectangles to fit in a large rectangle with an aspect ratio close to the specified aspect ratio.

This is achieved by arranging the rectangles in rows.

The aspect ratio must be greater than 0.

Throws:

IllegalArgumentException - if the aspect ratio is 0 or less

Parameters:

rectangles - the rectangles whose coordinates will be modified

finalRect - the exact dimension of the resulting rectangle

aspectRatio - the preferred aspect ratio of the resulting rectangle

alignment - one of the valid row alignments

Returns:

the number of used rows

assignReverseLayout

public static final void assignReverseLayout(LayoutGraph graph,
                                             Edge edge1,
                                             Edge edge2)

Applies the reversed layout of the first edge to the second edge.

Parameters:

graph - the graph to which both edges belong

edge1 - the edge which adopts the points

edge2 - the template

autoFlipBox

public static final boolean autoFlipBox(YOrientedRectangle rect)

Flips the orientation of a given rectangle, if its up vector points downward (upY> 0).

That means, it rotates the rectangle by 180 degrees without changing the rectangle's center.

Parameters:

rect - the given rectangle

Returns:

true if the given rectangle was flipped, false otherwise

clipEdgeOnBounds

public static final void clipEdgeOnBounds(LayoutGraph graph,
                                          Edge edge)

Clips the path of the given edge on the bounding box of the source and target points.

On a clipped edge, the source and target port will be located at the border of the corresponding node.

Parameters:

graph - the graph to which the edge belongs

edge - the edge to clip

clipEdgePathOnBounds

public static final YPointPath clipEdgePathOnBounds(IEdgeLayout edge,
                                                    INodeLayout source,
                                                    INodeLayout target)

Returns the path of an edge clipped on insets of the bounding box of the source and target node.

On the clipped edge, the source and target port will be located inside the node with an inset to the border of the corresponding node.

Parameters:

edge - the clipped edge

source - the source of the edge

target - the target of the edge

Returns:

the clipped path of the edge

clipEdgePathOnBounds

public static final YPointPath clipEdgePathOnBounds(IEdgeLayout edge,
                                                    INodeLayout source,
                                                    INodeLayout target,
                                                    double inset)

Returns the path of an edge clipped on insets of the bounding box of the source and target node.

On the clipped edge, the source and target port will be located inside the node with an inset to the border of the corresponding node.

Parameters:

edge - the clipped edge

source - the source of the edge

target - the target of the edge

inset - the inset of the node

Returns:

the clipped path of the edge

clipEdgePathOnBounds

public static final YPointPath clipEdgePathOnBounds(LayoutGraph graph,
                                                    Edge edge)

Returns the path of an edge clipped on the bounding box of the source and target node.

On the clipped edge, the source and target port will be located at the border of the corresponding node.

Parameters:

graph - the graph to which the edge belongs

edge - the clipped edge

Returns:

the clipped path of the edge

clipEdgesOnBounds

public static final void clipEdgesOnBounds(LayoutGraph graph)

Clips the path of all edges in the graph on the bounding box of their source and target points.

On a clipped edge, the source and target port will be located at the border of the corresponding node.

Parameters:

graph - the graph

See Also:

clipEdgeOnBounds(LayoutGraph, Edge)

clipPathOnBounds

public static final YPointPath clipPathOnBounds(YPointPath path,
                                                YRectangle sourceBox,
                                                YRectangle targetBox)

Returns the path of a given edge path clipped on the given bounding boxes of the source and target node.

In contrast to methods clipEdgePathOnBounds(LayoutGraph, Edge) and clipEdgePathOnBounds(IEdgeLayout, INodeLayout, INodeLayout, double), the path can explicitly be specified and is not queried from a given graph and edge. Furthermore, this method does not consider any insets on the given boxes

Parameters:

path - the path that will be clipped

sourceBox - the box of the source node that the given path should be clipped at

targetBox - the box of the target node that the given path should be clipped at

Returns:

the path clipped on the given nodes boxes

determineEdgeFlowDirection

public static final EdgeFlow determineEdgeFlowDirection(LayoutGraph graph,
                                                        IDataProvider considerEdges)

Determines the main direction of the edge flow by analyzing the current layout of the graph.

The method only considers edges that are marked in the given IDataProvider.

Parameters:

graph - the underlying graph

considerEdges - the edges to consider

Returns:

one of the predefined flow directions

edgeLayoutString

public static final String edgeLayoutString(LayoutGraph graph,
                                            Edge edge)

Returns a String representation of the path of the given edge.

The source and target ports are not included in the representation.

Parameters:

graph - the graph to which the edge belongs

edge - the edge

Returns:

the String that contains all control points of the edge

getBoundingBox

public static final Rectangle2D getBoundingBox(LayoutGraph graph,
                                               Edge edge)

Returns the bounding box of the given edge.

In this case, the bounding box is the smallest paraxial rectangle which contains the control points as well as the absolute coordinates of the source and target point of the edge.

The bounding box does not include edge labels.

Parameters:

graph - the graph that contains the edge

edge - the edge

Returns:

the bounding box of the edge

See Also:

LayoutGraph.getSourcePointAbs(Edge), LayoutGraph.getTargetPointAbs(Edge), LayoutGraph.getLayout(Edge)

getBoundingBox

public static final Rectangle2D getBoundingBox(LayoutGraph graph,
                                               IEdgeCursor edges)

Returns the bounding box of the edges accessible through the given cursor.

In this case, the bounding box is the smallest paraxial rectangle which contains the control points as well as the absolute coordinates of the source and target points of all given edges.

The bounding box does not include edge labels.

Parameters:

graph - the graph that contains the edges

edges - the edges to include in the bounding box

Returns:

the bounding box containing the given edges

See Also:

LayoutGraph.getSourcePointAbs(Edge), LayoutGraph.getTargetPointAbs(Edge), LayoutGraph.getLayout(Edge)

getBoundingBox

public static final Rectangle2D getBoundingBox(LayoutGraph graph,
                                               INodeCursor nodes)

Returns the bounding box of the nodes accessible through the given cursor.

In this case, the bounding box is the smallest paraxial rectangle which contains the given nodes.

The bounding box does not include node labels.

Parameters:

graph - the graph that contains the nodes

nodes - the nodes to include in the bounding box

Returns:

the bounding box containing the given nodes

See Also:

com.yworks.yfiles.layout.LayoutGraph.getNodeLayout(java.lang.Object)

getBoundingBox

public static final Rectangle2D getBoundingBox(LayoutGraph graph,
                                               INodeCursor nodes,
                                               IEdgeCursor edges)

Returns the bounding box of the nodes and edges accessible through the given cursors.

In this case, the bounding box is the smallest paraxial rectangle which contains the given nodes and the control points as well as the source and target points of all edges.

The bounding box does not include node labels or edge labels.

Parameters:

graph - the graph that contains the nodes and edges

nodes - the nodes to include in the bounding box

edges - the edges to include in the bounding box

Returns:

the bounding box containing the given nodes and edges

See Also:

getBoundingBox(LayoutGraph, IEdgeCursor), getBoundingBox(LayoutGraph, INodeCursor)

getBoundingBox

public static final Rectangle2D getBoundingBox(LayoutGraph graph,
                                               INodeCursor nodes,
                                               IEdgeCursor edges,
                                               boolean includeLabels)

Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels and edge labels.

In this case, the bounding box is the smallest paraxial rectangle which contains the given nodes and the control points as well as the source and target points of all edges. If labels should be included, it also contains their boxes.

Parameters:

graph - the graph that contains the given nodes and edges

nodes - the nodes to include in the bounding box

edges - the edges to include in the bounding box

includeLabels - true if labels of nodes and edges should be included, false otherwise

Returns:

the bounding box of the given nodes and edges

See Also:

getBoundingBox(LayoutGraph, INodeCursor, IEdgeCursor, boolean, boolean, boolean)

getBoundingBox

public static Rectangle2D getBoundingBox(LayoutGraph graph,
                                         INodeCursor nodes,
                                         IEdgeCursor edges,
                                         boolean includeNodeLabels,
                                         boolean includeEdgeLabels)

Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels or edge labels.

In this case, the bounding box is the smallest paraxial rectangle which contains the given nodes and the control points as well as the source and target points of all edges. If node or edge labels should be included, it also contains their boxes.

Parameters:

graph - the graph that contains the given nodes and edges

nodes - the nodes to include in the bounding box

edges - the edges to include in the bounding box

includeNodeLabels - true if labels of nodes should be included, false otherwise

includeEdgeLabels - true if labels of edges should be included, false otherwise

Returns:

the bounding box of the given nodes and edges

getBoundingBox

public static final Rectangle2D getBoundingBox(LayoutGraph graph,
                                               INodeCursor nodes,
                                               IEdgeCursor edges,
                                               boolean includeNodeLabels,
                                               boolean includeEdgeLabels,
                                               boolean includeHalos)

Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels, edge labels or NodeHalos.

In this case, the bounding box is the smallest paraxial rectangle which contains the given nodes and the control points as well as the source and target points of all edges. If node or edge labels should be included, it also contains their boxes. NodeHalos can also extend the bounding box if desired.

Parameters:

graph - the graph that contains the given nodes and edges

nodes - the nodes to include in the bounding box

edges - the edges to include in the bounding box

includeNodeLabels - true if labels of nodes should be included, false otherwise

includeEdgeLabels - true if labels of edges should be included, false otherwise

includeHalos - true if NodeHalos should be included, false otherwise

Returns:

the bounding box of the given nodes and edges

getBoundingBox

public static final Rectangle2D getBoundingBox(LayoutGraph graph,
                                               Node node)

Returns the bounding box of the given node.

In this case, the bounding box is the smallest paraxial rectangle which contains the given node. It is identical to the node's bounds.

The bounding box does not include node labels.

Parameters:

graph - the graph that contains the node

node - the node

Returns:

the bounding box of the node

See Also:

com.yworks.yfiles.layout.LayoutGraph.getNodeLayout(java.lang.Object)

getLabelFactory

public static final ILabelLayoutFactory getLabelFactory(LayoutGraph graph)

Returns the ILabelLayoutFactory for the given graph.

The factory instance is bound to the specified graph instance, i.e., you can only create, add and remove labels for this graph.

Parameters:

graph - the graph

Returns:

the label factory of the graph

getLabelPlacement

public static final YPoint getLabelPlacement(IEdgeLabelLayoutModel model,
                                             YDimension labelSize,
                                             IEdgeLayout edgeLayout,
                                             INodeLayout sourceLayout,
                                             INodeLayout targetLayout,
                                             Object param)

Returns the upper-left corner of the paraxial bounding box of the given edge label as encoded by the specified model parameter.

The parameter describes the abstract position of the label within the specified model. The parameter must have been generated by that model.

Parameters:

model - the IEdgeLabelLayoutModel used for placing the label

labelSize - the size of the label that should be placed

edgeLayout - the layout of the edge to which the label belongs

sourceLayout - the layout of the edge's source node

targetLayout - the layout of the edge's target node

param - the model parameter

Returns:

the upper-left corner of the label's bounding box

See Also:

IEdgeLabelLayoutModel.getLabelPlacement(YDimension, IEdgeLayout, INodeLayout, INodeLayout, Object), YOrientedRectangle.getBoundingBox()

getLabelPlacement

public static final YPoint getLabelPlacement(INodeLabelLayoutModel model,
                                             YDimension labelSize,
                                             INodeLayout nodeLayout,
                                             Object param)

Returns the upper-left corner of the paraxial bounding box of the given node label as encoded by the specified model parameter.

The parameter describes the abstract position of the label within the specified model. The parameter must have been generated by that model.

Parameters:

model - the INodeLabelLayoutModel used for placing the label

labelSize - the size of the label

nodeLayout - the layout of the node to which the label belongs

param - the model parameter

Returns:

the upper-left corner of the label's bounding box

See Also:

INodeLabelLayoutModel.getLabelPlacement(YDimension, INodeLayout, Object), YOrientedRectangle.getBoundingBox()

getNodeDistance

public static final double getNodeDistance(LayoutGraph graph,
                                           Node node1,
                                           Node node2)

Returns the distance between the centers of the two given nodes.

Parameters:

graph - the graph to which the nodes belong

node1 - the first node

node2 - the second node

Returns:

the distance between the nodes' centers

getNodePositions

public static final String getNodePositions(LayoutGraph graph)

Returns a String representation of all node positions in the graph.

Parameters:

graph - the graph

Returns:

the String containing all node locations

See Also:

LayoutGraph.getLocation(Node)

getPathLength

public static final double getPathLength(LayoutGraph graph,
                                         Edge edge)

Returns the length of the path of the given edge.

The path starts at the source point, traverses through all control points and ends at the target point.

Parameters:

graph - the graph to which the edge belongs

edge - the edge

Returns:

the length of the edge's path

isEdgeOutsideNodes

public static final boolean isEdgeOutsideNodes(IEdgeLayout edge,
                                               INodeLayout source,
                                               INodeLayout target,
                                               double halo)

Checks whether or not the path of an edge is outside the bounding box of the source and target node, considering the given halo.

The edge is outside the nodes if its control points as well as the source and target point are not inside the nodes' bounding boxes.

The nodes can be enlarged by a halo to check if the edge keeps some distance to the nodes.

Parameters:

edge - the edge

source - the source of the edge

target - the target of the edge

halo - the halo for the nodes

Returns:

true if the edge is outside the nodes, false otherwise

isEdgeOutsideNodes

public static final boolean isEdgeOutsideNodes(LayoutGraph graph,
                                               Edge edge)

Checks whether or not the path of an edge is outside the bounding box of the source and target node.

The edge is outside the nodes if its control points as well as the source and target point are not inside the nodes' bounding boxes.

Parameters:

graph - the graph to which the edge belongs

edge - the edge

Returns:

true if the edge is outside the nodes, false otherwise

isUsingOctilinearEdgeRoutes

public static final boolean isUsingOctilinearEdgeRoutes(LayoutGraph graph,
                                                        IDataProvider considerEdges)

Determines whether or not most of the edges of the graph are routed octilinear.

The method only considers edges marked in the given IDataProvider.

This method also returns true for orthogonal layouts.

Parameters:

graph - the underlying graph

considerEdges - the edges to consider

Returns:

true if most of the edges in the graph are routed octilinear, false otherwise

isUsingOrthogonalEdgeRoutes

public static final boolean isUsingOrthogonalEdgeRoutes(LayoutGraph graph,
                                                        IDataProvider considerEdges)

Determines whether or not most of the edges of the graph are routed orthogonally.

The method only considers edges marked in the given IDataProvider.

Parameters:

graph - the underlying graph

considerEdges - the edges to consider

Returns:

true if most of the edges in the graph are routed orthogonally, false otherwise

moveEdge

public static final void moveEdge(LayoutGraph graph,
                                  Edge edge,
                                  double dx,
                                  double dy)

Moves all control points of the given edge by the vector (dx,dy).

Parameters:

graph - the graph

edge - the edge

dx - the horizontal distance to move

dy - the vertical distance to move

moveEdges

public static final void moveEdges(LayoutGraph graph,
                                   IEdgeCursor edges,
                                   double dx,
                                   double dy)

Moves the control points of all edges accessible through the given IEdgeCursor by the vector (dx,dy).

Parameters:

graph - the graph

edges - the edges to be moved

dx - the horizontal distance to move

dy - the vertical distance to move

moveNode

public static final void moveNode(LayoutGraph graph,
                                  Node node,
                                  double dx,
                                  double dy)

Moves the given node by the vector (dx,dy).

Parameters:

graph - the graph

node - the node

dx - the horizontal distance to move

dy - the vertical distance to move

moveNodes

public static final void moveNodes(LayoutGraph graph,
                                   INodeCursor nodes,
                                   double dx,
                                   double dy)

Moves all nodes accessible through the given INodeCursor by the vector (dx,dy).

Parameters:

graph - the graph

nodes - the nodes to be moved

dx - the horizontal distance to move

dy - the vertical distance to move

moveSubgraph

public static final void moveSubgraph(LayoutGraph graph,
                                      IEdgeCursor edges,
                                      double dx,
                                      double dy)

Moves the subgraph induced by the edges accessible through the given IEdgeCursor by the vector (dx,dy).

Parameters:

graph - the graph that contains the subgraph

edges - the edges that induce the subgraph

dx - the horizontal distance to move

dy - the vertical distance to move

moveSubgraph

public static final void moveSubgraph(LayoutGraph graph,
                                      INodeCursor nodes,
                                      double dx,
                                      double dy)

Moves the subgraph induced by the nodes accessible through the given INodeCursor by the vector (dx,dy).

Parameters:

graph - the graph that contains the subgraph

nodes - the nodes that induce the subgraph

dx - the horizontal distance to move

dy - the vertical distance to move

pathIntersectsRect

public static final boolean pathIntersectsRect(LayoutGraph graph,
                                               Edge edge,
                                               Rectangle2D rect)

Checks whether or not the path of the given edge intersects the interior of a given rectangular area.

Parameters:

graph - the graph to which the edge belongs

edge - the edge

rect - the rectangular area to check for intersection

Returns:

true if the edge path intersects with the given rectangle, false otherwise

removeDuplicateBends

public static final void removeDuplicateBends(LayoutGraph graph)

Removes successive bends that have the same coordinates from all edges in the graph.

Parameters:

graph - the graph

removeDuplicateBends

public static final void removeDuplicateBends(LayoutGraph graph,
                                              Edge edge)

Removes successive bends that have the same coordinates from the given edge.

Parameters:

graph - the graph

edge - the edge

resetPath

public static final void resetPath(LayoutGraph graph,
                                   Edge edge)

Assigns a trivial path which has no control points to the specified edge.

Parameters:

graph - the graph

edge - the edge

resetPath

public static final void resetPath(LayoutGraph graph,
                                   Edge edge,
                                   boolean resetPorts)

Assigns a trivial path which has no control points to the specified edge.

Parameters:

graph - the graph

edge - the edge

resetPorts - true if the ports of the edge should be set to the center of the corresponding nodes, false otherwise

resetPaths

public static final void resetPaths(LayoutGraph graph)

Assigns a trivial path which has no control points to all edges in the specified graph.

Parameters:

graph - the graph

resetPaths

public static final void resetPaths(LayoutGraph graph,
                                    boolean resetPorts)

Assigns a trivial path which has no control points to all edges in the specified graph.

Parameters:

graph - the graph

resetPorts - true if the ports of the edges should be set to the center of the corresponding nodes, false otherwise

resetPorts

public static final void resetPorts(LayoutGraph graph)

Sets the ports of all edges in the graph to the center of the nodes.

The control points will not be changed.

Parameters:

graph - the graph

See Also:

LayoutGraph.setSourcePointRel(Edge, YPoint), LayoutGraph.setTargetPointRel(Edge, YPoint)

reverseEdgeLayout

public static final void reverseEdgeLayout(IEdgeLayout el)

Reverses the layout of an edge.

The order of the control points is reversed and source and target point are swapped.

This method will not reverse the edge in the graph structure.

Parameters:

el - the layout information of an edge

roundEdgeLayout

public static final void roundEdgeLayout(LayoutGraph graph,
                                         Edge edge)

Rounds the locations of the control points and ports of the given edge to integer values.

Parameters:

graph - the graph to which the edge belongs

edge - the edge whose values are rounded

roundLayout

public static final void roundLayout(LayoutGraph graph)

Rounds coordinates and sizes in the layout of an entire graph to integer values.

Parameters:

graph - the graph

See Also:

roundNodeLayout(LayoutGraph, Node), roundEdgeLayout(LayoutGraph, Edge)

roundNodeLayout

public static final void roundNodeLayout(LayoutGraph graph,
                                         Node node)

Rounds the location and size of the given node to integer values.

Parameters:

graph - the graph to which the node belongs

node - the node whose values are rounded

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge1,
                                            Edge edge2,
                                            double lineDistance)

Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.

The second edge gets a path that is parallel to the path of the first (leading) edge.

Parameters:

graph - the graph

edge1 - the leading edge

edge2 - the edge to be adjusted

lineDistance - the distance between the two edges

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge1,
                                            Edge edge2,
                                            double lineDistance,
                                            boolean joinEnds)

Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.

The second edge gets a path that is parallel to the path of the first (leading) edge.

Parameters:

graph - the graph

edge1 - the leading edge

edge2 - the edge to be adjusted

lineDistance - the distance between the two edges

joinEnds - true if the edges should share their end points (the ones of the leading edge), false otherwise

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge1,
                                            Edge edge2,
                                            double lineDistance,
                                            boolean joinEnds,
                                            double absJoinDist)

Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.

The second edge gets a path that is parallel to the path of the first (leading) edge.

Parameters:

graph - the graph

edge1 - the leading edge

edge2 - the edge to be adjusted

lineDistance - the distance between the two edges

joinEnds - true if the edges should share their end points (the ones of the leading edge), false otherwise

absJoinDist - the absolute distance between the end points and the beginning of the parallel segment routing if the ends are joined

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge1,
                                            Edge edge2,
                                            double lineDistance,
                                            boolean joinEnds,
                                            double absJoinDist,
                                            double relJoinDist)

Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.

The second edge gets a path that is parallel to the path of the first (leading) edge.

Parameters:

graph - the graph

edge1 - the leading edge

edge2 - the edge to be adjusted

lineDistance - the distance between the two edges

joinEnds - true if the edges should share their end points (the ones of the leading edge), false otherwise

absJoinDist - the absolute distance between the end points and the beginning of the parallel segment routing if the ends are joined

relJoinDist - the relative distance, measured relative to the length of the first/last segments if the ends are joined

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge,
                                            EdgeList edges,
                                            double lineDistance)

Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.

All edges get a path that is parallel to the path of the first (leading) edge.

The position of the leading edge may be adjusted if there is an odd number of parallel edges. It will be moved from the center to achieve a more symmetric port assignment.

Parameters:

graph - the graph

edge - the leading edge

edges - the list of edges that will be aligned with the leading edge

lineDistance - the distance between two edges

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge,
                                            EdgeList edges,
                                            double lineDistance,
                                            boolean adjustE1)

Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.

All edges get a path that is parallel to the path of the first (leading) edge.

The position of the leading edge may be adjusted if there is an odd number of parallel edges. It will be moved from the center to achieve a more symmetric port assignment.

Parameters:

graph - the graph

edge - the leading edge

edges - the list of edges that will be aligned with the leading edge

lineDistance - the distance between two edges

adjustE1 - true if the leading edge should be adjusted if the size of list is odd, false otherwise

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge,
                                            EdgeList edges,
                                            double lineDistance,
                                            boolean adjustE1,
                                            boolean joinEnds)

Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.

All edges get a path that is parallel to the path of the first (leading) edge.

The position of the leading edge may be adjusted if there is an odd number of parallel edges. It will be moved from the center to achieve a more symmetric port assignment.

Parameters:

graph - the graph

edge - the leading edge

edges - the list of edges that will be aligned with the leading edge

lineDistance - the distance between two edges

adjustE1 - true if the leading edge should be adjusted if the size of list is odd, false otherwise

joinEnds - true if the edges should share their end points (the ones of the leading edge), false otherwise

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge,
                                            EdgeList edges,
                                            double lineDistance,
                                            boolean adjustE1,
                                            boolean joinEnds,
                                            double absJoinDist)

Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.

All edges get a path that is parallel to the path of the first (leading) edge.

The position of the leading edge may be adjusted if there is an odd number of parallel edges. It will be moved from the center to achieve a more symmetric port assignment.

Parameters:

graph - the graph

edge - the leading edge

edges - the list of edges that will be aligned with the leading edge

lineDistance - the distance between two edges

adjustE1 - true if the leading edge should be adjusted if the size of list is odd, false otherwise

joinEnds - true if the edges should share their end points (the ones of the leading edge), false otherwise

absJoinDist - the absolute distance between the end points and the beginning of the parallel segment routing if the ends are joined

routeEdgesParallel

public static final void routeEdgesParallel(LayoutGraph graph,
                                            Edge edge,
                                            EdgeList edges,
                                            double lineDistance,
                                            boolean adjustE1,
                                            boolean joinEnds,
                                            double absJoinDist,
                                            double relJoinDist)

Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.

All edges get a path that is parallel to the path of the first (leading) edge.

The position of the leading edge may be adjusted if there is an odd number of parallel edges. It will be moved from the center to achieve a more symmetric port assignment.

Parameters:

graph - the graph

edge - the leading edge

edges - the list of edges that will be aligned with the leading edge

lineDistance - the distance between two edges

adjustE1 - true if the leading edge should be adjusted if the size of list is odd, false otherwise

joinEnds - true if the edges should share their end points (the ones of the leading edge), false otherwise

absJoinDist - the absolute distance between the end points and the beginning of the parallel segment routing if the ends are joined

relJoinDist - the relative distance, measured relative to the length of the first/last segments if the ends are joined

routeSelfLoop

public static final void routeSelfLoop(LayoutGraph graph,
                                       Edge edge)

Routes a self-loop.

For a self-loop edge, source and target are identical. The path of the self-loop will start at the top of the node, go around the upper-left corner and end at the left side of the node.

Parameters:

graph - the graph to which the edge belongs

edge - the self-loop