Interface Sugiyama<Ops>

set the Coord operator

The final stage is coordinate assignment, which takes a layered graph with nodes in the correct order, and assigns them x coordinates.

There are four built-in coordinate assignment operators:

• coordSimplex - This assigns x coordinates based on a simplex minimization that tries to produce long vertical edges. It usually produces attractive layouts in a reasonable amount of time.
• coordQuad - This uses a quadratic optimization that tries to minimize the curvature of lines, but usually produces worse layouts than the simplex variant.
• coordGreedy - If either of the above methods take too long, this uses a heuristic to assign x coordinates meaning it will run more quickly, but usually produce slightly worse layouts.
• coordTopological - This is a coordinate assignment tailored for a topological layout. It can use a simplex or quadratic optimization to create a topological layout.

You can also supply any function that satisfies the Coord interface. See that documentation for more information about implementing your own coordinate assignment operator.

(default: coordSimplex)

Example

const layout = sugiyama().coord(coordQuad());
Copy

get the current Coord.

set the Decross operator

The decross operator takes a layered graph with extra nodes for long paths, and reorders nodes along a layer to minimize the number of edge crossings (or other desired properties).

There are three built-in decrossing operators:

• decrossOpt - This optimally minimizes edge crossings, but due to the complex nature of the task, only works for reasonably small graphs.
• decrossTwoLayer - This is a heuristic method for decrossing minimization that tries to strike a balance between a small number of edge crossings, and reasonable running time.
• decrossDfs - This is a very cheap decrossing operator that orders nodes via a depth first search. It's mostly used for DecrossTwoLayer#inits of the two-layer operator.

You can also supply any function that satisfies the Decross interface. See that documentation for more information about implementing your own decrossing operator.

(default: decrossTwoLayer)

Example

const layout = sugiyama().decross(decrossOpt());
Copy

get the current Decross.

get the gap size between nodes

(default: [1, 1])

get the current gap size

set the Layering operator

The layering operator takes the graph, and assigns each node layer that respects

There are three built-in layering operators:

• layeringSimplex - This minimizes the overall length of edges, and is reasonably fast for most graphs. Minimizing edges also tends to make the next steps faster.
• layeringLongestPath - This minimizes the height of the overall graph.
• layeringTopological - This creates a topological ordering, which inherently minimizes the width of the graph, but will only produce good layouts with other topological operators.

You can also supply any function that satisfies the Layering interface. See that documentation for more information about implementing your own layering operator.

(default: layeringSimplex)

Example

const layout = sugiyama().layering(layeringLongestPath());
Copy

get the current Layering.

sets the NodeSize

(default: [1, 1])

get the current node size

set the Tweaks to apply after layout

get the current Tweaks.