IVORY - An Object-Oriented Framework for Physics-Based Information Visualization in Java.

T. C. Sprenger, M. H. Gross, D. Bielser, T. Strasser

Proceedings of IEEE Information Visualization '98Research Triangle Park, NC, USA

October 19-20, 1998, pp. 79-86, 1998

We present IVORY, a newly developed, platform-independent framework for physics-based visualiza-tion. IVORY is especially designed for information visualization applications and multidimensionalgraph layout. It is fully implemented in Java 1.1 and its architecture features client-server setup, whichallows to run the visualization even on thin clients. In addition, VRML 2.0 exports can be viewed by anyVRML plugged-in WWW-browser. Individual visual metaphors are invoked into IVORY via an ad-vanced plug-in mechanism, where plug-ins can be implemented by any experienced user. The configu-ration of IVORY is accomplished using a script language, called IVML. Some interactive visualizationexamples, such as the integration of an haptic interface illustrate the performance and versatility of oursystem. Our current implementation supports NT 4.0.

Zurich¨Technische HochschuleEidgenossische¨

Swiss Federal Institute of Technology ZurichPolitecnico federale di ZurigoEcole polytechnique federale de Zurich´ ´

IVORY - An Object-Oriented Framework for Physics-Based

Information Visualization in Java

T. C. Sprenger, M. H. Gross, D. Bielser, T. Strasser

Department of Computer Science, Swiss Federal Institute of Technology (ETH), Zurich, Switzerland

ABSTRACT

We present IVORY, a newly developed, platform-independentframework for physics-based visualization. IVORY is especiallydesigned for information visualization applications and multidi-mensional graph layout. It is fully implemented in Java 1.1 and itsarchitecture features client-server setup, which allows to run thevisualization even on thin clients. In addition, VRML 2.0 exportscan be viewed by any VRML plugged-in WWW-browser. Indi-vidual visual metaphors are invoked into IVORY via an advancedplug-in mechanism, where plug-ins can be implemented by anyexperienced user. The configuration of IVORY is accomplishedusing a script language, called IVML. Some interactive visualiza-tion examples, such as the integration of an haptic interface illus-trate the performance and versatility of our system. Our currentimplementation supports NT 4.0.1

keywords: three-dimensional information visualization,physics-based graph layout, object-oriented visualization toolkit,multidimensional information modeling, time varying data.

1 INTRODUCTIONVisual communication had always been of fundamental impor-tance to mediate information and to understand complex relation-ships. With the advent of the computer, scientific visualizationwas born as a discipline [1] and conquered many science andengineering applications. However, whereas in the past, researchwas mostly focussed on the visualization of spatial data sets andmetric spaces, the design of new visual metaphors for abstract,complex information spaces has recently emerged as a challeng-ing research topic. Applications are manifold and range fromweb/network visualization and document retrieval, via softwareengineering to risk and portfolio management in the financial ser-vices [11].

Due to the tremendous importance of visualization methodsvarious systems and toolkits had successfully been designed inthe past, part of which are available as commercial products. Oneof the pioneers is AVS/Exress [2] that uses a data flow paradigmand allows the user to compose a visualization application inter-actively by definition of data flow paths between individual mod-ules. Similar paradigms have been implemented in the IRISExplorer [3] or in IBM’s DataExplorer [4]. Another elegant visu-alization library is provided by General Electric’s VTK [5] andcan be customized in TCL/TK. However, most of the general pur-pose toolkits and libraries target at classical scientific visualiza-tion of spatial data.

For information visualization and visual data mining sophisti-cated algorithms and metaphors had been devised in recent yearsto visually inspect abstract and multidimensional informationspaces. Cone trees [6] and their hyperbolic projections [7] areonly one prominent example. Physics-based graph layout isanother important paradigm and has been successfully exploited

in various applications [8], [9], [10]. Good surveys of contempo-rary information visualization methods can be found in [11] or[12]. However, generic toolkits and systems are rare or mostlyfocussed, such as statistics packages, like Bell Lab’s XGobi [13],IVEE [14] or the hierarchical algorithms in SGI’s SiteManager.Conversely, visual data mining tools, like SGI’s MineSet [15]often comprise visualization functionality, however, have limitedflexibility regarding the integration new metaphors.

2 OUR APPROACHOur toolkit IVORY has been developed as an open and flexiblesystem for information visualization to fill the gap between gen-eral purpose visualization tools and application specific systems.Although it is primarily designed for physics-based approaches tomultidimensional information spaces and for the visual analysisof large financial data volumes, the underlying design principlesmake it a versatile framework for the investigation and applica-tion of new visual metaphors. Some algorithmic details of thevisualization paradigm currently used in IVORY have been pre-sented by the authors in [9] and [16].

Our essential design and engineering goals for IVORY can besummarized as follows:• Client-Server setup: This allows the separation of any visual-

ization mapping engine from the client and the user interface.• Java programming language: Despite of all hype, Java fea-

tures object-oriented programing paradigms and stands forplatform independence.

• Clustering and hierarchies: In order to manage complexity ofinformation objects IVORY supports specifically multireso-lution visualization methods, such as hierarchies and cluster-ing [9].

• 4 layered abstraction model for users: In order to offer anappropriate interface for different types of users, IVORY canbe configured at 4 different levels of abstraction, depicted inFigure 1. The standard user, such as a financial analyst, willapply preconfigured instances of IVORY in his everydaywork. The more advanced power user can customize existingconfigurations using the script language IVML. On an admin-1 IVORY will be made available in short.

Figure 1: User abstraction model and system architecture

Physics-based

Information Visualization-Kernel

Plug-ins

Interpreted Modules

Compiled Modules

System ConfigurationScript (IVML)

POWER USER

ADMINISTRATOR

PROGRAMMER(SYSTEM-DESIGNER)

App

licat

ion

Lev

el

Sys

tem

Leve

l

USER

istrators level Java plug-ins can be programmed to imple-ment individual visual metaphors and layout algorithms.Finally, the systems designer can modify and extend theIVORY kernel to add new classes for solvers, particle enginesor other kernel methods.

The remainder of the paper is organized as follows: In section3 we elaborate on general design and architectural issues underly-ing our system. Section 4 addresses the plug-in mechanism,which allows to implement new visualization paradigms. Next,we discuss the scripting language, where, however, for brevity,the complete EBNF is omitted. Finally, an example using a force-feedback interaction model illustrates the flexibility and versatil-ity of our approach.

3 ARCHITECTURAL ISSUESTo implement the introduced system architecture shown in Figure1 we choose an object-oriented framework. Our basic designgoals include a fast, compact kernel and a powerful interfacewhich can be flexibly expanded for a wide range of user-specificproblems.

3.1 Framework ConceptsWhen designing our toolkit, we focused specifically on physics-based information visualization, since it provides a promising andintuitive paradigm enabling the user to map abstract multidimen-sional information spaces onto appropriate subspaces, that can bevisualized in 3D or 2D.

Double SeparationAs illustrated by the horizontal separation in Figure 2 weemployed a frontend/backend-concept, where the backend isresponsible for efficient number crunching and the frontend han-dles the graphical user interface and user interactions. In addition,we distinguish between data-dependent and data-independentcomponents (vertical separation in Figure 2). For this reason wedistill all data-dependent components into so-called plug-ins. Thescript language IVML handles configurations of individual plug-ins. That is, in order to visualize a new data-type, the user hasessentially to write an appropriate plug-in. The remainder of thesystem is not affected at all. For a more detailed discussion of theplug-in concept we refer to Section 4.

System Configuration using IVMLThe configuration and parametrization of the kernel and the plug-ins to be loaded, has both to be comfortable for the users and toexhibit small turn-around times. Therefore, the framework isequipped with a high-level script language, called IVML (Infor-mation Visualization Modeling Language). In contrast to all othersystem components which are build by using a compiled lan-guage providing a maximum of speed, the configuration scriptsare handled by an interpreter. Since they execute only once atstart-up time we balance time against flexibility.

All in all, the fundamental question of compiled or inter-preted components is solved by a compromise: On the one handthe interpreted approach is used wherever the execution repetitionis very low and therefore the demand for speed is of secondaryinterest. On the other hand compiled code is used for all low-leveland often-run-through program segments.

Some Arguments pro JavaTwo important aspect have to bear in mind to give a frameworkthe chance for general acceptance: First the system should baseon already established standards. Second, the implementationshould be as independent of operating systems as possible.

In this context, a new trend in portability emerges with Java[17] and its “write once, run everywhere” philosophy. In this wayapplications run (almost) on any operating system supportingJava. We believe that the leak of performance compared to C++will get obsolete over time. Here, the performance improvementsmade with every new Java release and the availability of nativecode Java compilers [18], [19] are good evidences.

In addition, besides all the euphoria, Java is widely acceptedas a highly portable quasi-standard in the computer communityand is available on many operating systems. Furthermore Java isstrongly object-oriented, which is critical for a well structuredimplementation of a complex framework.

For 3D graphic output we selected the system independentmodeling language VRML 2.0 [20] to provide a high-leveldescription of the scene. Specifically, there are many viewers andAPIs available supporting VRML 2.0. Each of them handlesbasic object management such as adding, removing and pickingof an object.

3.2 Information FlowIn our terminology an information flow affects the visual repre-sentation of our input data. Consequently, one stream of informa-tion flow is the data itself. It starts with the data acquisition andends up in the visual representation. If we connect, for instance,real-time data feeds, such as a Reuters ticker, to the system thevisualization will be continuously driven by the data. A secondimportant flow of information is defined by the user interactions.The information contained in this flow range from mouse clicksto cursor updates of a connected haptical device.

Data AcquisitionThe data acquisition is the starting point of every visualization orvisual mining procedure and supplies the system with raw mate-rial. In the simplest case the data can be read from an ASCII-file.Since the acquisition process obviously belongs to the data-dependent components and is therefore settled in the data plug-incomponents, IVORY does not impose any further restrictions ondata access. Each instance of a data plug-in is responsible for itsown data acquisition, which is thus fully transparent to the rest ofthe system. This mechanism enables us to tap any data-source bya specifically designed method and conversely to access one data-type through different methods without changing the rest of the

Figure 2: Schematic overview of the system-components in IVORY

Data-dependentComponents

(Abstract Framework Kernel) Data-independent Components

NETWORK

Frontend

Visualizer

Java AWT

CosmoPlayer (VRML) Propagator

Visualizing Subsystem

Backend

Analyse

Layout

DataIVML

Subsystems

Subsystems

Tra

nspa

rent

Net

wor

k-La

yer

(Soc

ket/D

irect

Cal

ls)

IVML Script

StructureSubsystem

Data

Plug-ins

Frontend

Backend

system. Typical data-sources encompass conventional data bases(SQL, DB2, DBase, ...), search-engines in the internet, the WorldWide Web (WWW) or real-time data tickers.

Configuration of the Layout SystemIn many graph-based visualization methods, data units, as repre-sented in the system by instances of plug-ins, are considered asentities in a physical world and relations between them can bemapped onto interacting forces. However, the configuration of anindividual layout algorithm takes a direct influence on the result-ing object arrangement in 3D space [8], [10] and [16].

In IVORY, the configuration of the interacting forces is doneby a second type of plug-in, the connection plug-ins. They pro-vide two adjustable parameters, rest length and the spring stiff-ness . Their values are defined through the metric method of theconnection plug-in. This method calculates a scalar value depend-ing on similarity of the two connected data plug-ins and

. The definition of expressive metric functions is still an ongo-ing research issue in information retrieval and can therefore beindividually adjusted.

In the current setting we propose four different mapping mod-els summarized as follows:

• Similarity mapped onto the rest length only:

(Chose sufficiently large)

(Rest length inverse proportional to stiffness)

• Similarity mapped onto the spring stiffness only:

(Stiffness proportional to rest length)

.

• Similarity mapped onto both parameters and :

and .

• Similarity mapped onto the rest length and the reliabil-ity of the value of mapped on the spring stiffness :

and .

All methods mentioned above are aiming at a mapping of objectsimilarities onto the parameters of the physics-based metaphor.That means, similar data objects will be tighten together by alarge and/or a small . The last version especially considersthe reliability of individual similarity values and is used for thevisualization of uncertain or unreliable data.

Relaxed Layouts

Self-organizing layouts are results of a simulation process relax-ing the configured system into an energy minimum. This processeventually performs the dimensionality reduction and discoversknowledge in data or confirms existing hypotheses about the data.Specifically, in explorative data analysis, clustering and aggrega-tion of data objects are extremely important methods. The layoutalgorithms used perform implicit cluster-based object arrange-ments, a more detailed discussion of which is given in [9].

3D Representation

The 3D representation is the essential step in the data informationflow. In order to assign color, material, texture, geometry or otherfeatures to the data objects or aggregations IVORY provides theplug-in mechanism, where a data-specific property mappingcould be defined for each data-type. The mapping from data prop-erties to visual attributes is done by the visualizer task. In addi-tion, IVORY provides a powerful set of user interactionsdescribed in the following subsection.

User interactions

The user interaction closes the feed-back loop by which the usercan optimize the visual data analysis process. Besides genericinteraction methods, such as free or constraint navigation in the3D-representation or object picking, IVORY supports specificallya so-called “drill-through” mechanism. That is, when picking anobject we can invoke any data-dependent operation on it, such asrequesting a 2D-visualization of the underlying data or direct dataediting. This is accomplished by implementing the appropriatemethod in the objects plug-in. In this way, for each data-typethere are various data-specific interaction methods provided forthe user. Generally, IVORY advocates the same intuitive interac-tion methods many users are used to from modern desktop win-dowing systems.

Another class of user interactions are the computer aidedanalysis methods. By the use of view filtering, for instance, theuser can select interesting subsets of objects. Conversely, cluster-ing is used as a method to handle complex visualizations, wheregroups of objects are condensed to one meta-object, a cluster.Applying this process recursively we can build hierarchicalobject arrangements. This enhances the overview and simulta-neously reduces the computational efforts. A third class of meth-ods are pathfinders. They are specifically designed for graph-based visualizations and enable to identify paths between individ-ual nodes in a graph [21].

Figure 3: IVORY’s information flow pipeline. 1) Data driven informa-tion flow. 2) User interaction (feed-back) information flow

SimulationProcess

Visualizer

Data-Acquisition (Data Base, Ticker, Internet, ...)

Layout-System

Relaxed Layout

3D Visual Representation

Propagator

SimilarityMetrics

Visualizer

User Interactions

l0k

sij didj

sij l0

k const= const

l0 inv sij( )=

sij k

k sij=

l0 const=

sij l0 k

k sij= l0 inv sij( )=

sij l0r sij k

k r sij( )= l0 inv sij( )=

k l0

Figure 4: Results of possible user interactions. a) “Drill-through” the dataprovided by a currency plug-in. b) 3D Arrangement of aHTML-page domain (similarity criterion is the URL) after in-voking the Blob-clustering algorithm from [9]. (See also ColorPlates: Figure CP-1)

a) b)

3.3 Framework KernelThe abstract framework kernel of IVORY contains generic imple-mentations of all common components underlying to our physics-based visualization paradigms and belongs to the set of data-inde-pendent components of the framework. Thus, kernel methods arehighly reusable and shorten the design cycles of novel visual met-aphors. Unlike most visualization systems, where the fron-tend/backend-separation is introduced to detach system-dependent from system-independent code segments, weemployed this notion primarily to run the system in client-serversetup over a network.

FrontendThe frontend is designed to run in a Java enabled WWW-browser.It consists of three parts: The visualization subsystem, which isresponsible for all visual system outputs, as well as for the han-dling of user inputs. The 2D graphical user interface (GUI),

shown on the left side of Figure 5, covers all standard I/O taskswith appropriate menus and dialog boxes. Per default, an outlineof all loaded objects (plug-ins) is shown as a collapsible treestructure. The 3D viewer is presented on the right side of Figure5. Note that the visualized objects do not belong to the frontend.They manage the visualization of the calculated object arrange-ments and basic navigation functions. In order to decouple thefrontend from the viewer we defined a generic 3D viewer inter-face. Thus, only the defined interface has to be re-implementedwhen changing the VRML viewer.

In addition we introduce two messenger components. Thepropagator is responsible to inform the backend, if a user interac-tion has invalidated the integrity of the frontend and the backenddata-structures. E.g. whenever the user manipulates the layoutparameters, the backend has to recalculate the correspondingobject arrangement and synchronize itself with the frontend. Thevisualizer performs in a similar manner, but in the opposite direc-tion from the backend data-structure to the frontend visualization.

BackendThe backend supports two different execution modes: Either it isdirectly attached to the frontend and runs in the same addressspace or it runs as a separate server-application on a differentmachine. In the second case the frontend and backend communi-cate over a Java socket connection.

One of the main design goals for the backend was a respon-sive care data-structure, where all the instantiated objects (plug-ins) are stored. It is strictly optimized for fast object insertion,deletion and look up. The structure is initialized by the IVML

subsystem, which is responsible for dynamic object instantiatingaccording to the parsed configuration script. Hence, this sub-system must be able to load and link unknown plug-ins at run-time.

As indicated by Figure 2, we distinguish between two differ-ent subsystem components accessing the core data-structuredirectly. The layout subsystem builds up a mass-spring-networkbased on the objects stored in the core structure. It also containsstate-of-the-art differential-equation-solvers to simulate networksrelaxation over time. This includes specifically gradient (Euler,Runge-Kutta) or stochastic (annealing) based-methods, where, inpractice, gradient algorithms are much more suitable to treattime-varying data. The second subsystem type is provided by theanalysis component comprising selection filters, pathfinders andclustering algorithms. The subsystem interfaces allow users at asystems designer level to easily extended kernel algorithms.

Transparent Network-LayerAll communication between frontend and backend is streamedover the transparent network-layer. Hence, the communication isgenerally transparent to all system components from above andguarantees full independence of the IVORY execution mode(stand-alone or client/server).

4 PLUG-IN MODELWhile defining the abstraction level of IVORY’s plug-ins, wefocussed on productivity and ease of use. Since Plug-ins onlycontain functions which implement a specific metaphor or rulethe plug-in programmer can concentrate his efforts on the data-specific issues. Recalling the information flow pipeline shown inFigure 3, a plug-in contains, for instance, the similarity metricsand the property- and behavior-mappers driving the visualizers.

For reasons of simplicity, plug-ins contain both frontend- andbackend-components. Conceptional, the separation is reflected bytwo groups of methods. Unlike AVS 5 [2], where separate compu-tation and description modules exist, an IVORY plug-in is alwaysviewed as one entity even though individual classes belong eitherto the client or to the server.

The design of new plug-ins takes advantage of the object-ori-ented approach of the framework, where we make extensive useof object inheritance. All plug-ins are derived from a small set ofbase classes and are thus organized in a hierarchical structure,illustrated in Figure 6. The most important classes are discussedin the following subsections.

Figure 5: Screenshot of the IVORY frontend running on a WindowsNT 4.0 machine under Netscape 4.04 with AWT 1.1 support.(See also Color Plates: Figure CP-2)

Figure 6: IVORY’s plug-in hierarchy: The base classes.

SimpleCompute

HapticDevice

EllipsoidCluster

BlobCluster

...

SimpleData

TimevarMultichData

...

SimpleConn

Interface abstract ClassClass extendsimplements

TimevarMultichConn

Displayable

Editable

Netobj

BaseConn

BaseObj

BaseAbstract

BaseData

BaseCluster

...

InterestIndexData

CurrencyData

...

InterestIndexConn

CurrencyConn

4.1 Base ObjectsThe base object class (BaseObj) builds the root of all plug-ins.Practically it’s the only object class known in the abstract infor-mation visualization kernel of the system. It essentially deter-mines the set of methods, the plug-ins could be accessed through.

A selection of the most important (abstract) methods aregiven below:

Frontend Methods• getIcon (abstract)

Optionally returns a reference to an icon resource. If avail-able, it will be displayed in the 2D outline window.

• getAppearance (abstract) Returns the description of the representation of the object inthe 3D viewer and is described in native VRML 2.0 [20].

• getDisplayComponent (implemented)This method provides the dialog component, which displaysthe information contained in the corresponding object. Thisincludes administrative information (id, position, flags, ...) aswell as stored user data.

• getEditComponent (abstract)If the object features editing, the method provides an editorcomponent for the above information. This enables specifi-cally data editing at runtime.

• getVisPar (implemented)Returns the previously calculated visual parameters by call-ing the method calcVisPar.

Backend Methods• calcVisPar (abstract)

Calculates the visual parameters (position, scale, orientationand color) of an object depending on the underlying data.This way, specific data-properties can be mapped onto visualattributes.

4.2 Data ObjectsData objects are directly derived from the base object class andserve as an access interface to the explored data. The data man-agement is individually solved by the current implementation of adata object. For each instance of a data object a correspondingparticle-mass is automatically created in the layout-subsystem.The setup of particle parameters is handled by the additionalbackend method explained below.

Due to its paramount importance for many applications wesupport time-variant data and multiple data channels per dataobject in our implementation. A good example is the analysis of aset of critical interest rates of different countries over the lastyears. In this case, a data object is allocated for each country. Ineach data object one channel is opened for each data feed [9].

Additional Backend Methods• calcParticle (abstract)

In this method non-visual parameters of the particle attachedto the data object could be parametrized. In this way theobject behavior during the layout process can be defined.

4.3 Connection Objects Connection objects are of the same inheritance level as the dataobjects. This object type serves as a binding object, which repre-sents the relation of two data objects and is of fundamental rele-vance for the resulting object layout.

For each connection object instance a corresponding spring iscreated in the layout-subsystem. The physical parameters of thespring are defined via the additional backend method describedbelow.

Additional Backend Methods• calcConnection (abstract)

In this method non-visual parameters of the spring corre-sponding to the connection object can be parametrized.

4.4 Cluster Objects Another object type of the first derivation level are the clusterobjects. They enable a hierarchical organization of the visualiza-tion and can be looked at as data object containers.

Note, that they are created by the corresponding clusteringalgorithm located in the analysis subsystem. For each identifiedcluster a new instance is allocated. The appearance of thisinstance is a result of the cluster analysis calculations. In Figure 7the resulting appearances of two different clustering methods areillustrated.

4.5 Abstract System ObjectOur experience has shown that generic objects without a visualappearance are very helpful for efficient solutions. Thus, weintroduce so-called abstract system objects. Examples are param-eterized global functions, such as data or currency converters.

Another area of application is the attachment of additionalI/O-devices. For example, our physics-based system is predesti-nated for the use of force-feedback devices. In the example pre-sented in Section 7, for instance, an object representing the deviceis derived from the abstract system class and helps to seamlesslyintegrate it into IVORY.

5 THE INFORMATION VISUALIZATION MODELLING LANGUAGE (IVML)

5.1 ScopeAs already explained in Section 2, the purpose of the script lan-guage developed for IVORY is to configure and parameterizeindividual visual metaphors implemented by the plug-ins. SinceVRML 2.0 is not sufficient to specify the topology of largegraphs, we had to devise a proprietary extension called IVML. Asan interpreted high-level language it enables users on the powerlevel to elegantly describe individual visualization problems andto build fast prototypes. The language is open, object-orientedand features scene graphs. In order to describe the geometry andvisual appearance of layouts VRML 2.0 code can be embeddedinto IVML.

Figure 7: Two implemented types of clustering. a) Blob Cluster andb) Ellipsoid Cluster. (See also Color Plates: Figure CP-3)

a) b)

Similar to VRML 2.0 the basic building blocks describing thescene are objects defined by fields. The following example out-lines a typical IVML object:

DEF myObj SampleData {label "Hello world!"num (23+7)/sin(0.334)visual IVVisual {color <0, 0, 1> * settings.intensity

}appearance INLINE "file:/vrml/lora.wrl"datapath system.scriptbase + "/dbase"

}

The object type SampleData is implemented by the corre-sponding IVORY plug-in. Thus, we do not impose any restric-tions to the number of object types in IVML. Other featurescomprise inline arithmetic expressions and references (set-tings.intensity), which replace the route mechanism along withJavaScript.

5.2 IVML specific NodesIn essence, the following IVML-specific nodes, whose hierarchyis presented in Figure 8, make up the extensions to VRML 2.0:

The header identifies the IVML script and version. #IVML 1.0

Constants are represented as strings in IvoryConst objects.DEF myconst IvoryConst {myTitle “Hello World!”myURL “http://hello.world.ch/basics.html”

}

System parameters are stored in an IvorySystem object,which is automatically initialized at parse time. It contains vari-ous fields, which are omitted here for brevity.

DEF system IvorySystem {cluster BaseCluster {visible TRUEtransparency 0.8

}layout BaseLayout {series IVTimeSeries {start 1.1.75stop 31.12.95

}}

info IVInfo {title "Economic indices"info ["Example for Ivory V2.0"]

}}

Environment objects contain VRML inlays to define individualbackgrounds, light sources, cursors and static scene parameters.

DEF env IvoryEnvironment {lights INLINE "brightLight.wrl"cursor INLINE "crossCursor.wrl"environment INLINE "financeEnv.wrl"billboards INLINE "extendetBboard.wrl"

}

Connectors are objects which support the automatic descriptionof the graph topology of the visualization problem. We distin-guish between so-called NameConnector and TypeConnec-tor. Both support wildcards to simplify the generation of objectconnections in very complex environments.

5.3 The Plug-in Interface

In order to reflect the plug-in mechanism, IVML featuresdynamic loading to invoke plug-in classes at runtime. It is similarto SGI’s OpenInventor.

The following example illustrates the idea. Here, we define asimple, static graph consisting of 6 data objects and 12 intercon-nections. The associated connectivity matrix is given by:

The IVML code fragment depicted below gives the full defi-nition of the graph. We start with a prototype definition of ageneric data object from which all subsequent instances arederived. The prototype contains a default initialization of infor-mation assigned to all objects, such as color or scale factors. Notethat the geometry of the prototype object is hardwired in the plug-in SimpleData, which itself is derived from the BaseData class(see also Section 4). Next, two individual objects (ellipses in Fig-ure 9) are instantiated overwriting some of the default parametersof the prototype. In particular, we overwrite the object appearanceby an VRML 2.0 expression, which can be either inline or URL.Likewise, we generate the four spherical objects. The subsequentprototype definition of connection objects is used by the follow-ing expression, which describe the links between all objects. Itcan be seen, that the wildcard expressions in IVML, such as "R*"tremendously simplify the definition of the graph topology of ourexample.

Figure 8: Hierarchy of IVML specific Classes

abstract ClassClass Interfaceextendsimplements

IvoryFieldContainer

Connector

NameConnector

TypeConnector

IVGravity

IVInfo

IVVisual

IvoryConst

IvorySystem

IvoryEnvironment

Table 1: Connectivity matrix of the example shown below

T1 T2 R1 R2 R3 R4T1 1 1 1 1T2 1 1 1 1R1 1 1 1 1R2 1 1 1 1R3 1 1 1 1R4 1 1 1 1

Figure 9: Layout computed from IVML script presented above

6 IMPLEMENTATION ISSUESThe IVORY implementation takes full advantage of all sophisti-cated features provided by Java 1.1. Each plug-in is mapped ontoa Java class. Thus, the loading of individual plug-ins at runtimecan be accomplished by the dynamic class loading mechanism ofJava. The Java reflection model is used by the IVML interpreterto check, read and set the field values of plug-in objects.

We use the naming convention for setter and getter methodsof Java Beans to access the underlying Java member variables.The Beans compliance enable to use all advanced Beans features,such as property editing. Although our current client-serverimplementation is based on a proprietary object serialization pro-tocol, we are currently working on an RMI-based method invoca-tion.

One of the critical implementation issues of IVORY was (andstill is) the 3D API. The OpenGL bindings, available in beta-ver-sion from [22], are fast, however, are on a low abstraction leveland do not support advanced object management by scene graphs.In addition, some rendering features, such as texture mapping arenot implemented. In addition, VRML parsing has to be providedby the user.

Unlike OpenGL, Sun’s Java3D [23] provides a powerful APIfor 3D graphics including scene graph optimization and VRMLextensions. The platforms comprise SUN and Windows 95/NT,however, the API has not been available during the implementa-tion of IVORY.

Therefore, an early version of IVORY was based on Dimen-sion X’s Liquid Reality class library [25], which was the onlyappropriate 3D Java API at that time. The robust beta versionsupported VRML and has been ported onto many platforms.Since the scene graph data structures are maintained in Java, thesystem performance is low.

Our current implementation uses SGI’s CosmoPlayer [24] forvisualization. Unlike the libraries from above, the software isessentially a VRML 2.0 viewer plug-in for WWW browserswhich has no immediate 3D API for Java. However, viewer con-trol and callback-functions can be invoked through the LifeCon-nect mechanism of the WWW-browser and the External AuthorInterface (EAI) of CosmoPlayer. The scene rendering is based onOpenGL and thus supported by a wide range of hardware acceler-ators. At this time CosmoPlayer is available for SGI, Windows95/NT and Apple Macintosh.

7 EXAMPLEIn physics-based visualization environments force-feedback

provides a natural human-computer interface and mediates anadditional sensoric cue to the user. Therefore, we invoked a Phan-tom® as 3D haptic interface. The Phantom enables to pick indi-vidual objects in 3D and to pull or push to “feel” the connectionstrength of objects for a given graph layout.

Further examples can be seen on our IVORY project home-page [26].

8 CONCLUSIONS AND FUTURE WORKWe presented a new approach towards a portable, object-orientedframework especially designed for physics-based informationvisualization. The system is open and expandable by adding newplug-ins. With the 4 layered abstraction model for users we pro-vide adequate interfaces to configure our system at differentabstraction levels. This covers a fast visualization prototypingusing predefined plug-ins, but also a very flexible low-level sys-tem access. We also introduce a new script language named Infor-mation Visualization Modeling Language (IVML), which isdistinctively proposed to describe information visualization prob-lems. Future work has to encompass the development of hierachi-

#IVML V1.0# Example: Simple Objects

# First set some global parametersIvorySystem {info IVInfo {

title "Simple Objects"info ["Ivory V2.0 Example"]

}}

# Define a prototype for our # data objectsPROTO data {SimpleData {

label "Simple Object "+me.namespaceFactor 5.0visual IVVisual {

color <1,0.5,0.5>}

}}

# Define the 2 Top-Objects specialDEF T1 data {visual IVVisual {

color <1,1,0.5>}appearance INLINE “ellipse.wrl”

}DEF T2 data {visual IVVisual {

color <1,1,0.5>}appearance INLINE “ellipse.wrl”

}

# Define the ring objectsDEF R1 data {}DEF R2 data {}DEF R3 data {}DEF R4 data {}

# Define a prototype for our # connection objectPROTO conn {

SimpleConn {defaultLength 10.0

}}

# make the connections# connect first top with all# objects in ringNameConnector{

template conn {}names ["T1","R*"]

}

# connect second top with all# objects in ringNameConnector{

template conn {}names ["T2","R*"]

}

# connect the ring objectsconn {

label "R1_R2"leftObj R1rightObj R2

}conn {

label "R2_R3"leftObj R2rightObj R3

} conn {

label "R3_R4"leftObj R3rightObj R4

}conn {

label "R4_R1"leftObj R4rightObj R1

}

Figure 10: a) User sitting in front of the haptical device. b) View on thevirtual representation of the haptical workspace. The layoutshows the influence of four economic indicators onto the longterm interest rates of different countries; Canada is currentlybeing dragged by the user.

b)

a)

cally organized layout subsystems, which make use of the objectclustering analysis embedded into the system. We expect a tre-mendous speedup for the layout. Secondly, a widely strewnusability test including daily-business cases in the areas of ourcooperation partner will validate IVORY’s performance in prac-tice.

ACKNOWLEDGMENT

This research has been made possible by the IT-Camp of theSwiss Bank Corporation (SBV), Basel, Switzerland. The authorsthank T. Strasser and D. Bielser for implementing parts of thesoftware.

REFERENCES

[1] Bruce H. McCormick, Thomas A. DeFanti, Maxine D.Brown, Ed.: Visualization in Scientific Computing (ViSC).In Computer Graphics, ACM SIGGRAPH, Vol. 21, Number6, Nov. 1987.

[2] AVS Homepage, Advanced Visual Systems Inc.,http://www.avs.com.

[3] IRIS Explorer Users Guide, Silicon Graphics Inc., MountainView, CA, 1991.

[4] Data Explorer Reference Manual, IBM Corporation,Armonk, NY., 1991.

[5] William J. Schroeder, Kenneth M. Martin, William E.Lorensen: The Design and Implementation Of An Object-Oriented Toolkit For 3D Graphics And Visualization, Pro-ceedings IEEE Visualization ‘96, pp. 93-100, 1996.

[6] Robertson G. G., Mackinlay J. D., Card S. K.: Cone Trees:Animated 3D Visualization of Hierarchical Information,Proceedings Human Factors in Computing Systems CHI ‘91Conference, New Orleans, LA, 1991, pp. 189-194.

[7] Munzner T., Hoffmann E., Claffy K., Fenner B: Visualizingthe Global Topology of the mbone, Proceedings Sympo-sium on Information Visualization 1996.

[8] I. Bruss, A. Frick: Fast Interactive 3-D Graph Visualization,Proceedings of Graph Drawing 95, Springer Verlag, LNCS1027, pp. 99-110, 1996.

[9] M. H. Gross, T. C. Sprenger, J. Finger: Visualizing Informa-tion on a Sphere, Proceedings of the IEEE InformationVisualization 97, pp. 11-16.

[10] R. Hendley, et al.: Case Study - Narcissus: VisualizingInformation, Proceedings of the IEEE Information Visual-ization 95, pp. 90-96, 1995.

[11] S. Card, S. G. Eick, N. Gershon: Information Visualization,SIGGRAPH 96 Course Notes 8, 1996.

[12] Keim D. A.: Visual Techniques for Exploring Databases,Invited Tutorial, Int. Conference on Knowledge Discoveryin Databases (KDD'97), Newport Beach, CA, 1997.

[13] XGobi, a System For Multivariate Data Visualization,AT&T Labs Research, http://www.research.att.com/~an-dreas/xgobi.

[14] Ahlberg C., Wistrand E.: IVEE: An Information Visualiza-tion and Exploration Enviroment, Proceedings InternationalSymposium on Information Visualization, Atlanta, GA,1995, pp. 66-73.

[15] MineSet: Silicon Graphics data mining and visualizationproduct, Silicon Graphics Inc., Mountain View, CA,http://www.sgi.com/Products/software/MineSet.

[16] T. C. Sprenger, M. H. Gross, A. Eggenberger, M. Kauf-mann: A Framework for Physically-Based InformationVisualization. Eight EuroGraphics-Workshop on Visualiza-tion in Scientific Computing, France, pp. 77-86, 1997.

[17] The source for Java Technology, SUN Microsystems Inc.,Palo Alto, CA, http://java.sun.com.

[18] Home of the latest technologies from IBM, IBM Corpora-tion, http://www.alphaWorks.ibm.com.

[19] TowerJ High Performance Native Java, Tower Technolo-gies, Austin, TX, http://www.towerj.com.

[20] The VRML Consortium, VRML Consortium Inc.,http://www.vrml.org.

[21] A. M. Tannenbaum, Y. Langsam, M. J. Augenstein: DataStructures Using C, Prentice-Hall, 1990.

[22] The Magician OpenGL Interface, Arcane Technologies Ltd,http://www.hermetica.com/technologia/java/magician.

[23] Java3D API Homepage, SUN Microsystems Inc., Palo Alto,CA, http://java.sun.com/products/java-media/3D.

[24] Cosmo Software Homepage, Silicon Graphics Inc., Moun-tain View, CA, http://cosmosoftware.com/products/player.

[25] Dimension Xs Liquid Reality, Microsoft Corporation, Red-mond, WA, http://www.microsoft.com/dimensionx/lr.

[26] CGRG Homepage, ETH Zürich, http://www.inf.ethz.ch/department/IS/cg/html/research/infovis.html.

Figure CP-1: Results of possible user interactions. a) “Drill-through” the data provided by a currency plug-in. b) 3D Arrangement of a HTML-page do-main (similarity criterion is the URL) after invoking the Blob-clustering algorithm from [9].

Figure CP-2: Screenshot of the IVORY frontend running on a Windows NT 4.0 machine under Netscape 4.04 with AWT 1.1 support.

Figure CP-3: Two implemented types of clustering. a) Blob Cluster and b) Ellipsoid Cluster

a) b)

Switzerland - SZ

a) b)