Home
Overview
FAQ
Documentation
Download
Mailing List
Geomview For Windows?
Support
Users
Development
Bug Reporting
Contributing
Contact Us
Sponsors
Site Search
Advanced Search
|
|
General
A general purpose interactive viewing program for Unix.
It is used mostly for 3D graphics but can display data
in 2D and 4D as well. See the overview
for more general comments about Geomview.
Geomview is available for free from http://www.geomview.org/download. There are
binary distributions for Linux, FreeBSD, SGI, Sun SPARC, HP-UX, IBM
RS/6000, DEC Alpha, and NeXT machines, as well as a source code
distribution.
You can also download it via anonymous ftp from ftp://ftp.geomview.org/pub
Geomview is free software, but we like to hear from people using
it. Please send us mail
telling us what you're doing with it.
See the Documentation part of this web site.
There is a "geomview-users" mailing list for people using geomview
that can be used for communication between users regarding geomview
problems, questions, experiences, etc. The geomview authors are also
a part of this list and will respond to questions posted to it. We
also use this list to make announcements about new releases and other
things of interest to users. To join the list, send an empty note
with 'subscribe' in the subject line to geomview-users-request@lists.sourceforge.net,
or visit the list web page at http://lists.sourceforge.net/mailman/listinfo/geomview-users.
See also the list of third party software and
projects.
Configuration / Installation / Execution Problems
This problems seems to be associated with recent versions
of Lesstif (e.g. 0.91.x), at least on GNU/Linux. I don't
know if it's a problem with Lesstif itself, or if something
is wrong with the way Geomview uses Lesstif. In the meantime,
if you experience this problem, I suggest compiling Geomview
with Open Motif instead of Lesstif. There's a lightweight
binary distribution of Open Motif 2.1.30 available from
the Geomview download page, with
instructions for using it with Geomview. Or, you can get
the full Open Motif distribution (source or binary)
from either
http://www.opengroup.org/motif
or
http://www.openmotif.com.
If you're familiar with Lesstif and know what might cause
this problem (and especially if you know how to fix it!), please
email me [mbp@geomtech.com].
- Make sure you passed the argument "--with-opengl=DIR" to configure,
where DIR is the directory containing your OpenGL installation.
DIR should be the absolute path to a directory containing
subdirectories named "include" and "lib". The "include" subdir
should in turn include a subdir called "GL" that has the header
file "gl.h" (as well as other header files) in it. The "lib"
directory should contain the GL library (.so) files.
- Sometimes 'configure' will incorrectly report that OpenGl is missing
when in fact OpenGl is present, but the test for it fails for some
other reason, such as some missing dependent header file or
library. For example, if your installation of X windows is
screwed up or incomplete, it can confuse the tests that 'configure'
does for OpenGl. There are two places to look for clues about
this:
- The output from 'configure' itself --- look at the lines
related to checking for X windows, in particular. If X
was not found, or couldn't be linked with, then that is
probably the problem.
- The file 'config.log' that 'configure' writes as it runs.
This file contains all the gory details about the tests that
'configure' is doing. It'll have error messages that may
indicate why certain tests fail. IMPORTANT note about
reading 'config.log': many of configure's tests involve
loops which try several possibilities --- for example
several possible locations for a header file. 'configure'
will write a little program and try to compile it once for
each of these locations, until it finds one that works. For
each one that doesn't work, there will be error messages in
the 'config.log' file. When reading 'config.log', be sure
to look for ALL these test, not just the first one, in
trying to decide why a test is failing.
- If the output from 'configure', or the contents of 'config.log',
suggest that some parts of X can't be found (for example if it can't
find certain X header files, like "X11/X.h" or "X11/Intrinsic.h"),
then the problem could be that you have not installed the X windows
development package for your system. Some default Linux distributions
include the runtime X package but not the development package(s).
Make sure you've installed whatever packages are necessary for X
development work as well as the runtime X package(s).
- If 'configure' claims that it can't link with -lGL (or -lGLU)
but you are sure it's there, find the directory containing
your libGL.so.* and libGLU.so.* files; call this directory
DIR. DIR will probably contain one or more files with
names like libGL.so.VERSION and and libGLU.so.VERSION,
where VERSION is some version number, such as "1.2.0"
or "1.2.030200". It should also contain entries named
simply libGL.so and libGLU.so, with no VERSION suffix;
these are usually symbolic links to corresponding files
with version suffixes. For example, on my system I have
libGL.so -> libGL.so.1.2.030200
libGLU.so -> libGLU.so.1.2.030200
If the links (or files) libGL.so and libGLU.so are not present,
create them by making symbolic links to the corresponding file
with the highest version number.
I do not understand why these links would be missing in some
installations of OpenGL, because it's my understanding that they
have to be there for programs to link properly. I admit however
that I don't understand all the .so and .so.VERSION stuff, so
it could be that these links aren't really necessary and that
some change in Geomview's configure script or Makefiles could
eliminate the need for them. If you know a way to do this,
please let me
[mbp@geomtech.com] know.
Read all the
suggestions above in the answer to the analogous question about
OpenGL; they all
apply equally well to Motif. (The main header file to look for in the
"include" directory is "Xm/Xm.h").
Platforms
SGI Irix, Linux, FreeBSD, Solaris, SunOS, HP, IBM RS/6000, DEC Alpha
Certainly. If your workstation has the X Window System, OpenGL, Motif,
and an ANSI (ISO) C compiler, you can compile geomview from the source
code distribution at http://www.geomview.org/download.
Note that there is a free version of OpenGL called Mesa (www.mesa3d.org) which runs in
software on most of the free Unixes. See that page for details on the
ongoing efforts to incorporate hardware support for some of the
popular graphics cards.
Note also that there is a free version of Motif called lesstif (www.lesstif.org).
The INSTALL file has instructions about how
to port to new architectures. If you have problems, send mail to software@geomview.org. If you
succeed, we would appreciate receiving a copy of your
"makefile/mk.whatever" and hearing about what source modifications
were necessary. Ideally we'd also like to include your binaries in our
precompiled distribution list.
There is not a native version of Geomview for Microsoft Windows. The main
reason for this is that at the time when Geomview was written,
personal computers were not fast enough to make interactive 3D
graphics feasible so we focused our efforts on Unix workstations. By
the time fast-enough PCs came around, the Geometry Center, where
Geomview was developed, was in the process of being closed. The staff
started work on a port to Windows but was not able to finish it before
the Center shut down.
Geomview can run under Cygwin,
which provides Windows with a Unix-alike environment. See
Geomview for Windows? for more information.
If you would like to see a version of Geomview for Windows, you can
contribute to its development in several ways. See Contributing to Geomview for details.
The current speedtest result file is now
quite out of date. You can test Geomview on your own platform using
the files found in data/speedtests. Please contribute
your timings back to us so that we can update our master file with
results for modern machines.
We no longer distribute the NeXTStep/OpenStep version of Geomview,
which used the Quick Renderman graphics library. We did this just to
simplify code base maintenance after version 1.5.0. Fat binaries for
Motorola, Intel, and HP-PA architectures for version 1.5.0 are still available.
The SGI version will almost always be significantly faster, due
to hardware support for 3D graphics. For example, a Sun
Sparcstation 10 is slower than an Indy (SGI's old entry level
machine). In the future there might be hardware support for certain
OpenGL graphics cards available on some of the PC Unixes.
We release almost all external modules for all platforms. The list of
distributed modules is in the README file included in the
distributions. If the module you want is in that list but doesn't
appear in the modules list on main panel, Geomview probably wasn't
installed properly. Note that there are additional modules written by others which are not part of
the main distribution. The modules distributed in the most recent
version of Geomview (1.6.1p9) are:
MODULE DESCRIPTION
addbbox explicitly create enclosing bounding box
animate flip through a sequence of objects
clipboard cut, copy, and past geometric objects
cplxview visualize graphs of complex functions
drawbdy compute and draw boundary of an object
emodule_wish ????
example sample module Example2 described in manual
flythrough interactive version of "Not Knot"
hyperbolic flythrough
ginsu interactively slice objects with movable
clipping plane
graffiti draw line segments on objects
gvclock 3D clock, demonstrates real-time motion
hinge hinge copies of a polyhedron around its edges
maniview 3-manifold viewer
nose demonstrates picking
stereo hardware, crosseyed, or red/cyan stereo (beta)
sweep generates objects of rotation from line segments
tackdown redefine an object's "home" position
transformer explicitly control (and see) an object's
transformation matrix
The following modules use tcl/tk:
MODULE DESCRIPTION
3D-Snapshot create 3D snapshot of N-dimensional object view
Colormap create colormaps for N-dimensional objects
Crayola interactively color objects per-vertex
Labeler generate polygonal (or vector) text from string
NDdemo N-dimensional viewing demonstration
NDview N-dimensional viewing controls and demonstration
Slicer clip N-dimensional objects to hyperplanes
StageTools suite of tools for making MPEG/video/etc animations
The following modules are only included in the SGI distribution:
MODULE DESCRIPTION
trigrp explore triangle symmetry groups
The following utility programs are also included in the distribution:
UTILITY DESCRIPTION
anytooff convert one or many OOGL files into a single
OFF file
anytoucd convert an OOGL file to UCD (AVS) format
bdy compute boundary of an object (helper for drawbdy)
bez2mesh dice BEZ file to list of MESHes
clip clip objects against plane/sphere/cylinder
(helper for ginsu)
hvectext generate vector text object
math2oogl convert Mathematica graphics to OOGL
(helper for OOGL.m)
offconsol polylist vertex consolidator
offcvt convert between ASCII and binary OFF format
oogl2rib convert OOGL to Renderman RIB format
oogl2vrml convert OOGL to VRML 1.0
polymerge merge degenerate OFF vertices/edges/faces
(to Evolver or OFF)
togeomview send commands to geomview
ucdtooff convert UCD (AVS) format to OFF format
vrml2oogl convert VRML 1.0 to OOGL
MODULE DESCRIPTION
4dview 4-dimensional slicing & rotation
pssnap generate PostScript snapshot
warp interactively deform an object
4dview was replaced by the more general NDview, and its custom
viewpoint selector widget was only usable with the SGI version of
Forms.
The functionality of pssnap has been directly incorporated into
Geomview, and is available through the Save panel: one of the options
is Save As Postscript.
The warp module used Forms and wasn't converted to XForms like the
others. I'm not sure what the problem was.
Using Geomview
When objects aren't appearing where you think they should, it's
probably because normalization is on by default. Normalization
simply scales an object's bounding box to fit into a unit sphere,
with the center of the bounding box translated to the origin.
This is useful when examining a single object, as you can easily
view the whole object without having to worry about how big it
is. However, it also means that if you're loading multiple
objects that are supposed to belong in the same coordinate
system, all the objects will be scaled and placed at the origin.
To turn off normalization, bring up the Appearance Panel. The
normalization controls are in the lower-right quadrant of the
panel. Select the "None" option. The alternate hotkey shortcut is
'0N'.
To turn off normalization by default, customize
Geomview by inserting the line (normalization allgeoms
none) into a file called .geomview in your home
directory.
When you turn off normalization your objects might seem to vanish.
This is because the unnormalized objects do not lie in the camera's
viewing cone. The easiest way to see everything is to choose the
"World" object in the Object Browser, then click on "Look At" in the
Tools Panel.
See previous answer.
The most efficient way to display points in Geomview is to use
the VECT file format. This file format is mainly used for
building shapes made out of lines but we can also use it to specify
lines that contain only one vertex (i.e. points). Let's take
a look at an example VECT file that describes 3 points colored
red, green and blue:
VECT
3 3 3 # num. of polylines, num. of vertices, num. of colors.
1 1 1 # num. of vertices in each of the 3 polylines,
# in this case only 1 for each since we are doing points.
1 1 1 # num. of colors supplied for each polyline.
-1 -.2 0 # Here are the coordinates of each point.
1 -.2 0
0 .9 0
1 0 0 1 # Color for each vertex in RGBA format.
0 1 0 1
0 0 1 1
When loading this file into Geomview, you will probably need to turn
off the bounding box (via the appearance panel), otherwise you may
not be able to see the points.
By default, the thickness of lines and points in Geomview is 1. This
may be okay for most lines, but it causes each point to occupy only one pixel
on the computer screen. You can change line and point thickness by adding
an appearance tag to the top your geometry file that looks like this:
appearance {
linewidth 4
}
In this case, we have increased our line/point size to 4 and any points we
have in our file will now appear as small disks. You can also
change the line width using the Appearance panel. What Geomview actually
does is render each point as a many sided polygon which
approximates a disk.
If you want the points to appear as solid 3-dimensional objects, such
as tiny spheres, you can use a completely different method for
representing them: an INST object with multiple transforms. This lets
you specify an arbitrary geometric shape to be used to represent the
points. For example, the following file represents the three points
(1.5, 2.0, 0.1), (1.0, 0.5, 0.2), and (0.5, 0.3, 0.2) using small
cubes:
INST
geom {
OFF
8 6 12
-0.05 -0.05 -0.05
0.05 -0.05 -0.05
0.05 0.05 -0.05
-0.05 0.05 -0.05
-0.05 -0.05 0.05
0.05 -0.05 0.05
0.05 0.05 0.05
-0.05 0.05 0.05
4 0 1 2 3
4 4 5 6 7
4 2 3 7 6
4 0 1 5 4
4 0 4 7 3
4 1 2 6 5
}
transforms
1 0 0 0 0 1 0 0 0 0 1 0 1.5 2.0 0.1 1
1 0 0 0 0 1 0 0 0 0 1 0 1.0 0.5 0.2 1
1 0 0 0 0 1 0 0 0 0 1 0 0.5 0.3 0.2 1
#
# these are the matrices:
#
# 1 0 0 0 1 0 0 0 1 0 0 0
# 0 1 0 0 0 1 0 0 0 1 0 0
# 0 0 1 0 0 0 1 0 0 0 1 0
# 1.5 2.0 0.1 1 1.0 0.5 0.2 1 0.5 0.3 0.2 1
The OFF object between "geom { " and "} " is
the cube. The three lines after the word "transform" are 4x4
transforms, one for each point. Note that you can use any valid
OOGL expression for the geometry; for example, if you want to
use small dodecahedra to represent points, you could repace the
above OFF object with the following, which references the
dodecahedron object in the file dodec.off (distributed with
Geomview), scaling it by 0.05:
INST
geom {
INST
geom { < dodec.off }
transform
.05 0 0 0
0 .05 0 0
0 0 .05 0
0 0 0 1
}
transforms
1 0 0 0 0 1 0 0 0 0 1 0 1.5 2.0 0.1 1
1 0 0 0 0 1 0 0 0 0 1 0 1.0 0.5 0.7 1
1 0 0 0 0 1 0 0 0 0 1 0 0.5 0.3 0.2 1
Be aware that the more complicated the geometry you use for your
points, the longer it will take Geomview to refresh the window. This
can be important if you're dealing with a large number of points, in
which case you should stick to very simple point shapes or use
the method of displaying points in VECT format.
You have two options:
- You can use the Labeler external module, which gives you a GUI for
typing text and selecting the font: either vector or a polygonalized
version of an installed font. However, you need to position the text
in the 3D scene, either by hand or with some other module like
Transformer.
- You can use the hvectext command-line utility program for
Hershey vector fonts, which does let you specify a position for the
text. You would then need to load the resulting file into Geomview.
If you don't need the text to be a 3D object in the scene, you can
create an image or postscript
file of the scene and then use an image editor such as Illustrator,
Showcase, or XPaint to annotate it with text.
No, Geomview is intended to do surface visualization. You can either
create an isosurface and then view it using Geomview, or use a volume
visualization package. The free vtk visualization toolkit
has extensive support for volume visualization, as do commercial
packages like AVS, Iris Explorer, or IBM Data Explorer.
Volvis is free software
specifically for volume visualization.
Yes, in release 1.6 and higher, but only in the OpenGL version, not in
the X11 version.
This is probably due to a different interpretation of how an
OFF should be written. Geomview indexes vertices starting at zero,
while some other programs are known to start at one. The following C program
will convert a plain one-indexed OFF to a zero-indexed OFF.
#include "stdio.h"
int main(void) {
char s[256];
int v, f, i, n, t;
gets(s);
if (strcmp(s, "OFF")) {
fprintf(stderr, "not an OFF\n");
exit(1);
}
puts(s); gets(s); puts(s);
sscanf(s, "%d %d %d", &v, &f, &i);
for (i=0; i!=v; ) {
gets(s);
if (strlen(s)) {
puts(s); i++;
}
}
for (i=0; i!=f; i++) {
scanf("%d", &n);
printf("\n%d", n);
for (v=0; v!=n; v++) {
scanf("%d", &t);
printf(" %d", t-1);
}
}
printf("\n");
return 0;
}
You might try using Animator, an external module that is
distributed with all versions of Geomview. With Animator,
you can tell Geomview to read in a sequence of OOGL files and
then play through this sequence forwards, backwards and also in
single frame steps using the VCR like interface.
To use Animator click on the Animator entry in Geomview's
External Modules browser. If it does not appear in the browser,
then Geomview has probably not been installed properly. For
more information about Animator read the info panel available
through the program or the the man page (by typing man animate).
Output
There are several variants of this question:
-
> I would like to save a sequence of ppm snapshot files of a single
> off object while it is rotating so that I can convert the sequence
> into a movie. The only method I know of is to rotate the object
> slightly with the mouse, stop the motion, and save each frame
> individually. Is there a faster more automatic method, such as a
> command script. If so, do you have a sample command script that I
> could modify?
Two options:
-
> I have used Geomview to view movies with the animation tool. How can
> I convert that movie to another animated format (e.g. an animated
> GIF) so that I can put it on display in a web page, viewable by
> someone without Geomview?
It's true that StageTools will do this and much more too. But
there's also a very easy way to do this directly inside the Animate
module: the Command function will run an arbitrary GCL command after
each frame. So to automatically take snapshots at each frame, you'd
hit the Command button and type something like
(snapshot c0 /tmp/foo%03d.rgb)
into the text field. Then when you hit play you'll see that it's now
jerky since it's saving an image off to disk each time. You might want
to turn on the "Once" radio button so that it stops after running
through each frame once. Then you can use your program of choice to
create an animated gif or quicktime movie from this bunch of image
files. For instance, on the SGIs you could do this with
"mediaconvert".
Make sure that the camera window you want is the active one, then
select the "Save" item of the "File" menu on the main panel (or use
the ">" hotkey). In the panel that appears, there is a choice box that
is set to Command by default. Select one of the snapshot options,
enter the filename in the Selection input, and click "OK".
In the SGI version, you have three image snapshot choices: SGI screen,
PPM screen, and PPM software. Both the screen choices literally save
the onscreen pixels into a file, in either SGI (aka RGB) or PPM
format. The PPM software choice will rerender the image into an
offscreen buffer using the software renderer from the vanilla X
version of Geomview. Thus, it might not be pixel by pixel identical to
what you see.
In the X11 version, you have only the PPM choices.
Make sure that the camera window you want is the active one, then
select the "Save" item of the "File" menu on the main panel (or use
the ">" hotkey). In the panel that appears, there is a choice box that
is set to Command by default. Select the PostScript snapshot option,
enter the filename in the Selection input, and click "OK".
This method has advantages and disadvantages, compared to saving an
image bitmap. The advantage is that the result is resolution
independent -- you can print it on a high resolution printer and not
see any jagged edges. The disadvantages are that our PostScript
renderer can't do smooth shading and uses the painter's algorithm for
hidden surface removal. The latter means that intersecting objects and
some other ill-conditioned scenes will be drawn incorrectly, or even
that closer objects will be drawn behind faraway objects. It often
works, but not always.
See previous answer.
If you have Photorealistic Renderman (a commercial product of
Pixar), or BMRT (Blue Moon Rendering Toolkit, a public domain
implementation), you can create high quality images with transparency and
more accurate lighting in the SGI and X11 versions. To do this, bring up the
Save panel and select "RMan [->tiff]" from the save options.
Enter a filename and click "Ok". Bring up a shell window and
change directory to where you saved the file. Type "render
filename" (where filename is the name you saved as). When this
finishes, you will have an high quality image in "filename.tiff".
To create a higher resolution image (to reduce jagged edges),
edit the file you saved. There will be a line about fifteen lines
down from the top
that begins with "Format", i.e. "Format 450 450 1". The first two
numbers are the resolution of the created image. Change these to
what you like (you should keep the ratio of the numbers the same
to avoid distortion), then render the file again.
X Specific Questions
See the discussion of rendering options in the next question.
These control allow you to change how the X11 version renders
objects. The dithering checkbox, which only appears when running
on an eight bit display, allows you to turn dithering on and off.
Dithering is the method by which Geomview uses a small set of
colors (less than 217) to show any color you request. This is
done by placing pixels of slightly different color next to each
other and letting your eye blend them together. Unfortunately,
it takes a fair bit of computing to do this. Turning it
dithering off will speed up rendering, but colors used won't be
exactly what you want. Depending upon your scene, this may be an
acceptable tradeoff.
The Z-Buffer popup menu allows you to select between three different
methods of hidden line/surface removal: z-buffering, depth sort,
and none. Z-buffering is the most accurate and enables the near
and far clipping planes. Depth sort uses less computing, but
will be inaccurate if objects intersect (polygons will pop in
front when they should be partially obscured) and in certain
other circumstances (long, narrow polygons close to other
polygons are one example). Depending on your scene, using this
method could look just the same as z-buffering but be much
faster. The "None" option turns off all hidden line/surface
removal. This is only recommended for a scene which consists of
just lines in one color.
This happens when using the X11 version on an eight bit
display (currently common on workstations). An eight
bit display can only show 256 colors simultaneously. These
colors are shared by all the programs running. Once a
colorcell has been allocated by an application, its color is
fixed. Geomview tries to grab many colors when it starts.
If it fails to get them, it prints this message and uses a
private colormap. A private colormap means that Geomview now has
access to all 256 colorcells. Unfortunately, these colors will
only be displayed when the cursor is inside one of Geomview's
windows. The switching of colormaps when the cursor enters and
leaves the windows will give a technicolor look to the rest of
the display.
If you don't like the technicolor effect, you will have to quit
the programs which are using up colormap space. Examples of
programs which use lots of colormap space are background
pictures, image viewers, visualization software, and WWW browsers.
The X11 version of Geomview uses the shared memory extension to
move images quickly between the program and the X server.
However, this method of communicating with the X server only
works when running Geomview on the same machine as the display.
If Geomview can't use shared memory, it prints this message and
goes back to using standard X calls. Everything will work the
same, it will just run much slower, especially if you're running
over the network.
You're trying to compile the X11 version and the compiler can't
find the Motif header files. If you have Motif but the headers
are in a nonstandard place, change the "SYSCOPTS" in your
makefiles/mk.${MACHTYPE} file. If you don't have Motif, you
won't be able to compile Geomview. In this case, use one of the
binary distributions, if you can.
|