Skip to Content

Changes for page The Five Phases

Last modified by Alexander Schulz-Rosengarten on 2023/07/11 10:33
From version 7.1
edited by msp
on 2012/07/17 13:04
Change comment: There is no comment for this version
To version 3.1
edited by cds
on 2012/03/23 15:37
Change comment: There is no comment for this version

Summary

Details

Page properties
Author
... ... @@ -1,1 +1,1 @@
1 -XWiki.msp
1 +XWiki.cds
Content
... ... @@ -8,33 +8,22 @@
8 8  
9 9  The reversed edges have to be restored at some point. There's a processor for that, called ReversedEdgeRestorer. All implementations of phase one must include a dependency on that processor, to be included after phase 5.
10 10  
11 -|=(((
12 -Preconditions
13 -)))|=(% class="nohighlight" %)(% class="nohighlight" %)
14 -(((
11 +=== Precondition ===
12 +
15 15  * No node is assigned to a layer yet.
16 -)))
17 -|(% class="highlight" %)(% class="highlight" %)
18 -(((
19 -Postconditions
20 -)))|(((
14 +
15 +=== Postcondition ===
16 +
21 21  * The graph is now cycle-free. Still, no node is assigned to a layer yet.
22 -)))
23 -|(% class="highlight" %)(% class="highlight" %)
24 -(((
25 -Remarks
26 -)))|(((
27 -* All implementations of phase one must include a dependency on the {{code language="none"}}ReversedEdgeRestorer{{/code}}, to be included after phase five.
28 -)))
29 -|(% class="highlight" %)(% class="highlight" %)
30 -(((
31 -Implementations
32 -)))|(((
33 -* {{code language="none"}}GreedyCycleBreaker{{/code}}. Uses a greedy approach to cycle-breaking, inspired by \\
34 -** Peter Eades, Xuemin Lin, W. F. Smyth, A fast and effective heuristic for the feedback arc set problem. //Information Processing Letters// 47(6), pp. 319-323, 1993.
35 -* {{code language="none"}}InteractiveCycleBreaker.{{/code}} Detects feedback edges according to the current layout, hence it reacts to the user's placement.
36 -)))
37 37  
19 +=== Remarks ===
20 +
21 +* All implementations of phase one must include a dependency on the ReversedEdgeRestorer, to be included after phase 5.
22 +
23 +=== Current Implementations ===
24 +
25 +* GreedyCycleBreaker. Uses a greedy approach to cycle-breaking.
26 +
38 38  == Phase 2: Layering ==
39 39  
40 40  The second phase assigns nodes to layers. (also called //ranks// in some papers) Nodes in the same layer are assigned the same x coordinate. (give or take) The problem to solve here is to assign each node x a layer i such that each successor of x is in a layer j>i. The only exception are self-loops, that may or may not be supported by later phases.
... ... @@ -43,72 +43,50 @@
43 43  
44 44  Note that nodes can have a property associated with them that constraints the layers they can be placed in.
45 45  
46 -|=(((
47 -Preconditions
48 -)))|=(% class="nohighlight" %)(% class="nohighlight" %)
49 -(((
35 +=== Precondition ===
36 +
50 50  * The graph is cycle-free.
51 51  * The nodes have not been layered yet.
52 -)))
53 -|(% class="highlight" %)(% class="highlight" %)
54 -(((
55 -Postconditions
56 -)))|(((
39 +
40 +=== Postcondition ===
41 +
57 57  * The graph has a layering.
58 -)))
59 -|(% class="highlight" %)(% class="highlight" %)
60 -(((
61 -Remarks
62 -)))|(((
63 -* Implementations should usually include a dependency on the {{code language="none"}}LayerConstraintHandler{{/code}}, unless they already adhere to layer constraints themselves.
64 -)))
65 -|(% class="highlight" %)(% class="highlight" %)
66 -(((
67 -Implementations
68 -)))|(((
69 -* {{code language="none"}}LongestPathLayerer{{/code}}. Layers nodes according to the longest paths between them. Very simple, and doesn't usually give the best results.
70 -* {{code language="none"}}NetworkSimplexLayerer{{/code}}. A way more sophisticated algorithm whose results are usually very good, inspired by\\
71 -** (((
72 -Emden R. Gansner, Eleftherios Koutsofios, Stephen C. North, Kiem-Phong Vo, A technique for drawing directed graphs. //Software Engineering// 19(3), pp. 214-230, 1993.
73 -)))
74 -* {{code language="none"}}InteractiveLayerer.{{/code}} Detects layers according to the current layout, hence it reacts to the user's placement.
75 -)))
76 76  
44 +=== Remarks ===
45 +
46 +* Implementations should usually include a dependency on the LayerConstraintHandler, unless they already adhere to layer constraints themselves.
47 +
48 +=== Current Implementations ===
49 +
50 +* LongestPathLayerer. Layers nodes according to the longest paths between them. Very simple, but doesn't usually give the best results.
51 +* NetworkSimplexLayerer. A way more sophisticated algorithm whose results are usually very good.
52 +
77 77  == Phase 3: Crossing Reduction ==
78 78  
79 -The objective of phase 3 is to determine how the nodes in each layer should be ordered. The order determines the number of edge crossings, and thus is a critical step towards readable diagrams. Unfortunately, the problem is NP-hard even for only two layers. Did I just hear you say "heuristic"? The usual approach is to sweep through the pairs of layers from left to right and back, along the way applying some heuristic to minimize crossings between each pair of layers. The two most prominent and well-studied kinds of heuristics used here are the barycenter method and the median method. We have currently implemented the former.
55 +The objective of phase 3 is to determine how the nodes in each layer should be ordered. The order determines the number of edge crossings, and thus is a critical step towards readable diagrams. Unfortunately, the problem is NP-hard even for only two layers. Did I just hear you saying "heuristic"? The usual approach is to sweep through the pairs of layers from left to right and back, along the way applying some heuristic to minimize crossings between each pair of layers. The two most prominent and well-studied kinds of heuristics used here are the barycenter method and the median method. We have currently implemented the former.
80 80  
81 81  Our crossing reduction implementations may or may not support the concepts of node successor constraints and layout groups. The former allows a node x to specify a node y!=x that may only appear after x. Layout groups are groups of nodes. Nodes belonging to different layout groups are not to be interleaved.
82 82  
83 -|=(((
84 -Preconditions
85 -)))|=(% class="nohighlight" %)(% class="nohighlight" %)
86 -(((
59 +=== Precondition ===
60 +
87 87  * The graph has a proper layering. (except for self-loops)
88 88  * An implementation may allow in-layer connections.
89 -* Usually, all nodes are required to have a least fixed port sides.
90 -)))
91 -|(% class="highlight" %)(% class="highlight" %)
92 -(((
93 -Postconditions
94 -)))|(((
63 +* Usually, all Nodes are required to have at least fixed port sides.
64 +
65 +=== Postcondition ===
66 +
95 95  * The order of nodes in each layer is fixed.
96 96  * All nodes have a fixed port order.
97 -)))
98 -|(% class="highlight" %)(% class="highlight" %)
99 -(((
100 -Remarks
101 -)))|(((
102 -* If fixed port sides are required, the {{code language="none"}}PortPositionProcessor{{/code}} may be of use.
69 +
70 +=== Remarks ===
71 +
72 +* If fixed port sides are required, the PortPositionProcessor may be of use.
103 103  * Support for in-layer connections may be required to be able to handle certain problems. (odd port sides, for instance)
104 -)))
105 -|(% class="highlight" %)(% class="highlight" %)
106 -(((
107 -Implementations
108 -)))|(((
109 -* {{code language="none"}}LayerSweepCrossingMinmizer{{/code}}. Does several sweeps across the layers, minimizing the crossings between each pair of layers using a barycenter heuristic. Supports node successor constraints and layout groups. Node successor constraints require one node to appear before another node. Layout groups specify sets of nodes whose nodes must not be interleaved. See [[this page>>doc:Layer Sweep Crossing Minimization]] for more information.
110 -)))
111 111  
75 +=== Current Implementations ===
76 +
77 +* [[LayerSweepCrossingMinimizer>>url:https://trac.rtsys.informatik.uni-kiel.de/trac/kieler/wiki/Projects/KLay/Layered/LayerSweepCrossingMinimizer||shape="rect" class="wiki"]]. Does several sweeps across the layers, minimizing the crossings between each pair of layers using a barycenter heuristic. Supports node successor constraints and layout groups. Node successor constraints require one node to appear before another node. Layout groups specify sets of nodes whose nodes must not be interleaved.
78 +
112 112  == Phase 4: Node Placement ==
113 113  
114 114  So far, the coordinates of the nodes have not been touched. That's about to change in phase 4, which determines the y coordinate. While phase 3 has an impact on the number of edge crossings, phase 4 has an influence on the number of edge bends. Usually, some kind of heuristic is employed to yield a good y coordinate.
... ... @@ -115,82 +115,55 @@
115 115  
116 116  Our node placers may or may not support node margins. Node margins define the space occupied by ports, labels and such. The idea is to keep that space free from edges and other nodes.
117 117  
118 -|=(((
119 -Preconditions
120 -)))|=(% class="nohighlight" %)(% class="nohighlight" %)
121 -(((
85 +=== Precondition ===
86 +
122 122  * The graph has a proper layering. (except for self-loops)
123 123  * Node orders are fixed.
124 124  * Port positions are fixed.
125 125  * An implementation may allow in-layer connections.
126 126  * An implementation may require node margins to be set.
127 -)))
128 -|(% class="highlight" %)(% class="highlight" %)
129 -(((
130 -Postconditions
131 -)))|(((
92 +
93 +=== Postcondition ===
94 +
132 132  * Each node is assigned a y coordinate such that no two nodes overlap.
133 133  * The height of each layer is set.
134 134  * The height of the graph is set to the maximal layer height.
135 -)))
136 -|(% class="highlight" %)(% class="highlight" %)
137 -(((
138 -Remarks
139 -)))|(((
98 +
99 +=== Remarks ===
100 +
140 140  * Support for in-layer connections may be required to be able to handle certain problems. (odd port sides, for instance)
141 -* If node margins are supported, the {{code language="none"}}NodeMarginCalculator{{/code}} can compute them.
142 -* Port positions can be fixed by using the {{code language="none"}}PortPositionProcessor{{/code}}.
143 -)))
144 -|(% class="highlight" %)(% class="highlight" %)
145 -(((
146 -Implementations
147 -)))|(((
148 -* {{code language="none"}}LinearSegmentsNodePlacer{{/code}}. Builds linear segments of nodes that should have the same y coordinate and tries to respect those linear segments. Linear segments are placed according to a barycenter heuristic. Inspired by\\
149 -** (((
150 -Georg Sander, A fast heuristic for hierarchical Manhattan layout. In //Proceedings of the Symposium on Graph Drawing (GD'95)//, LNCS vol. 1027, pp. 447-458, Springer, 1996.
151 -)))
152 -* {{code language="none"}}BKNodePlacer.{{/code}} ??? Inspired by\\
153 -** (((
154 -Ulrik Brandes and Boris Köpf, Fast and simple horizontal coordinate assignment. In //Proceedings of the 9th International Symposium on Graph Drawing (GD'01)//, LNCS vol. 2265, pp. 33-36, Springer, 2002.
155 -)))
156 -)))
102 +* If node margins are supported, the NodeMarginCalculator can compute them.
103 +* Port positions can be fixed by using the PortPositionProcessor.
157 157  
105 +=== Current Implementations ===
106 +
107 +* LinearSegmentsNodePlacer. Builds linear segments of nodes that should have the same y coordinate and tries to respect those linear segments. Linear segments are placed according to a barycenter heuristic.
108 +
158 158  == Phase 5: Edge Routing ==
159 159  
160 160  In the last phase, it's time to determine x coordinates for all nodes and route the edges. The routing may support very different kinds of features, such as support for odd port sides, (input ports that are on the node's right side) orthogonal edges, spline edges etc. Often times, the set of features supported by an edge router largely determines the intermediate processors used during the layout process.
161 161  
162 -|=(((
163 -Preconditions
164 -)))|=(% class="nohighlight" %)(% class="nohighlight" %)
165 -(((
113 +=== Precondition ===
114 +
166 166  * The graph has a proper layering. (except for self-loops)
167 167  * Nodes are assigned y coordinates.
168 168  * Layer heights are correctly set.
169 169  * An implementation may allow in-layer connections.
170 -)))
171 -|(% class="highlight" %)(% class="highlight" %)
172 -(((
173 -Postconditions
174 -)))|(((
119 +
120 +=== Postcondition ===
121 +
175 175  * Nodes are assigned x coordinates.
176 176  * Layer widths are set.
177 177  * The graph's width is set.
178 178  * The bend points of all edges are set.
179 -)))
180 -|(% class="highlight" %)(% class="highlight" %)
181 -(((
182 -Remarks
183 -)))|(((
126 +
127 +=== Remarks ===
128 +
184 184  None.
185 -)))
186 -|(% class="highlight" %)(% class="highlight" %)
187 -(((
188 -Implementations
189 -)))|(((
190 -* {{code language="none"}}OrthogonalEdgeRouter{{/code}}. Routes edges orthogonally. Supports routing edges going into an eastern port around a node. Tries to minimize the width of the space between each pair of layers used for edge routing. Inspired by\\
191 -** (((
192 -Georg Sander, Layout of directed hypergraphs with orthogonal hyperedges. In //Proceedings of the 11th International Symposium on Graph Drawing (GD '03)//, LNCS vol. 2912, pp. 381-386, Springer, 2004.
193 -)))
194 -* {{code language="none"}}PolylineEdgeRouter{{/code}}. Simplest routing style that just inserts bend points at the position of long edge dummy nodes.
195 -* {{code language="none"}}SplineEdgeRouter{{/code}}. A simple method for routing the edges with splines. Uses the long edge dummy nodes as reference points for spline calculation.
196 -)))
130 +
131 +=== Current Implementations ===
132 +
133 +* ComplexSplineRouter. TODO: Document.
134 +* OrthogonalEdgeRouter. Routes edges orthogonally. Supports routing edges going into an eastern port around a node. Tries to minimize the width of the space between each pair of layers used for edge routing.
135 +* PolylineEdgeRouter. TODO: Document.
136 +* SimpleSplineEdgeRouter. TODO: Document.
Confluence.Code.ConfluencePageClass[0]
Id
... ... @@ -1,1 +1,1 @@
1 -1998960
1 +884889
URL
... ... @@ -1,1 +1,1 @@
1 -https://rtsys.informatik.uni-kiel.de/confluence//wiki/spaces/KIELER/pages/1998960/The Five Phases
1 +https://rtsys.informatik.uni-kiel.de/confluence//wiki/spaces/KIELER/pages/884889/The Five Phases