To appear in the VRML 99 conference proceedings
VRML History: Storing And Browsing Temporal 3D-Worlds Hartmut Luttermann
Manfred Grauer
University of Siegen
Abstract Spatio-temporal data are presented and explored by VR-based visualization systems which offer 3D-navigation and time-navigation for better immersion and analysis. If the visualization results are disseminated on the WWW, they are mostly transformed into videos or, recently, into animated VRML-files which neither support 3D-navigation nor time navigation nor a time-referenced data representation. In this paper, the script language VRML History is proposed which supports the description of spatio-temporal worlds on the internet by conceptually extending VRML with a new time dimension. This is realized by a set of new nodes representing temporal geometries and time references, and a set of Java-classes extending standard VRML-browsers to perform time navigation. CR Categories and Subject Descriptors: I.3.6 [Computer Graphics]: Methodology and Techniques I.3.7 [Computer Graphics]: Three-Dimensional Graphics and Realism—Animation, Virtual Reality H.5.2. [Information Interfaces and Presentation]: User Interfaces—Interaction Styles H.4.3 [Information Systems Applications]: Communications Applications—Information Browsers Additional Keywords: Spatio-Temporal Data, Data Visualization, Data Modeling, VRML
1 INTRODUCTION In the last years, the amount of temporal (historical) and especially spatio-temporal data has dramatically increased. They are produced by scientific experiments and simulations or recorded in data warehouses and temporal GIS for making management decisions more reliable and comprehensible [12, 2]. One particular point of research is the temporal nature of the data: how does a special feature behave at certain times and how does it evolve over time [9]. The presentation and exploration of spatio-temporal data is performed by special visualization systems which transform data into a graphical form [12, 7]. Many times, the temporal nature of the data leads to animated visualizations which depict change over time. There are two kinds of animations [4, 14]: temporal and cartographic animations. In temporal animations, a change in the presented objects is based on temporal data. In cartographic animations, there is a change relative to factors other than time, identified
University
of Siegen, D-57068 Siegen, Germany fhartmut,
[email protected], http://www-winfo.uni-siegen.de
as the visual animation variables [11], such as a change in the camera position, ligth source or other non-temporal variables. Therefore, VR-based interaction methods like navigating the spatial or temporal dimension of the visualization are offered to better investigate the data set and immerse in the presented virtual objects. In many applications, these visualizations are published in the WWW because of e.g. knowledge transmission, cooperative work, marketing, or documentation. Animations are transformed into videos or, recently, into animated VRML-files because they keep the temporal nature of the visualization. While videos do not support 3D-navigation, VRML itself does not support a technique which controls the time dimension of the visualization during the presentation. Instead, VRML-animations can neither be interactively stopped nor run backwards (possibly with different speeds). In the worst case, single frames may be skipped depending on the system’s frame rate. Additionally, VRML does not allow a distinction of the presentation of temporal data and cartographic animations because in the representation of the visualization every change is referenced to some unique time during presentation. A simple solution is a VRML-based navigation interface which controls the time used for animations. But this time is local to the specific animation object and does not give control to the whole scene. Additionally, there is no support for the description of temporal data. In visualization systems, there are two main approaches to store this type of visualization. Some systems store the basic spatio-temporal data together with a script instructing how to create the visualization [15, 19]. Others store the visualization itself using a proprietary, system-dependent file format [13, 8]. In both cases, browsing the visualization requires the specific visualization system and enough operating knowledge on the user’s side. Recently, new graphic libraries and graphic file formats were developed, e.g. Java3D, Chromeeffects or ScriptV [20], but all of them treat the presentation of temporal data like a cartographic animation without any time navigation technique. In this paper, VRML History [21] is described which consists of a set of nodes extending VRML with a new time dimension and a set of Java-classes extending a standard VRML-browser with a time navigation technique. With VRML History, spatio-temporal object data in 3D-worlds can be described, stored in VRML-files on the internet, and explored spatially and temporally by a VRMLbrowser.
2 TEMPORAL DATA MODELING Temporal data modeling is an essential part in the description of temporal 3D-worlds which involves concepts like valid time and time-variant objects.
2.1 System Time vs. Valid Time The time concept existing in VRML simulates approximately ”real time” by generating events as time passes. Therefore, it is not changeable by the viewer. For a better distinction, this time is called system time. All events specified in VRML are referencing this time and consequently, are only activated if they are referenced to a time
To appear in the VRML 99 conference proceedings
3 TIME NAVIGATION
during the presentation of a VRML-scene. Practically, they all are anchored relative to the beginning of the presentation. Future and past events being activated during presentation are only possible if a new time dimension, called valid time ([Snod95],[Lan92]), is introduced. Valid time is independent of system time and specifies the time when an event or a state was valid, is valid or will be valid in the real world. During presentation a specific valid time value only changeable by the viewer is used to show only those events or states which are valid at that time. The time model of valid time is linear and continuous to be independent of the resolution of discrete time values. With valid time, each object can be shifted to a temporal object o : (a0 ; :::; an ; vp) described by the attributes ai and by the valid period vp. The valid period restricts the time of existence or validity of the object in the temporal world to the time period [t0 ; tn ): The object starts to exist at t0 (object’s birth) and dies at tn . Outside this period the object does not exist, i.e. there is no information or representation of the object available. A temporal object can always ; ). be valid, i.e. the valid period specifies (
Presentation tools need a real-time interaction method which allows the viewer to investigate the temporal dimension of the visualization. Like in 3D-navigation, a special viewpoint in the valid time dimension is needed from which the temporal world is currently viewed by the user. In this view, only those objects and their representation are shown which are valid at the time given by the current viewpoint, such as a time-slice or snapshot of the temporal world. Changing this valid time allows the viewer to move through the temporal dimension of the world. The time navigation should be performed in parallel to the spatial navigation because both dimensions are independent. It should be global, i.e. performed synchronously to all objects defined in the temporal world. For the viewer, this is more intuitive and the presented scene is easier to be understood and recognized than if the local valid time of each object is changed independently like in [8] because the viewer has to keep in mind the chosen time values of every object presented. Instead, if some applications (e.g. scheduling, simulations) need to view different objects at different valid times, an easier technique is to move the valid period of these objects along the valid time dimension by e.g. an interactively given time offset for each object. Being aware of the valid time presented in the current scene might even be a big problem in the global time navigation paradigm because only one snapshot of the temporal world is shown which is not sufficient for the viewer to get an overview of the temporal dimension of the world. However, in the 3D-navigation this is possible by the spatial perspective view. Additionally, during presentation it is important to distinguish between change based on system time (cartographic animation) and change based on valid time. Therefore, some additional visual information are useful to tackle these problems, e.g. displaying the current valid time or a virtual time line showing the time of existence of all objects in the world. During presentation, events need a special handling because they are hard to be discovered. While navigating in the time dimension, their time of existence quite often falls in between two presented snapshots. If they are presented in a single snapshot, no information about their moment-like valid period is shown.
?1 1
2.2 Time-Invariant vs. Time-Variant Objects Integrating valid time moves the formerly only spatial world to a spatio-temporal world with many temporal 3D-objects whose spatial or graphical description may be time-invariant or time-variant. Time-invariant objects possess only one non-changeable representation which is valid during the given valid period. Time-variant objects may have different representations (versions) vi where each is valid at the associated version time period [ti ; ti+1 ) existing during the valid period of the object: o : (v : (v0 ; :::; vn?1 ); vp : [t0 ; :::; tn )). If no representation exists at a version time period this simulates the invisibility of the object at this period which is an allowed representation. The set of version time periods of each object is mutually exclusive and sums up to the valid period of the object because temporal objects can accept only one version of itself at each point in valid time. The list of consecutive representations one object possesses during its valid period is called version history. Different types of version histories can be identified in the real world which affect the semantical interpretation of how objects do evolve over time: they may describe a) a series of discrete, constant versions, where one version is valid until the consecutive version starts immediately (step-wise function). This type is mostly used for administratively registered spatial data (e.g. borderlines, streets, real estate). Or b) a time series, i.e. a sequence of pairs of discrete versions and time values forming the base points of a continuously changing, linearly interpolated property, which are mostly used for natural phenomena (e.g. ground water level, moving car). A special case are events which have only one version valid at a very short period approximating a moment in time (e.g. accidents). Each version has its own version time period, i.e. is timestamped. The question what a version describes is very important for temporal data modeling and storage [17]. Normally, each version describes the whole object representation (vi (o) = (a0i ; a1i ; :::; ani )) which is called tuple-timestamping [16]. If some attributes are constant, while others change very frequently at different times this would lead to many redundant attribute values. Therefore, a less redundant and spaceconsuming data structure called attribute-timestamping [1] exists which stores a timestamped version history to each single attribute (o : ((va0 ; vpa0 ); :::; (van ; vpan ))), though leading to a split object description. Although attribute-timestamping is preferred, both strategies should be offered to the author for describing spatiotemporal data because the efficiency (related to redundancy, space efficiency and data access) depends mainly on the data itself.
4 REALIZATION VRML is extended by a set of new and changed nodes (VRML History) to realize the concepts and requirements described above. In the following, these nodes are explained, justified, and compared with other realization options. It is assumed that the reader is familiar with the VRML-notation.
4.1 Valid Time Definition The ValidPeriod node is designed to define the validity of objects as well as of its versions by specifying a list of consecutive times (t0 ; :::; tn ) via the period field. ValidPeriod { exposedField exposedField exposedField }
SFBool MFTime SFTime
loop period periodOffset
FALSE [] 0.0
?1 1 1
Let n times t0 ; t1 ; :::; tn partition the time domain ( ;+ ) into n+2 subintervals given by ( ; t0 ); [t0 ; t1 ); :::; [tn ; + ) each subinterval defines one version time period and the interval [t0 ; tn ) defines the valid period of the object. For each subinterval
?1
2
To appear in the VRML 99 conference proceedings series of constant object versions. The valid period of this timevariant object is given by the sum of all version time periods.
in the valid period a version may be defined. In the subintervals ; t0 ) and [tn ; + ) the object does not exist, i.e. no version is valid. Time periods are designed as closed-open intervals, i.e. the time concluding a period simultaneously describes the beginning of the next period. Sometimes, a version is valid only at one discrete moment, i.e. the associating version time period has no duration. For this special case a closed subinterval [ti ] may be defined which automatically changes the following subinterval from a closed-open into an open subinterval: :::; [ti ]; (ti ; ti+1 ); ::: . The starting times of the version time periods are defined relative to an absolute time offset given by the field periodOffset which is mostly used in scientific experiments and simulations. The field loop specifies whether the version history of the object is periodical (e.g. tides), i.e. whether the first, second, etc. version is valid again right after the last version. All time values are given as numbers relative to a global time origin. This avoids parsing time values with different date formats and calendars. In VRML, values of the system time (type SFTime) are defined as seconds since 1 January 1970,00:00:00. For the valid time, the same is assumed, but other application-dependent units (e.g. days, years) may be used because valid time has no link to system time which has to use one time unit to identify specific times.
?1
(
1
4.4 Temporal Scene Graph In VRML, all objects are stored in a scene graph combined with geometrical transformations to determine the absolute location of the objects in the world. To determine the period of validity of each object in the world, valid time is integrated in the scene graph yielding a temporal scene graph (Fig. 1). The maximal validity of each child, regardless of being a time-invariant or time-variant object, is given by the version time period of the parent. Following the branches from the root of the temporal scene graph to the leaves, the period of validity of each branch can be limited again and again by History nodes (circles with time periods inside). The History node can also be the root of a set of children each giving its own mutual exclusive validity. The world specified with the root of the ; ). temporal scene graph is always valid, i.e. ( The temporal scene graph does not contain temporal transformations like move or scale because both are rarely used in the description of time information of temporal data. Instead of using relative time values transformed by multiple move operations possibly with different units (e.g. years, months, days), absolute time values are used more often by the user.
?1 1
4.2 Which VRML-Objects may be Time-Variant ? VRML supports nodes of various semantical types: grouping, graphical shape including sound, geometry, and appearance (with color, texture, and movie), environment, light, sensor, interpolator, and description. An extension with valid time does not make sense for grouping (which are structural elements), interpolator (which are functional descriptions of pairs of values), and description nodes (which are meta information to a visualization) because their meaning is time-independent. Sensor nodes (not TimeSenor) which are designed to react on user interactions may be active only in a limited period in valid time. Graphical shape and light nodes are the only ones which may have a limited validity and time-variant characteristics. Environmental nodes, like Background and Fog, are valid forever even in a temporal world, but may change their properties like their corresponding natural phenomena. For a seamless integration of VRML97 in VRML History, by default, every VRML97-object is time-invariant with the implicit ; ). valid period (
(-oo, oo)
[50, 99)
[00, 80)
[30, 70) [00,80) [30,70) [60,70)
?1 1
validPeriod version
[70,75) [75,80) [70,85) [85,99) [50,99)
4.5 Time-Referenced Attribute Versions
The new grouping node History is designed to limit the validity of its childrens.
SFNode MFNode
[70, 75)[75, 80)
Figure 1: Temporal scene graph with different valid periods.
4.3 Limited Validity and Time-Referenced Object Versions
History { exposedField exposedField }
[60, 70) [70, 85) [85, 99)
Attributes of time-variant objects are time-invariant or time-variant during the valid period of the object. Time-invariant attributes have only one value and are specified as defined in VRML. Time-variant attributes have multiple different values (versions), each valid at a specific version time period during the valid period of the object. Time-variant attributes change their versions instantly or continuously. In both cases, if the type of the single- or multiple-valued attribute is numerical, the time-referenced change is modelled via time series decribed in the next subsection. Categorical attributes (textual, boolean, image or node type) are normally time-invariant, especially in many VRML-nodes, but if these attributes should be time-variant they have to be modelled via time-referenced object versions. There are two special attributes of graphical objects which are handled separately because they may change frequently in valid time: geometry and texture. The HistoryGeometry node is designed to handle time-variant geometries and the HistoryTexture node to handle time-variant textures.
NULL []
Each child vi given in the version field specifies a local temporal world whose validity is given by the associated version time period i specified in the ValidPeriod node which is defined in the validPeriod field. Regardless of being time-invariant or time-variant, the maximal time of existence of each children is limited to the associated version time period and does not exist outside this period. This node can be used for two representations of temporal data: a) to limit the validity of a time-invariant object (possibly a VRMLobject) given as a child; b) to specify a time-variant object whose representation is changing in a step-wise mode, i.e. consists of a
3
To appear in the VRML 99 conference proceedings HistoryGeometry { exposedField SFNode exposedField MFNode }
validPeriod geometry
NULL []
HistoryTexture { exposedField SFNode exposedField MFNode }
validPeriod texture
NULL []
Interpolator nodes use a linear interpolation to compute new values. Quadratic, cubic or other functional descriptions may reduce the amount of base points needed to approximate a given timevariant behaviour. But linear interpolation is modelled more simply and easier to handle mathematically. Even in database systems, continuously time-variant attributes are stored using linear interpolation [17, 5].
4.7 Time Navigation To support time navigation, the current location of the viewer is extended with valid time which is responsible for the current snapshot of the temporal 3D-world. Only those objects and their representation whose version time period contain the current valid time are presented. In the temporal scene graph (Fig. 1) this means that only the branches containing the current valid time are used for rendering. The Viewpoint node specifies spatial and temporal key locations given by the field position, orientation, and valid time.
The HistoryGeometry node is usable for complex geometries like IndexedLineSet or IndexedFaceSet especially if they contain different amounts of coordinate points. These geometry types (instead of the simple geometry types Box, Cylinder, Cone and Sphere) include the spatial location and therefore mostly do not need any spatial transformation. Both nodes allow a possible implementation of morphing algorithms for geometries and textures, which do not yet exist in VRML.
Viewpoint { ... exposedField SFTime validTime 0.0 ... }
4.6 Time Series of Numerical Attributes Time series describe a list of pairs of attribute values and associated time values which are the base points of a linearly interpolated attribute function. They are used to compute and set the temporal values of time-variant numerical attributes according to the valid time used for current presentation. In our proposal, time series are divided into the time value definition (ValidTimeSensor) and the attribute value definition (Interpolator). Both nodes are linked together and further linked with the specific numerical attribute by employing the event routing technique, i.e. events are sent on defined routes from the ValidTimeSensor to the Interpolator and then to the attribute to change its value. This concept uses existing VRML-nodes and is more flexible than developing special time series nodes parametrized by the valid time. The ValidTimeSensor node is a sensor object which sends events if the viewer moves (employing time navigation) within a time period in valid time dimension given by the validPeriod field. ValidTimeSensor exposedField exposedField eventOut eventOut eventOut }
{ SFBool SFNode SFFloat SFBool SFTime
An author can automatically move the user’s view through the valid time dimension (i.e. doing a time journey) by binding the user to a Viewpoint and then animating the validTime field of this Viewpoint by a TimeInterpolator. The TimeInterpolator node interpolates linearly among a list of time values specified in the field keyValue. TimeInterpolator { eventIn SFFloat exposedField MFFloat exposedField MFTime eventOut SFTime }
enabled TRUE validPeriod NULL fraction_changed isActive validTime
set_fraction key keyValue value_changed
set_fraction key keyValue value_changed
[] []
The NavigationInfo node specifies the characteristics of the desired navigation behaviour, i.e. the physical parameters of the viewer, the viewing model and the navigation paradigm. The Navigation paradigm describes the way the position, orientation and valid time of the current viewpoint may be changed. To explore the valid time dimension two new navigation paradigms are introduced in the field type of the NavigationInfo node: TIME WALK and TIME-STUDY. The actual user interface provided to accomplish these navigation paradigms is described in the implementation section. One important feature of an immersed presentation while navigating in 3D-worlds is collision detection. While time navigation is performed, this feature may confuse the viewer because there are unknown objects in the future or past which may collide with the viewer, yielding an unexpected or unrecognized adjustment of the viewer’s position. Therefore, browsers should disable collision detection during navigating in the valid time dimension.
The field validPeriod simultaneously specifies the list of all time values of the base points of the time series (in the ValidPeriod node). The value of each event, sent by the fraction changed field on each time navigation action, is computed from the current valid time and the given list of time values. The Interpolator node is required to specify the attribute values of the base points of the time series (via keyValue field). Based on the events received from the ValidTimeSensor this node interpolates linearly the new temporal attribute value among the attribute values of the given base points. There are various Interpolator node types according to the different attribute types. Here, a ScalarInterpolator is shown as an example: ScalarInterpolator { eventIn SFFloat exposedField MFFloat exposedField MFFloat eventOut SFFloat }
# added
4.8 Temporal Sensors Sensors may be specified with limited validity according to valid time by grouping the sensor as one version of the History node. The ValidTimeSensor described above is designed to react if the viewer navigates in a specified period in valid time dimension. The ProximitySensor generates events (e.g. via the validTime changed field) when the viewer enters, exits, or moves within a given spatiotemporal region in the world (equal to a 4D-region) defined by the fields center, size and validPeriod.
[] []
4
To appear in the VRML 99 conference proceedings
Valid Time of Current Viewpoint
Time Navigation GUI
ValidPeriod Nodes Object and Attribute Versions
Script
VRMLBrowser
Temporal Scene Graph
Presentation Reactions
Nontemporal Scene Graph
Figure 2: Functional concept of time navigation.
versions, updating the non-temporal scene graph with the new versions and then traversing this scene graph by the browser to render the presentation. In more detail, the search for valid objects is done by searching all ValidPeriod nodes in an internal node storage list and identifying the versions of the objects using that ValidPeriod nodes which are valid at the current valid time. This is performed asynchronically to be timely independent of prompting for navigation actions. This solution has some benefits and drawbacks: One benefit is that this concept and its implementation can be used in every VRML-browser which supports the Java Scripting Authoring Interface (JSAI) in the Script node. Additionally, the implementation can be accelerated by using a time index which accesses the relevant set of object versions more quickly [17]. On the other hand, searching for valid object versions does not consider the current scene graph and location of the viewer. Some objects are spatially not visible in the current presentation because of the view direction and position, the level of detail, or the switch state. If a browser is enhanced by a spatial index this might not really work because temporal objects partly exist in the non-temporal scene graph without any geometries, and whenever a time navigation action is performed, the scene graph is updated with new geometries which then may cause an undesired spatial index update.
ProximitySensor { ... exposedField SFNode validPeriod NULL # added eventOut SFTime validTime_changed # added ... } This Sensor object may also be created by limiting the validity of a ProximitySensor by a History node. This solution sends the entering and exiting events exactly like the Sensor above, but does not send events on time navigation.
5 IMPLEMENTATION ISSUES 5.1 Extending the Language All new and changed node types are defined and implemented via the external prototyping feature of VRML. The prototype definition is realized in VRML and Java (via the Script node) and stored in external files which are loaded and executed by the VRML-browser only if needed [21]. Unfortunately, the prototype definitions are browser-specific because the two VRML-browser mostly used (Intervista’s WorldView and SGI’s CosmoPlayer) have realized event routing between the prototype interface and Script node in different ways. There are two possibilities to store browser-specific prototype definitions: using the universal resource name identifier or files locally stored on each computer. The former concept is not standardized among the VRML-browsers until now, and therefore, the second choice is used to transparently offer browser-specific implementations.
5.3 Navigation Instruments The navigation instruments consists of three elements (see Fig. 3): a) a time display shows textually the current valid time in different possible modes (as e.g. date, numbers, simulation ticks); b) the navigation controls allow the viewer to change the current valid time by pressing and/or dragging the mouse on the arrows in different modes: step-wise or continuous, slow or fast, forward or backward; and c) a virtual time line renders the valid periods of all temporal objects described in the visualization in two different resolutions in relation to the current valid time.
5.2 Time Navigation in the VRML-Browser A set of Java-classes extend the functionality of the VRML-browser to offer a time navigation technique to the viewer. Conceptually, Fig. 2 shows how the time navigation is implemented in the VRML-browser. A navigation action is prompted by the viewer through the time navigation instruments of the browser’s GUI or by a script stored in the scene graph of the temporal visualization. Each action changes the valid time of the current viewpoint. The newest valid time is taken to perform the current presentation, i.e. to traverse the temporal scene graph to identify which objects and versions are valid at that valid time, and where they are positioned in the current view. This may cause some other reactions in the scene graph, e.g. new events changing other objects or attributes, but these are executed before a new traversal with the next valid time is performed. Current VRML-browsers manage only a non-temporal scene graph. Therefore, in this implementation the traversal of the temporal scene graph is split into searching all valid objects and their
2 x Virtual Time Line
Current Valid Time
Time Display
Navigation Controls
Valid Periods of Temporal Objects
Figure 3: Time navigation instruments displayed in the VRMLbrowser.
5
To appear in the VRML 99 conference proceedings
Figure 4: Snapshots showing a temporal ground water head.
the base points of a geometrical time series which yields a continuously changing shape by a linear interpolation during presentation. The VRML-file’s size is about 1.2 MB, compressed 250 KB. Different valid times, viewpoint positions and orientations can be explored.
With these instruments, while navigating in the time dimension the viewer keeps in mind the time reference of the current snapshot presented, the time navigation speed, and the time of existence and temporal location of future or past temporal objects. Furthermore, the viewer may deduce data change in the world from identified discrete states of objects and from the recognized sequence of these states including their continuous and instant transitions, and may conclude the speed of change from comparing the time-references of each change.
6.2 Visualization of Temporal GIS-Data An application of a visualization front-end to a Temporal GIS [10] is demonstrated by visualizing a set of synthetically produced GIS-data. GIS-data consists of sets of polygonal data (2D/3Dcoordinates shaping region or line objects) describing the spatial extension of geographical objects (e.g. buildings, streets, cities, states), some non-geometrical data describing the characteristics of the geographical objects (e.g. ownership, soil of estates, roadway state, traffic density on streets), surface data, and some satellite or survey imageries. In many applications (e.g. real estate, survey, environmental studies, geo-marketing, archaeology) all this data are seen in a temporal context which, especially, allows two types of research directions: analysis of historical and current processes as well as prediction and analysis of future states in changing environments. Here, the historical development of a city according to the construction of buildings is shown (Fig. 5). The data stored as the temporal visualization are sets of temporal objects with different versions of geometries and appearances and different validities. The sea level is changing during time navigation describing higher and lower tides. Note that the waves are animated not by valid time but system time which can not be navigated by the viewer.
6 APPLICATION OF VRML HISTORY Two example applications which commonly explore spatiotemporal data sets are presented to show the use of VRML History: a visualization of temporal finite-element method (FEM) data and a visualization of temporal GIS-data. The description of the VRML History scenes of both examples can be browsed at [21].
6.1 Visualization of Temporal FEM-Data In the first application, VRML History was used to publish a visualization of temporal FEM-data which should be geographically and temporally explorable at project partners, at exhibitions or in the internet by using simple browsing tools. The background problem consists of an optimization problem: in a high water region the pumping costs (energy) of a well should be minimized over a year. The optimization algorithm [6] is linked with the FEM-simulation program Feflow [3] that checks the nonlinear constraint whether the ground water head which changes temporally and geographically by the pump rate will reach a specified upper level at a special control point. The resulting FEM-data representing the temporal ground water head are documented and explored to possibly improve the optimization results. In Fig. 4 (visualized with Netscape Navigator and SGI CosmoPlayer) several snapshots of the ground water head over a year are shown including the location of the control point (red/dark grey cylinder) and the upper level of ground water at that point (the almost transparent grey rectangle). The resulting VRML-file is automatically written by a exclusively developed filter in the simulation program. The data stored as the temporal visualization form a colored triangle irregular network (TIN) at 34 different valid times. The geographical extension is given by that one of the finite elements. The times are chosen by the automatic time stepping algorithm of the simulation program and is later further reduced manually. The TINs are modelled as
7 DISCUSSION AND FUTURE WORK A special problem is the description of chaotic and nonlinear behaviour of objects or sets of objects over time, especially, if this changes the time of existence of some objects (e.g. clouds of particles, smoke, explosion of objects, morphing). This behaviour is badly described by linear interpolation or step-wise functions because too many base points are needed to match the given behaviour. Sometimes, more special, i.e. functional, stochastic, evolutionary or morphing descriptions would be more apropriate. Therefore, new nodes have to be developed and integrated to meet these requirements. In our proposal, all time values are defined as numerical values relative to a global time origin like in VRML itself. Although this representation is very easy to manage, most time information
6
To appear in the VRML 99 conference proceedings
Figure 5: Snapshots showing historical views of a city.
is stored by the user using readable dates and times based on a specific calendar. Even in database systems time values are stored as dates and times to be readable to the user [16]. Integrating different date and time formats, even calendars in the proposal would have unnecessarily enlarged the implementation of the parser tool. A good compromise is if this special feature will be moved to the client side, i.e. extending editing and authoring tools with userspecific calendar semantics and date/time formats which transforms the given absolute time values in relative time values processable by VRML History. Normally, the description of historical spatial informations enlarges the VRML-file many times. Huge files increase not only the time for downloading files from the internet but also the time to build up the scene graph in the browser and to generate the presentation. There are various approaches to reduce the file size. The author of the VRML-file can reduce the spatial and temporal base points by using linear interpolation or a generalization method which deletes some base points according to the rendering resolution of the screen [12]. Other approaches are independent of the file contents which are all discussed by the VRML-community: reusing existing objects of the description, file compressing, binary file format, contents streaming. Especially contents streaming seems to be very promising for temporal data because one snapshot of the temporal world can be shown in the browser while the others a further loaded. The spatio-temporal description also leads to a huge scene graph and object storage in the browser. Many objects do not need to be processed because they are not visible in the current view depending on the current viewpoint position, orientation and valid time. For static temporal scenes, a spatio-temporal access method may be very usable to reach the relevant set of objects in a short time [18]. A feature which is often subjectly accompanied by temporal data is version and configuration control of worlds. This feature may also be realized with VRML History but in that subject each version describes a discrete editing state of a possibly even temporal 3Dworld which are constructed as finished steps in a longer or branching editing process. Additionally, some VRML-nodes can not be versioned in this way because they are not extended with valid time in this proposal. Version control may be a future research field for VRML-files.
nique. One important concept of VRML History is the distinction of the system time included in VRML and the new time dimension valid time. Now, temporal visualization can be created where valid time may be explored by time navigation and system time may be used for cartographic animations.
References [1] J. Clifford and A. Crocker. The Historical Relational Data Model (HRDM) and Algebra Based on Lifespans. In Proceedings of 3rd International Conference on Data Engineering, Los Angeles, pages 528-537, 1987. [2] P. Chamoni and P. Gluchowski, editors. Analytische Informationssysteme: Data Warehouse, Online Analytical Processing, Data Mining. Springer, 1998. [3] H.-J. G. Diersch and R. Gr¨undler. GIS-based Groundwater Flow and Transport Modeling - The Simulation system FEFLOW. In HYDROGIS’93, Wien, 1993. [4] D. Dransch. Temporale und Nontemporale ComputerAnimation in der Kartographie. Selbstverlag FB Geowissenschaften, FU Berlin, 1995. [5] M. Erwig, R.H. G¨uting, M. Schneider and M. Vazirgiannis. Spatio-temporal Data Types: An Approach to Modeling and Querying Moving Objects in Databases. In 1. CHOROCHRONOS Workshop on Spatio-Temporal Database Systems, Petronell-Carnuntum, Austria, Nov 1997. [6] M. Grauer and T. Barth. Multidisciplinary Optimization and Cluster Computing using the OpTiX-Workbench. In A.D. Belegundu and F. Mistree, editors, Optimization in Industry 1997 Conference Proceedings, pages 73-80. ASME, 1997. [7] N. Gershon and S.G. Eick. Information Visualization. IEEE Computer Graphics and Applications, 17(4):29-31, Jul/Aug 1997. [8] GRAPE Manual. Inst. of Applied Mathematics, University of Bonn and of Freiburg, 1997. [9] G. Langran. Time in Geographical Information Systems. Taylor & Francis, 1992.
8 CONCLUSION
[10] H. Luttermann and A. Blobel. CHRONOS: A SpatioTemporal Data Server for a GIS. In H. Kremers and W. Pillmann, editors, Space and Time in Evironmental Information Systems, CSEP’95, pages 135-142. Metropolis, 1995.
This paper outlined our approach, called VRML History, to store spatio-temporal objects in VRML-files on the WWW and to browse them spatially and temporally by featuring a time navigation tech-
7
To appear in the VRML 99 conference proceedings [11] N. Magnenat-Thalmann and D. Thalmann. Animation: Theory and Practice. Springer, 1990.
Computer-
[12] G.M. Nielsen, H. Hagen and H. M¨uller, editors. Scientific Visualization: Overview, Methodologies, Techniques. IEEE Computer Society Press, 1997. [13] University of Minnesota. GeomView. http://www.geom.umn.edu/software/. [14] M.P. Peterson. Interactive and Animated Cartography. Prentice Hall, 1995. [15] W.J. Schroeder, K.M. Martin and W.E. Lorensen. The Visualization Toolkit: An Object-Oriented Approach To 3D Graphics. Prentice Hall, 1997. [16] R.T. Snodgras, editor. The TSQL2 Temporal Query Language. Kluwer Academic Press, 1995. [17] A.U. Tansel, J. Clifford, S.K. Gadia, S. Jajodia, A. Segev and R.T. Snodgras, editors. Temporal Databases: Theory, Design, and Implementation. Benjamin/Cummings, 1993. [18] Y. Theodoridis. Indexing Methods for Spatiotemporal Databases. In 1. CHOROCHRONOS Workshop on SpatioTemporal Database Systems, Petronell-Carnuntum, Austria, Nov 1997. [19] C. Upson, T. Faulhaber, D. Kamins, D. Laidlaw, D. Schlegel, J. Vroom, R. Gurwitz, and A. van Dam. The Application Visualization System: A Computational Environment for Scientific Visualization. IEEE Computer Graphics and Applications, 9(4):30-42, 1989. [20] Visviva Software Inc. ScriptV. http://www.visviva.com. [21] University of Siegen. The VRML History Homepage. http://www-winfo.uni-siegen.de/vrmlHistory/docs/index.html.
8
