We are defining a foundation for data visualization based on the idea that a visualization process is a function from a set of data objects, called a data model, to a set of displays, called a display model. A prototype system called VIS-AD has been implemented based upon our ideas.
We are guided by the following principles:
We can define an order relation between data objects based on how precisely they approximate mathematical objects, and we can define an order relation between displays based on how precisely they approximate ideal displays (i.e., based on voxel resolution, etc.). These order relations define lattices of data objects and displays. Therefore we can model the visualization process as a function D:U --> V from a lattice U of data objects to a lattice V of displays. We can interpret the expressiveness conditions in this context and show that D satisfies the expressiveness conditions if and only if it is a lattice isomorphism.
We can define a particular lattice US appropriate for scientific data objects. These data objects are built up from primitive variables that we call scalars (e.g., time, latitude, radiance, and temperature) by tuple and array data type constructors (e.g., "array[time] of temperature" is a data type appropriate for a time series of temperatures). Thus the lattice US contains the data objects of a scientific programming language. We can also define a particular lattice VV of displays, in which a display is a set of voxels. Each voxel is specified by a set of graphics primitives that we call display scalars, e.g., a pixel's location and size in a volume, its color, and its place in an animation sequence.
We can show that functions D: US --> VV satisfying the expressiveness conditions are just the class of functions defined by mappings from the scalars used for primitive variables in data objects to the display scalars that specify graphics primitives of voxels. Of course, designers of scientific displays already assume that primitive variables are mapped to graphics primitives. For example, given a data object of type "array[time] of temperature", it is natural to display it as a graph with time along one axis and temperature along another. The remarkable thing is that we do not have to take this way of designing displays as an assumption, but that it is a consequence of the more fundamental expressiveness conditions.
We are developing and implementing a system called VIS-AD that allows scientists to experiment with algorithms, steer their computations, and visualize the data objects they create in their programs. The lattice US defines the data objects of the VIS-AD programming language, the system implements the lattice VV of displays, and data can be displayed using any function that satisfies the expressiveness conditions (however, the implementation is not quite precise). Just as data flow systems define a user interface for controlling data display based on abstraction of the rendering pipeline, the VIS-AD system defines a user interface for controlling data display based on the abstraction of mappings from scalars to display scalars.
It is possible to define data lattices for the recursively defined data types (i.e., complex linked types such as trees) used in general-purpose programming languages, and for the abstract data types and object classes in object-oriented programming languages.
Lattices provide a rigorous foundation for visualization. In particular, they can help us to develop an analytical alternative to the usual approach of defining a visualization process D constructively by writing a special-purpose program for computing a display D(u) for a specific data object u.