September 14-17, 2021

Tübingen, Germany

PhD School

The pre-conference PhD school is planned for September 13-14, 2021. Details on the program, the lecturers and the content of their lectures follow. Each participant must register by filling in the corresponding entry of the registration form before September the 8th. Note that the PhD school will be only on-site since there are hands-on sessions at each lecture.


Monday 13.09.2021

08.45 - 09.00 Covid Rapid Tests

09.00 - 10.30 Lecture 1, Part A

10.30 - 11.00 Coffee break

11.00 - 12.30 Lecture 1, Part B

12.30 - 14.00 Lunch break

14.00 - 15.30 Lecture 2, Part A

15.30 - 16.00 Coffee break 

16.00 - 17.30 Lecture 2, Part B

Tuesday 14.09.2021

08.45 - 09.00 Covid Rapid Tests

09.00 - 10.30 Lecture 3, Part A

10.30 - 11.00 Coffee break

11.00 - 12.30 Lecture 3, Part B

12.30 - 14.00 Lunch break

14.00 - 15.30 Lecture 4, Part A

15.30 - 16.00 Coffee break 

16.00 - 17.30 Lecture 4, Part B


Fouli Argyriou (yWorks GmbH)

Fouli Argyriou received her Ph.D. in Computer Science in 2013 from the National Technical University of Athens, Greece. Her research interests concern theoretical aspects of Computer Science, focusing on algorithms and their complexity mostly from the areas of graph drawing with emphasis on security applications, fraud detection, and information visualization. Since 2014 she works as a Software Engineer at yWorks, first as part of the layout team and now as part of the yFiles for HTML team.

Martin Gronemann 

Martin Gronemann received his PhD in Computer Science in 2015 from the University of Cologne. Currently, he is a postdoc at Osnabrück University. His main research focus is on everything related to graph drawing like algorithmic graph theory, algorithm engineering, computational geometry, and information visualisation.

Michael Krone (University of Tübingen)

Michael Krone is a junior professor at the University of Tübingen. The main focus of his work is on visualizations for the life sciences, especially molecular graphics, visual analysis of molecular dynamics simulations, and visualization of multi-dimensional biomedical data. His research interests include real-time rendering for (scientific) visualization, visual analytics, immersive visualization, and GPU computing (especially using CUDA). 

Jasmine Möller (yWorks GmbH)

Jasmine Möller studied Mathematics and Computer Science at the University of Konstanz. She focused on algebraic topology and graph drawing and graduated in 2005 with a diploma thesis about automatic layout of chemical structures, advised by Prof. Ulrik Brandes. Since 2005 she works at yWorks as a Software Engineer in the .NET and HTML teams.

Wouter Meulemans (TU Eindhoven)

Wouter Meulemans received his PhD in 2014 from TU Eindhoven, and was a postdoc at WWU Münster (Germany) and a research fellow at City University London (United Kingdom). He joined TU Eindhoven as an assistant professor at the end of 2016. In his research, he combines computational geometry, graph drawing, information visualization, and geographic information science to develop effective algorithms for visualizing data, with a focus on geospatial data and (hyper)graphs.


Lecture 1 by Wouter Meulemans: Hypergraph Drawing and Set Visualization

Most literature at in the area of graph drawing concerns itself with graphs having edges specified by two vertices, its endpoints. However, many datasets do not lend themselves well to such a representation, as relations are defined that connect not two but several vertices. To facilitate this data, a hypergraph generalizes regular graphs by allowing the (hyper)edges to be described by a set of any (finite) size. In the first half of this lecture, we formally introduce such hypergraphs, consider various ways of how these hypergraphs can be drawn, and discuss the algorithmic challenges that these drawing styles present.

Just as graph drawing and network visualization complement each other, hypergraph drawing finds its dual in set visualization. In the second half of this lecture, we explore this duality between hypergraphs and set systems, discuss how this type of data is explored and visualized in practice, and relate this to the challenges of hypergraph drawing.

Lecture 2 by Michael Krone: An Introduction to the Interactive Visualization of Networks

The interactive visualization of graphs or networks can be a challenging task both from the perspective of how to effectively represent the data as well as with respect to technical and computational aspects. In this course, you will learn about the most common visualization methods for networks and how to choose the best representation depending on your data and the targeted analysis task.

First, we will cover the required general principles of visualization, including the basics of task- and data-driven visualization and visual design principles. We will then look at fundamental visualization methods for node-link diagrams, which require layout algorithms such as force-directed layouts. Especially for larger node-link diagrams, approaches that use clustering, abstraction, or level-of-detail, such as edge bundling, can be beneficial. We will also discuss alternative visualization approaches such as adjacency matrices or chord diagrams.

Practice Session: Web-based Network Visualization

Due to the advances in web technologies and because of their cross-platform accessibility, web-based visualizations have gained a lot of popularity lately. In this hands-on session you will learn how to create simple network visualizations using web technologies. We will use popular visualization libraries like D3.js, which greatly speed up and simplify development. For example, we will create interactive node-link diagrams with different properties for different use cases. We will apply the previously learned visualization principles and design guidelines to ensure an effective representation of the data. We will also learn ways to efficiently render large networks such as Canvas or WebGL.

Lecture 3 by Fouli Argyriou and Jasmine Möller (yWorks GmbH): Large graph visualization with yFiles

Transforming large datasets into a both meaningful and performant visualization can be a challenge. Large graphs often suffer from very high complexity, which generally makes them extremely hard to grasp. While a typical “hairball” graph might look impressive it does not provide much insight to the viewer. Most of the time only a small part of the diagram or just getting an overview over the data is of real interest, and so reducing the complexity is an excellent strategy for browsing bigger diagrams. However, even after such a minimization step, the diagram can still be very large, or there really is a specific requirement to navigate the whole graph structure. Therefore techniques are needed to display those huge structures efficiently and interact with them smoothly.

Due to the advances in both JavaScript engines and general computer performance, purely javaScript based solutions now provide a viable alternative to create visualizations for even the largest datasets. yFiles for HTML offers a comprehensive and feature rich solution for those use cases, especially with the new 2.4 release.

In this presentation, a short introduction to the yFiles for HTML library and the new features in the upcoming yFiles for HTML 2.4 release will be given. After that, we will focus on a couple of different approaches to the challenges connected with large datasets: Strategies for complexity reduction including aggregation, clustering, filtering, drill-down techniques, and folding. In addition, using different layout algorithms and configuring their options can have a huge impact on the readability of the final drawing. If you actually have to deal with large visualizations that cannot be reduced in size, yFiles offers specialized techniques like WebGL or level-of-detail rendering, performing long-running layout calculations in a background thread and customizing user interactions to speed up the overall performance.

Practice session: From raw data to concise diagrams - using yFiles for rapid prototyping and high-performance visualization of large datasets

Creating a data visualization application from scratch can be very intimidating when you have nothing but the raw dataset to start with. The yFiles ecosystem offers a couple of tools that help with rapid prototyping. For this practice session, we'll use the App Generator for yFiles to quickly get a basic graph visualization project up and running. Building on this prototype, we will explore some of the complexity reduction techniques and layout configurations mentioned in the presentation to gain more insight into the initial dataset. We will also leverage several strategies for improving the application performance for interacting with the whole dataset at once. At the end of the session, we will compare the results and also discuss alternative ideas that might not have been covered in this workshop.

yWorks specializes in the development of professional software solutions that enable the clear visualization of graphs, diagrams, and networks. Founded as a spin-off of the University of Tuebingen in 2001, yWorks today is offering market-leading graph visualization and diagramming solutions. The yFiles product family offers high-quality diagramming for cross-platform applications.

Lecture 4 by Martin Gronemann: An introduction to the Open Graph Drawing Framework (OGDF)

The Open Graph Drawing Framework (OGDF) is a research-oriented open source C++ library that provides an extensive list of algorithms to draw graphs and visualize networks. The library provides solid and fast implementations of algorithms and data structures that enable rapid development of new approaches. Over the years many researchers and students contributed their results that then also have been released to the public. Recently, more and more algorithms have been added that are not necessarily related to the field of graph drawing.

In this lecture, we introduce the audience to the concepts and functionality of the Open Graph Drawing Framework. Starting with a description of the essential data structures, we also provide some details how these are implemented in the library. These details can be crucial when it comes to debugging an algorithm or solving performance issues. The lecture concludes with a description how to complete various tasks that arise when implementing a new algorithm or data structure. These include for example testing for planarity, obtaining a corresponding embedding and traversing it.

In the hands-on session, the participants are given small programming tasks with the aim that at the end of the session everyone has a basic understanding of how the OGDF works and how to write small programs that use it. These tasks include loading or generating graphs, computing a graph layout, customization of the output, or implementing a simple algorithm. Basic knowledge in C++ and graph drawing is recommended.


Uni Tuebingen