Extending the WilmaScope 3D Graph Visualisation System — Software Demonstration Tim Dwyer† †
HUM Programme National ICT Australia0 Australian Technology Park Everleigh NSW 1430 Australia Email:
[email protected] WilmaScope URL: http://www.wilmascope.org
• visualising world-wide web structures (Eckersley 2000);
Abstract WilmaScope is an open-sourced, platform independent, interactive 3D graph visualisation system based on Java and Java3D. Application to a number of real-world relational network visualisation problems and continuous development over a number of years have seen the system evolve to a stage where it is becoming a stable and versatile platform for third-party developers. This paper outlines the architecture that has made this possible and briefly describes some of the features available in the current version.
• visualising fund manager flow graphs (Dwyer & Eades 2002, Dwyer 2003, Dwyer & Gallagher 2004); • visualising metabolic pathways (Brandes, Dwyer & Schreiber 2003, Brandes, Dwyer & Schreiber 2004a, Brandes, Dwyer & Schreiber 2004b, Dwyer, Rolletschek & Schreiber 2004); • visualisation of phylogenetic trees (Dwyer & Schreiber 2004);
Keywords: Information Visualisation, Graph Visualisation, 3D Graphics 1
• and visualisation of bibliographic citation networks (Ahmed, Dwyer, Murray, Song & Wu 2004).
Introduction
A number of powerful software libraries and systems for 2D graph visualisation exist, most famously Tom Sawyer Software1 and yFiles2 . However, these are generally closed-source and expensive. Some interesting 3D graph visualisation systems also exist, two notable examples are: Tulip3 and Walrus4 The WilmaScope 3D graph visualisation system, however, provides a degree of extensibility that is currently unrivalled by other 3D graph visualisation systems. WilmaScope5 began life in the year 2000 as part of an honours project investigating methods for representing UML diagrams using 3D graphics (Dwyer 2000, Dwyer 2001). In 2001 this initial system was rewritten as a more general 3D graph visualisation and editing system and was presented as a software demonstration at the 2001 Graph Drawing Symposium in Vienna (Dwyer & Eckersley 2001). A more extensive article covering WilmaScope is also featured as a chapter in the Graph Drawing Software book (Dwyer & Eckersley 2003). WilmaScope’s utility has been demonstrated in a number of papers discussing various 3D graph visualisation applications, such as: c Copyright 2005, Australian Computer Society, Inc. This paper appeared at the Asia Pacific Symposium on Information Visualisation (APVIS 2005), Sydney, Australia. Conferences in Research and Practice in Information Technology, Vol. 45. Seokhee Hong, Ed. Reproduction for academic, not-for profit purposes permitted provided this text is included. 0 National ICT Australia is funded by the Australian Government’s Backing Australia’s Ability initiative, in part through the Australian Research Council 1 http://www.tomsawyer.com 2 http://www.yworks.com 3 http://dept-info.labri.fr/˜auber/projects/tulip/ 4 http://www.caida.org/tools/visualization/walrus/ 5 http://www.wilmascope.org
More recently, significant efforts have been devoted to improving the system’s extensibility such that it can easily be used by developers as a library for graph visualisation in their own applications. In this paper we discuss the architecture enabling this extensibility and describe some features that may be useful for developers utilising WilmaScope in this way. 2
Extending WilmaScope
There are a number of ways that WilmaScope can be used for graph visualisation applications, for example (see Figure 1): • WilmaScope XML Graph (XWG) files can be created by another program, converted from other XML formats using XSLT, or constructed in a text or XML editor, and loaded into the standard WilmaScope front-end. • Developers can create plug-ins extending one of several different types of base classes to extend the functionality of WilmaScope. The various plug-in types include: – Graph Generators: to automatically generate graphs based on simple algorithms. – Graph Modifiers: to modify the structure of existing graphs. – Graph Analysis: to calculate graph analysis metrics that can be mapped to visual attributes. – Graph Element Views: to provide new graphical representations for graph elements (glyphs).
Graph Generator, Modifier and Analysis plug-ins XWG Files conversion
WilmaScope API calls
Graph Data Source
Layout plug-ins Observer notification
Custom Application
View plug-ins
Algorithm Library (eg. LEDA, yFiles)
Layout Program (eg. DOT)
Figure 1: This diagram summarises the various ways in which WilmaScope may be adapted for use in applications. • New layout algorithms can also be added as plug-ins by extending the WilmaScope LayoutEngine framework. Such layout algorithms can use the WilmaScope graph data structures or they can use external graph data-structure libraries such as Leda6 or yFiles. They can also potentially use other programs such as DOT (see Section 4). • Developers can create stand-alone applications which use the WilmaScope GraphCanvas in a custom GUI. Note that none of these methods require developers to understand, modify or recompile existing WilmaScope source code. In this paper we discuss the WilmaScope architecture and design philosophy that makes this extensibility possible. 3
Architecture
As shown in Figure 2, WilmaScope is based around a model–view–controller architecture in that classes that maintain the underlying data-model (in this case a clustered graph) are decoupled from both: • classes that allow external entities to update this graph model; • and classes which create the visual representation of the graph. This decoupling of the model, view and controller aspects of the graph visualisation architecture means that new: • graph element glyphs; • graph layout algorithms; • and algorithms for generating graphs automatically 6
http://www.algorithmic-solutions.com/
Figure 2: The WilmaScope Model–View–Controller architecture. can all be created as plug-in components which can be loaded into WilmaScope at run-time. Therefore, applications which require such custom components can be developed for WilmaScope without any modification or even recompiling of the WilmaScope source. Further, since WilmaScope is released into open-source via the Lesser Gnu Public License (rather than the full GPL), the source code for plugins containing confidential intellectual property does not need to be released back into open source. Developers need only compile their new plug-ins, make them known to WilmaScope via the WilmaScope control panel and they will be loaded at run-time. Figure 3 shows the hierarchy of classes which realise the model and view components. The graph package contains classes which define the graph model. A WilmaScope graph defines an objectoriented model for a clustered graph with a recursive class definition. A graph is defined as a Cluster
Figure 3: Hierarchy of key classes in the graph and view packages and examples of how these classes may be implemented by layout and view plug-ins.
consisting of nodes and edges, both implementing the GraphElement interface. Since the Cluster class is a subclass of the Node class, a cluster may be an aggregation of, not only nodes and edges, but also other clusters. Each cluster has its own instance of a LayoutEngine. A layout engine provides an implementation of a layout algorithm for finding an embedding of the cluster’s graph structure in two or three dimensional space. Figure 3 includes the class hierarchy for the forcelayout package which is the default WilmaScope layout engine. Users may create their own layout engines by implementing the LayoutEngine, NodeLayout and EdgeLayout interfaces. The fact that each cluster has its own layout engine means that it is possible to arrange the contents of each cluster with different layout parameters or even different layout algorithms. For example, one might have force-directed layout engines with strong edge attraction inside nested clusters than for the root cluster, thus exaggerating cluster cohesion. A more exotic example might involve hierarchical layout (Eades & Sugiyama 1990) inside nested clusters and force directed layout for the root cluster. The view package provides abstract classes defining the visual attributes of nodes, edges and clusters in an inheritance hierarchy that mirrors the structure of the graph model. Users can extend the NodeView, EdgeView and ClusterView classes to create their own glyph geometries which are, again, loaded at run-time by WilmaScope as plug-ins. 4
• Principal components projection of a simple high-dimensional embedding (Harel & Koren 2002). Node and edge view plug-ins for various 3D primitive shapes (such as spherical and box-shaped nodes, and cylindrical edges) are included as well as some other more exotic geometries and labels. Figures 4, 5, 6 and 7 give examples of graphs arranged using different layout-engine and view plug-ins. 5
WilmaScope is designed to be interactive. That is, as well as providing the ability to visualise graphs WilmaScope allows users to edit graphs. This interactivity also extends to layout. For example, iterative layout algorithms—such as force-directed layout (Eades 1984)—are animated and allowed to run continuously while a graph is being edited, or while the layout algorithm’s parameters are being adjusted. Such interactivity is made possible through extensive use of the observer design pattern (Gamma, Helm, Johnson & Vlissides 1995). For example, edge glyphs extending the EdgeView class can register to be notified when an end node’s colour or geometry is modified—at which time the edge glyph can update itself accordingly. This architecture also has implications for developers utilising WilmaScope from within their own applications. For example, such applications can register observer classes to be notified of events such as:
Implemented Plug-ins
A number of layout engine, view and graph generator plug-ins are supplied with the current WilmaScope distribution7 . Currently WilmaScope comes with the following graph generators: • Random graphs — parameters: number of nodes and edges. • Clustered graphs — parameters: number and size of clusters. • Grids — parameters: width and height. • Scale-free graph growth simulator based on a stochastic model (Barab´ asi, Albert & Jeong 2000)— parameters: initial nodes, final nodes The following layout engine plug-ins are supplied:
• Selection of a graph element by the user (by clicking directly on the element with the mouse). • The start and finish of a layout process. In this way, WilmaScope can be used for on-line browsing (Huang, Eades & Wang 1998) of very large (or infinite) graphs. That is, while exposing only a small portion of the graph at a time, users can navigate the graph by selecting a node for closer inspection directly. This node then notifies the application of the selection event—via the observer interface— and the application can reveal the node’s neighbours by adding them to the WilmaScope visualisation. Notification of layout start and finish allows such applications to wait while animated layout changes complete. 6
• Auto-rotation. • Automatic centring and zooming of the graph to fit the window.
• A multi-scale force-directed layout method (Walshaw 2000).
• High-resolution image capture. • Generating a timed sequence of images to create movies.
• The FADE spatial decomposition based forcedirected layout algorithm (Quigley & Eades 2000).
7
The current WilmaScope distribution (Version 3.0.1 as of October 2004) is available as a self installing package for Windows, Unix and Mac OSX from http://www.WilmaScope.org/download.html 8 http://www.graphviz.org
Other Features • Sophisticated lighting editor.
• A standard force-directed layout method (Fruchterman & Reingold 1991), including magnetic field forces for aligning edges in directed graphs (Kamada & Kawai 1989).
• A wrapper for the Graphviz DOT8 hierarchical layout program. A DOT format file is generated, DOT invoked, the file pipe into it and the result is parsed to obtain the layout.
Interactivity
• Stereo 3D support on appropriate hardware. 7
Further Work
Work is currently underway to create more layoutengine plug-ins that will be distributed with WilmaScope. The default force-directed layout engine has been designed to work well with clustered graphs, but work is ongoing to adapt other layout algorithms, such as hierarchical layouts to work in a clustered environment.
Figure 4: A visualisation of a set of metabolic pathways (see Section 1) demonstrating use of the hierarchical layout plug-in implemented with the DOT program. Also visible is a cross-sectional viewer which allows users to step through layers in such 2 12 D graph visualisations.
Figure 5: Visualisation of the evolution of a citation network. The force-directed layout plug-in has been used together with constraints keeping nodes related to specific years aligned in parallel planes.
Figure 6: Another view of the citation-network from Figure 5. Nodes are constrained to concentric spherical shells with high-degree nodes placed on the outermost shells.
Figure 7: A small scale-free network produced by the stochastic scale-free graph generator plug-in.
Another project involves creating a remote interface based on Java RMI to support collaborative graph editing. Plug-in support for other file formats, or possibly a suite of graph file format conversion tools, is also being considered. 8
Acknowledgements
The following people participated in designing the graph visualisations shown in figures throughout this paper: Colin Murray, Ying Xin Wu, Le Song, Adel Ahmed, Peter Eades, Falk Schreiber and Ulrik Brandes. References Ahmed, A., Dwyer, T., Murray, C., Song, L. & Wu, Y. X. (2004), WilmaScope graph visualization, in ‘Proceedings of the IEEE Symposium on Information Visualization (InfoVis’04)’, Vol. To Appear. Barab´asi, A.-L., Albert, R. & Jeong, H. (2000), ‘Scale-free characteristics of random networks: the topology of the world-wide web’, Physica A 281, 69–77. Brandes, U., Dwyer, T. & Schreiber, F. (2003), Visualizing related metabolic pathways in two and a half dimensions, in ‘Proceedings of the 11th International Symposium on Graph Drawing (GD’03)’, Vol. 2912 of LNCS, Springer, pp. 111– 122. Brandes, U., Dwyer, T. & Schreiber, F. (2004a), Visual triangulation of network-based phylogenetic trees, in ‘Proc. 6th Joint Eurographics - IEEE TCVG Symp. Visualization’. Brandes, U., Dwyer, T. & Schreiber, F. (2004b), ‘Visual understanding of metabolic pathways across organisms using layout in two and a half dimensions’, Journal of Integrative Bioinformatics 2. Dwyer, T. (2000), ‘Three dimensional UML using force directed layout’, Honour’s thesis, School of Computer Science, the University of Melbourne. Dwyer, T. (2001), Three dimensional UML using force directed layout, in P. Eades & T. Pattison, eds, ‘Australian Symposium on Information Visualisation, (invis.au 2001)’, ACS, Sydney, Australia. Dwyer, T. (2003), A scalable method for visualising changes in portfolio data, in ‘Proc. of the Australian Symp. on Information Visualisation (invis.au)’, Vol. 24 of Conferences In Research and Practice in Information Technology, Australian Computer Society. Dwyer, T. & Eades, P. (2002), Visualising a fund manager flow graph with columns and worms, in ‘Proceedings of the 6th International Conference on Information Visualisation, IV02’, IEEE Computer Society. Dwyer, T. & Eckersley, P. (2001), WilmaScope — an interactive 3d graph visualisation system, in ‘The 9th international symposium on Graph Drawing (GD2001)’, Vol. 2265 of LNCS, Springer, pp. 442–443. Dwyer, T. & Eckersley, P. (2003), Graph Drawing Software, Mathematics and Visualization, Springer, chapter WilmaScope — a 3D graph visualization system, pp. 55–76.
Dwyer, T. & Gallagher, D. (2004), ‘Visualising changes in fund manager holdings in two and a half dimensions’, Journal of Information Visualisation - to appear . Dwyer, T., Rolletschek, H. & Schreiber, F. (2004), Representing experimental biological data in metabolic networks, in ‘Proceedings of the second conference on Asia-Pacific bioinformatics’, Australian Computer Society, Inc., pp. 13–20. Dwyer, T. & Schreiber, F. (2004), Optimal leaf ordering for two and a half dimensional phylogenetic tree visualisation, in ‘Proceedings of The Australian Symposium on Information Visualisation (InVis.au’04)’, Vol. 35 of CRPIT, pp. 109–115. Eades, P. (1984), ‘A heuristic for graph drawing’, Congress Numerantium 42, 149–160. Eades, P. & Sugiyama, K. (1990), ‘How to draw a directed graph’, Journal of Information Processing 13, 424–437. Eckersley, P. (2000), ‘Classiscope: Using metastructure analysis to build a better magnet for the web haystack’. Fruchterman, T. & Reingold, E. (1991), ‘Graph drawing by force-directed placement’, Software Practice and Experience 21(11), 1129–1164. Gamma, E., Helm, R., Johnson, R. & Vlissides, J. (1995), Design Patterns: Elements of reusable object-oriented software, Addison-Wesley. Harel, D. & Koren, Y. (2002), Graph drawing by highdimensional embedding, in ‘Proceedings of the 10th International Symposium on Graph Drawing (GD’02)’, Vol. 2528 of Lecture Notes in Computer Science, Springer, pp. 207–219. Huang, M. L., Eades, P. & Wang, J. (1998), ‘Online animated visualization of huge graphs using a modified spring algorithm’, Journal of Visual Languages and Computing 9(6), 623–645. Kamada, T. & Kawai, S. (1989), ‘An algorithm for drawing general undirected graphs’, Information Processing Letters 31(1), 7–15. Quigley, A. & Eades, P. (2000), Fade: Graph drawing, clustering, and visual abstraction, in ‘Proceedings of the 8th International Symposium on Graph Drawing (GD2000)’, Vol. 1984, Springer, pp. 197–210. Walshaw, C. (2000), A multilevel algorithm for forcedirected graph drawing, in ‘Proceedings of the 8th International Symposium on Graph Drawing (GD2000)’, Vol. 1984, Springer, pp. 171–182.
