First Page

News

In a Nutshell

About OGDF

FAQs

Key Features

Publications

Documentation

Overview Pages

How-Tos

Developer Resources

Reference Documentation

Get OGDF

Download

Installation (Linux/Mac)

Installation (Windows)

Projects using OGDF

Team & Contact

Imprint

Many OGDF layout algorithms can be customized through module options, which allow to easily replace the implementation of a specific step of the algorithm. This pages gives an overview about the various layout algorithms contained in OGDF and lists the available module options for each algorithm. These modules are then listed on a separate module overview page.

General Orthogonal and Polyline Layouts | |
---|---|

| The algorithm applies the planarization approach for crossing minimization, combined with the topology-shape-metrics approach for orthogonal planar graph drawing. It produces drawings with few crossings and is suited for small to medium sized sparse graphs.planarization layoutUses: PlanarSubgraphModule, EdgeInsertionModule, EmbedderModule, LayoutPlanRepModule, CCLayoutPackModule |

| The algorithm is similar as planarization layout, but uses a planar grid layout algorithm to produce a drawing on a grid.planarization grid layoutUses: PlanarSubgraphModule, EdgeInsertionModule, GridLayoutPlanRepModule, CCLayoutPackModule |

| The algorithm applies the planarization and topology-shape-metrics approaches to clustered graphs.cluster planarization layoutUses: LayoutClusterPlanRepModule, CCLayoutPackModule |

Multilevel Layouts | |

| The algorithm by Hachul and Jünger is a multilevel, force-directed layout algorithm that can be applied to very large graphs. FM³ layout |

| The algorithm is a variant of multilevel, force-directed layout, which utilizes various tools to speed up the computation. It can also make use of SSE-instructions and multicore processors. FMME layout |

| The is a general framework for multilevel graph layout. The different steps of the multilevel approach (modular multilevel-mixercoarsening, initial placement, and single-level layout) can be customized through module options.Uses: LayoutModule, MultilevelBuilder, InitialPlacer |

Energy-based Layouts | |

| The layout algorithm is a typical force-directed layout algorithm; this version implements the grid-variant of the algorithm to speed up the computation of repulsive forces. Fruchterman-Reingold |

| The layout algorithm is a force-directed layout algorithm that tries to place vertices with a distance corresponding to their graph theoretic distance. Kamada-Kawai |

| The layout algorithm uses Davidson-Harelsimulated annealing to find a layout of minimal energy. Due to this approach, the algorithm can only handle graphs of rather limited size. |

| The algorithm by Frick, Ludwig, and Mehldau. GEM layout |

| An alternative to force-directed layout is distance-based layout, which is realized by the approach. stress majorization |

| One of the oldest layout algorithms has been proposed by ; it simply fixes some external vertices and places the other vertices in the barycenter of their neighbors.TutteRequires: COIN |

Upward Layouts | |

| The classical, layer-based approach for producing upward drawings is the algorithm by . It consists of three steps (in our case four, since we place connected components separately) which can all be customized through module options: Assign vertices to levels (Sugiyama, Tagawa, and Todaranking), minimize crossings by permuting the vertices on the layers, and finally compute coordinates.Uses: RankingModule, TwoLayerCrossMin, HierarchyLayoutModule, CCLayoutPackModule |

| The algorithm is an alternative to the classical Sugiyama approach. It adapts the planarization approach for hierarchical graphs and produces significantly less crossings than Sugiyama layout. It also provides various module options for customization.upward-planarization layoutUses: UpwardPlanarizerModule, UPRLayoutModule |

| This is a simple upward drawing algorithm based on of st-digraphs.dominance drawingsUses: UpwardPlanarizerModule |

| This is a simple upward drawing algorithm based on .visibility representationsUses: UpwardPlanarizerModule |

Planar Layouts | |

| The algorithm is a polyline drawing algorithm for planar graphs. It routes edges with at most three bends per edge and guarantees a grid size of at most (2mixed-model layoutn-6) * (3/2n-7/2), where n is the number of vertices.Uses: EmbedderModule, AugmentationModule, ShellingOrderModule, MixedModelCrossingsBeautifierModule |

| The algorithm is a straight-line drawing algorithm for planar graphs. It draws a planar graph with planar-straight layoutn vertices on a grid of size at most (2n-4) * (n-2) without edge crossings.Uses: AugmentationModule, ShellingOrderModule |

| The algorithm is also a straight-line drawing algorithm for planar graphs, which produces compacter drawings. It draws a planar graph with planar-draw layoutn vertices on a grid of size at most (n-2) * (n-2) without edge crossings.Uses: AugmentationModule, ShellingOrderModule |

Miscellaneous Layouts | |

| The algorithm places each vertex's children in its enclosing circle (centered at the root vertex). The vertices are placed to avoid overlapping between vertices and to make the layout compact. balloon layout |

| The algorithm arranges the biconnected components of the graph on circles. circular layout |

Tree Layouts | |

| Th algorithm is a linear-time tree layout algorithm with straight-line or orthogonal edge routing. tree layout |

| The algorithm produces radial tree layouts in linear-time, i.e, the root is drawn in the center and the levels are arranged on concentric circles around the root. radial-tree layout |

tech/layouter.txt · Last modified: 2014/12/16 12:20 (external edit)

This page is driven by DokuWiki