Crossing Minimization in Time Interval Storylines

TL;DR

This paper introduces new models and algorithms for creating storyline visualizations that handle grouped time intervals, aiming to reduce crossings and space usage, and evaluates their effectiveness on benchmarks.

Contribution

It proposes a novel model for storylines with time intervals and two algorithms to minimize crossings and space, addressing limitations of previous methods assuming total orderings.

Findings

Algorithms effectively reduce crossings in storylines.

Methods decrease horizontal space in visualizations.

Evaluation shows improved visualization clarity.

Abstract

Storyline visualizations are a popular way of visualizing characters and their interactions over time: Characters are drawn as x-monotone curves and interactions are visualized through close proximity of the corresponding character curves in a vertical strip. Existing methods to generate storylines assume a total ordering of the interactions, although real-world data often do not contain such a total order. Instead, multiple interactions are often grouped into coarser time intervals such as years. We exploit this grouping property by introducing a new model called storylines with time intervals and present two methods to minimize the number of crossings and horizontal space usage. We then evaluate these algorithms on a small benchmark set to show their effectiveness.

Tables

Table 1. Table 1 : Statistics for the input data sets. The column | ℒ | ℒ |\mathcal{L}| -coloring shows the number of layers achieved by the graph coloring pipeline step, which is used for the algorithms P s subscript P s \mathrm{P_{s}} , P p subscript P p \mathrm{P_{p}} , ILP1ML ILP1ML \mathrm{ILP1ML} , and ILP2ML ILP2ML \mathrm{ILP2ML} .

	$\left|ℐ\right|$	$\left|𝒞\right|$	$\left|T\right|$	$\left|ℒ\right|$-coloring
gdea10	41	9	16	35
gdea20	100	19	17	47
ubiq1	41	5	19	41
ubiq2	45	5	18	38
anna1	58	41	34	53
jean1	95	40	65	88
huck	107	74	43	81

Table 2. Table 2 : The number of crossings achieved by the different algorithms for all the datasets. If a number is red, then the approach timed out and we only report the best upper bound of a feasible solution given by the ILP solver.

	$P_s$	$P_p$	$\mathrm{ILP1}$	$\mathrm{ILP1ML}$	$\mathrm{ILP2}$	$\mathrm{ILP2ML}$
gdea10	6	6	7	7	6	6
gdea20	38	38	44	42	796	34
ubiq1	10	9	10	10	8	8
ubiq2	19	17	15	15	14	15
anna1	19	19	23	23	16	16
jean1	12	12	23	25	3	3
huck	44	42	58	55	59	45

Table 3. Table 3 : The runtime for the different algorithms and datasets in seconds. If an approach timed out (3600 s 𝑠 s ), we report the relative gap between best lower and upper bound in percent given by the ILP solver in red. If the gap is 100% then no lower bound greater than zero was found, otherwise it is calculated as ( UB − LB ) / UB UB LB UB (\textsc{UB}-\textsc{LB})/\textsc{UB} where UB is the upper bound and LB is the lower bound.

	$P_s$	$P_p$	$\mathrm{ILP1}$	$\mathrm{ILP1ML}$	$\mathrm{ILP2}$	$\mathrm{ILP2ML}$
gdea10	4	4	32	10	40	12
gdea20	114	141	100%	88%	100%	91%
ubiq1	3	3	45	45	24	25
ubiq2	4	4	1039	176	1291	281
anna1	16	16	1826	330	1108	289
jean1	19	19	95%	92%	100%	33%
huck	136	127	84%	78%	95%	73%

Equations

$$\sum _{\ell \in {\mathcal{L}}_t}{y}_{\ell ,I}$$

$$y_{\ell ,I}+y_{\ell ,I^{\prime }}$$

$$0\le x_{\ell ,c_h,c_i}+x_{\ell ,c_i,c_j}-x_{\ell ,c_h,c_j}$$

$$x_{\ell ,c_i,c_k}$$

$$x_{\ell ,c_j,c_k}$$

$$x_{\ell ,c_k,c_i}$$

$$x_{\ell ,c_k,c_j}$$

$$x_{\ell ,c_i,c_k}$$

$$x_{\ell ,c_k,c_j}$$

$$z_{\ell ,c_i,c_j}\ge x_{\ell ,c_i,c_j}-x_{{\ell }^{\prime },c_i,c_j}$$

$$z_{\ell ,c_i,c_j}\ge x_{{\ell }^{\prime },c_i,c_j}-x_{\ell ,c_i,c_j}$$

$$a_{c,\ell }$$

$$a_{c,{\ell }^{\prime }}+1$$

$$z_{\ell ,c_i,c_j}\ge x_{\ell ,c_i,c_j}-x_{{\ell }^{\prime },c_i,c_j}-4+a_{c,\ell }+a_{c,{\ell }^{\prime }}+a_{c^{\prime },\ell }+a_{c^{\prime },{\ell }^{\prime }}$$

$$z_{\ell ,c_i,c_j}\ge x_{{\ell }^{\prime },c_i,c_j}-x_{\ell ,c_i,c_j}-4+a_{c,\ell }-a_{c,{\ell }^{\prime }}+a_{c^{\prime },\ell }+a_{c^{\prime },{\ell }^{\prime }}$$

Full text

1 Introduction

Storyline visualizations are a popular way of visualizing characters and their interactions through time. They were popularized by Munroe’s xkcd comic [13] (see Fig. 1 for a storyline describing a movie as a series of scenes through time, in which the characters participate). A character is drawn using an $x$-monotone curve, and the vertical ordering of the character curves varies from left to right. A scene is represented by closely gathering the curves of characters involved in said scene at the relevant spot on the $x$-axis, which represents time. Storylines attracted significant interest in visualization research, especially the question of designing automated methods to create storylines adhering to certain quality criteria [12, 14, 16].

While different design optimization goals can be specified, most theoretical research has been focused on crossing minimization [8, 11] and variants like block crossing minimization [17, 18]. This problem is \NP-hard [11, 17] and is commonly solved using ILP and SAT formulations [8, 18]; it has many similarities with the metro line crossing minimization problem [2, 1, 4, 3]. Recently a new model for storylines was proposed by Di Giacomo et al. [7] that allows for one character to be part of multiple interactions at the same point in time, by modeling each character as a tree rather than a curve. Using this model, it is possible to represent data sets which have a more loosely defined ordering of interactions. Furthermore, authorship networks have been a popular application for storylines visualizations [7, 10]. In this paper we introduce time interval storylines, an alternative approach to visualize data sets with less precise temporal attributes. In the time interval model, a set of discrete, totally ordered timestamps is given, which serve to label disjoint time intervals (e.g., the timestamp 2021 represents all interactions occurring between January and December of the year 2021). Each interval is represented in a storyline as a horizontal section in which all interactions with the same timestamp occur. The horizontal ordering within this section, however, does not correspond to a temporal ordering anymore (see Fig. 2). For example, an authorship network often sorts publications by year. In a traditional storyline model, the complete temporal ordering of the interactions must be provided. Previous models like the one by van Dijk et al. [18] can place multiple disjoint interactions in the same vertical layer, but the assignment of interactions to the totally ordered set of layers must be given as input. Unlike the traditional model, we have no pre-specified assignment of interactions to layers, but interactions with the same timestamp can be assigned to any layer within the time interval of this timestamp.

Problem setting.

We are given a triple $\mathcal{S}=(\mathcal{C},\mathcal{I},T)$, of characters $\mathcal{C}=\{c_{1},\dots,c_{n}\}$, interactions $\mathcal{I}=\{I_{1},\dots,I_{m}\}$, and totally ordered timestamps $T=\{t_{1},\dots,t_{p}\}$ as input. Each interaction $(C_{j},t)=I_{j}\in\mathcal{I}$ consists of a set $C_{j}\subseteq\mathcal{C}$ of characters involved in the interaction and a timestamp $t\in T$ at which the interaction $I_{j}$ occurred, respectively denoted by $\texttt{char}(I_{j})=C_{j}$ and $\texttt{time}(I_{j})=t$. A subset of interactions can form a layer $\ell$, when for every pair of interactions $I,I^{\prime}$ in $\ell$, $\texttt{time}(I)=\texttt{time}(I^{\prime})$. A time interval storyline is composed of a sequence of layers to which interactions are assigned. Intuitively, a layer represents a column in the storyline visualization, in which interactions are represented as vertical stacks. Thus, to each layer we associate a vertical ordering of $\mathcal{C}$. Consider the set $S$ containing all interactions with timestamp $t$, we call the union of layers containing $S$ a slice.

Characters are represented with curves passing through each layer at most once. To represent an interaction $I=(C,t)$ in a layer $\ell$, the ordering of the characters in $\ell$ must be such that the characters of $C$ appear consecutively in that ordering. For a pair $I,I^{\prime}$ of interactions in the same layer, it must hold that $\texttt{char}(I)\cap\texttt{char}(I^{\prime})=\emptyset$.

For a layer $\ell$, we denote the set of interactions by $\texttt{inter}(\ell)$ and the timestamp of a layer by $\texttt{time}(\ell)$ (with slight abuse of notation). We focus on combinatorial storylines, as opposed to geometric storylines, meaning that our algorithm should output a (horizontal) ordering $o_{L}(\mathcal{S})$ of layers, and for each layer $\ell$, a (vertical) ordering $o_{c}(\ell)$ of the characters, and all interactions must occur in some layer. For two interactions $I,I^{\prime}$ such that $\texttt{time}(I)<\texttt{time}(I^{\prime})$, let $\ell$ and $\ell^{\prime}$ be the layers of $I$ and $I^{\prime}$, respectively. Then $\ell$ must be before $\ell^{\prime}$ in $o_{L}(\mathcal{S})$. A character is active in a layer if it appears in the character ordering for that layer. A character must be active in a contiguous range of layers including the first and last interaction it is involved in. A character is active in a layer if it appears in the character ordering for that layer.

Contributions.

In this paper we introduce the time interval storylines model, as well as two methods to compute layer and character orderings. In Section 2.1 we introduce an algorithmic pipeline based on ILP formulations and heuristics that computes time interval storylines. We further present an ILP formulation that outputs a crossing-minimal time interval storyline in Section 2.2. Lastly in Section 3, we experimentally evaluate our pipeline and ILP formulation.

2 Computing combinatorial storylines

2.1 A pipeline heuristic

As the traditional storyline crossing minimization problem is a restricted version of the time interval formulation, our problem is immediately \NP-hard [11]. Thus, we first aim to design an efficient heuristic to generate time interval storylines, which consists of the following stages.

1. (i)

Initially, we assign each interaction to a layer, 2. (ii)

then, we compute a horizontal ordering $o_{L}(\mathcal{S})$ of the layers obtained in step (i), and 3. (iii)

finally, we compute a vertical ordering $o_{c}(\ell)$ of the characters for each layer $\ell\in o_{L}(\mathcal{S})$.

For step (i), the assignment is obtained using graph coloring. For each $t\in T$, we create a conflict graph $G_{t}=(\mathcal{I}_{t},E)$ where $\mathcal{I}_{t}\subseteq\mathcal{I}$ and $I\in\mathcal{I}_{t}$ if and only if $\texttt{time}(I)=t$. Two interactions are connected by an edge if they share at least one character. Each color class then corresponds to a set of interactions which share no characters and can appear together in a layer. We solve this problem using a straightforward ILP formulation based on variables $x_{v,c}=1$ if color $c$ is assigned to vertex $v$ and [math] otherwise. We can choose to limit the size of each color class by adding an upper bound on the number of interactions assigned to each color, which forces fewer interactions per layer. While this allows us to limit the height of each slice, it likely results in more layers.

To compute a horizontal ordering of the layers in step (ii), we use a traveling salesperson (TSP) model. Concretely, for the slice corresponding to the timestamp $t$, we create a complete weighted graph $G=(\mathcal{L},E)$, where $\mathcal{L}$ corresponds to all the layers $\ell$ such that $\texttt{time}(\ell)=t$. For each edge $e$ between a pair of layers $\ell$ and $\ell^{\prime}$ in $\mathcal{L}$, we associate a weight $w_{e}$, estimating the number of crossings that may occur if the two layers are consecutive as follows.

Minimizing the crossings of the curves representing the characters is \NP-complete [6, 11], thus we propose two heuristics to estimate the number of crossings. First, we propose to use set similarity measures to describe how similar the interactions in two layers $\ell$ and $\ell^{\prime}$ are: If $\ell$ and $\ell^{\prime}$ both have an interaction that contains the same set of characters, then no crossing should be induced by the curves corresponding to those characters, when these two layers are consecutive (see Fig. 3a). Second, we consider pattern matching methods that guess how many crossings could be induced by a certain ordering of the characters. There are certain patterns of interactions between two layers for which a crossing is unavoidable (see Fig. 3b). We count how many of these patterns occur between each pair of layers in $G$ and set the weight of the corresponding edge to that crossing count.

Set similarity.

We propose the use of the Rand index to evaluate how similar two layers are to one another. For the layers $\ell$ and $\ell^{\prime}$, the Rand index is calculate in the following manner.

• •

We count how many character pairs are together in an interaction in $\ell$ and $\ell^{\prime}$ ($n_{1}$).

• •

We count how many character pairs are in different interactions in $\ell$ and in $\ell^{\prime}$ ($n_{2}$).

• •

We count how many character pairs are in different interactions in $\ell$ and in the same interaction in $\ell^{\prime}$ ($n_{3}$).

• •

We count how many character pairs are together in an interaction in $\ell$ and not in $\ell^{\prime}$ ($n_{4}$).

The Rand index [15] is then given by the value $\frac{n_{1}+n_{2}}{n_{1}+n_{2}+n_{3}+n_{4}}$. If this value is closer to one then most interactions between $\ell$ and $\ell^{\prime}$ have a similar set of characters.

Pattern matching.

Consider the four interactions $I_{1},I_{2},I_{3},I_{4}$, all having timestamp $t$. We set $\texttt{char}(I_{1})={a,b}$, $\texttt{char}(I_{2})={c,d}$, $\texttt{char}(I_{3})={a,c}$ and $\texttt{char}(I_{4})={b,d}$. Naturally these four cannot be in the same layer, so we assume $I_{1}$ and $I_{2}$ are in layer $\ell_{1}$ and $I_{3}$ and $I_{4}$ are in layer $\ell_{2}$. Then, if $\ell_{1}$ and $\ell_{2}$ are consecutive, there is necessarily a crossing induced by the curve of actor $b$ and $c$ or $a$ and $d$. We count how often this pattern occurs between each layer pair in the same slice.

To finish step (ii), we solve the path formulation of the TSP problem on $G$ and find a horizontal ordering of the layers for each time slice. We have now obtained a traditional storyline, in which each interaction belongs to a specific layer, and all layers are totally ordered. Thus, we can solve step (iii) using the state-of-the-art crossing minimization ILP by Gronemann et al. [8].

We call the pipeline variants $\mathrm{P_{s}}$ and $\mathrm{P_{p}}$, when using the set similarity heuristic and the pattern matching heuristic in step (ii), respectively.

2.2 ILP formulations

Crossing minimization in storylines is generally solved using ILP formulations [8, 17]. We propose two formulations to handle slices, which build on the ideas of Gronemann et al. [8]. Both formulations will give us an assignment of interactions to layers, that are already totally ordered, and an ordering of characters per layer. For each timestamp $t\in T$, let $\mathcal{L}_{t}$ be a set of $|\{I\mid\texttt{time}(I)=t\}|$ layers corresponding the number of interactions at $t$, and let $\mathcal{L}=\bigcup_{t\in T}\mathcal{L}_{t}$. In the first formulation we assume that a character $c$ is active in all layers between the first timestamp and last timestamp, inclusively, where there exists an interaction $I$ such that $c\in\texttt{char}(I)$. In the second formulation we will introduce additional variables that model whether a character really needs to be active, since, in fact, character curves do not need to be active before their first interaction or after their last interaction. In contrast to the pipeline approach, the presented ILP formulations are able to find the crossing-minimal solution for the explored search space. For both formulations we also present an adaptation that allows for the minimum number of layers.

First formulation.

Let $\mathcal{C}_{\ell}$ be the characters that appear in layer $\ell\in\mathcal{L}$, as discussed before. First we introduce for each $t\in T$ the binary variables $y_{\ell,I}$ for $\ell\in\mathcal{L}_{t}$ and $I\in\mathcal{I}$ where $\texttt{time}(I)=t$. These should be one iff interaction $I$ is assigned to layer $\ell$. This is realized by constraints of type (1). If two different interactions $I$ and $I^{\prime}$ share a character they cannot be in the same layer, realized by type (2) constraints.

[TABLE]

Next we introduce binary ordering variables $x_{\ell,c_{i},c_{j}}$ for each layer $\ell\in\mathcal{L}$ and $c_{i},c_{j}\in\mathcal{C}_{\ell}$ with $i<j$. Variable $x_{\ell,c_{i},c_{j}}$ should be one iff $c_{i}$ comes before $c_{j}$ on layer $\ell$. Standard transitivity constraints (3) (see e.g. [9]) ensure that the binary variables induce a total order.

[TABLE]

The crux is now to model the assignment of some interaction $I$ to some layer $\ell$, linking the $x$- and $y$-variables together. This is done with so-called tree-constraints [8]: Let $\ell\in\mathcal{L}_{t}$, $I\in\mathcal{I}$ with $\texttt{time}(I)=t$ and $c_{i},c_{j},c_{k}\in\mathcal{C}_{\ell}$ such that $i<j$, $c_{i},c_{j}\in\texttt{char}(I)$, and $c_{k}\not\in\texttt{char}(I)$. If $i<j<k$ we add constraints (4) and (5), which ensure that $c_{k}$ is either before or after both $c_{i}$ and $c_{j}$.

[TABLE]

Similarly, if $k<i<j$ we add constraints of type (6) and (7).

[TABLE]

Lastly, if $i<k<j$ we add constraints of type (8) and (9).

[TABLE]

Lastly, to optimize the number of crossings we have to provide an objective function. For this we introduce binary variables $z_{\ell,c_{i},c_{j}}$ for all layers $\ell$ but the rightmost one and all $c_{i},c_{j}\in\mathcal{C}_{\ell}\cap\mathcal{C}_{\ell^{\prime}}$ where $\ell^{\prime}$ is the adjacent layer of $\ell$ to the right. Variable $z_{\ell,c_{i},c_{j}}$ should be one iff the character lines of $c_{i}$ and $c_{j}$ cross between layers $\ell$ and $\ell^{\prime}$. Linking variables $z_{\ell,c_{i},c_{j}}$ is done by introducing the constraints corresponding to setting z_{\ell,c_{i},c_{j}}\geq x_{\ell,c_{i},c_{j}}{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\oplus}x_{\ell^{\prime},c_{i},c_{j}} where $x\oplus y$ denotes the exclusive-or relation of two binary variables $x$ and $y$. This is done with the following constraints.

[TABLE]

The objective is then to simply minimize $\sum z_{\ell,c_{i},c_{j}}$. A solution to the ILP model is then transformed into a storyline realization of the input. We call this formulation $\mathrm{ILP1}$.

In the above formulation we have one layer for each interaction, which does not utilize the potential of having multiple interactions in one layer. We can, however, minimize the number of layers beforehand, using the graph coloring problem as in Section 2.1. If we need $q$ colors for timestamp $t$, we let $\mathcal{L}_{t}$ only consist of $q$ layers. This can of course result in more crossings in the end. We call this adapted formulation $\mathrm{ILP1ML}$.

Second Formulation.

In the above models $\mathrm{ILP1}$ and $\mathrm{ILP1ML}$ a character was contained in all layers of the first and last timestamp that contains an interaction, in which the character appears. We also present a second ILP formulation called $\mathrm{ILP2}$ that accounts for the active range of a character. This formulation contains the same variables as $\mathrm{ILP1}$ plus the binary variables $a_{c,\ell}$ for all $c\in\mathcal{C}$ and all $\ell\in\mathcal{L}$ such that $c\in\mathcal{C}_{\ell}$. If $c\in C_{\ell}$ this does not mean that $c$ will be in layer $\ell$ when transforming a solution of the ILP to a storyline realization. This is only the case if additionally $a_{c,\ell}$ is one. The formulation $\mathrm{ILP2}$ contains the constraints for layers (1) and (2), the transitivity-constraints (3), the tree-constraints (4),(5), and (6)-(9), and the objective function from formulation $\mathrm{ILP1}$. Additionally, it contains the following constraints. First, if character $c$ appears in some interaction $I$ that is present in layer $\ell$, then $c$ has to be active in $\ell$ (see (12)).

[TABLE]

Now for each three different layers $\ell,\ell^{\prime}$, and $\ell^{\prime\prime}$ such that $\ell$ appears first, $\ell^{\prime}$ appears second, and $\ell^{\prime\prime}$ appears third in the ordering of layers, let $c\in\mathcal{C}_{\ell}\cap\mathcal{C}_{\ell^{\prime}}\cap\mathcal{C}_{\ell^{\prime\prime}}$. We have to ensure that if $c$ is active in $\ell$ and $\ell^{\prime\prime}$, it also has to be active in $\ell^{\prime}$, done with constraints of type (13).

[TABLE]

Lastly, we only have to count crossings between two character lines in two layers, if both characters are active in the corresponding layers. Hence, let $c$ and $c^{\prime}$ be two different characters and let $\ell$ and $\ell^{\prime}$ be two consecutive layers such that $c,c^{\prime}\in\mathcal{C}_{\ell}\cap\mathcal{C}_{\ell^{\prime}}$. We transform the xor-constraints (10) and (11) into the new constraints (14) and (15). Notice that none of the constraints have an effect on the $z$-variable, if at least one of the $a$-variables is zero.

[TABLE]

We can then introduce the fewest possible number of layers as for $\mathrm{ILP1}$, resulting in formulation $\mathrm{ILP2ML}$.

3 Experimental Evaluation

We performed a set of experiments to evaluate all of our presented algorithms. In the following we describe the datasets, implementation and setup, and elaborate on the results.

3.1 Datasets

Our dataset consists of 7 instances provided by different sources. All of them come from work on storyline visualizations. General statistics on these datasets can be found in Table 1. The datasets gdea10 and gdea20 are from the work of of Gronemann et al. [8] and consist of a set of publications from 1994 to 2019. These publications are the interactions and the characters are the union of all authors of these publications. The years of interactions are set as their timestamps. Similarly, datasets ubiq1 and ubiq2 is publication data of a work by Giacomo et al. [7] on storylines with ubiquituous characters. Interactions, characters, and timestamp are determined as in the gdea10 and gdea20 datasets. The last three datasets are interactions between characters of a book. These consist of the first chapter of Anna Karenina (anna1), the first chapter of Les Misérables (jean1), and the entirety of Huckleberry Finn (huck). The timestamps of interactions are taken as the scenes of the book (or chapter).

3.2 Implementation and Setup

All implementations were done in Python3. For the graph coloring step of the algorithms we used a simple ILP formulation. For the TSP formulation in the algorithms $\mathrm{P_{p}}$ and $\mathrm{P_{s}}$ we used a simple subtour elimination formulation. As the graph coloring and TSP steps of our algorithms take negligible time when compared to the crossing minimization, we do not provide more details here.

All ILP formulations in the algorithms $\mathrm{P_{p}}$ and $\mathrm{P_{s}}$ were solved using CPLEX 22.1 and were run on a local machine with Linux and an Intel i7-8700K 3.70GHz CPU. All formulations in the algorithms $\mathrm{ILP1}$, $\mathrm{ILP1ML}$, $\mathrm{ILP2}$, and $\mathrm{ILP2ML}$ were solved using Gurobi 9.5.1 and were run on a cluster with an AMD EPYC 7402, 2.80GHz 24-core CPU. No multithreading was used in any algorithm.

The timeout for all algorithms was set to 3600 seconds. If we run into a timeout during one of our algorithms we report the best feasible solution (in Table 2) and the gap to the best lower bound found by the ILP solver (in Table 3).

3.3 Results

Next, we provide the results on layer minimization, number of crossings and runtime. Examples for storylines produced by our algorithms are given in Section 3.4.

Layer minimization.

Table 1 shows the number of layers that was achieved by the graph coloring pipeline step ($|\mathcal{L}|$-coloring). The layer minimization step is applied by the algorithms $\mathrm{P_{s}}$, $\mathrm{P_{p}}$, $\mathrm{ILP1ML}$, and $\mathrm{ILP2ML}$. When comparing these numbers with the upper bound of the number of interactions $|\mathcal{I}|$ we can see that for some of the datasets we could reduce the number of layers significantly. There is only one dataset where we could not reduce the number of required layers.

Crossings.

Table 2 shows the number of crossings for all algorithms and datasets. If an algorithm times out we provide the number of crossings for the best feasible solution. We can see that the ILP-formulations produce fewer crossings than the pipeline-approaches whenever they do not time out. Further, even if they time out, sometimes the best feasible solution is better than the solution produced by the pipeline-approaches. It is also the case that the ILP formulations $\mathrm{ILP2}$ and $\mathrm{ILP2ML}$ using activity-variables achieve fewer crossings than the formulations $\mathrm{ILP1}$ and $\mathrm{ILP1ML}$ without these additional variables. Another interesting observation is that the layer minimization does not have a negative effect on the number of crossings in most cases (see $\mathrm{ILP1}$vs. $\mathrm{ILP1ML}$ and $\mathrm{ILP2}$ vs. $\mathrm{ILP2ML}$). The size of the solution space depends on the combination of number of characters, number of interactions, and number of layers, so it is hard to quantify the effect of a single input parameter onto the runtime. But generally, the increase of any of these parameters also increases the solution space and thus also the runtime of our algorithms.

Runtime.

Table 3 reports the runtimes of the algorithms. If an algorithm times out then we report the gap between the best feasible solution and best lower bound found by the solver. As expected, the runtimes of the ILP-algorithms are much higher than the pipeline-algorithms. Further, minimizing the number of layers seems to positively affect the runtime of the ILP-approaches. This is due to the fact that having less layers also reduces the search space of the ILP-formulations. The optimality gaps of the ILP-approaches on instances that timed out are quite high, so we do not expect that the solvers would find an optimal solution for these instances in a feasible time. Additional experiments even showed that most of these instances could not be solved by our ILP-formulations optimally even after one week.

3.4 Example Storylines

Figure 4 show storylines created by the different algorithms and the anna1 dataset. We have applied a simple wiggle-height minimization post-processing algorithm to the purely combinatorial output of our algorithms. This post-processing algorithm assigns actual $x$- and $y$-coordinates to the character lines, and is based on a similar approach that was applied to drawing directed graphs [5]. Notice that in the outputs for $\mathrm{ILP1}$ and $\mathrm{ILP1ML}$ character lines sometimes start before their first interaction and end before their last interaction. This is never the case for all other algorithms. But those algorithms have the problem, that character curves are often very short, making it hard to follow these curves. Further, some characters only appear for one layer (see the last layer of all shown storylines). In follow-up visualizations we should add some offset to these curves so they are visible. We do not dare to give a qualitative judgement about which of the visualizations looks best, but generally the visual clarity of the visualizations is increased due to having few crossings.

4 Conclusion

We introduced storylines with time intervals, which capture many real-world datasets, such as authorship networks with multiple papers per year. We also provide two methods to compute the vertical and horizontal orderings in these storylines. Preliminary experiments show that these storylines allow for more effective width-minimization, by assigning multiple interactions to one (vertical) layer, and more effective crossing-minimization, by exploiting different horizontal orderings of interactions. Further research directions include optimizing our current methods and extending the model further, for example with overlapping slices.