On Minimizing Crossings in Storyline Visualizations

Transcription

1 On Minimizing Crossings in Storyline Visualizations Irina Kostitsyna Martin No llenburg Valentin Polishchuk Andre Schulz Darren Strash CC BY-NC 2.5 Kostitsyna, No llenburg, V.and Polishchuk, A. Schulz, KIT I. University of the StateM. of Baden-Wuerttemberg National of the Helmholtz Association OnLaboratory Minimizing Crossings in Storyline Visualizations D. Strash:

2 Storyline Visualizations Input: A story (e.g., movie, play, etc.): set of n characters and their interactions over time (m meetings) Output: Visualization of character interactions x-axis! time Characters! curves monotone w.r.t time (no time travel) Curves converge during an interaction, and diverge otherwise a b c d time

3 Storyline Visualizations Input: A story (e.g., movie, play, etc.): set of n characters and their interactions over time (m meetings) Output: Visualization of character interactions x-axis! time Characters! curves monotone w.r.t time (no time travel) Curves converge during an interaction, and diverge otherwise a b c Meetings have start and end times d time

4 Previous Results Draw pretty pictures! minimize crossings between curves NP-hard in general! reduction from BIPARTITE CROSSING NUMBER! In practice: Layered graph drawing! try permutations of curve ordering [Sugiyama et al. 8] Heuristics to minimize crossings, wiggles, and gaps [Tanahashi et al. 2, Muelder et al. 3] 2

5 Towards a Theoretical Understanding of Storylines Almost no existing theoretical results! Many interesting questions... Among them: Can we bound the number of crossings? Fixed-parameter tractable (FPT) for realistic inputs? 3

6 Towards a Theoretical Understanding of Storylines Almost no existing theoretical results! Many interesting questions... Among them: Can we bound the number of crossings? Yes! We show: matching upper and lower bounds for a special case Fixed-parameter tractable (FPT) for realistic inputs? Yes! We show:! FPT on # characters k 3

7 Pairwise One-Time Meetings We consider a special case: meetings are restricted to two characters these characters meet only once Event graph: characters! vertices, meetings! edges a pairwise one-time meetings a event graph b b c d d c 4

8 Pairwise One-Time Meetings We consider a special case: meetings are restricted to two characters these characters meet only once Event graph: characters! vertices, meetings! edges a pairwise one-time meetings a event graph b b c d d c We further restrict to the case where the event graph is a tree. 4

9 Algorithm for O(n log n) Crossings Intuition: Full binary tree can be drawn with O(n log n) crossings Achieve the same bound for arbitrary trees using a heavy path decomposition 5

10 Algorithm for O(n log n) Crossings Intuition: Full binary tree can be drawn with O(n log n) crossings Achieve the same bound for arbitrary trees using a heavy path decomposition 5

11 Algorithm for O(n log n) Crossings Intuition: Full binary tree can be drawn with O(n log n) crossings Achieve the same bound for arbitrary trees using a heavy path decomposition 5

12 Algorithm for O(n log n) Crossings Intuition: Full binary tree can be drawn with O(n log n) crossings Achieve the same bound for arbitrary trees using a heavy path decomposition 5

13 Algorithm for O(n log n) Crossings Intuition: Full binary tree can be drawn with O(n log n) crossings Achieve the same bound for arbitrary trees using a heavy path decomposition 5

14 Algorithm for O(n log n) Crossings Intuition: Full binary tree can be drawn with O(n log n) crossings Achieve the same bound for arbitrary trees using a heavy path decomposition Observation: Build bottom-up! draw subtree and connect with root. 5

15 Heavy-Path Decomposition Heavy edge := child subtree > /2 parent subtree Light edge := otherwise Key property: O(log n) light edges on any root-leaf path

16 Heavy-Path Decomposition Heavy edge := child subtree > /2 parent subtree Light edge := otherwise Key property: O(log n) light edges on any root-leaf path Treat heavy paths as single unit 6

17 Heavy-Path Decomposition Heavy edge := child subtree > /2 parent subtree Light edge := otherwise Key property: O(log n) light edges on any root-leaf path Treat heavy paths as single unit Key idea: Draw light subtrees, then connect roots 6

18 Drawing Tree Event Graphs Draw each light subtree in an axis-aligned rectangle 7

19 Drawing Tree Event Graphs Draw each light subtree in an axis-aligned rectangle Order light children vertically by start time of meeting with root 7

20 Drawing Tree Event Graphs Draw each light subtree in an axis-aligned rectangle Order light children vertically by start time of meeting with root 7

21 Drawing Tree Event Graphs Draw each light subtree in an axis-aligned rectangle Order light children vertically by start time of meeting with Introduce detours : connect roots on heavy path root 7

22 Drawing Tree Event Graphs Draw each light subtree in an axis-aligned rectangle Order light children vertically by start time of meeting with Introduce detours : connect roots on heavy path root 7

23 Drawing Tree Event Graphs Draw each light subtree in an axis-aligned rectangle Order light children vertically by start time of meeting with Introduce detours : connect roots on heavy path root New light subtree embedded in axis-aligned rectangle! 7

24 Drawing Tree Event Graphs Draw each light subtree in an axis-aligned rectangle Order light children vertically by start time of meeting with Introduce detours : connect roots on heavy path root New light subtree embedded in axis-aligned rectangle! Recurrence: N(T ) apple  light subtrees L N(L) + 5n light subtree crossings! N(T )=O(n log n) depth of recurrence is O(log n) root crossings 7

25 Lower Bound for All Inputs Use length L of optimal linear ordering of a graph Embed vertices on the line (unique integers) to minimize total edge length 2 3 total edge length = 7! 2 L = 5 8

26 Lower Bound for All Inputs Use length L of optimal linear ordering of a graph Embed vertices on the line (unique integers) to minimize total edge length 2 3 total edge length = 7! 2 L = Our problem: Optimal cost = L # edges Edge! meeting Crossings for 2 vertices to meet! edge length - 8

27 Lower Bound for All Inputs Claim: total # of crossings L #edges ! meet 0 0 L changes: New cost for to meet! 0 Other costs increase by: apple # crossings 2 9

28 Lower Bound for All Inputs Claim: total # of crossings L #edges ! meet 0 0 L changes: New cost for to meet! 0 Other costs increase by: apple # crossings 2 u u, v cross v! v u Each edge has cost increase of Increase by apple d(u)+d(v) apple 2 9

29 Lower Bound for All Inputs Claim: total # of crossings L #edges ! meet 0 0 L changes: New cost for to meet! 0 Other costs increase by: apple # crossings 2 total u # of crossings 2 v u, v cross v! u total # of crossings total cost Eachincrease edge has cost increase of original total cost L #edges L #edges Increase by apple d(u)+d(v) apple 2 2 9

30 Lower Bound for Tree Event Graphs Trees: Optimal linear ordering = minimum valuation Minimized for full binary tree L = (n log n) [Chung 78], = 3 (n log n) m # crossings = ( 2 3 )= (nlog n) 0

31 FPT for All Inputs We transform to shortest path problem vertex! valid vertical ordering of curves at meeting start time edge! transformation between orderings by swaps (weight = min # crossings) characters meet meet 3 2

32 FPT for All Inputs We transform to shortest path problem vertex! valid vertical ordering of curves at meeting start time edge! transformation between orderings by swaps (weight = min # crossings) characters meet meet adjacent during meeting 3 2 adjacent during meeting

33 FPT for All Inputs Evaluate all vertical orderings with one search valid vertical orderings s t s s 2... s applem meeting start times 2

34 FPT for Crossing Minimization Parameter! k characters precompute edge weights between all k! 2 pairs in time O(k! 2 k log k) with merge sort find shortest s! t path in linear time O(k!m) vertices s t Total running time O(k! 2 k log k + k! 2 m) O(k! 2 m) edges 3

35 Questions? Is the FPT algorithm efficient in practice for small k (e.g., k apple 6)? Is there a polynomial time exact algorithm for tree event graphs? How about other graph classes? (e.g., small arboricity, unicyclic graphs, cactus graphs) Are there sparse event graphs that require (n 2 ) crossings? What about minimizing the number of bends/wiggles? CC BY-NC 2.5 4