The staff of the Geometry Center is proud to announce release 1.3 of
geomview, an interactive viewer for 3- and 4-D geometric objects built
on OOGL, an object-oriented geometry library.  Geomview is loosely a
successor of our earlier program MinneView, and the current OOGL
libraries have many new features.

To clarify the difference between geomview, OOGL, and MinneView:
geomview is an application written using the OOGL libraries as a
foundation.  You could write an application that uses OOGL that has
nothing to do with geomview, but geomview would be useless without
the OOGL libraries.  The new version of OOGL retains the same name as
the old.  Geomview and MinneView are both viewers: geomview is newer
and is different enough from MinneView we are considering it a
different program and have changed the name, instead of regarding it
as just "the new version of" MinneView.

Geomview, OOGL, and MinneView run on Iris workstations using Silicon
Graphics GL.  A Next version of geomview and OOGL using Quick
Renderman and a Sun X-windows version of them using XGL are under
development.

Geomview and OOGL are part of an ongoing effort at the Geometry Center
to provide interactive 3D graphics software which is particularly
appropriate for displaying the kinds of objects and doing the kinds of
operations of interest in mathematics research and education.  You can
compute an OOGL data file of a mathematical object that would be
difficult or impossible to build a model of in the real world.  In
geomview, besides examining an object in ordinary Euclidean 3-space,
you can look at objects in hyperbolic 3-space and Euclidean 4-space.
The hyperbolic model is the projective one, where geodesics are
straight lines and isometries are represented as 4x4 projective
matrices.  While geomview is tailored for mathematical visualization,
it is written to be extensible and can serve as a general-purpose
tool. Its functionality can be extended in an almost unlimited fashion
by external modules or programs as described below.

The most basic way to use geomview is to interactively examine
geometric data loaded from pre-computed files written in one of the
OOGL file formats.  Geomview turns numerical data that specifies an
object or a world of objects into a scene in one or more graphics
windows on your workstation.  The most direct way to interact with
this world is by moving the objects around and changing your point of
view using the mouse.  There is a control panel that allows you to
change various aspects of the world.  You interactively control the
appearance and motion of the objects and the motion of the points of
view. Multiple objects can be manipulated independently and there may
be several windows looking at the same scene with different points of
view.  OOGL data files can be generated by a C program, written by
hand, or converted from Mathematica 3D graphics objects using
the conversion package that is also available via anonymous ftp.

In the old version of OOGL, files could only specify geometry.  Object
file formats in the new version have been extended to also include
appearances, transformations, and cameras.  Any object appearance that
you can establish through the geomview control panel can also be
established by including an appearance specification in the same data
file as that object.  A path of motion can be specified in a file by a
list of 4x4 transformations, allowing you to compute a path that would
be very hard to trace freehand with the mouse.  Geomview allows you to
hook up the motion of an unlimited number of individual objects to
separate transform files while keeping others under interactive
control.

Almost everything else that can be done interactively through the
graphical user interface in geomview can be specified by a lisp-like
command language.  At present it has only viewer controls, no
variables nor control structures.  Data in any of the file formats
described above (geometry, appearances, transforms, cameras) can be
embedded within the language.  Geomview can read in and act on a
command language file at any time during an interactive session, and
will automatically look for a file named ".geomview" in your home
directory to configure itself when it starts up.

Finally and most importantly, geomview can act as a graphical front
end for a separate application.  Besides interactive control or
reading from a file, geomview can also be driven by external programs
by reading through a Unix pipe.  Anytime that you can read data from a
file in geomview you could hook up a pipe. Meanwhile, interactive
controls still apply to all features not being externally controlled.
For example, hooking up a pipe to a geometry allows the viewer to show
a simulation's dynamically changing output, while hooking up a pipe to
the motion of a geometry allows externally-driven animation. The most
general route is for an external program to send commands through a
pipe, since all other file formats are a subset of the command
language.  Also one can externally supply geometric objects and
transformations, changing all or part of a geometric hierarchy on the
fly.

Another new feature of the OOGL libraries, support for four
dimensional data types, was implemented by Charlie Gunn.  All
geometric primitives, such as polygons, meshes, and vector lists,
now can be supplied with either 3 or 4 dimensional vertices.
The extensive use of projective coordinates in computer
graphics allows the addition of this support with minimal programming
effort.  Geomview comes with an external module which allows the user
to apply four dimensional rotations to these objects. The 4-D objects
are shown in 3-D by projection rather than by slicing.

We strongly encourage mathematical programmers to consider using
geomview as a front end for graphics.  Just as a text editor allows
you to concentrate on the content of your program instead of the
mechanics of displaying letters on a computer screen or an efficient
algorithm for recalling previously cut text, geomview offers a way to
incorporate visualization into mathematical programs without sinking
huge amounts of time and energy into graphics programming.

For users familiar with MinneView, here are the major differences
between geomview and MinneView in a nutshell: Geomview has an
easier-to-use user interface, multiple objects with independently
controllable motion and appearances, multiple windows for different
views of the same world of objects, different keyboard shortcuts,
camera fly and orbit interactive motion modes, 4D support, and a
lisp-like command language that allows external control of the
viewer's state (actually a superset of what can be done interactively
with the mouse).  External programs that that use shared memory will
need updating to work.  The OOGL libraries now allow communication of
geometry, appearances, transformations and cameras between programs,
which is supported by extensions to the OOGL object formats.
Arbitrary portions of hierarchies may be transmitted; the process
involves creating references to named items, then transmitting values
for those names.

Similarities between the two are: all old OOGL files that MinneView
could read can be used by geomview.  The object motion modes rotate,
zoom, and translate still exist.  External programs that used "stuff",
a program that stuffs geometric data into a named pipe, to communicate
with MinneView should work unchanged with geomview.

Geomview may be obtained via anonymous ftp from geom.umn.edu; it is in
the "pub" subdirectory in the file "geomview.tar.Z".  After retrieving
it (in binary ftp mode), the command "uncompress < geomview.tar.Z |
tar xvopf -" will unpack it into the current directory.  This
distribution includes binaries, documentation, and sample data files
for geomview and a collection of auxiliary programs.
See the file README for details after unpacking.

Please send all correspondence regarding this software via email
to "software@geom.umn.edu".

------------------------------------------------------------------------
Stuart Levy		  Tamara Munzner	       Mark Phillips