a software framework for interactive information visualization

Although information visualization (infovis) technologies have proven indispensable tools for making sense of complex data, wide-spread deployment has yet to take hold, as successful infovis applications are often difficult to author and require domain-specific customization. To address these issues, we have created prefuse, a software framework for creating dynamic visualizations of both structured and unstructured data. prefuse provides theoretically-motivated abstractions for the design of a wide range of visualization applications, enabling programmers to string together desired components quickly to create and customize working visualizations. To evaluate prefuse we have built both existing and novel visualizations testing the toolkit's flexibility and performance, and have run usability studies and usage surveys finding that programmers find the toolkit usable and effective. Interactive demonstrations, video demonstrations, and open-source software for the prefuse project are available at http://prefuse.sourceforge. net. INTRODUCTION Since the introduction of data graphics in the late 1700’s [46], visual representations of abstract information have been used to demystify data and reveal otherwise hidden patterns. The recent advent of graphical interfaces has enabled direct interaction with visualized information, giving rise to over a decade of information visualization research. Information visualization (or infovis) seeks to augment human cognition by leveraging human visual capabilities to make sense of abstract information [12], providing means by which humans with constant perceptual abilities can grapple with increasing hordes of data. Still, as inexpensive processing and graphics capabilities continue to improve, there remains a dearth of information visualization applications on current systems. While some of the reasons are economic [20], there are technical roadblocks as well. One is that information visualization applications are difficult to build, requiring mathematical and programming skills to implement complex layout algorithms and dynamic graphics. Another reason is that infovis applications do not lend themselves to “one size fits all” solutions; while successful visualizations often reuse established techniques, they are also uniquely tailored to their application domain (e.g., [31]), requiring customization. This suggests a toolkit approach, supporting a diversity of customized applications by providing high-level support for common, reusable visualization solutions. While infovis toolkits attempting to fill this gap have begun to emerge, current offerings [9,17] provide libraries of pre-built visualizations rather than a set of reusable components for building customized or novel visualization designs. To address these concerns and better support the design and implementation of novel visualizations, we have built prefuse, an extensible user interface toolkit for crafting interactive visualizations. Instead of providing only ready-made infovis “widgets” that can be applied much like buttons or checkboxes in traditional GUI tools, prefuse provides a set of finer-grained building blocks for constructing tailored visualizations. This approach simplifies the composition of established methods, such as layout or distortion algorithms, while providing an integrated structure in which to develop novel techniques and domain-specific designs. The formalism of a graph — a set of entities and relations between them — is used 1 In line with the musical naming conventions of Java user interface toolkits, the prefuse (pronounced "pref-use") name derives from Prefuse 73, an electronic musician whose work fueled my own. prefuse is intentionally spelled in the lower-case. as the toolkit’s fundamental data structure, enabling a broad class of visualizations comprising node-link diagrams, containment diagrams, and visualizations of unstructured (edge-free) data such as scatter plots and timelines (Figure 1 contains a sample visualization). prefuse includes a library of layout algorithms, navigation and interaction techniques, integrated search, and more. prefuse is written in the Java programming language using the Java2D graphics library. Informed by a review of existing applications, our own years of experience designing novel visualizations, and earlier toolkit evaluations, the prefuse toolkit offers: Figure 1. Consecutive snapshots of a prefuse-built graph viewer featuring automatic zooming. • Data structures and I/O libraries for unstructured, graph, and tree data • Multiple visualizations of a single data source • Multiple views of a single visualization • Scalability to thousands of on-screen items, and to backing data sources with millions of elements • Batch processing of data using composable actions • A library of provided layout and distortion techniques • Animation and time-based processing • Graphics transforms, including panning and zooming • A physical force simulator for layout and interaction • Interactor components for common interactions • Integrated color maps and search functionality • Event logging to support visualization evaluation To provide a principled toolkit flexible enough to support novel visualizations while providing ample coverage of the visualization design space, we based the design of prefuse on an existing theoretical framework for infovis, the “data state” or infovis reference model [11,12,15]. This model decomposes design into a process of representing abstract data, mapping data into an intermediate, visualizable form, and then using these visual analogues to provide interactive displays (Figure 2). Prior work has validated the model’s expressiveness, providing a comprehensive taxonomy of visualization techniques [15]. In particular, prefuse introduces abstractions for filtering source data into visualizable content, providing both scalability and representational flexibility, and using composable actions to perform batch processing of this content, for example data transformation, layout, or color assignment. Programmers craft visualizations by stringing together actions into executable chains that can then be run to manipulate visual data and perform animation. Interactive views are then created from this visual data through a highly-configurable rendering system, to which pre-built controls can be added to specify interactive behaviors. This separation of concerns provides a degree of flexibility unmatched by existing infovis toolkits [9,17], supporting multiple views, semantic zooming, data and visual transformations, and application extension and customization. prefuse further demonstrates that these generalized abstractions can be provided without unduly sacrificing performance. In the next section we survey related work, motivating the need for our toolkit. Next, we describe the design of prefuse and walk through an example prefuse-built visualization. We then present evaluations of the toolkit, including applications showcasing the toolkit’s power and flexibility, and a qualitative study demonstrating the usability of prefuse’s application programming interface (API). MOTIVATION AND RELATED WORK The goal of prefuse is to simplify the creation of visualizations akin to how GUI toolkits have facilitated the design of traditional WIMP (Windows-Icons-Menus-Pointing) user interfaces. As such, prefuse draws from pioneering work on input abstractions like the model-view-controller [29] and interactor [36] paradigms, and the rich history and lessons learned from toolkit development [37]. This includes early systems for graph layout and editing [23,26] and for including animation in user interface toolkits [24]. While cutting-edge 2D user interface toolkits such as Piccolo [7] and its predecessor Jazz [8] provide facilities useful for information visualization such as zooming and animation support, they are not focused on supporting common visualization techniques directly. Our goal is to construct a framework of higherlevel abstractions for presentation, navigation, and batch processing of interactive objects that simplifies visualization creation while affording the freedom to explore new designs. The past 15 years have witnessed a rich body of information visualization work, featuring the creation of novel visualization designs for both structured and unstructured data. Examples include TreeMaps [10,44], Cone Trees [42], Perspective Walls [34], StarField displays [1], Hyperbolic trees [30], DOITrees [13,22], SpaceTrees [39], and more. Advances also came in the form of selection, transformation and navigation techniques, including focus+context schemes [18], space distortion [32], point-of-interest navigation [33], and panning and zooming [25,38]. Perhaps the first integrated framework for infovis was the Information Visualizer [14], featuring many of the aforementioned techniques as well as a centralized “governor” to oversee animation and ensure smooth interactive frame rates. Concurrently, the graph drawing community has devised algorithms for the aesthetic layout of graph structures. These are given thorough coverage by di Battista et al. in [4]. Perhaps the best known software for graph drawing is the excellent graphviz package from AT&T [19]. There are several other research and commercial graph drawing systems, including Marshall et al.’s Graph Visualization Framework (GVF) [35], the University of Ljubljana’s Pajek [3], and products from Tom Sawyer and yWorks. These applications produce largely static visualizations and do not constitute programming platforms for highlyinteractive visualizations. However, in recent years the graph drawing community has begun moving towards increasingly interactive solutions, signaling a possible convergence with the information visualization community. While most information visualization research to date has consisted of exploring the space of successful designs and techniques, the field is now moving into a second pha