Using 3D to visualise temporal data

Using 3D to Visualise Temporal Data Brian Farrimond, Robina Hetherington Liverpool Hope University College {[email protected], [email protected]} Abstract Dynamic 3D models generated from historical, time stamped data provide opportunities for insights and understanding that would otherwise be difficult or impossible to gain in applications as diverse as the teaching and learning of history and the analysis of aerospace experiments. This paper describes how historical data in a temporal database can be used to generate dynamic 3D models expressed in VRML. The models include facilities to move back and forth in time, to hide or reveal groups of objects and their labels and to show the paths traced by individual objects as they move through space and time. The change of shape of objects over time can also be modelled. The tools described in this paper enable the user to create these 3D worlds automatically without needing to know anything about the underlying 3D modelling language employed. Keywords--- Animation, Data model, Information Visualization, Interactive 3D Graphics, Temporal Database, VRML, XML.

1

Introduction

Animated 3D models provide opportunities for insights and understanding of how things develop and change over time that would otherwise be difficult or impossible to gain. Animation created from time stamped data is a particularly desirable asset for understanding visually what is going on in a complex process. Unfortunately, the creation of such animations has not been a trivial task. The advantages of the use of 3D modelling to enhance and encourage understanding are well established. 3D modelling tools have been used, for example, by students in schools to enhance their learning experience [1] . A drawback for these efforts has been the high level of skill required in the use of modelling tools to create even quite simple models. This paper describes steps taken to simplify the task of model creation, remove the requirement for technical skills in 3D modelling yet still enable the users such as

teachers and engineers to create dynamic 3D worlds that model time stamped data. Luttermann and Grauer [2] have proposed extensions to VRML to support temporal scene graphs. In contrast, the 3D worlds described in this paper do not require VRML to be extended. In Section 2, an innovative historical data model is described that provides very flexible storage for temporal data and that is used as the starting point for the generation of the 3D worlds. Section 3 explains how the temporal data has been used to generate time maps that display the data dynamically and how the time map structure can be mapped onto 3D worlds. Section 4 explains how software tools are used to carry out the mapping automatically so that the user does not need to understand anything of 3D modelling languages. Section 5 describes the mapping in some detail and highlights how the ability to change the entities over time in the 3D world is achieved. Section 6 describes examples of the generated 3D worlds.

2

The historical data model

History is based on large volumes of data and many historians have seen the benefit of applying information technology to its capture and analysis. The use of relational data modelling implemented in relational database management systems is a popular solution [3] . An innovative relational data model has been proposed which overcomes some of the problems associated with the traditional data modelling approach that requires the different attributes in the domain to be part of the data model. [3] [4] . The new model uses just three tables yet allows unlimited types of thing to be stored along with unlimited attribute types. Each of these attributes is date stamped so that the model is, in fact, a temporal data model [5] . The new data model is shown in Figure 1.

This paper describes how further work has enabled the data to viewed in 3D worlds expressed in VRML.

3 3.1

Figure 1: New temporal data model In Figure 1, the fields that form the primary keys are indicated by underlines. The meaning of the Old English word "thing" includes entities, ideas and qualities and seems quite apt in the context of a historical database. The model regards any thing as being describable in terms of either strings or arrays of strings. The strings may contain numeric data such as size and location or they may contain text such as names, descriptions or references to objects such as URLs. A particular attribute may have different values for an object over time. This would be represented by a collection of records in the StringTimePoint table having the same value for thingID and attributeName but different date and timeOfDay values. Some attributes need to be expressed as an array of items. Each element in the array for a given time will be expressed as a record in the StringArrayTimePoint table. An example would be the sequence of points representing a river in a GIS system. In the new data model, the river's path would be represented as a collection of records in the StringArrayTimePoint table. Storing point array data in this way is very inefficient in that each coordinate requires a separate record. Future work will focus on how to enhance the data model to increase the efficiency without loss of generality and simplicity of concept. Meanwhile, the continuing improvements in the cheapness and speed of data storage make the efficiency of a data model a less significant issue. Once data has been stored in a database based on this model, it becomes available for querying and viewing. Work so far has focussed on users interested in historical research or the teaching and learning of history. The first use of the data was to combine it with GIS data to generate two dimensional time maps. A time map is an electronic map with controls to move the map objects back and forth through time. Time maps can be created either graphically through the TMap editor [6] [7] or through the tools accompanying the historical database [4] .

Using the historical data model Time maps

Time maps expressed as XML files can be viewed through a Java Applet on the Internet [6] . Software tools have been developed [4] that can: • create a temporal database using the new model described above from spreadsheets created by a historian; • generate time maps from the temporal database combined with GIS data in Arc/Info Export (E00) format [8] . The animated nature of the time maps and their hierarchical struture lend themselves to transformation into 3D worlds. These worlds would enhance the viewers' experience by increasing realism, interaction and the possibilities of exploration. [9] An important object attribute used in time maps is the information_url. This attribute contains timestamped URLs of web sites relevant to the thing in question. The time map viewer applet uses these URLs to create time sensitive hyperlinks in the viewed time map. As the map time changes, so can the URL value for a particular object on the map [6] . The hyperlinks can be used to open different 3D models of map objects according to the map time. In the 3D worlds generated from time maps, the URLs are used to link to 3D models of the objects represented symbolically on the time map. The 3D world will show the appropriate models according to the 3D world time. This paper describes the tools that have been developed that can automatically transform time maps into 3D worlds. Further work will aim to generate the 3D worlds directly from the historical database and the GIS data so that generation is not restricted to time map artifacts. In order to show how the 3D worlds have been created, it is first necessary to explain the structure of the time maps from which they are derived.

3.2

Time map structure mapped into 3D worlds

The relevant time map XML structure is shown below ... ... ... : : :

The tag contains information such as the map extent, the map start time and the map end time. It also contains the size of the time step used when the map moves through time. This step can be any multiple of years, months, days, hours, minutes or seconds. The tag also contains the specification of the format to be used to display time. e.g. Years only or day, month and year, or hour:min with day, month and year. The data stored in the header is used directly in creating the 3D world which will model the same geographical extent, time step, time interval and time display format. The tag contains a collection of layers expressed as elements. Each layer can contain a collection of historical objects. The geography from the GIS is itself time stamped in the generation of the XML from GIS data and is represented as historical objects on layers. Grouping into layers is retained in the transformation into 3D in order to enable selective viewing of objects, labels and paths followed by moving objects. Each historical object is stored in a element. Each thing has time stamped attributes. For the sake of the time map, particular attributes are important such as location, size and colour. The colour may represent some aspect of the object. For example, in a time map of Cromwell's campaign in Ireland, the allegiance attribute of towns and armies was used to determine the colour values of objects generated in the time map XML. Objects in time maps are represented symbolically as polygons, polylines and icons. Polygons and polylines are currently transformed unchanged into 3D. The addition of height information to the historical database will make it straightforward to replace polygons representing, for example, blocks of buildings with appropriate IndexedFaceSet nodes in 3D. The time map icons are generally circles and squares representing towns, buildings, armies etc. These icons are replaced by cylinders and boxes respectively. As explained above,

3D models of objects can be included in the 3D world and these models can replace the symbols. A further development would be to have Level of Detail (LOD) addressed by using symbols at a distance and using the 3D models close up. In XML time map format, the historical objects have the following structure: class name attribute name sequence of string timepoints attribute name sequence of string timepoints : : attribute name sequence of real timepoints attribute name sequence of real timepoints : sequence of position timepoints sequence of vertex timepoints

We identify the class name within the tag. Within the database, the class of an object (or type) can be changed over time since it is just another attribute. However, when generating time map XML, the class currently remains fixed. Next come sequences of string attributes identified by the tag. A string attribute is an attribute whose value is a string of characters. Names, descriptions etc are the kind of thing that could be stored in a string attribute. Note that we do not use explicit tags to identify the attributes. Instead, we identify the name of the attribute with a tag. This gives us the flexibility to have any number of different string attributes within a class without having to redefine the XML document type definition (DTD) and mirrors the relational data model described above. The actual name of the object is an example of a string attribute. Because it is time stamped, the object's name is able to change over time in the database and in the XML. This is achieved by the element having a number of elements each containing a time stamped value for the attribute. The string attributes are followed by real attributes which are identified by the element. A real attribute is an attribute whose value is a real

number or an integer number. Integers are represented as reals for the sake of reducing complexity in coding applications. Real attributes are used to represent Boolean values, such as visibility. If an object is not yet visible on the map then its visibility attribute is set to 0. When the time comes for it to appear, the visibility is set to 1. elements within the contain the time stamped real values. The position of an object is introduced by the element. It contains elements to store the time stamped position values. To illustrate the time stamping we show below a fragment of XML code for the position element of Oliver Cromwell in his campaign in Ireland: 2323588.0 0.0 G 1649 8 31 0 0 0 -6.248889 53.333056 0.000000 2323590.0 0.0 G 1649 9 2 0 0 0 -6.347778 53.718889 0.000000

We show just two position time points in the time map made of Cromwell's campaign to illustrate the principle of time stamping. The and elements contain his position expressed in latitude and longitude. The element contains a boolean value indicating whether for times between this timepoint and the next timepoint, his position was fixed or else whether the time map viewer can interpolate his position between the two timepoint positions. In each case the fixed value is zero indicating that, at times between the timepoint, Cromwell's location is linearly interpolated between the two given values. This can lead to the criticism that he might not have travelled at a uniform rate but perhaps stayed overnight somewhere. If the historian can provide evidence, then extra timepoints can be inserted to reflect more accurately what happened. Otherwise, it can be argued that linear interpolation is a reasonable approximation. It also highlights the absence of data to the contrary. The tag contains the timestamp itself. The structure is:  Julian day number according to the system of dates used by astronomers that counts the number of days since Greenwich noon on 4713 BC January 1 [10] . This makes it easy to carry out the calculations that convert dates to fractions in the interval 0 to 1 representing the time interval covered by a 3D world.

 number of seconds from the start of the day.  G to indicate that what follows is the date according to the Gregorian calendar in use today.  Year  Month number  Day in month  Hours from start of day  Minutes  Seconds Hence the time stamp 2323588.0

0.0 G 1649 8 31 0 0 0

refers to midnight at the beginning of 31 August 1649. Strictly speaking, there is redundancy here. However, it has been found that the representation of time explicitly in the XML in Gregorian format is very useful in providing an easily understood time stamp during development. Optimisation would remove all but the Julian day and the number of seconds. The tag introduces time stamped coordinate sets in the case of polygons and polylines. The mapping into 3D worlds generates VRML scripts and interpolators from the time stamped data described above. The 3D world time can be changed manually or by running a TimeSensor. The time changes are routed through the scripts and interpolators to change the state of the 3D world objects.

3.3

Time map viewer

Figure 2 shows a time map in the Java applet viewer. This particular map shows the development of railways in Lancashire UK in the nineteenth century.

Figure 2: Time map of railways in nineteenth century Lancashire The map time is shown at the upper left. In this case time is measured in years but other formats are available. The layer controls are down the left hand side. The user can display or hide layers and change the order in which they are painted. The time controls and the label controls are along the top. Time can be changed by using the scroll bar (known as a time slider) or by using the

buttons that allow time to run freely or be single stepped forward or backwards. The other buttons are used to control the display of object labels. All these controls are mapped into the 3D world as described later in this paper.

4

Conversion into VRML

3D modelling formats are undergoing continual development [11] [13] . For the sake of this research, it was decided that an older, well established format such as VRML be used [12] . This was because the purpose of the research is principally to prove the concept of creating 3D worlds from historical data. This did not require novel features in 3D modelling. The proven reliability of well established VRML browsers offered a reduction in development time and this was decisive in the choice of language. Further work may indeed call upon novel 3D modelling features. Migration to new 3D languages is not expected to cause significant problems since the features of VRML used are likely to be present in any new developments. Time maps in XML format are converted into VRML. The VRML includes objects equivalent to the navigation objects in the map including a time slider and stop and start buttons. It is also arranged that each object in the world will have its own viewpoint so that users can track individual items. It is often useful to see the path followed by a moving object in 3D and this is available in the generated VRML. The process of creating the VRML is shown in Figure 3.

One feature of VRML is that the number of vertices an object can have cannot change, although the values of the vertex coordinates can be changed through the use of a CoordinateInterpolator. However, time map objects may change their numbers of vertices over time. For example, a river may change course, a region may change shape. In order to achieve this flexibility, which is difficult using XSL, the VRML generated through XSL is post processed by a C program called xtx. The XSL adds markers as comments in the VRML code to those objects that require different numbers of vertices to be catered for over time. The xtx program identifies these markers and generates more VRML that is inserted into the XSL generated VRML. The additional VRML pads out the vertex data sets for each time point so that each data set contains the same number of points as the largest and is now VRML compliant. The VRML output by xtx is ready for viewing in a VRML viewer. The next section describes how the time map objects, associated 3D models and the time map controls are mapped into VRML.

5

The VRML file structure

In this section, the structure of the generated VRML is described.

5.1

Overall structure

The overall structure of the generated VRML files is shown below: ProximitySensor TimeSensor NavigationInfo Background Viewpoint Transform for map floor Script for time control Transform for Layer 1 Transform for Layer 2 : Transform for Control Panel Brief explanations follow: ProximitySensor

Figure 3: Generation of VRML from time map XML VRML generation is currently done off-line during development but migration to serving 3D worlds over the Internet is an important future goal. Since the time map is in XML format, XSL technology [14] can be used to perform the bulk of the 3D world generation. The XSL template file describes how the xt XSL processor is to filter the XML time map in order to generate VRML. How the time map features map onto VRML is described later in this paper.

Change in position of viewer is routed to change the head up display Panel's position and rotation

TimeSensor Change in clock when running is routed to change interpolation of object positions, path trails etc

NavigationInfo Background Background of blue sky with ground is created

Viewpoint Viewer's starting point is directly above time map centre facing down with the whole generated world visible. A change of viewpoint (all objects have viewpoints) causes a smooth glide down towards the selected object. The user is thus able to contextualise the selected object.

Transform for map floor A thin brown box with width and height equal to map width and height is drawn on the ground to show the extent of time map world

Script for time control Javascript code to handle events and time. Transform for Layer 1 Transform for Layer 2

: Each time map layer becomes a separate Transform. The layers form groups which can be hidden or displayed together or have their labels hidden or displayed together. The paths traced by moving objects are also hidden or displayed in groups identified by the layers.

Transform for Control Panel This is the collection of sliders and buttons used to control the simulation. It also contains the current map time display. The Control Panel always stays in the view of the user.

5.2

Structure of a Transform for a layer

The structure of the Transform implementing an individual layer is shown below Transform for Layer 1 Switch Script for Layer 1 name visibility Switch Script for Layer 1 path visibility Switch for Layer 1 choice [ Transform for a visible Layer 1 Transform for Thing 1 Transform for Thing 2 : WorldInfo ] whichChoice 0 Switch Script for Layer 1 visibility

The Switch scripts receive inputs via ROUTEs activated when controls on the Control Panel are clicked on or dragged. There are three types of control buttons that deal with a layer's objects' name visibility, object path visibility and the overall layer visibility. The overall layer visibility button activates the Switch Script for Layer 1 visibility. This script changes the whichChoice attribute for the Switch for Layer 1. When its value is 0, the Transform for a visible Layer 1 displays all the objects in this layer. When its value is 1, none of the objects are shown. The WorldInfo node acts as a placeholder for an empty Transform.

5.3

Structure of a Transform for a Thing

The structure of the Transform implementing an individual thing is shown below

Transform for Thing 1 Switch Script for Thing 1 visibility Switch Script for Thing 1 models Switch for Thing 1 path choice [ Transform for Thing 1 path Shape for path Coordinate Interpolator for path WorldInfo ] whichChoice 0 Transform for Thing 1 viewpoints Switch for Thing 1 choice [ Transform for Thing 1 Switch for Thing 1 models PositionInterpolator for position CoordinateInterpolator for vertices PositionInterpolator for size of symbol ColorInterpolator for color of symbol Switch for Thing 1 name choice [ Transform for Thing 1 name Billboard WorldInfo ] whichChoice 0 WorldInfo ] whichChoice 0

The purpose of the structure is to enable a number of object characteristics to change over time. These are: visibility, the position, size and colour of symbols representing objects, the path traced by a moving object, the position and number of points forming an object represented by a polygon or polyline, the 3D model of an object. These characteristics are now discussed in turn. 5.3.1 Changing the visibility of a thing over time The visibility of a thing can vary over time. In modelling the real world development of the railways in the north west of England in the 19th Century, for example, the appearance of new lines over time is achieved by manipulating the visibility of the new lines. The lines are invisible until the time arrives when they are built. At this time, they are made visible. Existence is expressed in the 3D world as visibility. Visibility is expressed as the whichChoice attribute in the Switch for Thing 1. Changes to visibility are achieved through scripts generated from the time stamped data in the XML files. The scripts consist of if statements that use the time values passed in the variable value to determine the appropriate visibility. A typical code fragment follows:

path increases its number of vertices over time, by the xtx C program padding each set with the last vertex value until all sets are the same length. Note the use of an interpolator to provide smooth change in contrast to the Script described in section 5.3.1 that provides step changes.

if (value >= 0.69989) { whichChoice = 1; } else if (value >= 0.39978) { whichChoice = 0; } else if (value >= 0) { whichChoice = 1; }

The VRML generator transforms the time at which changes of visibility take place into a real number in the range 0.0 to 1.0 where 0.0 corresponds to the time map's start time and 1.0 corresponds to the time map's end time. A whichChoice value of 1 indicates the object is invisible, while a value of 0 indicates the object is visible. Thus, in the example code shown above, the object is initially invisible, becomes visible 0.39978 of the way from start time to end time and becomes invisible again 0.69989 of its way. Hence, over the world's time interval, the object starts off invisible (does not yet exist), becomes visible (comes into existence) and then becomes invisible again (ceases to exist). ROUTEs are used to connect the time controls on the Control Panel, through the Switch Script for Thing 1 visibility to change the whichChoice attribute in Switch for Thing 1. 5.3.2 Extending paths of moving objects over time The path of a moving object increases in length over time. The path consists of the polyline formed by joining successive positions of the object as it moves through time and space. This is modelled in 3D by using a CoordinateInterpolator on an IndexedLineSet. The VRML below shows a typical CoordinateInterpolator generated for a moving thing. CoordinateInterpolator { key [ 0 .099945 .19989 .299835 ] keyValue [ 96 1 71 96 1 71 96 1 71 96 1 96 1 71 151 1 82 151 1 82 151 1 96 1 71 151 1 82 204 1 129 204 1 96 1 71 151 1 82 204 1 129 268 1 ]

5.3.3 Changing colour of a symbol over time Changing the colour of a symbol is achieved by applying a ColorInterpolator to the diffuseColor attribute of the symbol's Material node. The ColorInterpolator is driven by a ROUTE from the Control Panel's time controls. 5.3.4 Changing size of an icon over time Changing the size of an icon (for example to represent the size of population of a town) is achieved by applying a PositionInterpolator to the scale attribute of the Transform for Thing 1. The PositionInterpolator is driven by a ROUTE from the Control Panel's time controls. Whether scaling to size is done is determined when the time map is created. 5.3.5 Changing position of objects over time A PositionInterpolator is used to change the position of an object over time. The interpolator is driven by a ROUTE from the Control Panel's time controls. The interpolator changes the value of the translation attribute of Transform for Thing 1. The VRML below shows a typical interpolator. PositionInterpolator { key [ 0 .099945 .19989 .299835 ] keyValue [ 96 1 71 151 1 82 204 1 129 268 1 152 ] }

5.3.6 71 82 129 152

96 151 204 268

1 1 1 1

71 82 129 152

}

The keys are map time expressed as real numbers in the range 0.0 to 1.0. The start position is (96, 1, 71). The thing moves to (151, 1, 82) at 0.099945 of the time from start to finish, moving to (204, 1, 129) at 0.19989 of the time and to (268, 1, 152) at 0.299835 of the time. The corresponding coordinate sets are stored in the keyValues field. Note that each set is of the same length as required by VRML. This is achieved, even though the

Changing the vertices of polygons and polylines over time This is achieved in the same manner as the implementation of the paths described above.

5.3.7 Changing object models over time The structure of a Transform implementing alternative 3D models is shown below. Switch for Thing 1 Models choice [ Transform for symbol model Transform for first 3D model Transform for second 3D model : ] whichChoice 0 The value of whichChoice is determined by the 3D world time sent by ROUTEs from the time controls via a script generated from the time map's information_url time-stamped values. 5.3.8 Displaying the names of things The names of things are displayed as Billboard nodes so that they always face the viewer. The Billboard is embedded inside a Switch node which is controlled by a Script that receives inputs via ROUTES activated when the user clicks on buttons to hide or reveal object names in the Control Panel.

5.4

Structure of the Control Panel Transform

The Transform for Control Panel contains the controls used to manipulate time and the visibility of layers and names and paths. The panel always stays in view of the user. The VRML structure for the control panel is shown below: Transform for Control Panel Transform Shape for background Transform for time display Transform for time slider background Transform for time slider thumb PlaneSensor to detect sliding PositionInterpolator for the slider thumb Transform for start button TouchSensor for start button Transform for stop button TouchSensor for stop button Transform for left button TouchSensor for left button Transform for right button TouchSensor for right button Transform for Layer 1 label Transform for Layer 2 label : 5.4.1 Time control Time can be controlled manually through the time slider and its associated thumb, left button and right

button. Time can be run freely using the start button and stopped from free running by the stop button. The time slider: Movement of the time slider thumb invokes the getslidercoords JavaScript function. This function translates the slider position into a new time value expressed as a fraction of the time interval for the 3D world. This fraction is then expressed as a date in Gregorian format (and time of day if the original time map used a time format requiring it) to be used in the time display. The output of the getslidercoords function activates all ROUTEs that inform the various interpolators and scripts controlling size, position, colour etc of things (as described above) that time has changed and trigger them to carry out fresh interpolations and calculations. The left and right buttons: These buttons decrement and increment the time slider by one step of the original time map's time step. The getslidercoords function is again invoked for this purpose. The start and stop buttons: The start button Transform node contains a TouchSensor which activates a ROUTE to set the TimeSensor running. The stop button Transform contains a TouchSensor which activates a ROUTE to stop the TimeSensor from running. TheTimeSensor fraction_changed event activates the same ROUTEs as the getslidercoords function. 5.4.2 Layer control The Control Panel node contains a Transform for each of the layers in the original time map. The VRML structure of one is shown below: Transform for Layer 1 label TouchSensor for layer button Shape for layer button Shape for layer button caption Transform for names button TouchSensor for names button Shape for names button Transform for paths button TouchSensor for paths button Shape for paths button The TouchSensor for layer button activates a ROUTE to the Switch Script for Thing 1 visibility. This

toggles the visibility of the layer as described above when discussing the structure of the Transform for a layer. The TouchSensor for names button activates a ROUTE to the Switch Script for Layer 1 name visibility. This toggles the appearance of names of things on this layer. The TouchSensor for paths button activates a ROUTE to the Switch Script for Layer 1 path visibility. This toggles the appearance of paths of moving things on this layer.

6

The 3D models in the VRML viewer

In this section, some example 3D models generated from time maps are described. The first example is from the field of economic history, the second is from military history, the third is from architectural history while the fourth example shows an aerospace engineering application.

Figure 6: Railway station detail The railway lines represented as polylines and the buildings as polygons.

Figure 4: Lancashire Railways in the Nineteenth Century Figure 4 shows the opening viewpoint on nineteenth century railways in Lancashire, UK. It is a bird's eye view of the whole modelled world. The time has been advanced to 1887 by dragging the time slider (broad arrow pointing upwards) to the right. The stop and start buttons control time running freely. The layer controls are underneath the time display 1887 at the upper left. Each layer has a row of three buttons. These buttons toggle the visibility of object names, the entire layer and the paths traced by moving objects respectively.

Figure 7: Napoleon's Waterloo Campaign in 1815 Figure 7 shows the Waterloo Campaign of 1815. The main French, Prussian and Allied army corps are shown on the morning of 15 June 1815. The view is facing north. Note the time display gives date and time of day. This world advances in time steps of one hour.

Figure 8: Building as first built in 1901 Figure 5: Changing viewpoint to Bury In Figure 5, the viewpoint has been changed to Bury which is to the north of Manchester. Note the branchline heading north west of Bury. The next image, Figure 6, shows a closer view of the station half way along the branch line.

The next example world shows the lifetime of a building. In this world which starts in 1900, the building does not initially exist and then is built in 1901 as shown in Figure 8.

Figure 9: Building in 1904 with missing roof In 1904, the roof is blown off in a storm as shown in Figure 9. In 1907, the roof is replaced and a porch is

added as shown in Figure 10. In 1909, the whole lot is demolished. This world was generated from a time map in which the information_url time stamped values were treated as references to 3D models. Each model shows the building in different stages of its life.

3D world generation tools were then described that removed the need for the user to have expertise in the use of a 3D modelling language. The structure of the generated VRML was described next with particular reference to methods by which VRML, can show change over time in response to the user's manipulation of the time controls. No extensions to VRML are required. Finally, some examples of generated 3D models were discussed. The tools developed to date work off-line. Further work will involve the refinement of the technologies so that VRML can be generated on-line from the historical databases.

Figure 10: Building with restored roof and porch

8

References

[1]

Bonnett J. Following in Rabelais' Footsteps: Immersive History and the 3D Virtual Buildings Project, Journal of the Association for History and Computing Vol VI, Number. September 2003. Luttermann, H. And Grauer, M. VRML History: Storing and Browsing Temporal 3D-Worlds. Proceedings. of Fourth. Symposium. on VRML, ACM-Press, 153-160. 1999. Harvey, C. And Press, J. Databases in Historical Research. St Martin's Press. 1996. Farrimond B., Parkinson L., And Pogson F. Cromwell in Ireland: A temporal database, Conference of Digital Resources for the Humanities. 2003. Date, C. J., An Introduction to Database Systems 7th Edition, Addison Wesley pp 730-768. 2000. Farrimond, B., Parkinson, L., And Pogson F.. Modelling history with XML, In DRH 2001 and 2002, OHC, London. J. Anderson, A. Dunning and M. Fraser Ed. 2001 Farrimond B., Parkinson L., and Pogson F. Teaching with Dynamic Maps on the Web, IBITE 2001 International Conference on Information Technology in Higher Education, Eindhoven. 2001. Letham G. 2003. Working with E00 data. http://spatialnews.geocomm.com/education/tutorials/e00 data/ (last accessed 30 October 2003) Polys, N. F. Stylesheet Transformations for Interactive Visualisation: Towards a Web3D Chemistry Curricula, Proceedings of the Web3D 2003 Symposium, ACM Siggraph, pp 85-90. 2003. Norton, A. P. Norton's 2000.0 Star Atlas and Reference Handbook (Epoch 2000.0) 18th Edition Ed Ridpath I. 1989. Walsh, A. E. And Bourges-Sevenier M., Core Web3D. Prentice Hall PTR, USA. 1999. Web3d Consortium, The Virtual Reality Modeling Language. http://www.web3d.org/technicalinfo/specifications/ISO_I EC_14772-All/index.html. 1997. Web3d Consortium 2003, Web3D Working Groups http://www.web3d.org/fs_specifications.htm (last accessed 29th October 2003) Goldfarb, C. F., And Prescod, P. The XML Handbook, Third Edition, Prentice Hall. 2001.

[2]

[3]

Figure 11: Missile tracking a target plane Any time stamped data set can be converted into time map XML format. Figure 11 shows an aerospace engineering application in which icons represent a missile and target with their paths. This VRML model can be generated from radar tracking data converted to time map XML with a third dimension added. This enables streams of experimental real time data to be reviewed rapidly in 3D thus reducing time needed for analysis and decision making during trials. This world advances time in steps of one second. Note that, since interpolators are used, free running results in smooth movement.

7

Conclusion

This paper has demonstrated how animated 3D worlds can be created automatically from historical data stored in a temporal database and used in a range of applications. The database uses an innovative data model that has been used to generate time maps for use in the teaching and learning of history. Current work bases the 3D world on the structure used in the earlier time maps. This structure provides a framework for storing general information about the world such as the extent of the world and its start time and end time. The structure partitions the modelled objects into groups called layers that can be manipulated independently. Manipulation includes hiding and showing objects, hiding and showing their labels and, in the case of moving objects, hiding or showing the paths followed by the objects.

[4] [5] [6]

[7]

[8] [9]

[10] [11] [12]

[13] [14]