[This local archive copy mirrored from the canonical site: http://www.vrml.org/WorkingGroups/dbwork/vrmlxml.html, 980727; links may not have complete integrity, so use the canonical document at this URL if possible.]

Integrating XML and VRML:
A Technical Discussion

Daniel Lipkin
Oracle Corporation

Contents

Introduction

One of the most significant new web standards to emerge recently is XML, the Extensible Markup Language. XML defines a standard format for representing and exchanging structured data on the web, enabling the use of a standard API, the Document Object Model (DOM), for managing that data, and the deployment of standard services for generating and viewing XML content. XML has already been widely adopted by an industry eager to overcome the limitations of HTML for structured data. XML is expected to become a standard means for delivering database-driven web content, and already serves as the basis for a variety of web applications, from metadata representation to domain-specific markup languages.

Although designed originally for different problem domains, the two technologies of VRML and XML have much to offer each other, and there are a variety of areas where tighter integration between the two can provide powerful benefits. Some existing work in this area already exists; for example, the Visual XML proposal for using XML and VRML to represent and display structured information spaces. This paper investigates additional potential areas of synergy and suggests useful next steps.

Background

An XML file is a structured document consisting of elements that are denoted by tags. Whereas HTML defines a particular set of valid tags, XML documents may incorporate arbitrary markup as defined by the XML Specification. Typically, a particular application of XML will be based upon a specific definition of valid elements known as a Document Type Declaration (DTD). A DTD specifies the allowed sets of elements, the attributes of each element, and the valid content of each element. Elements may contain data content, that is, plain text, additional elements, or a combination of both. There are a variety of attribute types; one of the most common is the ID attribute, which serves to unqiuely identify an element within a document.

XML inherently contains no information about the visual display of its contents. The display of an XML document is determined by an XML style sheet, which contains instructions for translating an XML document into an HTML document. These style sheets are defined using Extensible Style Language (XSL), and a variety of tools are being developed to aid in creating and editing style sheets.

An XSL document consists of construction rules, containing patterns to identify particular elements in the source XML document, and actions for translating the specified elements into HTML content. Actions specify flow objects to create, which correspond to specific formatting tasks. Generating flow objects can be a recursive process, so that each element's children in turn define additional flow objects. In addition to flow objects, custom scripts can also be used to programatically determine formatting behavior.

XSL defines a set of core HTML flow objects, as well as more general DSSSL flow objects. While flow objects do not necessarily have to be expressed as HTML, they do fundamentally assume a two-dimensional, page layout model.

Metadata

One of the main design goals of the Resource Description Framework (RDF) is to provide a robust and flexible system for metadata on the Web. RDF uses XML as its transport mechanism; that is, an RDF document is by definition an XML document. Therefore, rather than duplicating existing work by devising a custom metadata framework for VRML, it makes more sense to devise a system and syntax for VRML to work with any XML document. This allows VRML take advantage of RDF, as well as the variety of other applications based on XML. This approach leverages the rigorous design work of RDF and XML and the expected ubiquity of these formats.

A reasonable approach is to take the Document Object Model, the standard API for reading and writing XML and HTML documents, and support an appropriate subset of its features within VRML. This will enable a VRML author to extract data from any XML document and incorporate that data within an application's logic and scripts, using familiar VRML syntax.

In this case, we can reduce the scope of the problem by assuming that authors will only be reading existing XML documents. This means that the following operations defined by the DOM are the operations of interest:

• Node.getNodeType()
• Node.getChildNodes()
• Attribute.getName()
• Attribute.getValue()
• Element.getTagName()
• Element.getAttributes()

We define the following VRML PROTO to express our interface:

EXTERNPROTO Metadata [ 
	exposedField MFString url [] 
	eventIn SFString elementID  
	eventOut MFString elementIDs
	eventOut SFString tagName
	eventOut MFString attributeNames 
	eventOut MFString attributeValues 
	eventOut MFString childElements 
	eventOut MFString childElementTypes 
	] 
"urn:inet:vrml.org:dbwork.Metadata"

On initialization, and whenever the url field subsequently changes, the elementIDs event is generated. This event contains the ID values of the elements in the document for all elements that have an ID attribute explicitly specified.

The remaining events are generated whenever the elementID event is received and contain information about the specified element, if it exists.

tagName contains the string that is the element's name.

attributeNames contains a list of all attribute names defined for this element. attributeValues contains the corresponding attribute values.

childElement contains values of all child elements of the specified element, and childElementTypes defines the type of the child element. Valid values are:

childElementType	contents of childElements
ELEMENT	ID value of the element, or empty string if no ID is defined
TEXT	Value of the text

Note that only elements and #PCDATA children are returned; processing instructions and comments are ignored.

As an example, consider the following simple XML document:

<?xml version="1.0"?>
<books id="vrml">
<book id="cmarrin" author="Chris Marrin" published="1997"> 
Teach Yourself VRML 2.0 in 21 Days 
</book> 
<book id="vrml20" author="Rikk Carey & Gavin Bell" published="1997"> 
The Annotated VRML 2.0 Reference Manual
</book> 
</books>

An elementID eventIn of vrml would produce the following eventOuts:

Event Name	Event Value
tagName	book
attributeNames	["id"]
attributeValues	["vrml"]
childElements	["cmarrin", "vrml20"]
childElementTypes	["ELEMENT", "ELEMENT"]

An elementID eventIn of cmarrin would produce the following eventOuts:

Event Name	Event Value
tagName	book
attributeNames	["id", "author", "published"]
attributeValues	["cmarrin", "Chris Marrin", "1997"]
childElements	["Teach Yourself VRML 2.0 in 21 Days"]
childElementTypes	["TEXT"]

The following fragment of VRML code uses the Metadata node to retrieve the title of a specified book:

DEF books Metadata {
	url [ "books.xml" ]
	}

# script to generate a book ID
DEF S1 Script {
	eventOut SFString bookID
	url "javascript:
		function initialize() {
			bookID = 'cmarrin';
			}"
	}

# display text of book
Shape {
	appearance DEF white Appearance {
		material Material {
			diffuseColor 1 1 1
			}
		}
	geometry DEF book_name Text { 
		string [""] 
		fontStyle DEF Font FontStyle {
				size 2
				justify "MIDDLE"
				style "BOLD"
			}
		}
	}


ROUTE S1.bookID TO books.elementID
ROUTE books.childElements TO book_name.set_string

Visualization and Style Sheets

On the other hand, there are already a variety of technologies for the real-time generation of XML from live databases and other data sources, and it is safe to assume that this will be a major application of XML. Style sheets can then be used to translate this dynamic data into HTML. However, the current specification for style sheets is limited in that it focuses only on generating HTML. There are many cases where more robust visualizations of an XML document are desirable, visualizations such as those afforded by VRML. Thus, it is natural to extend XSL to also support the creation of VRML based on an XML document.

To achieve this support, the same model for construction rules and patterns applies, since these are solely used to select subsets of the source XML document for translation. However, some additional flow objects need to be defined to take advantage of the unique properties of VRML. These flow objects fall into two categories:

1. PROTO mappings. Rather than limit the possible means of displaying XML, we allow any VRML PROTO instantiation based on XML content. This maximizes the flexibility of the system, since authors can design an arbitrary PROTO to encapsulate a visualization component, then instantiate that PROTO based on the contents of the XML document.

2. Transformation mappings. Unlike HTML flow objects, which are simply placed one after the other on the page, VRML flow objects need to be placed in three-dimensional space. To accomodate this, we define a flow object to specify how objects are translated and rotated in space.

PROTO Mappings

One approach is to define a new flow object called PROTO, used to specify the name of a PROTO definition. When this flow object is encountered, a VRML node of the specified type is created in the target document. Child elements in the XML document are then candidates for defining the values of fields. Field mappings are defined by specifying the name of the field in the action section, using the placement of the <children/> tag to specify the location of the target text within the generated field value.

As an example of how this might work, consider the following XML document containing information about stock data:

<?xml version="1.0"?>
<stocks>
<stock id="ORCL">
<symbol>ORCL</symbol>
<growth>10</growth>
<performance>9</performance>
<pe>5</pe>
</stock>
</stocks>

PROTO bar [
	field SFInt32 x 0
	field SFInt32 y 0
	field SFInt32 z 0
	field MFString label [ "" ]
	]

  <rule>
    <target-element type="stock"/>
	<PROTO>bar</PROTO>
	<children/>
  </rule>

  <rule>
    <element type="stock">
      <target-element type="growth"/>
    </element>
	x <children/>
   </rule>

  <rule>
    <element type="stock">
      <target-element type="performance"/>
    </element>
	y <children/>
   </rule>

  <rule>
    <element type="stock">
      <target-element type="pe"/>
   </element>
   z <children/>
   </rule>

    <element type="stock">
      <target-element type="symbol"/>
    </element>
	label "<children/>"
   </rule>

bar {
  x 10
  y 9
  z 5
  label "ORCL"
  }

Transformation Mappings

We define a new TRANSFORM flow object to indicate that a Transform node should be placed in the generated document. This flow object has two attributes. The increment_field attribute is used to specify one or more fields of the generated Transform node, in the format "field.component", for example, translation.z. The increment_value attribute is used to specify the amount by which the specified field of each Transform instantiation has its value incremented.

As an example, consider an XML document that displays some basic employee information, perhaps for use by a human resources application:

<?xml version="1.0"?>
<people>

<person>
<name>Smith</name>
<salary>1500</salary>
<years>14</years>
</person>

<person>
<name>Jones</name>
<salary>1800</salary>
<years>12</years>
</person>

<person>
<name>Johnson</name>
<salary>1200</salary>
<years>15</years>
</person>

</people>

  <rule>
    <target-element type="person"/>
	<TRANSFORM increment_field="translation.x" increment_value=10>
	<PROTO>EmpIcon</PROTO>
	<children/>
	</TRANSFORM>
  </rule>

We then use the same syntax as in the previous example to specify mappings for field values:

  <rule>
    <element type="person">
      <target-element type="name"/>
    </element>
	name [ "<children/>" ]
   </rule>

  <rule>
    <element type="person">
      <target-element type="salary"/>
    </element>
	salary [ "<children/>" ]
   </rule>

  <rule>
    <element type="person">
      <target-element type="years"/>
    </element>
	years 10 <children/> 10
   </rule>

Transform {
  translation 0 0 0
  children [
    EmpIcon {
      name [ "Smith" ]
      salary [ "$1500" ]
      years 10 14 10
      }
    ]
   }

Transform {
  translation 10 0 0
  children [
    EmpIcon {
      name [ "Jones" ]
      salary [ "$1800" ]
      years 10 12 10
      }
    ]
   }

Transform {
  translation 20 0 0
  children [
    EmpIcon {
      name [ "Johnson" ]
      salary [ "$1200" ]
      years 10 15 10
      }
    ]
   }

The above simple cases serve to illustrate the power and versatility of this approach and the usefulness of being able to graphically represent arbitrary XML documents.

Next Steps

The next step on the standards path is to introduce these proposals into the working group process of the respective standards bodies, the VRML Consortium and the World Wide Web Consortium. The working groups are the appropriate forums for developing a consensus and drafting a formal standards proposal.

As the XSL proposal in particular impacts both standards, it should be pursued through both the Enterprise Technology Working Group and the XML Working Group in conjunction. This work also provides an excellent opportunity to establish closer coordination and cooperation between the two standards bodies, hopefully paving the way for future cooperative efforts.

In addition, simultaneous efforts should be undertaken to provide working implementations.

The Metadata node can be implemented as a PROTO wrapper around a custom Java script, which will provide a useful tool for initial testing and evaluation. VRML browser authors should also implement this node as a native EXTERNPROTO extension within their browsers.

An initial implementation of the proposed VRML flow objects might use a preprocessor to translate an XSL document with VRML flow objects into an XSL document with custom ECMAScript functions for generating VRML text. The generated document can then be processed by any compliant XSL processor. Additionally, it may be useful to provide this functionality through server-side components, such as a Java Servlet, so that server-generated XML can be seamlessly delivered as VRML code to clients. Eventually, XSL will support an extensibility mechanism which can be used to directly support these new flow objects. In the long term, just as HTML browsers are now being extended with support for XML and XSL, VRML browsers should seamlessly process XML and XSL and automatically display the resulting VRML.

Another critical aspect to making these technologies usable is the availability of appropriate authoring tools. In this case, a new category of authoring tool is called for, one that combines the 3D modeling and composition of VRML authoring tools with the style sheet generation of XSL authoring tools. Such a tool would be the basis of a new and powerful paradigm for web-based data visualization applications.