the prefuse visualization toolkit

prefuse is a user interface toolkit for building highly-interactive information visualization applications.

See:
          Description

Packages
prefuse The top-level Visualization and Display classes, as well as Constants used throughout the toolkit.
prefuse.action A library of reusable and composable modules for performing data processing or assigning visual attributes.
prefuse.action.animate Action modules for constructing animations.
prefuse.action.assignment Action modules for assigning visual properties such as colors, sizes, and fonts.
prefuse.action.distortion Actions modules which distort the presentation space to support enhanced navigation and browsing.
prefuse.action.filter Action modules for visually filtering items by controlling their visibility.
prefuse.action.layout Action modules providing layout algorithms for use by prefuse visualizations.
prefuse.action.layout.graph Action modules for computing the layout of graph or tree structured data.
prefuse.activity General classes for scheduling and running activities with specified starting times and durations.
prefuse.controls Control modules for incorporating interaction in prefuse Displays.
prefuse.data Table, Graph, and Tree data structures for organizing data.
prefuse.data.column Data columns for storing typed data within a data table.
prefuse.data.event Listener interfaces for monitoring prefuse data structures and expressions.
prefuse.data.expression Classes implementing an SQL-like expression language for filtering and manipulating data.
prefuse.data.expression.parser Parser/compiler for the prefuse expression language.
prefuse.data.io Input/output classes for reading and writing data from formatted files.
prefuse.data.io.sql Input libraries for loading data from SQL databases.
prefuse.data.parser Text parsers for different data types and machinery for automatically inferring data types.
prefuse.data.query Dynamic query bindings and data range models for creating dynamic queries.
prefuse.data.search Text search support for prefix, keyword, and regular expression searches.
prefuse.data.tuple Implementing classes for data tuples, object proxies to a row of table data.
prefuse.data.util Utility classes for supporting prefuse data structures, including indexes, iterators, filters, and column projections.
prefuse.render Interfaces and modules for rendering VisualItems into a graphics context.
prefuse.util Utility classes for use by both the toolkit and applications, including color and font support.
prefuse.util.collections Utility classes providing useful data structures not present in the Java Collections framework.
prefuse.util.display Utility classes specific to the Display class.
prefuse.util.force Utility classes providing a physical force simulation for layout and animation.
prefuse.util.io Utility classes pertaining to input and output.
prefuse.util.ui Utility classes facilitating the generation and composition of user interface components.
prefuse.visual Classes for representing and storing VisualItems.
prefuse.visual.expression Expressions in the prefuse expression language that are specific to VisualItems.
prefuse.visual.sort ItemSorter instances for determining the rendering order of VisualItems.
prefuse.visual.tuple Implementations of VisualItem types and backing TupleManager instances.

 

prefuse is a user interface toolkit for building highly-interactive information visualization applications. Prefuse provides facilities for data management, spatial layout, color, size, and shape encodings, rendering, zooming, animation, search, and interaction. Furthermore, it attempts to do so in a modular way, allowing users to piece together desired functionality to build custom visualization applications.

The general pattern of building prefuse applications is to

  1. Load the data to be visualized into prefuse's data structures. prefuse provides built-in support for Table, Graph, and Tree data structures, and can read from a number of different file formats (prefuse.data.io) as well as communicate with relational databases (prefuse.data.io.sql).
  2. Create a Visualization that maps the loaded data to a visual abstraction -- a representation of the data amenable to visual processing, rendering, and interaction. Each data element can have one or more corresponding VisualItems that represent an interactive object on the screen. Each VisualItem includes properties such as the x,y location of the object and color, shape, and size settings, while providing access to the underlying data.
  3. Construct a series of data processing Actions that operate on the visual abstraction. These operations can involve just about anything, but common examples include setting the location, color, size, and shape of visual items or animating these properties between different configurations. These Action instances can be grouped into ActionLists for performing various processing tasks, and are backed by a flexible ActivityManager supporting event scheduling and animation. Furthermore, the API for these Actions is very simple--just a single method-- making it easy to extend prefuse to suit your own needs or explore new ideas.
  4. Specify how visual items will be drawn to the screen. For example, do you want to see abstract shapes, text labels, or images? This is determined by constructing a RendererFactory which maps visual items to Renderer instances responsible for drawing visual items to the screen.
  5. Initialize one or more interactive Displays for viewing and manipulating visual items. Displays provide optimized rendering of a viewing region, and also support view transformations, such as panning and zooming. Interactivity can be supplied using any number of pre-built controls (prefuse.controls), or custom interactions can be written by implemening the Control interface. Also, to support rich search and filtering through data items, various search engines (prefuse.data.search) and dynamic query bindings (prefuse.data.query) are available.

Prefuse also provides a host of other features, including a physics simulation engine for layout and interaction (prefuse.util.force), bounds management for optimized rendering, data indexing and internal query optimization, and a small SQL-like expression language for creating queries to prefuse's data structures, manipulating data, and creating derived data columns (prefuse.data.expression). Not all of this, however, is required for taking advantage of the toolkit, and often much of it is done for you in the background.

The latest version of the prefuse code, this documentation, a user's manual, and example applications are available online at http://prefuse.org



Copyright 2007 Regents of the University of California