The JavaViewLib – A Visualization PowerTool for Researchers and Educators

The JavaViewLib – A Visualization PowerTool

Steven Peter Dugaro

Center for Experimental and Constructive Mathematics

Simon Fraser University

sdugaro@sfu.ca

~~Konrad Polthier~~

~~Institut fuer Mathematik~~

~~Technische Universitaet Berlin~~

~~polthier@math.tu-berlin.de~~

Abstract

The JavaViewLib is a Maple package that employs a Java appletcation called JavaView to augment and enhance a user’s visualization experience with Maple. It offers a superior viewing environment, a set of real-time modeling tools, a means of preserving the dynamic characteristics of Maple plots upon html export, and the ability to import models from a variety of other formats. Pedagogically, the JavaViewLib serves as a tool for quickly visualizing and displaying mathematical formulations. Holistically, it serves as an example of the power that lies in application connectivity between Maple and other applications.

~~These p~~This paper ~~roceedings~~ aims to introduce the typical features and workflow of the JavaViewLib PowerTool through a series of examples. It will also discuss the method by which connectivity was achieved and the importance of allowing for 3^rd party software integration. Finally, ~~these proceedings~~this paper will describe a few desired improvements and a few recent developments that ~~the recent Maple developments that~~ may begin to resolve them.

The following examples are designed to appeal to the educator, researcher and casual user alike. They will show: i. A JavaView -enhanced HTML~~html~~-exported Maple worksheets. ii. The import of externally modeled geometries. iii. The export of procedurally generated Maple ~~models~~plots to higher end packages. iv. The use of the JavaView standalone and its toolset v. The use of JavaView’s XML based file format for information interchange. vi. The automatic generation of an web based~~html~~ geometry gallery.

1.~~get right into it … usage examples….~~

a.~~Intro:first describe the superiority of the JavaViewer for visualization and presentation.~~

i.~~Side by side snapshot~~

a.~~Exporting to a webpage: runApplet -> fileconversion~~

a.~~Importing other models: a first. Introduce the standalone for file conversion~~

1.~~why is connectivity important, how was it achieved in this case… system calls and flat files housing the geometric data only. how might it better be achieved.~~ à ~~tighter application integration.~~

1.~~state of mathml and interface plugin… write an sdk to parse an entire file. Xml document factories.~~

1.tap into file conversion tools of JavaView… export(…, sdf) .. like to be able to use javaviews libs as an engine to invoke methods ie export(sdf,”vrml”) ?? how to talk to javaview to do this? Environment configuration parameters.

Introduction

Maple is a comprehensive computer algebra system. It offers packages from various branches of mathematics to aid in solution and visualization. It also offers word processing facilities with typeset mathematics and export capabilities to aid in the composition of mathematical papers. Furthermore, it provides a unique environment for the rapid development of mathematical programs using its own programming language and function libraries. These features are encapsulated in a single Maple Worksheet (mws), which can be transported and executed between Maple applications

JavaView is a sophisticated visualization appletcation and geometric software library. Among other features, it offers a superior viewing environment that employs scaling, translation, quaternion rotation, customizable axes, colouring, materials and textures, transparency, anti-aliasing, depth cueing, animation, and camera control. It is capable of importing and exporting 3d geometries in a wide variety of formats, and can perform basic real-time modeling upon these geometries. It also offers an api, allowing custom plug-ins and visualizations to be developed for it. Furthermore, JavaView can be used as a standalone application or may be embedded as an applet in web pages for remote use via web browsers.

The JavaViewLib (JVL) is an amalgam of JavaView with a Maple library; an interface between them. It makes use of the strong aspects of both to facilitate the exchange of geometries between the two, quickly build web pages with those geometries, and enhance the interactive experience one has with Maple plots. JVL is typically used to preserve the dynamic qualities of a Maple plot upon export to the web; static plot snapshots in Maple HTML exports can now be replaced with dynamic plots in a JavaView applet. Via JavaView, geometries can be exported from Maple to a variety of modeling packages and vice versa. JVL can quickly build web-based geometry galleries with little effort, and these geometries can be exported and displayed in a legible XML format to ease further development.

While Maple’s mathematics engine is among the industry’s best, its’ visualization and web features are few. While JavaViews viewing and modeling features are were built precisely for web based visualizations it does not provide any algebra or word processing utility. JVL is the first attempt to overcome these deficiencies by providing a means by which the two applications can work in unison. Researchers and educators can now take their visualizations, publications, and demonstrations further than ever before.

~~Maple~~

~~JavaView~~

~~JVL~~

~~Important to be able to quiclly access a powerful math library to generate viz data,~~

~~But just as important to present the findings easily and interactively.~~

Connectivity

Software development is typically an ongoing process where there is always room for improvement and embellishment. It is not unusual for one aspect of a program to be further developed at the expense of another, such that a comparable application has a more attractive feature set in a certain domain. Mature software applications tend to counter development shortcomings with an allowance for end-user customization by way of scripting or third party plug-ins that build upon the functionality of the host application using its native language. This is an important aspect of software development, but is still far from the idea of cross application interoperability, where the end-user would like to transparently utilize the best aspects of two or more applications through one interface. To use a relevant example, a Maple user may want to render a plot in a more advanced viewer than the default plot viewer, but would like for that advanced viewer to be embedded within the Maple worksheet and configurable from within Maple. On the other hand, a JavaView user may want to send a computation to a particular library in Maple’s math engine and incorporate the results into a geometrical rendering. In order to achieve this, each application would need to provide a certain measure of application connectivity, such that one applications’ representation of the underlying data can be reliably interpreted by the other.

Application connectivity refers to one programs' ability to link to other programs. In the Mathematics community, application connectivity is typically of secondary importance. Software is commonly developed from the ground up to realize the research goal, not the potential for integration with other mathematics applications. However, some applications do make provisions and have great connectivity. JavaView provides an application programmers interface for 3rd party development in addition to great import and export utility for the exchange of geometric data. Mathematica has provided a very thorough interface known as MathLink on top of which a Java version known as J/Link allows Java programs to be controlled from within Mathematica, and the Mathematica kernel to be controlled from within any Java program. In fact, the ease of application connectivity provided by these two applications has already allowed for their quick and seamless integration.

Unfortunately, Maple versions to date make little provision for application connectivity with a poor degree of control over the user interface. These constraints make it impossible to create a true plug-in for Maple, let alone reach the levels of connectivity illustrated above. However, Maple does allow for packages written in the Maple programming environment to be loaded into a Maple session, and referenced via function calls within the worksheet interface. In the absence of a connectivity mechanism, JVL was developed as a standard maple package enabling Maple and JavaView to exchange geometric data through flat files, applet tags and system pointers. Two file formats are utilized to allow plot information to pass between the applications; an MPL file which is nearly identical to the Maple plot data structure, and a JVX file which is JavaView’s native XML based file format. JVL parses and prepares Maple plot data in one of these two formats for import into JavaView, and provides the mechanism by which the data in these files can be rendered in Maple. JVL also builds the necessary HTML code that browsers require to render these geometries, provides a small set of configuration parameters, and launches the browser and JavaView standalones from within Maple. In short, JVL makes a peripheral attempt at establishing a rudimentary level of application connectivity between the web browser, Maple, and JavaView.

Package Overview~~Examples~~

The library functions made available by the JavaViewLib are listed upon successfully loading the package. These functions may be categorized according to their naming constructs as the import/export, run, gen, and lite functions, with a few remaining utilities.

[> with(JavaViewLib);

[exportHTM, exportHTMLite, exportJVX, exportMPL, genTag, genTagLite, getInfo,

import, runApplet, runAppletLite, runJavaView, runMarkupTree, set, viewGallery]

The export functions convert the Maple Plot data structures into one of the two aforementioned JavaView parse able file formats. Exporting in the JVX file format via exportJVX produces an xml file containing only the raw geometric data. This provides a human readable crude representation of the geometry, which can be embellished by adding attributes according to the JavaView dtd. Exporting in the MPL file format via exportMPL produces a more compact representation of the Maple plot that is rendered by JavaView in the same stylistic manner as the Maple plot viewer. These two formats may then be opened with the JavaView standalone. The exportHTM and exportHTMLite functions export the Maple plot data to an applet embedded HTML page by referencing exported MPL or JVX files in the applet tag or by the default inclusion of the plot data in an applet tag parameter. This HTML file may then be opened in any java enabled web browser. The import function imports JVX and MPL formatted files into the Maple plot viewer. With this command, any of nearly a dozen geometric file formats that JavaView is able to import can also be imported into a Maple worksheet for viewing or publishing.

The run functions are basically wrappers around the above export functions serving to launch the appropriate application from within Maple. The runApplet and runAppletLite functions export the Maple plot into the configured web browser and the runJavaView function exports the plot into the local JavaView standalone. These functions take combinations of a plot object, a filename and an export method as arguments. Specifying a plot object with a filename and an export method writes the plot object to the filename in the format of the export method and launches the exported file into the designated application. These commands may also be used to launch the web browser or JavaView on existing plot exports by providing the path to the exported file as a single argument. For the semantics of various other argument combinations refer to the documentation in Maples help browser under Graphics > JavaView. The remaining runMarkupTree function displays the XML markup tree of the argument plot or referenced file in the web browser.

The gen functions print to the Maple worksheet the applet tag that would otherwise be output to any generated html file. The arguments are the same as the export and run functions, but as the output can be copied and pasted from the maple worksheet to an html file, multiple JavaView viewports can be quickly built into a single page.

Some functions have the Lite suffix appended. These variants of the html generating functions make use of an alternative version of JavaView optimized for loading time. Unlike the standard version, the Lite version has no supplementary control panel. This dramatically reduces the applet size at the expense of a greatly reduced feature set. As a result, the Lite version is typically used as a geometry viewer only, especially when there are many geometries to display in a single HTML page.

Of the remaining functions, the set function configures the JVL state variables. These include the working directory, the web browser to launch with, as well as various HTML and applet attributes. When a function call is made, the current state definitions are referenced to configure some basic JavaView parameters before loading the Maple plot. The getInfo function displays the list of JVL state variables, their current values, and the state variable names to bind to with the set command. When using JVL, one typically sets a working directory, configures any desired attributes and then runs or exports a series of Maple plots. In the working directory JVL maintains an organized relative directory structure for the various exports so that an entire working directory, or project, can be quickly put on-line. To expedite this process further, JVL offers the viewGallery function to build a frames based, indexed web gallery of all the geometries with corresponding html pages in the /htm folder of the working directory. Upon executing this function, a rudimentary web site is automatically created for exported maple plots, such that the dynamic qualities of plots and animations within a Maple worksheet may be preserved when exported to the web.~~- use the ones in the presentation….. put poisson quote in the presentation & apple texture mapping.~~

~~Auto export to a webpage~~

~~Importing non maple geometries~~

~~Exporting maple generated geometries to Third party packages\~~

~~(use javaview standalone along the way to make modifications)~~

~~i.e. merge points.~~

~~Gallery~~

~~Connectivity~~

~~Importance – evidenced using jvl to io between maple and other packages.~~

~~xml file format for info intercahge~~

Examples

The following examples illustrate some of the common applications of JVL. In depth usage instructions can be found in the gettingStarted maple worksheet provided with the package distribution.

1 JVL maintains a small amount of state information to assist in the configuration of the JavaView viewer. For the most part, these states specify how the JavaView applet is to be rendered in a browser. These states can be set to specify the size of the JavaView viewport, its background image, and some viewing initializations such as autorotation, axes, and depth cueing. The list of state information can be obtained with the getInfo command.

[> getInfo();

JavaViewLib State Information

-----------------------+------

[W ] Applet Width | 400

[H ] Applet Height | 400

[A ] Applet Alignment | Center

[R ] AutoRotate | 1. 1. 1.

[X ] Axes | Hide

[BG] Background Colour | 255 255 255

[BG] Background Image | images/jvl.jpg

[B ] Border | Hide

[BB] Bounding Box | Show

[BR] Browser | iexplore

[V ] Camera Direction | 1. 2. 3.

[DC] Depth Cueing | Hide

[EA] Edge Aura | Show

[WK] Working Path | C:\Program Files\Maple 6\JavaViewLib\

Installation Path | C:\Program Files\Maple 6\JavaViewLib\

Operating System | Windows NT/2000

JVL states can be configured with the set command by specifying a list of attribute = value pairs. It is recommended that a working path be set before using JVL, otherwise exports will be output to the JavaViewLib installation directory. Setting the working path creates four folders in the specified directory: a /jars folder containing the necessary JavaView applets, /jvx and /mpl folders to house exported geometry files, and an /htm folder containing the JavaView enhanced web pages. In this example we set the working path for the export project and specify that all subsequent tags are to be rendered with a left aligned 500 pixel by 600 pixel viewport, in autorotate mode.

[> set(wk=”c:\\temp\\myGeoms\\”,w=500,h=600,axes,autorotate,align=left):

2 The easiest way to render a Maple plot in JavaView is to simply wrap a JVL function around a Maple plot command. Here we launch an animated Maple plot in an html page. By default, JVL will create an MPL file in the /mpl folder of the working directory named JVLExport.mpl as well as the corresponding JavaView enhanced web page in which the geometry is rendered much like that of the Maple plot viewer. An animation panel appears allowing for greater animation control while the plot rotates freely.

[> runApplet(plots[animate3d]((1.3)^x * sin(u*y), x=-1..2*Pi, y=0..Pi, u=1..8, coords=spherical));

"c:\\temp\\myGeoms\\htm/JVLExport.htm"

3 Maple plots may be exported into MPL, JVX and HTML files. An html page may be exported such that the geometric data is either self contained or, when the appropriate file extension is appended to the destination filename, referenced in a separate geometry file. Typically files are exported to the corresponding folder of the working directory. However, geometries may also be exported to arbitrary paths. When the fully qualified path of the destination directory is provided as an argument to an export function, JVL copies all the necessary files to the destination directory including the JavaView archives to be embedded in the page. When a relative path is provided as an argument, JVL exports the files to that depth while referencing the JavaView archives of the parent working directory. The following command exports a 2D plot into a single html file to be opened with an html browser at a later time.

[> exportHTM(plot([sin(4*x),x,x=0..2*Pi],coords=polar), “c:\\temp\\arbitrary\\path\\flower.htm”);

"c:\\temp\\arbitrary\\path\\flower.htm"

4 When using Maple to export worksheets as HTML, all output including plots are converted to static gifs. Consequently, the benefit of a dynamically viewable plot is lost. In addition, an HTML page is more portable than a Maple worksheet as it does not require a proprietary application to view it. Using JVL, an exported Maple worksheet may preserve the dynamic qualities of the plot within a broadly distributable HTML page. Simply export the worksheet to the /htm directory of the working path, run genTag on the Maple plot to generate the appropriate applet tag, open a text editor, and replace a plots’ <img … alt=’Maple plot’> tag with the JVL generated applet tag for the corresponding Maple plot. Suppose we have defined a function called grow to procedurally generate the plot of an l-system tree, holding that plot in a reference variable a. The following command will produce the JavaView tag that may be cut and paste into the HTML worksheet exported by Maple. The leftmost screenshot below shows a static HTML export of a Maple plot. Particularly in the case of an l-system it is difficult to distinguish the details of the plot. At best, the size of the exported image can only be increased by enlarging the boundary of the Maple plot viewer as the viewer has no zoom feature. This proves to be somewhat awkward as the size of the viewer – hence the size of the exported image – is limited by the size of the enclosing Maple worksheet. The remaining two screenshots show the dynamic and configurable qualities of a JavaView enhanced HTML export by comparison. Notice that we are able to zoom into the branches of the l-system at any desired level of detail and manipulate the characteristics of the plot itself. Since these enhanced web-pages may be manipulated remotely, they serve as a great online instructional tool.

[> genTag(a,plant1.mpl);

<APPLET CODE='javaview.class' CODEBASE='..'
ARCHIVE='jars/javaview.jar,jars/jvx.jar'

WIDTH='300' HEIGHT='300' ID='JVLAPPLET' ALT='JVL - MAPLE Export'>

</APPLET>

[> genTag(a,plant2.mpl);

<APPLET CODE='javaview.class' CODEBASE='..'
ARCHIVE='jars/javaview.jar,jars/jvx.jar'

WIDTH='300' HEIGHT='300' ID='JVLAPPLET' ALT='JVL - MAPLE Export'>

</APPLET>

5 Included in the JVL distribution is the platform independent JavaView standalone application. Among other features such as texture mapping, effects, and geometric games, JavaView provides a set of modeling tools. For instance, under the Method > Modeling menu, the Identify Vertices command allows vertices within an epsilon neighborhood to be merged into a single point. Considering that Maple plots do not re-use adjacent vertices this proves to be a useful tool as JavaView is able to optimize Maple generated plots and export them to higher end modeling applications. For instance, this example uses Maple to procedurally generate a Serpinski Cube, then JavaView to apply the aforementioned method and export the geometry to the OBJ format for use in MAYA, a high end modeling and animation application. Before the identification, the unconnected Maple geometry consisted of 9600 vertices and 9600 edges, afterwards the geometry is seamless, containing 896 vertices and 2376 edges. Of course the modeling tools can also be used remotely with a JavaView enhanced webpage, however, due to applet security restrictions, format conversion requires an additional cut and paste step.

6 JVL not only enables Maple models to be exported to third party applications; it enables third party models to be exported into Maple. For the first time, a document published from a Maple worksheet is not restricted to models generated by Maple. VRML, OBJ, BYU and other geometric formats can be converted by JavaView into the MPL or JVX formats and then subsequently imported into Maple with JVL. When possible, plot characteristics that map between JavaView and Maple are carried over. For instance, saving a JavaView geometry without its edges showing will render the geometry likewise when imported into a Maple worksheet. Here we import two very unorthodox geometries into the Maple plot viewer after using JavaView to save them down as JVL compliant geometries. It is possible to import relative to the working path, however MPL files must be in the /mpl directory and JVX files in the /jvx directory. One drawback of the Maple plot viewer – evidenced by the porche – is that it is only capable of bi-directional rotation; there are some vantage points that are not covered by the Maple viewer. Notice that the porche can only be pitched and rolled, it can never be viewed sideways with its wheels on the ground.

7 JavaView’s native file format is the XML based JVX format. XML files with many repeated tags tend to compress nicely, and this is indeed the case with geometric data. After compression, a JVX file is typically reduced from four to six times its original size. JavaView is able to decompress files internally, so it may be loaded with a zipped MPL or JVX geometry file. This can save in transport time when loading models into the JavaView applet over the Internet. JVX files are also human readable, containing only the raw geometric data needed for the model. This allows geometric data to be inspected for error, or easily parsed by third party applications. Consequently, this file format serves as a point of information interchange between Maple, JavaView and any third party application that can build a format conversion utility. In fact, the JavaView api itself can be used to write such a utility. With JVL, it is possible to view the XML markup tree of a Maple plot with a single command that exports a JVX file and launches it in the browser.

[> runMarkupTree(plots[polyhedraplot]([0,0,0],polytype=tetrahedron)):

8 After exporting a series of dynamic html pages, a common next step is to thread the pages together into some sort of website, or gallery. JVL accelerates this process by providing a single command that automatically generates a geometry gallery with a table of contents indexing into all of the exported html pages. The web savvy directory structure maintained by JVL serves as an elementary starting point for the creation of more elaborate websites. Here we have created a JavaView enhanced html page with multiple orthogonal viewports using exportHTMLite to generate an HTML table into which we copy tags generated by genTagLite. The set function specifies the orthogonal views at each generation step, and viewGallery builds the interface to this and all other html pages found in the working path. Notice that three of the viewports reference a single instance of a zipped MPL geometry file, and the remaining viewport references a zipped JVX file

[> b:=plot3d((1.3)^x * sin(y),x=-1..2*Pi,y=0..Pi,coords=spherical):

[> set(viewDir="0 -1 0", bg="200 200 200", border="on", w=250, h=250):

[> exportHTMLite(b,bounty.mpl.gz):

[> set(viewDir=”0 1 0”):

[>genTagLite(b,bounty.mpl.gz); # copy and paste into [WP]/mpl/bounty.mpl

<APPLET CODE='jvLite.class' CODEBASE='../'

ARCHIVE='jars/jv_lite.zip,jars/jvx.jar'

WIDTH='250' HEIGHT='250' ID='JVLAPPLET' ALT='JVL - MAPLE Export'>

</APPLET>

[> set(viewDir=”0 0 1”):

[>genTagLite(b,bounty.mpl.gz);

<APPLET CODE='jvLite.class' CODEBASE='../'

ARCHIVE='jars/jv_lite.zip,jars/jvx.jar'

WIDTH='250' HEIGHT='250' ID='JVLAPPLET' ALT='JVL - MAPLE Export'>

</APPLET>

[> set(viewDir=”1 1 1”, axes=”boundingbox”, rotate):

[>genTagLite(b,bounty.jvx.gz);

<APPLET CODE='jvLite.class' CODEBASE='../'

ARCHIVE='jars/jv_lite.zip,jars/jvx.jar'

WIDTH='250' HEIGHT='250' ID='JVLAPPLET' ALT='JVL - MAPLE Export'>

</APPLET>

Conclusion and Outlook

The JavaViewLib has made its mark as a proponent of application connectivity. By establishing even a basic level of connectivity, both JavaView and Maple were enhanced. Maple was afforded greater visualization and web functionality, while JavaViews’ geometry generation capabilities were extended to match that of Maple. By bridging these applications, the JavaViewLib broadens the toolset available for researchers and educators of mathematics and other disciplines.

At the time of its development, the JavaViewLib made the best possible use of the connectivity resources made available by Maple and JavaView. However, in the year since its release, there is now room for improvement. Both Maple and JavaView appear to be making considerable advancements in the provision for third party control. JavaView has introduced a secondary XML file format for the initialization and preservation of display properties. Through this format, known as JVD, precise control over camera, lighting, and viewport properties can be specified and launched in conjunction with JavaView. This is a step in the right direction, but covers only a small portion of JavaView’s rich feature set. Ideally, this file format will mature into a full featured scripting language that allows the broad range of JavaView operations to be applied to the geometry or geometries loaded into the viewer. Maple has introduced Maplets – an interface library that gives Maple packages more control over Maple’s user interface and consequently, the transparent look and feel of a true plug-in. Future plans purport to integrate Java Servlet technologies with Maple’s Mathematics engine which may finally enable proper third party integration.

There are a few ideal implementations of the JavaViewLib not afforded to it. Preferably, it would be possible to embed JVL as a true third party export plug-in. While there is some provision for Maple objects to be associated with context menus, the plot object context menu cannot be overridden. A right click over a Maple plot should open a context menu that allows the plot to be exported to a JavaView enhanced webpage or geometry file in the same way that a plot can be exported to a static image. Under Maple’s file menu, it is possible to export as RTF, HTML, LaTeX, and in Maple 7, as HTML with MathML. Ideally, one should be able to export an entire maple worksheet as a JavaView and MathML enhanced html page, thereby retaining all of the features of the worksheet. Unfortunately there is no mechanism in place that allows Maples’ menu bar to be customized.

In retrospect, the author would have preferred to see both Maple and JavaView accessible as algorithmic engines.

Consider that comparable applications typically have different internal representations for the same domain inherent data. This gives rise to a variety of competing file formats that may or may not be supported across applications. As the source data is invariant and the application is employed to operate upon it, it seems reasonable to suggest that the data, and a means of understanding that data be given to an application engine to perform a desired operation that returns the modified data in the original format. That data then has the leeway to freely move in an application connected environment employing the best resources of all participating applications. Envision a system in which the data lives as a single standardized XML file and a collection of applications all make provision for scriptable access. One could direct Maple to generate plot data for a given algebra, send the resulting output to JavaView to be optimized, and then couple the subsequent output with an animation script to have MAYA render a small video. It follows that the glue connecting the applications should not need to be more sophisticated than scripting language of the host operating system, perhaps along the lines of the following

hypothetical system call:

C:\> Maple.plot3d(sin(x+y),x=-1..1,y=-1..1) –output(jvx.dtd) | JavaView.[identifyVerticies(0.1),export(obj)] | maya –input(anim.mel)

~~Desired improvements~~

~~Maple directions.~~

References

Dugaro, Steven and Konrad Polthier. Visualizing Maple Plots with the JavaViewLib. Springer-Verlag, 2002

Proceedings of The Integration of Algebraic and Geometric Software Systems. 14 – 19 October 2001. Wadern : Schloss Dagstuhl

Nicolaides, Roy, and Noel Walkington. MAPLE A Comprehensive Introduction. Cambridge: Cambridge UP, 1996

Dugaro, Steven. “gettingStarted.mws” JavaViewLib Vers. 1.0. Computer Software. 2000-2002. Maple 6 or higher.

Dugaro, Steven. The JavaViewLib Website: www.cecm.sfu.ca/news/coolstuff/JVL/htm/webdemo.htm. 2000 - 2002

Polthier, Konrad. The JavaView Website: www.javaview.de. 1999 - 2002