Visualizing Evolving Trees

06/16/2021 ∙ by Kathryn Gray, et al. ∙ 0

Evolving trees arise in many real-life scenarios from computer file systems and dynamic call graphs, to fake news propagation and disease spread. Most layout algorithms for static trees, however, do not work well in an evolving setting (e.g., they are not designed to be stable between time steps). Dynamic graph layout algorithms are better suited to this task, although they often introduce unnecessary edge crossings. With this in mind we propose two methods for visualizing evolving trees that guarantee no edge crossings, while optimizing (1) desired edge length realization, (2) layout compactness, and (3) stability. We evaluate the two new methods, along with four prior approaches (two static and two dynamic), on real-world datasets using quantitative metrics: stress, desired edge length realization, layout compactness, stability, and running time. The new methods are fully functional and available on github.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 13

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Dynamic graph visualization is used in many fields including social networks [27], bibliometric networks [46], software engineering [13], and pandemic modeling [6]; see the survey by Beck et al. [9]. Here we focus on a special case, evolving trees. In evolving trees the dynamics are captured only by growth (whereas in general dynamic graphs, nodes and edges can also disappear). While this is a significant restriction of the general dynamic graph model, evolving trees are common in many domains including the Tree of Life [35] and the Mathematics Genealogy Graph [34]. An evolving tree can also model disease spread, where nodes correspond to infected individuals and a new node is added along with an edge to existing node if infected . Visualizing this process can help us see how the infection spreads, the rate of infection, and to identify “super-spreaders.”

There are several methods and tools that can be used to visualize evolving trees [37, 14, 15, 2], however, most of them have limitations that can impact their usability in this domain. Many represent nodes only as points ignoring labels [14, 15], which makes them less useful in real-life applications where it is important to see what each node represents. Others utilize the level-by-level approach to drawing hierarchical graphs [26, 39], which does not capture the underlying graph structure well. Force-directed algorithms tend to better capture the underlying graph structure [30], although they may introduce unnecessary edge crossings. With this in mind, we propose two methods for drawing crossing-free evolving trees that optimize the following desirable properties:

  1. Desired edge length realization: The Euclidean distance between two nodes and in the layout should realize the corresponding pre-specified edge length , or be uniform when no additional information is given.

  2. Layout compactness: The drawing area should be proportional to the total area needed for all the labels. A good visualization should have the labeled graph drawn in a compact way [38]. This prevents the trivial solution of scaling the layout until all overlaps and crossings are removed, which can create vast empty spaces in the visualization.

  3. Stability: Between time steps, nodes should move as little as possible. This helps the viewer maintain a mental map of the graph [36]. If the graph moves around too much, it is difficult to see where new nodes and edges are added and we lose the context of the new node’s relation to the rest of the graph.

We propose two force-directed methods that ensure no edge crossings and optimize desired edge length, compactness and stability. Minimizing edge crossings is important in graph readability [41], and since we work with trees, a layout without edge crossings is possible and desirable. We use two trees extracted from Tree of Life [35] and the Mathematics Genealogy [34] projects to demonstrate the new methods and quantitatively evaluate their performance, measuring desired edge length realization, compactness, stability, stress, crossings, and running time. We also evaluate the performance of four earlier methods, showing the two proposed methods perform well overall; see Fig. 1.

Figure 1: The layouts obtained by DynNoSlice, DynaGraph, Dagre, Radial, DynaCola and DynaSafe of the same evolving math genealogy tree; each row adds six new nodes.

2 Related Work

Dynamic graph drawing has a long history [10, 44]. It can be divided into two broad categories: offline and online. In the easier offline setting we assume that all the data about the dynamics is known in advance. Algorithms for offline dynamic visualization use different approaches including combining all time-slice instances into a single supergraph [17, 18, 19], connecting the same node in consecutive time-slices and optimizing them simultaneously [21, 22, 23], providing animation [4], and showing small multiples type visualization [3]. DynNoSlice by Simonetto et al. [42] is one of the most recent approaches for this setting and is different from the prior methods as it does not rely on discrete time-slices.

Online dynamic graph drawing deals with the harder problem – when we do not know in advance what changes will occur. One can optimize the current view, given what has happened in the past, but cannot look into the future, as the information is not available. Cohen et al. [14, 15] and Workman et al. [48] describe algorithms for dynamic drawing of trees that place nodes that are equidistant from the root on the same level (same coordinate). These algorithms do not take edge lengths into consideration and the hierarchical nature of the layout can lead to exponential differences between the shortest and longest edges.

DynaDAG is an online graph drawing method for drawing dynamic directed acyclic graph as hierarchies [39].This method moves nodes between adjacent ranks based on the median sort. It was not specifically developed for trees and may introduce crossings; see Fig. 1(a). Other approaches for online dynamic graph drawing have maintained the horizontal and vertical position of nodes [36], used node aging methods [28], and adapted multilevel approaches [16] (using FM [29]). Online approaches have also been implemented on the GPU [24]. However, these methods do not guarantee crossing free layouts for trees and do not take into account desired edge lengths; see Fig. 1(a).

Dagre is a multi-phase algorithm for drawing directed graphs based on [26]

. The initial phase finds an optimal rank assignment using the network simplex algorithm. Then it sets the node order within ranks by an iterative heuristic incorporating a weight function and local transpositions to reduce crossings (via the barycenter heuristic) 

[31]. However, since Dagre draws graphs in a hierarchical structure, the edge lengths may vary arbitrarily; see Fig. 1(b).

(a)
(b)
Figure 2: (a) A DynaDAG layout of a tree with 100 nodes that introduces some edge crossings. (b) A Dagre layout of a tree with 300 nodes, with large edge length variability. Both trees are extracted from the math genealogy dataset.

The radial layout implemented in yFiles [47] displays each biconnected component in a circular fashion. Radial layouts were introduced by Kar et al. [32] for static graphs. Dougrusoz et al. [20] described an interactive tool for dynamic graph visualization based on the radial layout. Six and Tollis [43] adapted the radial idea to circular drawings of static biconnected graphs and experimentally showed that their layout has fewer edge crossings. Kaufmann et al. [33] extended this model to handle dynamic graphs, providing the basis of the yFiles radial implementation. Pavlo et al. [40] adapted the idea to make the radial layout computation parallelizable. Bachmaier [5] further improved the radial layout algorithm for static graphs by adapting the hierarchical approach [45] to minimize edge crossings. Radial layout methods have more freedom than the traditional level-by-level tree layout methods. Nevertheless, they are still constrained and can result in unstable visualization for dynamic graphs in general and evolving trees in particular; see Fig. 3.

(a)
(b)
Figure 3: A radial layout of a 400-node evolving tree of life (a) and the layout after adding 100 nodes (b). As most of the growth occurred on the right side, a lot of movement was needed to accommodate it.

Force-directed algorithms [17, 18, 19, 42] underlie many static and dynamic graph visualization methods. Unlike hierarchical and radial approaches, force-directed algorithms place nodes at arbitrary positions, and so tend to generate more compact layouts that better realize desired edge lengths. By adjusting forces appropriately, one can also generate stable layouts by this approach. To the best of our knowledge, there are no force-directed methods for evolving trees.

3 Algorithms for Visualizing Evolving Trees

Here, we describe two force-directed algorithms for evolving tree visualization, DynaCola and DynaSafe, that realize desired edge lengths without creating crossings, and optimize compactness and stability. DynaCola avoids edge crossings by creating and maintaining a “collision region” for each edge. While collision detection/prevention is usually applied to nodes, by carefully applying it to the edges we can prevent all edge crossings. DynaSafe prevents edge crossings with a “safe” coordinate update at every step of the algorithm. Before updating a coordinate, it first checks whether the update will introduce a crossing and then limits the update magnitude to avoid the crossing.

3.1 DynaCola

DynaCola stands for Dynamic Collision, as the algorithm uses the collision forces to prevent edge crossings. This is a force-directed algorithm, augmented with edge-regions used to prevent crossings; see Algorithm 1. Recall that we are gradually growing a tree, one node at a time, while maintaining a crossing-free layout and optimizing desirable properties (desired edge lengths, compactness, stability). The DynaCola force-directed algorithm relies on the following forces and is implemented in d3.js [11].

  • A force for each edge, to realize the desired edge length. The strength of this force is proportional to the difference between the edge distance in the layout and the desired edge length.

  • A general repulsive force defined for all pairs of nodes and implemented with the Barnes-Hut quad-tree data structure [7]. This helps realize the global structure of the underlying tree.

  • A collision force for each edge, described in details below. This force prevents edge crossings.

  • A gravitational force that attracts all nodes to the center of mass. This force draws the nodes closer together and improves compactness.

To ensure that no edges cross during an update, we define a collision region around each edge: if any edge/node moves too close to another edge, it will be pushed away. To create a collision region for an edge , we can create collision circles with diameter equal to the length of for both and . Then every point of will be either inside the collision region of or . However, the sum of all collision regions for all nodes will be unnecessarily large and the layout will not be compact. With the help of subdivision nodes along the edges, we can reduce the sum of all collision regions. Let be an edge in the graph. We use a set of subdivision nodes and replace the edge by a set of edges . We assign the desired edge length of an edge in equal to , where is the desired edge length. In general, the number of subdivision nodes per edge should be a small constant (by default ), since the complexity of the algorithm increases as increases. Also, note that determines the number of bends per edge (no bends when , one bend when , and so on).

When a new node is added to the tree, a new edge also is added, with one of its endpoints already placed. To place the new node, we randomly sample a set of 100 nearby points at a distance equal to the desired edge length, trying to find a crossing-free position. If we cannot find such a suitable point, we gradually reduce the distance and repeat the search until we find a crossing free position. Once the new node has been placed, we subdivide its adjacent edge as described above.

Result: A crossing-free layout, maintaining the desired properties
Let ;
Let ;
Find a crossing free position for by random sampling;
Reduce the edge length of if necessary;
Add subdivision nodes for ;
Add the new edges to ;
for each node of  do
       ;
      
for  do
       Compute the collision circle radius;
       for each edge of  do
             Let ;
             ;
            
      for each node of  do
             ;
             ;
             ;
            
for each node of  do
       ;
      
Algorithm 1 DynaCola(Current tree layout , new edge , , Number of subdivision nodes )

3.2 DynaSafe

DynaSafe stands for Dynamic Safety, as the algorithm prioritizes safe moves and will not make a move if it introduces an edge crossing; see Algorithm 2. DynaSafe is also a force-directed algorithm, however, it differs from DynaCola as it draws straight-line edges (rather than edges with bends). The algorithm utilizes the following forces and is implemented in d3.js [11]

  • A force on the edges to realize the desired edge length. The strength of the force is proportional to the difference between the edge distance in the layout and the desired edge length.

  • A stress-minimizing force on every pair of nodes not connected by an edge, used to improve global structure. The desired distance is the shortest-path distance between the pair, and the magnitude of the force is proportional to the difference between the realized and desired distance.

  • A repulsive force between nodes, which somewhat counter-intuitively, improves the compactness of the layout. The force has an elliptical contour since we are optimizing for labeled nodes, where the value of the coordinate must be farther away from other labels than the value of the coordinate.

  • A gravitational force that attracts all nodes to the center of mass. This force draws the nodes closer together and improves compactness.

DynaSafe prevents edge crossings from occuring at any time by updating the coordinates safely: if the proposed new coordinate of a node introduces crossings, we gradually reduce the magnitude of the movement until the crossing is avoided. To place the new node, we randomly sample a set of 100 nearby points to find a crossing-free position for its adjacent edge. If we cannot find a crossing free position using the sample points, we continuously reduce the edge length until we find a crossing free position. Once the node is added, an iteration of force-directed algorithm optimizes the layout (again without introducing crossings).

Result: A crossing-free layout, maintaining the desired properties
Let ;
Let ;
Find a crossing free position for by random sampling;
Reduce the edge length of if necessary;
Add the new edge to ;
for each node of  do
       ;
      
for  do
       for each edge of  do
             Let ;
             ;
            
      for each node of  do
             ;
             ;
            
      for each node pair  do
             ;
            
for each node of  do
       Reduce by % for at most times;
       Update by if no crossing occurs;
      
Algorithm 2 DynaSafe(Current tree layout , new edge , )

By the nature of force-directed algorithms, after one phase of force computations each node has a proposed new position. Before moving any node to its proposed new position, we check that the move is “safe,” i.e., it does not introduce a crossing. If the movement of a node introduces any crossings, then the magnitude of the move is set to % of the original movement. This is repeated (if needed) at most times and if the crossing is still unavoidable, then the node is not moved in this phase. By default and .

4 Experimental Evaluation

We evaluate DynaCola and DynaSafe, along with 4 earlier methods: DynNoSlice, DynaGraph, Dagre, and Radial. We use two evolving trees to visually compare the results, as well quantitatively evaluate the desired properties.

4.1 Datasets

We use two real-world datasets to extract evolving trees for our experiments.

The Tree of Life: captures the evolutionary progression of life on Earth [35]. The underlying data is a tree structure with a natural time component. As a new species evolves, a new node in the tree is added. The edges give the parent-child relation of the nodes, where the parent is the original species, and the child is the new species. We use a subset of this graph with 500 nodes. The maximum node degree of this tree is 5, and the radius is 24.

The Mathematics Genealogy: shows advisor-advisee relationships in the world of mathematics, stretching back to the middle ages [34]. The dataset includes the thesis titles, students, advisors, dates, and number of descendants. The total number of nodes is around 260,000 and is continuously updated. While this data is not quite a tree (or even connected, or planar), we extract a subset to create a tree with 500 nodes. The maximum node degree of this tree is 5 and the radius is 14.

4.2 Evaluation Metrics

We use standard metrics for each of our desired properties: desired edge length preservation, compactness, and stability. Additionally, we compute the stress of the drawing and the number of crossings. This gives a total of five quantitative measures. For each of these measures we define a loss function as follows:

Desired Edge Length (DEL): To measure how close the realized edge lengths are to the desired edge lengths, we find the mean squared error between these two values. Given the desired edge lengths , and coordinates of the nodes in the computed layout, we evaluate with the following formula:

Desired edge length loss (1)

This measures the root mean square of the relative error as in [1], producing a non-negative number, with corresponding to a perfect realization.

Compactness: To measure the compactness of each layout, we use the ratio between the drawing area and the sum of the areas for all labels [8]. We assume that a label is at most 16 characters, as we abbreviate longer labels. The sum of the areas for all labels gives the minimum possible area needed to draw all labels without overlaps (ignoring any space needed for edges). The area of the actual drawing is given by the smallest bounding rectangle, once the drawing has been scaled up until there are no overlapping labels. Once we have this scaled drawing, we find the positions of the nodes with the largest and smallest x and y values (, and ). Using these values we calculate the area of the bounding rectangle.

Compactness loss (2)

This formula produces a non-negative number; the ideal value for this measure is and corresponds to a perfect space utilization.

Stability: To measure stability, we consider how much each of the nodes moved after adding a new node. We then sum the movements of all nodes over all time steps. Since different algorithms use different amounts of drawing areas, we divide the value by the drawing area to normalize the results. This measure is similar to that used in DynNoSlice [42], but since DynNoSlice does not use time slices, it is closer to the measure found in [12]:

Stability loss (3)

Here, is the maximum time (500 in our two datasets). This formula produces a non-negative number; the ideal value is and corresponds to a perfectly stable layout (no movement of any already placed nodes).

Stress: This measure evaluates the global quality of the layout, looking at the differences between the realized distance between any pair of nodes and the actual distance between them. This measure is used in a variety of graph drawing algorithms [42, 12, 25]:

Stress loss (4)

This formula produces a non-negative number; the ideal value is and corresponds to a perfect embedding (that captures all graph distances by the realized Euclidean distances).

Edge Crossings: Finally, we measure the number of edge crossings in each of the outputs. Note that our algorithms DynaSafe and DynaCola enforce “no edge crossings” as a hard constraint. However, DynNoSlice and Dynagraph do not have such a constraint and so can and indeed do, introduce crossings. Therefore we include the number of edge crossings for a complete comparison.

4.3 Experimental Setup

We compare these algorithms to four previous algorithms: DynNoSlice, DynaGraph, Dagre, and Radial. We note that while Dagre and Radial are not specifically designed for dynamic graphs, they can be modified very naturally for this purpose. We can simply pass in the trees at every timestep and redraw.

We consider the simplest case for the desired edge length by using a uniform length of 100 for all edges. This is a necessary parameter for our algorithms DynaCola and DynaSafe, but only needed in the other four algorithms in order to compute the desired edge length measure. To be able to compare our methods to the other four (that do not take desired edge length into account), we set the desired edge length equal to the average edge obtained in the layout. We then normalize these values for a fair comparison.

The performance of DynNoSlice depends heavily on two parameters, and that must be tuned. With the help of the authors, we found and worked well for our 500-node trees. The performance of DynaCola depends on the number of subdivision nodes ; we use for the experiments. For the radial layout algorithm, we have used the default settings in the yFiles [47] implementation. The other algorithms are also used with their default settings.

4.4 Results

Both the visual and quantitative results indicate that the two new methods perform well overall; see Fig. 4.

Figure 4: The layouts of the six methods for the tree of life dataset.

Desired Edge Lengths: The quantitative results are shown in Table 5 and indicate that DynaCola does best. DynNoSlice is second best and DynaSafe is third. Dynagraph has the worst performance – not surprising given that it is a hierarchical layout, which is forced to use some very long edges near the root.

Nodes DynNoSlice Dynagraph Dagre Radial DynaCola DynaSafe
100 MG 0.37691 1.95933 0.682568 0.653853 0.282521 0.589865
200 MG 0.36552 1.95179 0.679827 0.640628 0.270322 0.575430
300 MG 0.35007 1.94213 0.666440 0.63058 0.253877 0.564747
400 MG 0.34402 1.93822 0.646479 0.619203 0.243184 0.553141
500 MG 0.33377 1.91979 0.639766 0.592694 0.237139 0.548756
100 TOL 0.21675 1.28710 0.448483 0.448205 0.158071 0.411747
200 TOL 0.21972 1.37271 0.494261 0.460161 0.166190 0.443935
300 TOL 0.23986 1.40404 0.510473 0.481034 0.176748 0.453332
400 TOL 0.25597 1.45660 0.553543 0.510352 0.183856 0.470334
500 TOL 0.26652 1.52650 0.581648 0.530249 0.189373 0.485759
Figure 5: Desired edge lengths of math genealogy tree (MG) and tree of life (TOL).

Compactness: The quantitative results are shown in Table 6 and indicate that DynNoSlice outperforms the rest of the algorithms. DynaCola is second best and DynaSafe is third. Here, Dagre has the worst performance.

Nodes DynNoSlice Dynagraph Dagre Radial DynaCola DynaSafe
100 MG 85.60 192.07 219.20 153.53 124.90 147.80
200 MG 87.94 196.29 224.54 162.80 130.87 153.31
300 MG 95.24 201.41 225.86 169.34 137.00 159.87
400 MG 98.89 206.48 227.74 175.07 145.47 169.68
500 MG 106.82 208.39 236.94 192.53 149.43 174.93
100 TOL 96.46 196.79 223.43 179.05 147.82 160.58
200 TOL 100.24 214.29 231.38 183.06 154.10 169.38
300 TOL 110.56 216.16 239.98 190.82 157.19 170.04
400 TOL 119.98 233.85 255.76 203.92 167.52 194.28
500 TOL 126.85 235.72 272.82 214.09 173.94 196.03
Figure 6: Compactness of math genealogy tree (MG) and the tree of life (TOL).

Stability: The quantitative results are shown in Table 7 and idicate that DynaCola does best. DynaGraph is second, and DynaSafe is third. The radial layout performs worse in this metric because it rotates the subtrees as more edges are added.

Nodes DynNoSlice Dynagraph Dagre Radial DynaCola DynaSafe
100 MG 0.001584 0.001393 0.0016502 0.001998 0.001348 0.001459
200 MG 0.000752 0.000447 0.0012497 0.001839 0.000264 0.000410
300 MG 0.000577 0.000227 0.0010083 0.001450 0.000225 0.000295
400 MG 0.000249 0.000190 0.0009504 0.001203 0.000164 0.000216
500 MG 0.000037 0.000014 0.0007591 0.001047 0.000011 0.000019
100 TOL 0.000437 0.000139 0.001241 0.003609 0.000105 0.000163
200 TOL 0.000323 0.000125 0.001196 0.003408 0.000097 0.000146
300 TOL 0.000263 0.000099 0.001163 0.003174 0.000072 0.000106
400 TOL 0.000235 0.000073 0.001136 0.002490 0.000064 0.000101
500 TOL 0.000199 0.000071 0.000834 0.001941 0.000052 0.000101
Figure 7: Stability of math genealogy tree (MG) and tree of life (TOL).

Stress: The quantitative results are shown in Table 8. In general, DynaSafe does much better on this measure than the rest. DynNoSlice is second and DynaCola third. DynaGraph and Dagre perform the worst in this metric due to the limitations inherent in the hierarchical layout. Note that the stress is normalized, so the numbers are comparable.

Nodes DynNoSlice Dynagraph Dagre Radial DynaCola DynaSafe
100 MG 113.10 150.59 230.75 125.37 76.51 49.44
200 MG 161.45 186.17 250.98 172.05 151.74 68.42
300 MG 179.48 264.90 286.77 205.98 184.47 94.05
400 MG 186.68 292.66 286.83 262.09 227.98 107.56
500 MG 249.61 393.11 396.72 314.93 291.39 109.00
100 TOL 136.52 210.06 263.98 192.64 128.45 59.77
200 TOL 165.75 262.24 325.65 243.59 201.76 65.10
300 TOL 181.62 305.15 369.57 287.93 220.63 81.81
400 TOL 254.20 328.59 398.11 317.28 306.89 93.99
500 TOL 285.19 400.81 461.43 374.02 351.23 119.77
Figure 8: Stress scores of math genealogy tree (MG) and tree of life (TOL).

Edge Crossings: The quantitative results are shown in Table 9. There are four winners here – the four algorithms that prevent any edge crossings: DynaCola, DynaSafe, Radial, and Dagre. DynNoSlice and Dynagraph do introduce some crossings.

Nodes DynNoSlice Dynagraph Dagre Radial DynaCola DynaSafe
100 MG 43 8 0 0 0 0
200 MG 82 11 0 0 0 0
300 MG 168 11 0 0 0 0
400 MG 217 13 0 0 0 0
500 MG 277 13 0 0 0 0
100 TOL 21 0 0 0 0 0
200 TOL 67 0 0 0 0 0
300 TOL 106 0 0 0 0 0
400 TOL 176 0 0 0 0 0
500 TOL 231 0 0 0 0 0
Figure 9: Edge crossings of math genealogy tree (MG) and tree of life (TOL).

Running time: The Radial layout has the lowest running time, taking 34.93 seconds and 28.03 seconds, respectively, to draw the 500-node math genealogy tree and tree of life. On the other end, DynNoSlice is the slowest algorithm, taking more than 6 hours to draw the 500-node trees. Our two new methods are not as fast as the Radial algorithm and not as slow as DynNoSlice, taking about 5 minutes on the 500-node trees; see Fig. 10.

(a) DynaCola
(b) DynaSafe
Figure 10: Running time w.r.t. number of nodes in the math genealogy tree.

5 Discussion, Limitations, Conclusions and Future Work

While there are many algorithms and tools for drawing static trees, there are only a few that can handle dynamic trees well. Among those, there are even fewer that take edge labels into account while also preventing edge crossings. With this in mind, we described two methods for visualizing evolving trees. Fully functional prototypes and videos showing them in action are available online: https://ryngray.github.io/dynamic-trees/index.html. Source code and all experimental data can be found on github: https://github.com/abureyanahmed/evolving_tree.

The two new methods, DynaCola and DynaSafe perform well overall. However, we only used two 500-node trees in the evaluation. We used 5 metrics to quantitatively evaluate the new methods against 4 earlier methods, but it is likely that other earlier methods can be adapted to this setting and might perform better than the ones we used. Further, we did not evaluate how the algorithms behave as the size of the trees grows. Our algorithms have not been optimized for speed and will likely struggle with larger instances.

The two new methods are designed for evolving trees, where growth is the only type of change. A natural question is whether these algorithms can be generalized to the more difficult problem of online dynamic tree visualization.

Acknowledgements

We thank the authors of DynNoSlice, Dynagraph, as well as Felice de Luca and Iqbal Hossain for their assistance with running and tuning algorithms. We also thank yFiles whose radial layout implementation we use in the evaluation, as well as Michael Kaufmann and Michael Pfahler for help with the system.

References

  • [1] R. Ahmed, F. D. Luca, S. Devkota, S. Kobourov, and M. Li (2020) Graph drawing via gradient descent, . In 28th International Symposium on Graph Drawing and Network Visualization (GD), pp. 3–17. Cited by: §4.2.
  • [2] D. Archambault, H. Purchase, and B. Pinaud (2010) Animation, small multiples, and the effect of mental map preservation in dynamic graphs. IEEE Transactions on Visualization and Computer Graphics 17 (4), pp. 539–552. Cited by: §1.
  • [3] B. Bach, N. Henry-Riche, T. Dwyer, T. Madhyastha, J. Fekete, and T. Grabowski (2015) Small multipiles: piling time to explore temporal patterns in dynamic networks. Computer Graphics Forum 34 (3), pp. 31–40. Cited by: §2.
  • [4] B. Bach, E. Pietriga, and J. Fekete (2013) Graphdiaries: animated transitions and temporal navigation for dynamic networks. IEEE Transactions on Visualization and Computer Graphics 20 (5), pp. 740–754. Cited by: §2.
  • [5] C. Bachmaier (2007) A radial adaptation of the sugiyama framework for visualizing hierarchical information. IEEE Transactions on Visualization and Computer Graphics 13 (3), pp. 583–594. Cited by: §2.
  • [6] D. Balcan, B. Gonçalves, H. Hu, J. J. Ramasco, V. Colizza, and A. Vespignani (2010) Modeling the spatial spread of infectious diseases: the global epidemic and mobility computational model. Journal of Computational Science 1 (3), pp. 132–145. Cited by: §1.
  • [7] J. Barnes and P. Hut (1986) A hierarchical o(n log n) force-calculation algorithm. Nature 324 (6096), pp. 446–449. Cited by: 2nd item.
  • [8] L. Barth, S. G. Kobourov, and S. Pupyrev (2014) Experimental comparison of semantic word clouds. In Experimental Algorithms, pp. 247–258. Cited by: §4.2.
  • [9] F. Beck, M. Burch, S. Diehl, and D. Weiskopf (2014) The state of the art in visualizing dynamic graphs. In 16th Eurographics Conference on Visualization, (EuroVis), Cited by: §1.
  • [10] F. Beck, M. Burch, S. Diehl, and D. Weiskopf (2017) A taxonomy and survey of dynamic graph visualization. In Computer Graphics Forum, Vol. 36, pp. 133–159. Cited by: §2.
  • [11] M. Bostock, V. Ogievetsky, and J. Heer (2011) D data-driven documents. IEEE Transactions on Visualization and Computer Graphics 17 (12), pp. 2301–2309. Cited by: §3.1, §3.2.
  • [12] U. Brandes and M. Mader (2011) A quantitative comparison of stress-minimization approaches for offline dynamic graph drawing. In 19th International Symposium on Graph Drawing (GD), pp. 99–110. Cited by: §4.2, §4.2.
  • [13] M. Burch, C. Müller, G. Reina, H. Schmauder, M. Greis, and D. Weiskopf (2012) Visualizing dynamic call graphs.. In Vision, Modeling, and Visualization (VMV), pp. 207–214. Cited by: §1.
  • [14] R. F. Cohen, G. Di Battista, R. Tamassia, I. G. Tollis, and P. Bertolazzi (1992) A framework for dynamic graph drawing. In Proceedings of the eighth annual symposium on Computational geometry, pp. 261–270. Cited by: §1, §2.
  • [15] R. F. Cohen, G. Di Battista, R. Tamassia, and I. G. Tollis (1995) Dynamic graph drawings: trees, series-parallel digraphs, and planar st-digraphs. SIAM Journal on Computing 24 (5), pp. 970–1001. Cited by: §1, §2.
  • [16] T. Crnovrsanin, J. Chu, and K. Ma (2015) An incremental layout method for visualizing online dynamic graphs. In 23rd International Symposium on Graph Drawing (GD), pp. 16–29. Cited by: §2.
  • [17] S. Diehl, C. Görg, and A. Kerren (2000) Foresighted graph layout. Technical Report, University of Saarland, pp. . Cited by: §2, §2.
  • [18] S. Diehl, C. Görg, and A. Kerren (2001) Preserving the mental map using foresighted layout. Proceedings of Joint Eurographics - IEEE TCVG Symposium on Visualization (VisSym), pp. . Cited by: §2, §2.
  • [19] S. Diehl and C. Görg (2002) Graphs, they are changing. 10th International Symposium on Graph Drawing (GD), pp. 23–31. Cited by: §2, §2.
  • [20] U. Doğrusöz, B. Madden, and P. Madden (1996) Circular layout in the graph layout toolkit. In 4th International Symposium on Graph Drawing (GD), pp. 92–100. Cited by: §2.
  • [21] C. Erten, P. J. Harding, S. G. Kobourov, K. Wampler, and G. Yee (2003) GraphAEL: graph animations with evolving layouts. In 11th International Symposium on Graph Drawing (GD), pp. 98–110. Cited by: §2.
  • [22] C. Erten, S. G. Kobourov, V. Le, and A. Navabi (2003) Simultaneous graph drawing: layout algorithms and visualization schemes. In 11th International Symposium on Graph Drawing (GD), pp. 437–449. Cited by: §2.
  • [23] D. Forrester, S. G. Kobourov, A. Navabi, K. Wampler, and G. V. Yee (2004) Graphael: a system for generalized force-directed layouts. In 12th International Symposium on Graph Drawing (GD), pp. 454–464. Cited by: §2.
  • [24] Y. Frishman and A. Tal (2008) Online dynamic graph drawing. IEEE Transactions on Visualization and Computer Graphics 14 (4), pp. 727–740. Cited by: §2.
  • [25] E. R. Gansner, Y. Koren, and S. North (2004) Graph drawing by stress majorization. In 12th International Symposium on Graph Drawing (GD), pp. 239–250. Cited by: §4.2.
  • [26] E. R. Gansner, E. Koutsofios, S. C. North, and K. Vo (1993) A technique for drawing directed graphs. IEEE Transactions on Software Engineering 19 (3), pp. 214–230. Cited by: §1, §2.
  • [27] F. Gilbert, P. Simonetto, F. Zaidi, F. Jourdan, and R. Bourqui (2011) Communities and hierarchical structures in dynamic social networks: analysis and visualization. Social Network Analysis and Mining 1 (2), pp. 83–95. Cited by: §1.
  • [28] T. E. Gorochowski, M. di Bernardo, and C. S. Grierson (2011) Using aging to visually uncover evolutionary processes on networks. IEEE Transactions on Visualization and Computer Graphics 18 (8), pp. 1343–1352. Cited by: §2.
  • [29] S. Hachul and M. Jünger (2004) Drawing large graphs with a potential-field-based multilevel algorithm. In 12th International Symposium on Graph Drawing (GD), pp. 285–295. Cited by: §2.
  • [30] Y. Hu and Y. Koren (2009) Extending the spring-electrical model to overcome warping effects. In 2009 IEEE Pacific Visualization Symposium, pp. 129–136. Cited by: §1.
  • [31] M. Jünger and P. Mutzel (2002) 2-layer straightline crossing minimization: performance of exact and heuristic algorithms. In Graph Algorithms and Applications I, pp. 3–27. Cited by: §2.
  • [32] G. Kar, B. Madden, and R. Gilbert (1988) Heuristic layout algorithms for network management presentation services. IEEE Network 2 (6), pp. 29–36. Cited by: §2.
  • [33] M. Kaufmann and R. Wiese (2002) Maintaining the mental map for circular drawings. In 10th International Symposium on Graph Drawing (GD), pp. 12–22. Cited by: §2.
  • [34] M. T. Keller Math genealogy project. External Links: Link Cited by: §1, §1, §4.1.
  • [35] D. Maddison, K. Schulz, A. Lenards, and W. Maddison Tree of life web project. External Links: Link Cited by: §1, §1, §4.1.
  • [36] K. Misue, P. Eades, W. Lai, and K. Sugiyama (1995) Layout adjustment and the mental map. Journal of Visual Languages & Computing 6 (2), pp. 183–210. Cited by: item 3, §2.
  • [37] S. Moen (1990) Drawing dynamic trees. IEEE Software 7 (4), pp. 21–28. Cited by: §1.
  • [38] Q. H. Nguyen (2018) INKA: an ink-based model of graph visualization. CoRR abs/1801.07008. External Links: 1801.07008 Cited by: item 2.
  • [39] S. C. North (1995) Incremental layout in dynadag. In 3rd International Symposium on Graph Drawing (GD), pp. 409–418. Cited by: §1, §2.
  • [40] A. Pavlo, C. Homan, and J. Schull (2006) A parent-centered radial layout algorithm for interactive graph visualization and animation. arXiv preprint cs/0606007. Cited by: §2.
  • [41] H. Purchase (1997) Which aesthetic has the greatest effect on human understanding?. In 5th International Symposium on Graph Drawing (GD), pp. 248–261. Cited by: §1.
  • [42] P. Simonetto, D. Archambault, and S. Kobourov (2018) Event-based dynamic graph visualisation. IEEE Transactions on Visualization and Computer Graphics 26 (7), pp. 2373–2386. Cited by: §2, §2, §4.2, §4.2.
  • [43] J. M. Six and I. G. Tollis (1999) A framework for circular drawings of networks. In 7th International Symposium on Graph Drawing (GD), pp. 107–116. Cited by: §2.
  • [44] M. Skambath and T. Tantau (2016) Offline drawing of dynamic trees: algorithmics and document integration. CoRR abs/1608.08385. External Links: 1608.08385 Cited by: §2.
  • [45] K. Sugiyama, S. Tagawa, and M. Toda (1981) Methods for visual understanding of hierarchical system structures. IEEE Transactions on Systems, Man, and Cybernetics 11 (2), pp. 109–125. Cited by: §2.
  • [46] N. J. Van Eck and L. Waltman (2014) Visualizing bibliometric networks. In Measuring Scholarly Impact, pp. 285–320. Cited by: §1.
  • [47] R. Wiese, M. Eiglsperger, and M. Kaufmann (2004) Yfiles visualization and automatic layout of graphs. In Graph Drawing Software, pp. 173–191. Cited by: §2, §4.3.
  • [48] D. Workman, M. Bernard, and S. Pothoven (2004) An incremental editor for dynamic hierarchical drawing of trees. In International Conference on Computational Science, pp. 986–995. Cited by: §2.

Appendix

Fig. 1 shows a small evolving tree with labels, as obtained by the six algorithms: DynNoSlice, DynaGraph, Dagre, Radial, DynaCola and DynaSafe. Fig. 11 shows the same layouts without the labels, allowing us to see the structure a bit better.

Figure 11: The unlabeled layouts obtained by DynNoSlice, DynaGraph, Dagre, Radial, DynaCola and DynaSafe of the same evolving math genealogy tree; each row adds six new nodes.

Fig. 4 shows the layouts of the tree of life, obtained by DynNoSlice, DynaGraph, Dagre, Radial, DynaCola and DynaSafe. Fig. 12 shows the layouts of math genealogy tree, obtained by DynNoSlice, DynaGraph, Dagre, Radial, DynaCola and DynaSafe.

Figure 12: The layouts of different algorithms of the same evolving math genealogy trees at different steps.

Tab. 13 shows the running times of DynNoSlice, DynaGraph, Dagre, Radial, DynaCola and DynaSafe.

Graph DynNoSlice Dynagraph Dagre Radial DynaCola DynaSafe
Math genealogy 24804.39 72.77 117.87 34.93 368.48 398.15
Tree of life 22212.30 36.28 52.49 28.03 99.30 153.89
Figure 13: Running time of different algorithms in seconds.