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 “superspreaders.”
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 reallife applications where it is important to see what each node represents. Others utilize the levelbylevel approach to drawing hierarchical graphs [26, 39], which does not capture the underlying graph structure well. Forcedirected 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 crossingfree evolving trees that optimize the following desirable properties:

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

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.

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 forcedirected 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.
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 timeslice instances into a single supergraph [17, 18, 19], connecting the same node in consecutive timeslices 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 timeslices.
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 multiphase 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).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 levelbylevel 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.
Forcedirected algorithms [17, 18, 19, 42] underlie many static and dynamic graph visualization methods. Unlike hierarchical and radial approaches, forcedirected 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 forcedirected methods for evolving trees.
3 Algorithms for Visualizing Evolving Trees
Here, we describe two forcedirected 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 forcedirected algorithm, augmented with edgeregions used to prevent crossings; see Algorithm 1. Recall that we are gradually growing a tree, one node at a time, while maintaining a crossingfree layout and optimizing desirable properties (desired edge lengths, compactness, stability). The DynaCola forcedirected 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 BarnesHut quadtree 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 crossingfree 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.
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 forcedirected algorithm, however, it differs from DynaCola as it draws straightline 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 stressminimizing force on every pair of nodes not connected by an edge, used to improve global structure. The desired distance is the shortestpath 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 counterintuitively, 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 crossingfree 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 forcedirected algorithm optimizes the layout (again without introducing crossings).
By the nature of forcedirected 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 realworld 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 parentchild 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 advisoradvisee 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 nonnegative 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 nonnegative 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 nonnegative 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 nonnegative 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 500node 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.
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 
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 
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 
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 
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 
Running time: The Radial layout has the lowest running time, taking 34.93 seconds and 28.03 seconds, respectively, to draw the 500node math genealogy tree and tree of life. On the other end, DynNoSlice is the slowest algorithm, taking more than 6 hours to draw the 500node 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 500node trees; see Fig. 10.
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/dynamictrees/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 500node 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] (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] (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] (2015) Small multipiles: piling time to explore temporal patterns in dynamic networks. Computer Graphics Forum 34 (3), pp. 31–40. Cited by: §2.
 [4] (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] (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] (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] (1986) A hierarchical o(n log n) forcecalculation algorithm. Nature 324 (6096), pp. 446–449. Cited by: 2nd item.
 [8] (2014) Experimental comparison of semantic word clouds. In Experimental Algorithms, pp. 247–258. Cited by: §4.2.
 [9] (2014) The state of the art in visualizing dynamic graphs. In 16th Eurographics Conference on Visualization, (EuroVis), Cited by: §1.
 [10] (2017) A taxonomy and survey of dynamic graph visualization. In Computer Graphics Forum, Vol. 36, pp. 133–159. Cited by: §2.
 [11] (2011) D datadriven documents. IEEE Transactions on Visualization and Computer Graphics 17 (12), pp. 2301–2309. Cited by: §3.1, §3.2.
 [12] (2011) A quantitative comparison of stressminimization approaches for offline dynamic graph drawing. In 19th International Symposium on Graph Drawing (GD), pp. 99–110. Cited by: §4.2, §4.2.
 [13] (2012) Visualizing dynamic call graphs.. In Vision, Modeling, and Visualization (VMV), pp. 207–214. Cited by: §1.
 [14] (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] (1995) Dynamic graph drawings: trees, seriesparallel digraphs, and planar stdigraphs. SIAM Journal on Computing 24 (5), pp. 970–1001. Cited by: §1, §2.
 [16] (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] (2000) Foresighted graph layout. Technical Report, University of Saarland, pp. . Cited by: §2, §2.
 [18] (2001) Preserving the mental map using foresighted layout. Proceedings of Joint Eurographics  IEEE TCVG Symposium on Visualization (VisSym), pp. . Cited by: §2, §2.
 [19] (2002) Graphs, they are changing. 10th International Symposium on Graph Drawing (GD), pp. 23–31. Cited by: §2, §2.
 [20] (1996) Circular layout in the graph layout toolkit. In 4th International Symposium on Graph Drawing (GD), pp. 92–100. Cited by: §2.
 [21] (2003) GraphAEL: graph animations with evolving layouts. In 11th International Symposium on Graph Drawing (GD), pp. 98–110. Cited by: §2.
 [22] (2003) Simultaneous graph drawing: layout algorithms and visualization schemes. In 11th International Symposium on Graph Drawing (GD), pp. 437–449. Cited by: §2.
 [23] (2004) Graphael: a system for generalized forcedirected layouts. In 12th International Symposium on Graph Drawing (GD), pp. 454–464. Cited by: §2.
 [24] (2008) Online dynamic graph drawing. IEEE Transactions on Visualization and Computer Graphics 14 (4), pp. 727–740. Cited by: §2.
 [25] (2004) Graph drawing by stress majorization. In 12th International Symposium on Graph Drawing (GD), pp. 239–250. Cited by: §4.2.
 [26] (1993) A technique for drawing directed graphs. IEEE Transactions on Software Engineering 19 (3), pp. 214–230. Cited by: §1, §2.
 [27] (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] (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] (2004) Drawing large graphs with a potentialfieldbased multilevel algorithm. In 12th International Symposium on Graph Drawing (GD), pp. 285–295. Cited by: §2.
 [30] (2009) Extending the springelectrical model to overcome warping effects. In 2009 IEEE Pacific Visualization Symposium, pp. 129–136. Cited by: §1.
 [31] (2002) 2layer straightline crossing minimization: performance of exact and heuristic algorithms. In Graph Algorithms and Applications I, pp. 3–27. Cited by: §2.
 [32] (1988) Heuristic layout algorithms for network management presentation services. IEEE Network 2 (6), pp. 29–36. Cited by: §2.
 [33] (2002) Maintaining the mental map for circular drawings. In 10th International Symposium on Graph Drawing (GD), pp. 12–22. Cited by: §2.
 [34] Math genealogy project. External Links: Link Cited by: §1, §1, §4.1.
 [35] Tree of life web project. External Links: Link Cited by: §1, §1, §4.1.
 [36] (1995) Layout adjustment and the mental map. Journal of Visual Languages & Computing 6 (2), pp. 183–210. Cited by: item 3, §2.
 [37] (1990) Drawing dynamic trees. IEEE Software 7 (4), pp. 21–28. Cited by: §1.
 [38] (2018) INKA: an inkbased model of graph visualization. CoRR abs/1801.07008. External Links: 1801.07008 Cited by: item 2.
 [39] (1995) Incremental layout in dynadag. In 3rd International Symposium on Graph Drawing (GD), pp. 409–418. Cited by: §1, §2.
 [40] (2006) A parentcentered radial layout algorithm for interactive graph visualization and animation. arXiv preprint cs/0606007. Cited by: §2.
 [41] (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] (2018) Eventbased dynamic graph visualisation. IEEE Transactions on Visualization and Computer Graphics 26 (7), pp. 2373–2386. Cited by: §2, §2, §4.2, §4.2.
 [43] (1999) A framework for circular drawings of networks. In 7th International Symposium on Graph Drawing (GD), pp. 107–116. Cited by: §2.
 [44] (2016) Offline drawing of dynamic trees: algorithmics and document integration. CoRR abs/1608.08385. External Links: 1608.08385 Cited by: §2.
 [45] (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] (2014) Visualizing bibliometric networks. In Measuring Scholarly Impact, pp. 285–320. Cited by: §1.
 [47] (2004) Yfiles visualization and automatic layout of graphs. In Graph Drawing Software, pp. 173–191. Cited by: §2, §4.3.
 [48] (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.
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.
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 
Comments
There are no comments yet.