1 Introduction

Graphs offer a natural way to represent a static set of relations. In order to encode changes to a graph over time, static graphs can be extended to dynamic graphs. Dynamic graphs are traditionally thought of as a sequence of static graphs in a finite number of moments in time, or timeslices. We refer to these dynamic graphs as discrete dynamic graphs. Discrete dynamic graphs are widely used for several reasons. Drawing timesliced graphs is similar to drawing static graphs, allowing force-directed approaches to be easily adapted to dynamic data. Also, timeslicing works fine for data that changes at discrete, regular time intervals.

Algorithms to draw discrete dynamic graphs strike a balance between graph drawing readability and stability [3]. Readability requires the drawing of individual timeslices to be of high quality while stability (mental map preservation) requires nodes to not move too much between consecutive timeslices for easy identification [2]. These requirements conflict with each other as node movement is required for timeslice readability, while it negatively impacts stability.

Approaches for discrete dynamic graph drawing extend static graph drawing algorithms. Each timeslice is a static graph that is drawn considering the timeslices before and after to stabilize the transition. However, when the time dimension is continuous, there are no timeslices. Thus, evenly spaced timeslices are selected and the graph elements are projected to the closest one. This operation implicitly aggregates data along the time dimension (Fig. 1). Selecting too many timeslices leads to slow layout computation while selecting too few leads to information loss due to projection errors when events are of short duration, obscuring graph structure. Even for graphs with nodes and edges that span long periods of time, regular timeslices can obscure important temporal patterns.

A natural solution to the problems above would be to refrain from imposing timeslices on the continuous data and draw the graph directly along a continuous time dimension. In a recent state-of-the-art report, Beck et al.  [7, p. 15] states “the effects of using continuous time with arbitrary fine sampling rates, rather than discretized time, are largely unexplored”. In this paper, we introduce a model for dynamic graph drawing that does not use timeslices. We call these graphs continuous dynamic graphs and propose the first dynamic graph drawing algorithm, DynNoSlice, to draw them along a continuous time dimension.

Fig. 1.
figure 1

A dynamic graph with 5 nodes. (a) A discrete representation with nodes projected onto timeslices. Projecting the nodes (purple dots) results in information loss due to aggregation across time. (b) In our approach, nodes are defined as piecewise linear curves in the space-time cube, as timeslices are not imposed on continuous data. (Color figure online)

Full size image

2 Related Work

Dynamic graphs visualization is a well established field of research, as shown in the recent survey by Beck et al.  [7]. If we were to place our approach in this model, it would be an “offline time-to-time mapping” without timeslices, as it works with full knowledge of the input data. Related approaches also include the “superimposed time-to-space mapping”, as this approach inherently defines a space-time cube.

Offline Drawing. Offline dynamic graph drawing algorithms capture all of the dynamic data beforehand and optimize across it simultaneously. Foresighted layout algorithms [17, 18] are among the first attempts at offline dynamic graph drawing. They create a supergraph as the union of the elements at each timeslice. The supergraph is then used to define the position of nodes and edge bends. Mental map preservation is the primary focus of this approach.

Brandes and Corman [8] designed an approach for offline dynamic graph drawing that visually refers to time as a third, discrete spacial component. Timeslices are placed on top of each other, forming a layered space-time cube. A similar technique is also used by Dwyer and Eades [19]. In both approaches, the time dimension is modeled using timeslices.

Erten et al.  [21] explored several ways to superimpose different graphs, including the use of different colors for different timeslices of a layered space-time cube. In GraphAEL [20, 23], the space-time cube was created by connecting the same nodes in consecutive timeslices with inter-timeslice edges and optimizing this structure with a force-directed algorithm. A similar technique is used by Groh et al.  [30] and by Itoh et al.  [32] for social networks. Brandes and Mader [9] perform a metric-based evaluation of several strategies for drawing discrete dynamic graphs including aggregation, anchoring, and linking. Linking strategies performed best in balancing drawing quality (measured using stress) and mental map preservation (measured using distance traveled). Rauber et al.  [43], identify vectors \(v_i[t]\) in the cost gradient whose geometrical interpretation would be identical when working in a layered space-time cube.

Our approach can be seen as an extension of offline discrete dynamic graph drawing approaches to continuous time. However, the difference is substantial as in related work timeslices are imposed on the data. By drawing in continuous time, each node and edge defines its own trajectory with its own complexity whereas discrete algorithms impose linear interpolations between timeslices.

Time-to-space mapping approaches [7] use one dimension for space and one dimension for time in order to visualize the network [12, 36, 45, 49]. Recent scalable approaches use dimensionality reduction to show time as a curve in the plane [6, 50]. By using spatial dimensions to represent time, these visualizations are substantially different from classic dynamic node-link diagrams.

Online Drawing. Given an incoming stream of data, online drawing algorithms continuously update the current graph drawing to take into account new data. Misue et al.  [37] optimize mental map preservation by maintaining the horizontal and vertical order of the nodes through adjustments. Frishman and Tal [25] proposed a different force-directed algorithm which could also be partially executed on the GPU. Gorochowski et al.  [28] use node aging to decide how much a node position should be preserved at a given time. Finally, Crnovrsanin et al.  [14] adapted the \(\mathtt{FM}^\mathtt{3}\) [31] multilevel approach to an online setting.

Although related, online approaches are different as they operate under more stringent constraints due to lack of access to future information. Offline algorithms, such as DynNoSlice, use the full knowledge of the graph evolution.

3D Graph Drawing. Several 2D algorithms have been extended to 3D. Bruß and Frick [11] proposed Gem3D, which extends Gem [24] to 3D. Cruz and Twarog [15] extended the simulated annealing approach of Davidson and Harel [16] to 3D. Other algorithms work in both 2D and 3D, such as GRIP by Gajer and Kobourov [26]. Munzner [38] proposed an algorithm to draw directed graphs in a 3D hyperbolic space. Several other algorithms deal with particular constraints, such as orthogonal [34], or nested [41] drawings. Cordeil et al.  [13] investigate the visualization of graphs in 3D using immersive environments.

Although our approach does compute a 3D layout of the dynamic graph, we do not produce a 3D visualization. Since our third dimension is time, nodes and edges have additional constraints and are not free to move arbitrarily in 3D.

Space-Time Cubes. Sallaberry et al.  [44] visualize dynamic graphs by manipulating the space-time cube. Several other information visualization methods perform similar operations in the space-time cube, as discussed in Bach et al.  [5]. These approaches assume that the space-time cube is already given and focus on how to accommodate it in 2D, whereas our approach constructs the space-time cube for dynamic graphs using a continuous time dimension.

Fig. 2.
figure 2

A continuous dynamic graph in the space-time cube. (a) Position attribute for a node v. (b) The appearance attribute. (c) An edge in a continuous dynamic graph, as encoded by the edge appearance attribute.

Full size image

3 Continuous Dynamic Graph Model

Let \(G=(V,E)\) be a static graph defined with node set V and edge set \(E \subseteq V \times V\). We define attributes (functions) on the nodes and edges of the graph that encode characteristics such as their positions, weights, and labels. The node position attribute (\(\mathcal {P}_G : V \rightarrow \mathbb {R}^2\)) maps a node v into its position in the 2D plane \(\varvec{p}_v\), e.g., \(\mathcal {P}_G(v) = (1,4)\). This attribute is not integral to our model of continuous dynamic graphs, but is used to compute and store the layout of these graphs.

We define a continuous dynamic graph \(D = (V,E)\) as a graph whose attributes are also a function of time. Let T be the time domain defined as an interval in \(\mathbb {R}\). Attributes are functions defined in the domain \(V \times T\) for nodes, and \(E \times T\) for edges. For example, the node position attribute \(\mathcal {P}_D : V \times T \rightarrow \mathbb {R}^2\) is the function that describes the position of v for each time \(t \in T\). We assume (w.l.o.g.) that the node and edge attributes can be defined piecewise, e.g.:

$$ \mathcal {P}_D(v,t) = \mathcal {P}_v(t) = {\left\{ \begin{array}{ll} \mathcal {P}_{v,1}(t) &{} \text {for } t \in T_1 \\ \vdots \\ \mathcal {P}_{v,n}(t) &{} \text {for } t \in T_n \\ \varvec{p}_{v,\omega } &{} \text {otherwise} \end{array}\right. } $$

In other words, a dynamic attribute can be thought of as a map that links each node (edge) to a sequence of functions \(\mathcal {P}_{v,i}\) that describe its behavior in disjoint intervals of time \(T_i\), with a default value returned for \(t \notin \bigcup _{i} T_i\). In the rest of paper we consider only piecewise linear functions for nodes and edges.

Attributes specify a variety of node and edge characteristics. For data that can be meaningfully interpolated (e.g., colors, weights, positions), the functions above can be described by initial and final values. For attributes without meaningful interpolation (e.g., labels), we prefer functions that are constant in the related interval. Position and label attributes for a node v of D can be:

$$ \mathcal {P}_v(t) = {\left\{ \begin{array}{ll} (1,0) \rightarrow (4,0) &{} \text {for } t \in (9,12] \\ (2,-2) \rightarrow (5,1) &{} \text {for } t \in (12,15] \\ (5,1) \rightarrow (4,5) &{} \text {for } t \in [17; 19] \\ (0,0) &{} \text {otherwise} \end{array}\right. } \mathcal {L}_v(t) = {\left\{ \begin{array}{ll} \text {Jane Doe} &{} \text {for } t \in (10,11] \\ \text {Jane Smith} &{} \text {for } t \in (11,16] \\ \text {unknown} &{} \text {otherwise} \end{array}\right. } $$

We define the attribute appearance that implements the classic dynamic graph operations node/edge insertion and deletion.

$$ \mathcal {A}_v(t) = {\left\{ \begin{array}{ll} \text {true} &{} \text {for } t \in [2,7) \\ \text {true} &{} \text {for } t \in (9,13] \\ \text {false} &{} \text {otherwise} \end{array}\right. } $$

In order to mark an edge \(e=(u,v)\) as present in \(T_x\), we need to ensure that both u and v are present for the entire \(T_x\).

This definition supports changes in node (edge) characteristics at any time, whereas discrete dynamic graphs allow changes only to occur in timeslices. DynNoSlice implements the above model as a collection of piecewise, linear functions defined on intervals in the space-time cube. Fast access to these functions at any given time is required. In our implementation, we use interval trees. When the intervals are guaranteed to be non-overlapping, simpler structures such as binary search trees can be used.

4 DynNoSlice Implementation

A continuous dynamic graph D can be transformed into a 3D static graph \(D'\) by embedding it in the space-time cube. Algorithms for static or discrete dynamic graphs can be extended to work with this new representation. In this section, we describe our force-directed algorithm for drawing continuous dynamic graphs. It has been implemented and the source code is availableFootnote 1.

4.1 Representation in the Space-Time Cube

We can define a space-time cube transformation (STCT) that transforms a continuous dynamic graph into a drawing in the space-time cube. In \(D'\), the presence and position of each node is represented by a sequence of trajectories. The shapes of these trajectories are defined by the position attributes. In the example above, the trajectory of v is defined by three line segments, \((1,0,9) \rightarrow (4,0,12)\), \((2,-2,12) \rightarrow (5,1,15)\) and \((5,1,17) \rightarrow (4,5,19)\), and by portions of the line (0, 0, x) (see Fig. 2a). The number of these trajectories is also affected by the appearance attribute. In the example above, the node v appears two times: at [2, 7) and at (9, 13]. Clearly, the behavior of the node at times when it is not part of the graph is non-influential. Therefore, the node appearance and position in the space-time cube can be identified by the segments \(s_{v,1} = (0,0,2) \rightarrow (0,0,7)\), \(s_{v,2} = (1,0,9) \rightarrow (4,0,12)\) and \(s_{v,3} = (2,-2,12) \rightarrow (3,-1,13)\) (see Fig. 2b). The trajectory given by the polyline is made of the start and end points, as well as the bends (the junctions of consecutive segments).

The representation of edges in the space-time cube is less intuitive. By connecting two trajectories with lines in the space-time cube, we obtain a ruled surface. Therefore, an edge \(e=(u,v)\) is a surface that connects trajectories u and v for a duration indicated by \(\mathcal {A}_e\). If the node trajectories are not continuous as in the above example:

$$ \lim _{t \rightarrow 12^{-}} \mathcal {P}_v(t) = (4,0) \qquad \text{ and } \qquad \lim _{t \rightarrow 12^{+}} \mathcal {P}_v(t) = (2,-2), $$

an edge might create two or more surfaces (see Fig. 2c).

If the trajectory segments, considered as vectors, form an acute angle with respect to the positive time axis, this transformation is easily invertible. Thus, trajectory segments cannot fold back on themselves, as it would identify multiple positions for that node at a given time. We can then work on this continuous dynamic graph in 3D as if it were a static graph as follows:

$$\begin{aligned} D_a \ \rightarrow \ \text {STCT} \ \rightarrow \ D_a' \ \rightarrow \ \,\, Operation\,\, \ \rightarrow \ D_b' \ \rightarrow \ \text {STCT}^{-1} \ \rightarrow \ D_b \end{aligned}$$

4.2 Force-Directed Drawing Algorithm

Our force-directed algorithm is based on earlier variants by Simonetto et al. [46, 47]. As in most force-directed algorithms, after an initialization phase, the algorithm iteratively improves the current layout of the drawing in 3D for a given number of iterations in the following way:

  • For each iteration of the algorithm:

    • Compute and sum the forces based on the force system.

    • Move nodes based on these forces and the constraints.

    • Adjust trajectory complexity in the space-time cube.

Initialization. Each node v is randomly assigned a position (a, b) in the 2D plane. The points defining v’s trajectory are extruded linearly along the time axis (a, b, x), where x is the time coordinate.

Forces. DynNoSlice has five forces. The first three forces adapt standard, force-directed approaches to work with trajectories in the space-time cube. The final two are novel for continuous dynamic graph drawing. In our notation, a star transforms 3D vector to 2D by dropping the time coordinate. For example, if \(p=(1, 2, 3)\) then \(p^*\) is (1, 2). The parameter \(\delta \) is an ideal distance between two node trajectories.

1. Node Repulsion. This force repels trajectories from each other. The force evenly distributes node trajectories in space and prevents crowding [35, 42].

Fig. 3.
figure 3

Forces and constraints. (a) and (b) Node repulsion force between point a and the line segment \(c \rightarrow d\) that represents the trajectories of nodes u and v. (c) and (d) Edge attraction for an edge in the interval highlighted with yellow background. (e) Time movement restriction. Endpoints (a and c) must keep their assigned time coordinates. Bend b cannot move past half the distance with other bends or endpoints.

Full size image

For each segment endpoint a in the trajectory of node u and segment \(s_{v,j} = c \rightarrow d\) of node v, with \(u \ne v\), we compute the forces generated on the points a, c and d (see Fig. 3). If the points a, c and d are not collinear and (\(p \in s_{v,j}\)), they form a plane. In this case, we apply the force EdgeNodeRepulsion (\(\delta \)) described in previous work [47], except node positions are in 3D. If the points are collinear or the projection p of a does not fall in the segment \(s_{v,j}\) (\(p \notin s_{v,j}\)), we apply NodeNodeRepulsion(\(\delta \)) [47] between a and c and between a and d.

Since distant segments do not interact significantly, they can be ignored to reduce the running time. A multi-level interval tree is used to identify segments that are sufficiently close (<5\(\delta \)). All other pairs are ignored.

2. Edge Attraction. This attractive force pulls trajectories that are linked by an edge closer to each other. The force is exerted only for the intervals where the edge is present.

Let us consider an edge \(e = (u,v)\) that appears at interval \((t_1, t_2)\) and let \(I = (t_1 \tau , t_2 \tau )\) be the transformed time interval in the space-time cube with conversion factor \(\tau \) that transforms time into the third dimension of the space time cube. For each pair of segments \(s_{u,i} = a \rightarrow b\) and \(s_{v,j} = c \rightarrow d\) that overlap with the interval (f, g), we compute the points m, n of segment \(s_{u,i}\) and p, q of segment \(s_{v,j}\) so that:

$$\begin{aligned} \min \big \{f \in I : \exists m \in s_{u,i}, \ \exists p \in s_{v,j}, \ f = m[2] = p[2]\big \} \end{aligned}$$
$$\begin{aligned} \max \big \{g \in I : \exists n \in s_{u,i}, \ \exists q \in s_{v,j}, \ g = n[2] = q[2]\big \} \end{aligned}$$

where x[2] is the time coordinate of the point x in the space-time cube. We compute the attractive force between the points m and p, and n and q, using EdgeContraction (\(\delta \)) [47] (see Fig. 3c). This force is applied to the segment endpoints once scaled by its distance from the application point and by the coverage of the edge appearance on the segment (see Fig. 3d). For example, if the force \(F_m\) attracts m to p, then \(F_a\) applied to a will be:

$$\begin{aligned} F_a = F_m * \frac{a[2] - m[2]}{a[2] - b[2]} * \frac{n[2] - m[2]}{a[2] - b[2]}. \end{aligned}$$

3. Gravity. This force encourages a compact drawing of node trajectories. Let c be the center in 2D of the initial node placement in the space-time cube. The gravity F of each segment endpoint a is \(F = c^* - a^*\).

4. Trajectory Straightening. This force smooths node trajectories, helping with node movements over time. For trajectory bends, we use the CurveSmoothing [47] force, which pulls a bend b to the centroid of the triangle \(\varDelta abc\) formed by using the previous and next bends or endpoints a and c. A trajectory endpoint a has no such triangle. Therefore, it is pulled in 2D toward the midpoint of the segment formed with the closest bend or endpoint b.

5. Mental Map Preservation. This force prevents trajectory segments from making large angles with respect to time. When segments form a \({90}^{\circ }\) angle with time, a node essentially “teleports” from one place to another, while segments parallel to the time axis result in no node movement. Thus, segments should form small angles with the time axis. This force pulls endpoints a and b of each trajectory towards each other in 2D with a magnitude based on the angle \(\alpha \) the segment makes with the time axis:

$$\begin{aligned} F_a = (b^*-a^*) * \frac{\alpha }{{90}^{\circ } - \alpha } \end{aligned}$$

Constraints. Node movement constraints ensure valid drawing of the continuous dynamic graph in the space-time cube. In particular, constraints are needed to prevent undesired movements.

Decreasing Max Movement. We insert a constraint on the maximum node movement allowed at each iteration. This allows large movements at the beginning of the computation, and smaller refinements towards the end. This constraint is similar to DecreasingMaxMovement (\(\delta \)) [47].

Movement Acceleration. This constraint promotes consistent movements with previous iterations and penalizes movements in the opposite direction. This constraint corresponds to MovementAcceleration (\(\delta \)) [47].

Time Correctness. This constraint prevents a node from changing its time coordinate. Consider the trajectory formed by the segment \(t = a \rightarrow b\). If a changes its time coordinate in the space-time cube, the time of its appearance will also change. Now, consider a trajectory formed by several segments, \(t = a \rightarrow b \rightarrow c \rightarrow d\). The trajectory endpoints a and d, corresponding to the appearance and disappearance of the node, should have fixed time positions. However, bends b and c can move in time, so long as they do not pass each other (\(a[2]< b[2]< c[2] < d[2]\)) as this would result in a node being in two locations at once. Therefore, the movement \(M_a\) of node a in time is constrained to be: \(M_a \leftarrow M_a^*\) if a is the endpoint of a trajectory, and

$$\begin{aligned} M_b \leftarrow M_b * \max \left\{ r \in [0,1] : \frac{M_a[2] - M_b[2]}{2}< r M_b[2] < \frac{M_c[2] - M_b[2]}{2} \right\} \end{aligned}$$

if b is a trajectory bend between other bends or endpoints a and c (see Fig. 3e).

Complexity Adjustment of Node Trajectories. As bends move freely in time and space, node trajectories can be oversampled or undersampled. Therefore, bends can be inserted or removed from the polyline representing a node trajectory. If a segment of the trajectory between bends a and b is greater than a threshold (\(2\delta \) in this paper), a bend is inserted at its midpoint. Similarly, if two consecutive segments ab and bc are placed such that the distance between a and c is less than a threshold (\(1.5\delta \) in this paper), the bend b is removed and the two segments are replaced by ac.

5 Evaluation

We perform a metric-based evaluation of our approach against the state-of-the-art algorithm visone  [10] to demonstrate the advantages of our model.

5.1 Data Sets

InfoVis Co-Authorship (Discrete): a co-authorship network for papers published in the InfoVis conference from 1995 to 2015 [1]. Authors collaborating on a paper are connected in a clique at the time of publication of the paper. Note this is not a cumulative network as authors can appear, disappear, and appear again. The data is of discrete nature with exactly 21 timeslices (one per year).

Van De Bunt (Discrete): shows the relationships between 32 freshmen at seven different time points. A discrete dynamic graph is built using the method of Brandes et al.  [9], with an undirected edge inserted into a timeslice if the participants reciprocally report “best friendship” or “friendship” at that time.

Newcomb Fraternity Data (Discrete): contains the sociometric preference of 17 members of a fraternity in the University of Michigan in the fall of 1956 [39]. As in previous work [9], at each timeslice, we inserted undirected edges connecting students to their three best friends.

Rugby (Continuous): is a network derived from over 3,000 tweets involving teams in the Guinness Pro12 rugby competition. The tweets were posted between 09.01.2014 and 10.23.2015. Each tweet contains information about the involved teams and the time of publication with a precision down to the second.

Pride and Prejudice (Continuous): lists the dialogues between characters in the novel Pride and Prejudice in order [29]. The book has 61 chapters and the data set includes over 4,000 interactions between characters.

5.2 Method

As there are no continuous dynamic graph drawing algorithms, we need to compare our results with discrete dynamic graph drawing algorithms. In our metric evaluation, we considered three drawing approaches:

  • Visone (v) drawings were computed using the discrete version (timesliced) with visone  [10]. We use a linking strategy [9] with a default link length of 200 and a stability parameter \(\alpha =0.5\).

  • Discrete (d) drawings were computed using a modified version of DynNoSlice on the discrete version. Each trajectory bend coincides with a timeslice and bends cannot be inserted or removed. The rest of the algorithm is unaltered. We used \(\delta =1\) as the desired edge length parameter.

  • Continuous (c) drawings were computed using DynNoSlice. We used \(\delta =1\) as the desired edge length parameter.

We evaluate the results using a variety of metrics:

  • Stress: the average edge stress, as defined by Brandes and Mader [9, Formula 1]. As stress is defined for a static graph, we slice the space-time cube and average the stress computed on each timeslice.

  • Node Movement: the average 2D movements of the nodes. Intuitively, this is the average distance traveled by nodes when animating the dynamic graph.

  • Crowding: This metric counts the number of times nodes collide during the animation of the dynamic graph.

  • Running Time in seconds.

For continuous dynamic graphs, we can compute the stress of the nodes and edges present in the timeslice defined by the discrete dynamic graph or on the node and edge set at that precise point in continuous time. We can also compute stress between timeslices. Thus, we consider four measures of stress:

  • StressOn (d): the stress computed on the timeslices using the node and edge set of that timeslice.

  • StressOff (d): the stress computed on and between the default timeslices using the node and edge set of the closest timeslice in time, when between two timeslices.

  • StressOn (c): the stress computed on the timeslices using the precise node and edge appearances in continuous time.

  • StressOff (c): the stress computed on and between the timeslices using the precise node and edge appearances in continuous time.

Graph Scaling. Uniformly scaling node positions changes the measure of stress even though the layout is the same [27, 33, 40]. In order to compare methods as fairly as possible, we used a strategy where scale-independent values of stress are compared as follows. Both visone and DynNoSlice have a parameter that indicates the desired edge length. First, we verified that visone produces the same result (up to scale) when changing the edge length parameter. Thus, we use the default value of edge length but consider different scaling factors to compare to the output of our algorithm. For the experiment, we defined nodes to be circles of diameter 0.2 and with an ideal edge length of 1. To obtain such drawing with our approach, we run the algorithm with an ideal edge length parameter \(\delta =1\). To obtain such drawing with visone, we run it with the default edge length of 200 and scale it down by a factor 200.

Related work in static graph drawing [27, 33, 40] searches for the best scaling factor via binary search, as a minimum is guaranteed. For our metric (average stress across all timeslices) we have no such guarantee. Thus, we evaluate scaling factors \((1.1)^i\), with \(i \in \mathbb {Z}: -20< i < 20\) for the best StressOn(d) value. This scaling factor is used to compute all metrics. After plotting the average stress for each data set, a minimum in this range was consistently observed.

Table 1. Results for the discrete data sets on our metrics.
Full size table

5.3 Results

Videos of Newcomb, Rugby, and Pride and Prejudice are availableFootnote 2. In this section, we present our quantitative results.

visone is often faster than our continuous approach as DynNoSlice operates on a greater volume of data – the data between timeslices. The discrete version of DynNoSlice is often slower than both, as the continuous approach is more naturally expressed without timeslices. Therefore, there is a penalty for imposing timeslices on it.

Table 1 shows the results on the discrete data sets. Continuous stress metrics are not computed, because nodes and edges only appear on timeslices. In the VanDeBunt and Newcomb data sets, visone outperforms DynNoSlice in terms of stress. Movement and crowding are comparable among all three approaches. Our continuous approach is sometimes able to improve on visone when stress is computed off timeslices. When comparing the discrete and continuous versions of DynNoSlice, our discrete version is often able to optimize on-timeslice stress. InfoVis is an outlier for the timesliced data sets. In particular, our continuous approach outperforms visone in terms of stress.

Table 2 shows the results of our metric experiment on the continuous data sets. Our continuous approach has lower off-timeslice stress, lower average movement, fewer crowding events, and occasionally lower on-timeslice stress.

Table 2. Results for the continuous data sets on our metrics.
Full size table

5.4 Discussion

Our results on the discrete data sets were expected: visone optimizes for stress directly on every timeslice and so outperforms our force system in terms of stress, while it is comparable in terms of movement and crowding. As a state-of-the-art algorithm for timesliced graph drawing, it is difficult to compete with visone when it is running on the type of data for which it was designed. However, when stress is measured off the timeslices, our continuous approach often outperforms visone. The timesliced model does not allow for stress to be optimized between timeslices and must resort to linear interpolation, leading to suboptimal stress. In our continuous dynamic graph model, we optimize for stress in continuous time, leading to this performance improvement. The InfoVis data set is an exception where DynNoSlice is able to improve on visone in terms of stress. This result could be due to the bursty nature of this graph (edges are only present if two authors published a joint paper that year). Therefore, large parts of the graph change drastically from year to year. Allowing node trajectories to evolve independently of timeslices may allow DynNoSlice to perform better.

For nearly all continuous data sets, our continuous model often outperforms visone in terms of stress, movement, and crowding. This is likely due to the fact we do not use timeslices to compute the layout of the dynamic graph. As a result, we are able to optimize stress between timeslices as well. On-timeslice stress is an exception, as it is directly optimized by visone.

It is surprising that our continuous dynamic graph drawing algorithm simultaneously improves node movement and crowding while remaining competitive or improving on stress. This finding may seem counter-intuitive as low stress usually corresponds to high node movement. This result can be explained by the fact that nodes in our continuous models are polylines of adaptive complexity in the space-time cube. Nodes with few interactions in the data will be long straight lines, potentially passing through many timeslices. These areas of low complexity will reduce average node movement. In a model that uses timeslices, each timeslice is forced to have that node with inter-timeslice edges. Therefore, timeslices impose additional node movement that may not be necessary.

In terms of crowding, the continuous model allows the polyline representing a node to adapt its complexity between timelices if there are many interactions. When there are many changes to the graph in a short period of time, these polylines have increased complexity, allowing nodes to avoid crowding. In a timesliced model, only linear interpolation is possible, and all nodes must follow straight lines. Thus, crowding is incurred. Crowding is also avoided in our continuous model as our polylines have repulsive forces between them. In all timeslice approaches, inter-timeslice edges do not repel each other, potentially causing crowding events.

6 Conclusions and Future Work

We presented a model for dynamic graph drawing without timeslices in which nodes and edges, along with their attributes, are defined on continuous time intervals. We developed a dynamic graph drawing algorithm, DynNoSlice, that visualizes graphs in this model by working on the space-time cube. An implementation of this algorithm is available along with a video. In our evaluation, we demonstrate that our continuous approach has significant advantages over timeslicing the continuous data.

The focus of this paper is a method to draw dynamic graphs without timeslices. An animation of a slice traversing the layout in the space-time cube is a natural visualization. However, animation is not always effective in terms of human performance [4, 22, 48], especially when events are of short duration. More effective visual representations the layout present in the space-time cube are necessary.

The primary issue that we have found with collapsing continuous time down onto a series of timeslices is that the timeslices could oversample/undersample the data in the continuous dimension. In signal processing, the Nyquist frequency gives the minimum sampling rate required to reconstruct the signal. Regular timeslices taken a the smallest temporal distance between two events should be sufficient to avoid undersampling, but lower sampling frequencies could be possible and remain future work.