3 3 3W W WP P PS S S : a 3D Web-based Process Visualization System

creepytreatmentAI and Robotics

Nov 14, 2013 (3 years and 10 months ago)

134 views




: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


1
/
10

3
3
3
W
W
W
P
P
P
S
S
S

: a 3D Web
-
based Process Visualization System

Delfina Malandrino


Gennaro Meo

Giuseppina Palmieri


Vittorio Scarano


ISIS Lab

Dipartimento di Informatica ed Applicazioni “R.M. Capocelli”

Università di Salerno

84081
-

Baronissi (Salerno)
-

Italy


Abs
tract

In this paper, we describe 3WPS, a distributed system that is able to monitor and interact with a process
by a 3D interface accessible via the World Wide Web. 3WPS is easily configurable, easily adaptable to
different processes with high reuse of its

software components and its distributed architecture leverages on
off
-
the
-
shelf components of the WWW infrastructure such as Java applets and VRML browsers.

We present the characteristics of 3WPS, its design and implementation and, then, briefly present

several
applications built using 3WPS framework.

1

Introduction

The role of multimedia in the process control industry keeps growing: it is important for supervisors and other
personnel to be quickly informed of the behavior of a process so that further inv
estigations and/or appropriate
actions can be taken to keep the process along the required trail. In this field, multimedia visualization is an
appealing tool for this kind of users that need to be updated on (sometimes several) processes only through a q
uick
glimpse. It is, in fact, recognized that multimedia allows an increased amount of information to be communicated
and an improved way of drawing the operators attention to high priority information [
6
]. In some critical
app
lications multimedia role is critical since it avoids that high volume data either delays the appearance of a failure
or possible malfunctioning in the so called
“user’s universe”

[
17
] or makes the faults completely transparent

for the
operator altogether [
12
]. A non negligible aspect of multimedia is also that its ease of assimilation leads to more
efficient and effective operation [
15
] and that an engaging interface inc
reases operators satisfaction therefore can
improve operators efficiency in their job [
6
].

3D visualization techniques can be indeed a powerful technique to show large amount of information compactly
and, moreover, in such a wa
y to suggest behavior and affinity among different entities because of their placement in
the virtual world. Other techniques that use sounds to represent behavior of processes (“Sonification”) are currently
studied and research is very active in this area
. Examples for monitoring a WWW server in real
-
time by sounds and
graphical icons can be found in [
2
,
3
].

Recently, several specific systems for information visualization were designed, each one with

a definite realm of
application. The always growing availability of high performance client workstation and the widespread diffusion of
the Internet and the World Wide Web demand for a well
-
established platform that can be used to build 3D
visualization s
ystems that can be efficiently deployed with the minimal resource of work from programmers,
engineers and designers. A nicely built framework has been recently proposed by [
5
] that takes into account all the
technologies availa
ble on the Web to design a 3D Visualization System. Their framework is, nevertheless, intended
exclusively to the task of visualization of static data sets and neither dynamically changing data (necessary in process
monitoring) nor interaction with the und
erlying system by the 3D representation are taken into account.

In this paper we present a distributed system called 3WPS (pronounce “threewops”) that provides a framework to
build Web
-
based 3
-
dimensional visualization systems of processes. The framework a
llows to build a client
-
server
interface to a process whose behavior is monitored by the 3D representation. Furthermore, our framework allows to
easily program the client and the server in such a way that the user can interact with the 3D representation a
nd
his&her actions are then convoyed to the process. In this paper, therefore, we present the characteristics of the
system that allows, besides navigation of static data sets, to assemble a 3D
monitor

of a process, i.e. a 3D abstract
representation to the

behavior of the process, and (with little effort from the programmer) a 3D
interface

to the
process, allowing the user to interact with the process by using and navigating its three
-
dimensional representation.




: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


2
/
10

In the rest of the paper we briefly present t
he system and then propose several applications that substantiate our
claim of easy design and implementation of 3D monitors and interfaces to processes.

2

System Design and Architecture

3WPS is designed to offer an easily configurable and adaptable framewor
k to provide 3D dynamic monitoring and
interaction with software processes. Our system is directly interfaced with the data generated by the software
process that can be the originator of the data or, in case of monitoring of external devices, can be simpl
y a process
able to acquire data from the device. In the rest of the paper, if not differently specified we indicate by the term
process the software process.

2.1

Building Blocks Technologies

Virtual Reality Modeling Language

VRML (acronym for Virtual Realit
y Modeling Language) represents the WWW standard file format for describing
3D interactive and animated objects and worlds. It was conceived in the spring of 1994 when was presented at the
First International Conference on the World Wide Web. After a long
period of discussion, first VRML 1.0
specifications was presented in 1995 and was followed by the official VRML 2.0 specification that was released at
SIGRAPH 96. Later the proposal was standardized by ISO/IEC with the name of VRML 97 [
16
].

The specification of this version of VRML presented several extensions with respect to the previous version like
advanced static worlds, interaction, animation, prototyping but the most important to our objectives was the
integration with sc
ripting languages. In fact, before VRML 97, VRML 1.0 did not get the success that it deserved
because (among other reasons) it did not provide any expressive way of coding virtual animated and interactive
worlds and, moreover, integration with other progr
amming languages, such as JAVA, for power calculation
extension. Currently, the Web3D consortium is studying a proposal for X3D, an extensible and reduced version of
VRML that should favor portability and compatibility with the ultimate goal of proposing i
n 2002 a revision of
VRML and X3D into a common definition of what is likely to become VRML 2002.

Java External Authoring Interface (EAI)

It represents an external environment to interface a VRML world and a Java applet and is standardized in the ISO
stand
ard of VRML 97 (Part 2) [
16
]. It defines the functionalities of the VRML browser that are accessible. The
interface is mainly designed to allow an external environment to access nodes in a VRML scene by using the VRML
event mod
el where events are routed from a node in the scene to another node. It also allows interaction with the
VRML nodes that contain ECMAScript programs (
Script

nodes) therefore allowing a complete interaction between
the programs inside and outside the VRML b
rowser.

JESS: A Java Expert System Shell

JESS is an expert system shell and scripting language written in Java [
13
]. It is a tool for building rule
-
based expert
systems that can be coupled with code written in Java. JESS is ru
le
-
based: it uses repeatedly a set of rules to the
known facts about the topic. Using JESS it is possible to build Java applets and applications that can apply the rules
to known facts and it is used in 3WPS as the engine to determine the 3D representation

of the entities that represent
the status of the process. Once designed and realized the client, JESS offers the programmer the capability to
modify the representation of entities without having to write additional code.

2.2

Design Requirements

The overall g
oal of the project was to design a highly programmable and reusable framework to build 3D interfaces
to processes. Therefore, the main issue during our design was to keep the architecture as most abstract as possible
so that it could be easily adapted to d
iverse situations. This requirement also forced us to review beta versions of
3WPS by quick early prototyping 3D interfaces during the development of the system so that the necessary changes
could take place to introduce new features into the system.

The
3D interfaces built by 3WPS must be able to be distributed over different machines: it is often the case that
processes run on dedicated, highly specialized hardware/software platforms and the client is located elsewhere and is
a plain, vanilla
-
style works
tation (often a PC) that is available for the personnel involved in the management and
control of the processes. Therefore 3WPS had to offer also a high degree of portability as well as (almost) effortless
deployment, by leveraging on off
-
the
-
shelf softwar
e components freely accessible and easily configurable.




: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


3
/
10

3WPS was designed as a programmer
-
friendly development system: to adapt the system to simple process
monitoring few modifications are needed on the server and even fewer
(
if any) on the client side.
Once taken care
of the coding involved, the system can be easily made profitable by leveraging on VRML “programming” to develop
well simulated 3D metaphors of the objects that can be expressive and familiar for the users.

While using 3WPS for building an e
ffective and suggestive 3D
monitor

of a process is a rather trivial and smooth task,
3WPS offers the experienced programmer the tools to build a true 3D
interface

to a process by allowing the
processing of users interaction with the 3D representation that
are performed directly on the process
1
.

2.3

Software components of the system

3WPS architecture is a standard 3
-
tier structure where the real
process is interfaced to a process server that is originating the data
for the 3D representation and acts as a data
collector in both
directions therefore assuring data processing of user interactions
with the representation toward the process. In the rest of the paper
we will refer the process server as both
process

or
server
(depending
from the context).

The softwar
e components that we describe here are the process
server and the client. For each component, we briefly describe the
modules and their interaction with other modules of the same
component and with other components of the system. We anticipate, here, that
the client gets information also from
a standard WWW server, as described later in the paper.

The process server

The server consists of three modules: a
monitor

module, a
data
-
forwarder

module and a
request
-
processor

module. The
monitor is connected to t
he real server and collects the data from the real process to be repeatedly sent to the data
-
forwarder. The monitor is in charge of the association between the data sent from the real process and the abstract
intermediate representation of the entity that
are to be
represented by the client. Obviously, the monitor is the
part of the server that needs consistent code rewriting
since it is application dependent.

The data
-
forwarder module gets the abstract information
about entities to be represented, compar
e them to those
previously received and determines the changes occurred
in the state of the real process. For each entity, the
module receives an identifier and a set of attributes. By
comparing the data received to those previously received,
the data.
-
for
warder is able to understand whether there
are new entities, if existing entities are non existing anymore and must be deleted or if attributes of previously
created entities are changed. The result of this comparison is sent to the client by using a simp
le communication
protocol: each message consists of
<action, id, attr1, attr2, ..>
where action is one of
{CREATE, MOD, DEL}
for
creation, modification or deletion of the entity whose unique identifier is
id

and
attr1, attr2, …

are the value of the
attribu
tes.

Finally, the request
-
processor module is in charge of processing user interaction with the 3D representation and
send the information to the monitor module that will perform the requested actions on the real process.

The parts of this components that

are application
-
dependent and therefore can require some coding are the monitor
(since it is the interface to the real process and transforms the information into semantically meaningful entity) and
(if a 3D interface is desired) the request
-
processor.

T
he client

The client is a Java applet that is interfaced with a VRML scene via External Authoring Interface and exploits an
expert system shell called JESS to associate entities and their modification (as received by the server) with the



1

Of course, such an interface must conform to the necessary security and privacy requirements that are dependant on the nature

of the process itself.
Authentication of interfaces are not provided by 3WPS b
ut can be easily adapted by using standard protocols used on the WWW such as Secure HTTP
(HTTPS) and Secure Sockets (SSL).

Process

Server

Real
Process

Client

Real

Proces
s

Client

Data
-

forwarder

Request
-

processor

Monitor

Process Server




: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


4
/
10

correspondent 3D r
epresentation. Therefore, this component also consists of three modules: a
communication

module, a JESS
expert system

module and a
visualization

module.

The communication module is in charge of sending/receiving the information about entities from the se
rver. Data
received from the process server are first sent to the JESS module that is able to compute the necessary changes into
the 3D representation from the JESS rules specified and the values of the attributes received. This information is
then sent to

the visualization module that can instruct the VRML browser to perform the changes in the scene. The
visualization module is also in charge of sending, when triggered by user events taken from the VRML browser
(such as mouse clicks). User events can be mo
re complexly defined by using VRML sensors and have events
triggered, e.g., by a Proximity sensor when the user is navigating the scene and approaches a position.

2.4

3D representation of entities

Entities are the abstract representation of objects in the re
al process such as files (when monitoring a filesystem),
users (when monitoring users behavior on a machine), etc. The association between real process objects and entities
is first done from the monitor module into the server that is also in charge of fix
ing the semantics of the attributes,
giving each field an interpretation that is later used by the client (with JESS rules) to associate VRML parameters of
the 3D representation (color, size, rotation, positioning, etc.). For example, for each file, the fi
rst attribute may
indicate the size in bytes, the second may indicate the file extension and so on.

Categories

It is important to be able to group (in the representation) entities that are semantically homogeneous. Obviously,
this aspect is application de
pendent, but 3WPS offers a flexible tool by allowing the superimposition (on the
representation) of a hierarchy to the entities by mean of
categories.
This is a particularly useful feature of 3WPS: it is
recognized that the usage of 3D representations has
the possible drawbacks of possibly cluttering and occluding the
vision by unstructured and casual positioning of objects in the virtual scene therefore degrading the usefulness of
3D display [
11
]. Offering the programmer the ab
ility to specify the categories and the criteria used to distinguish the
category an entity belongs to, it is possible to design a scene that is informative for the user.

A category is a collection of objects that share some characteristics of the 3D repre
sentation. Belonging to a category
is determined by programming the rules used by the JESS expert system. In order to facilitate the usage, we
structured categories hierarchically: each category may contain one or more children categories and all categorie
s
(except the root) has a parent category. It this way we can easily use the natural hierarchical organization of 3D
objects by VRML. Any category is represented by a VRML node and it is assigned a unique identifier, a position and
a set of attributes. It
is relevant to notice the root category contains the whole VRML scene while 3D objects are
Real

Process

JESS

module

Visualization

Communication

Client

Process

Server

WWW server

(rep
ository)

EAI


VRML

templates

JESS

rules

VRML browser

Figure
1
:
The architecture of the client: a Java Applet with modules to interface with process server and the VRML browser.




: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


5
/
10

visualized only by leaves categories (with associated VRML nodes) that establish how entities are represented by the
corresponding 3D VRML object.

Positioning of the

objects

To ensure comprehensibility, we also give to any category a position and a gap, to interleave different objects.
Position of an object is obviously dependent on the category it belongs to. Each time an object is added into the
category (at visuali
zation time) its position is evaluated using the initial position of the category, the gap between
objects in the category and the number of objects in the category. In this way it is easy to achieve the linear
placement of objects by simply choosing the p
arameters. In case more complex placement are required (circle, etc.)
it is possible to modify the strategy to evaluate the position by programming the Client.

Using JESS to represent 3D objects

JESS rules are used to bind each entity with the correspondin
g 3D VRML representation. The programmer writes
the JESS rules in a file that is loaded by the applet at startup; in this way smooth modifications of the representation
can be achieved.

First of all, JESS rules allow to specify categories and their charac
teristics. The following is an example: after initial
settings and functions loading, the function
AddTemplate

is called to insert a new category
Object
having as parent the category
RootScene
.
The third field of the function contains the
VRML definition o
f the category: in most cases
it is convenient to use the VRML characteristics
of defining an external prototype
2

(in this case
Acube
) that has three exposed fields (therefore
instantiated by the client applet with the
corresponding parameters) and an URL
where
the prototype resides. Then also the root scene
is inserted with empty parent and with no
VRML representation (the VRML scene is
passed as a parameter to the applet). Finally, positioning is obtained by calling the function
PositionCategory

with init
ial
coordinates.

Once categories and entities are associated to VRML objects, JESS rules can drive their representation. A rule is in
the form
Condition
-
Action
. In the example on the right, the entity is a
file in a directory and the first attribute is it
s extension while the
second is its size in KBs. The first rule sets the entity to belong to
category TextFile if the extension is .txt while the second,
depending on the size, sets its attributes (as defined in the
prototyped node), i.e. size of the cube
and color. Other functions
are available, like
SetGap
to choose the gap in the positioning.
Standard JESS operators to manipulate boolan values, integers and
string can be composed providing the programmer a easily
customizable environment. Rules can be al
so written for categories,
in order to allow, for example, adequate resizing of the VRML
objects acting as physical container in the scene (the object is specified in the category definition) according to the
size (i.e. number of entities within) of the ca
tegory. The only difference is that for categories only two attributes are
usable: its name and the number of entities currently inserted.

3

Programming monitors and interfaces by 3WPS

In this section, we describe the nature and the amount of work to interfa
ce a process with 3WPS and obtain a 3
-
dimensional representation of the process to be monitored. The work is concentrated on several components and its



2

Of course, it is possible to insert directly into the JESS rule the definition of simple VRML objects but prototypes are very

usefu
l for accessing and reusing
libraries of VRML objects.

(defglobal ?*funz* = nil)

(bind ?*funz* (fetch OGGETTI))

(call ?*funz* AddTemplate "Object" "RootScene"

"EXTERNPROTO ACube[

exposedField SFVec3f translation

exposedField SFVec3f scale

exposedField SFC
olor colorOfText

]

\
"http://isis.dia.unisa.it/Prototipi/Cubo.wrl
\
"

ACube {}


"

)

(call ?*funz* AddTemplate "RootScene" " " " ")

(call ?*funz* PositionCategory "Object" "0 15 20")


(defrule reg1


(oggetto (id ?i) (attrib1 ?a1) (attrib1 ?a2) )


(tes
t (eq (str
-
compare ?a1 “.txt”) 0) )

=>


(call ?*funz* SetCategory ?i "TextFiles")


)

(defrule reg2


(oggetto (id ?i) (attrib1 ?a1) (attrib1 ?a2) )


(test (and (< ?a2 30) (> ?a2 14) ) )

=>


(call ?*funz* set_attribute ?i 1 ”1 1 1")


)






: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


6
/
10

consistence depends on the particular nature of the process and the degree of interaction with the proce
ss itself, i.e.
if we want to build a simple 3D monitor or rather obtain a 3D interface by which it is possible to drive the process.

Let us start with the work necessary to build a monitor. In general, different skills are required to visually render th
e
behavior of a process: first of all, it is necessary to have the core competence of the nature of the process to be
monitored. It is, in fact, crucial that the relevant parameters are identified so that the representation is helpful and
informative
3
. In
this case, the competence in the application field is used to build and modify the server (Java) that is
in charge of driving the client in the representation.

Secondly, it is necessary that the 3D virtual representation, while retaining its information f
or the user, is also nicely
designed and pleasantly suggestive of the nature of the objects monitored in order to avoid cognitive overload [
19
]
and grasp the positive characteristics of 3D worlds. To such a goal, it is necessary t
o make use of VRML features by
providing templates of good quality to represent the objects and the process.

Finally, it may be necessary, because of the particular nature of the process, to add categories of objects and
constrain the placement and behav
ior of the objects in the system. In this case, it may be necessary to modify and
integrate both JESS rules and the client (Java Applet) to obtain the desired representation. It is relevant to notice,
though, that the modifications required to interface wi
th simple processes are very simple and straightforward and,
in some cases, can be obtained by simple rewriting of the code (VRML, Java, JESS rules) that has been developed by
us for the example applications provided in Section
4
.

The 3WPS client of an interface is, of course, more complex and, therefore, more work is necessary to build a client
that is able to catch the interactions of the users with the 3D representation of the process and use them to drive the
process accord
ingly.

4

Applications and examples

3WPS is built to be easily adapted to several fields of applications, shown in the figures at the end of the paper. We
implemented several interfaces and monitors to diverse applications that supplied us with the proof
-
of
-
c
oncept of
the reusability of 3WPS system components [
18
].

Here we briefly describe some of the applications. The first two applications were simple monitors to the behavior
of a Unix machine by visualizing users activity (idle

time, Cpu utilization and user) and processes activity (Memory
and Cpu usage, users, type of process).

The third application is a 3D interface to a filesystem, a known technique to improve navigation and accessibility to
large directories (an example in
this area is a prototype of the Silicon Graphics 3D File Manager [
8
,
20
]).

Here 3WPS has proven itself useful and effective as a tool to build interfaces rather than simple monitors. In fact,
the v
isualization system built with 3WPS is able to perform actions on entities (files) represented by VRML objects
through user interaction with the VRML browser and the applet.

The entity here is the file and the attributes for the representation are its siz
e and its extension (i.e. its type).
Categories are very relevant for this application and are represented by small houses whose size is proportional to
the number of items in each category. In fact, in this example, rather than associate category only wit
h a position (as
in previous examples), each category is associated with a VRML file that is introduced into the scene with attributes
dependent on the size (i.e. number of entities). Interaction with the user is given by responding to the click on the
VRM
L object: if the click is on a folder object than the process performs a change directory and redraw the new
environment for the navigation. A
Back

button is provided for switching back to the parent directory. Interaction
with other files corresponds to l
aunching the browser with the new URL: it is shown according to its type by
leveraging on the general display mechanism provided by the Web browser and the underlying environment.

Another (marginal) field of application is algorithm animation. It is clear

to the reader, at this point, that 3WPS is
not an algorithm animation system since (among other differences) it lacks the control over the animation by a
director module for synchronizing and orchestrating the representation (for an example of a sophistic
ated and
complete algorithm animation system see [
9
]). Nevertheless, it has been satisfactorily used for simple animation
(monitor) of Java distributed algorithms using JPDC (Java Package Distributed Library) a prototype Java l
ibrary
actually in the final phase of development in our laboratory.




3

In our case, as shown in Section
4
, we chose as example applications typical software processes so that our team had the necessary expertise and knowledge to
find the mos
t relevant parameters to be represented.




: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


7
/
10

5

Conclusions and further research

3WPS is a highly and easily programmable environment to build 3D monitors and interfaces over the Internet to
processes. Java coding to modify client and

server is very small (for standard applications) and the most part of the
“programming” is done by adequately configuring JESS rule files and VRML templates.

3WPS can be used also for off
-
line navigation of static data files such as, e.g., the graphical
interpretation (over the
time) of a large log file. In fact, it is a common to collect information about the behavior of a process on data files
that are often huge and that necessarily need an highly evolved interface to allow a batch, off
-
line but quick

interpretation. In this context, 3WOPS supplements the capabilities offered in [
5
] by offering also the possibility to
build a monitor and an interface to a real
-
time process.

3WPS is distributed in nature and this important
characteristic allows both an easy extension to multiple displays for
the same process (therefore improving the reliability of the whole monitoring process by involving several operators
at once) as well as multiple data sources as input real process, an i
mportant feature given the increased complexity of
large scale distributed systems that dictates efficient monitoring services [
1
].

An important consideration is about the efficiency of the representation on the client
-
side. Si
nce the system places a
rather high computational load on the client
-
side, that is, furthermore, using non specialized software components
such as VRML browsers, it is clear that the client is to be a machine with a considerable amount of processing
powe
r (
fat
-
client
). However, it must be also said that, according to our experiences, commonly available PCs are
appropriate for medium size processes.

Future work includes other applications as well as further improvement of programmer interface, including a

graphic tool to build the JESS rules to be used, as well as testing more efficient ways for representation and
navigation of 3D scenes (Java 3D, X3D browsers) to overcome known shortcomings [
5
] of availability and
compatibilit
y of VRML browsers.

Information about 3WPS, source code and other material will be soon available at
http://isis.dia.unisa.it/3WPS
.

Acknowledgments

The authors gratefully acknowledge helpful and stimulating discussion with Umberto Ferraro and Alberto Negr
o. We also thank the students
of the ISIS
-
Lab and, in particular, Ada Compagnone for the help provided by interfacing 3WPS with Java distributed programs using Java
Package for Distributed Computing.

References

1.

E. Al
-
Shaer, H. Abdel
-
Wahab, K. Maly (1999).


HiFi: A New Monitoring Architecture for Distributed Systems
Management”
. Proceedings of IEEE 19
th

International Conference of Distributed Computing Systems.

2.

M. Barra, T. Cillo, A. De Santis, U. Ferraro, A. Negro, V. Scarano. “
Webmelody: Sonification of W
eb Servers
”. Poster
Proceedings of 9
th

World Wide Web Conference (WWW9). May 15
-
19 2000. Elsevier Science. Winner of the
Best Poster Award at the conference.

3.

M. Barra, T. Cillo, A. De Santis, U. Ferraro, A. Negro, V. Scarano. “

MMM: MultiModal Monitoting o
f Web Servers
”.
Submitted for publication.

4.

M. Barra, T. Cillo A. De Santis, U. Ferraro, A. Negro, V. Scarano, T. Matlock, P. Maglio. “
Personal WebMelody:
Customized sonification of Web Servers”
. Proceedings of the 2001 International Conference on Auditory
Display
(ICAD 2001). Espoo (Finland) July 29
-
August 1, 2001. (Accepted for publication as long paper).

5.

M. Bender, R. Klein, A. Disch, A. Ebert (2000). “
A Functional Framework for Web
-
based Information Visualization
systems”.
IEEE Trans. On Visualization an
d Computer Graphics. Vol.6, No.1. January
-
March 2000.

6.

M. Bergan, J.L. Alty (1992). “
Multimedia Interface Design in Process Control”
. Proceedings of IEEE Colloquium on
Interactive Multimedia: A Review and Update for Potential Users.

7.

D. Brutzman (1998). “
The

Virtual Reality Modeling Language and Java”
. Communications of ACM
41

6 (1998).

8.

R. Camiciottoli, J.M. Corridoni, A. Del Bimbo (1998).
“3D Navigation of Geographic Data Sets”
. IEEE Multimedia.
Vol. 5 2, April
-
June 1998.

9.

G. Cattaneo, U. Ferraro, G.F. Italia
no, V. Scarano. “
Concurrent Algorithms and Data Types Animation over the
Internet”
. Proceedings of
Fundamentals and Foundation of Computer Science
, 15
th

IFIP World Computer Congress,
Wien (Austria), August 31, Sept. 4 1998.

10.

E. Chan, S.T.Y. Liang, H.Y. Ta
m (1994). “
Design of a Monitoring and Control System for the Support of a Cooperative
Dynamic Monitoring Model”
. Proceedings of IEEE International Conference on Industrial Technology 1994.




: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


8
/
10

11.

J. Cugini, S. Laskowski, C. Piatko. “
Document Clustering in Concept

Space: the NIST Information Retrieval Visualization
Engine (NIRVE)”
. Available at
http://www.nist.gov/itl/vvrg/cugini/uicd/cc
-
paper.html

12.

V. De Florio, G. Deconink, M. Truyens, W. Rosseel, R. Lauwereins (1998). “
A Hypermedia Distributed Application
for Mon
itoring and Fault
-
Injection in Embedded Fault
-
Tolerant Parallel Programs
”. Proceedings of 6
th

EuroMicro
Workshop on Parallel and Distributed Processing.

13.

E.J. Friedman
-
Hill (2000). “
Jess, the Java Expert System Shell
”. Sandia National Laboratories Tech. Rep
.
http://herzberg.ca.sandia.gov/jess

14.

W.I. Grosky (1994).
“Multimedia Information Systems”
. IEEE Multimedia, Spring 1994.

15.

A. Guha, A. Pavan, J.C.L. Liu, B.A. Roberts (1995).
“Controlling the Process with Distributed Multimedia”
. IEEE
Multimedia. Vol. 2 2 (S
ummer 1995).

16.

International Standard ISO/IEC (1997) “
14772
-
1:1997: The Virtual Reality Modeling Language.”

http://www.vrml.org/Specifications/VRML97
.

17.

B.W. Johnson (1989).
“Design and Analysis of Fault
-
Tolerant Digital Systems”
. Addison
-
Wesley, New York.

18.

D.M
alandrino, G.Meo, G.Palmieri, V.Scarano (2001). “
Web
-
based Visualization of Processes
”. Submitted for
publication.

19.

J. Nielsen (1995)
"Multimedia and Hypertext. The Internet and beyond"
. AP Professional, 1995.

20.

S. Strasnick, J. Tesler (1995). “
3D Informati
on Landscapes
”. Tech. Rep., Silicon Graphics, Mountain View,
California (USA), 1995






: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


9
/
10

6

Figures


Figure
3
:

Monitoring processes by CPU and memory usage (size and
rotation speed), type (icons) and user (grouping).

Figure
2
:

An example of the 3D representation of users on
a Unix machine. Here rotation speed is the inverse of Idle time, size is CPU
usage and icons are dependent on the users (they may be also the picture of the user).




: A 3D Web
-
based Process Visualization System

Version:
14/11/13

(
12.10
)

D. Malandrino, G. Meo, G. Palmieri, V. Scarano


10
/
10


Figure
5
:
An example of a simple animation of a distributed algorithm to build a spanning tree over a set of 7 nodes. Rather
than
depict the image of the spanning tree, we chose to represent the message complexity of the running algorithm i.e. each edge c
orresponds
to a message. This example is paradigmatic of an unconventional use of 3WPS that required little coding more on the

client side to
represent messages by edges.






Figure
4
:

On the left it is shown the representation of the di
rectories as a set of houses, one for each category while on the left the
user has navigated by the VRML browser inside one of the houses. Notice that the size of the houses is dependent on the numbe
r of
items in the corresponding category.