\documentclass[12pt,a4paper]{article}
\usepackage[linktocpage]{hyperref}
\begin{document}
\vspace*{6cm}
\huge
\begin{center}
FAQ\\
Geomview
\end{center}
\normalsize
\newpage
\tableofcontents
\newpage

\section{General Questions}

    \subsection{What is Geomview?}

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 \url{http://www.geomview.org/overview} for more general
comments about Geomview.

    \subsection{How do I download Geomview?}

        Geomview is available for free from \url{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
        
        \url{ftp://ftp.geomview.org/pub}

        Geomview is free software, but we like to hear from people using it.
        Please send us mail using register@geomview.org telling us what
        you're doing with it.

    \subsection{What Geomview documentation is available?}

        See the Documentation \url{http://www.geomview.org/docs} part of this web site.

    \subsection{How can I get in touch with other Geomview users?}

        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:\\
        \url{http://lists.sourceforge.net/mailman/listinfo/geomview-users}
	\\
        See also the list of third party software and projects:\\
        \url{http://www.geomview.org/thirdparty}.

\section{Configuration/Installation/\\ Execution Problems}

    \subsection{The checkboxes and certain other GUI widgets are either \\
    absent from Geomview's panels, or don't work when I compile \\
    the latest version. What's up?}

        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 \url{http://www.geomview.org/download}, with
        instructions for using it with Geomview. Or, you can get the full Open
        Motif distribution (source or binary) from either \url{http://www.opengroup.org/motif}
        or ..............................\\ \url{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 at geomtech.com).

    \subsection{configure claims it can't find OpenGl on my system, but I'm sure that it is installed}
    \label{aswer:OpenGl}
        \begin{itemize}
          \item 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.

          \item 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 window 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:
              \begin{itemize}
              \item The output from 'configure' itself --- look at the lines related
                to checking for X window, in particular. If X was not found, or
                couldn't be linked with, then that is probably the problem.

              \item 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.
             \end{itemize}
          \item 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 window
            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).

          \item 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 libGLU.so.VERSI\\ ON, 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
	    \begin{verbatim}
            libGL.so -> libGL.so.1.2.030200
            libGLU.so -> libGLU.so.1.2.030200
	    \end{verbatim}
            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.
     \end{itemize}

    \subsection{configure claims it can't find Motif (or Lesstif or OpenMotif) on my system, but I'm sure that it is installed }

        Read all the suggestions above in the answer to the analogous question
        about OpenGL in section \ref{aswer:OpenGl}; they all apply equally well to
        Motif. (The main header file to look for in the ``include'' directory is
        ``Xm/Xm.h'').

\section{Platforms}

    \subsection{What platforms have binary downloads available?}

        SGI Irix, Linux, FreeBSD, Solaris, SunOS, HP, IBM RS/6000, DEC Alpha

    \subsection{There isn't a binary for my workstation. Is there hope?}

        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 \url{http://www.geomview.org/download}.

        Note that there is a free version of OpenGL called Mesa\\
        (\url{http://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) \url{http://www.lesstif.org/}.

        The INSTALL \url{http://www.geomview.org/docs/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.

    \subsection{Why isn't there a Windows version?}

        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 \url{http://www.cygwin.com}, which provides
        Windows with a Unix-alike environment. See Geomview for Windows?
        \url{http://www.geomview.org/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 \url{http://www.geomview.org/contributing} for details.

    \subsection{How fast does Geomview run on various platforms?}

        The current speedtest result file \url{http://www.geomview.org/docs/speeds}
        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.

    \subsection{I have access to an X11 and SGI workstation. Which version should I use?}

        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.

    \subsection{What happened to the NeXT Quick Renderman version?}

        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 in\\
        \url{http://www.geomview.org/download/dist/geomview-1.5.0-next.tar}.

    \subsection{What modules are shipped for which platforms with the current release?}

        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
        \url{http://www.geomview.org/thirdparty} which are not part of the main
        distribution. The modules supported in the most recent GNU/Linux version of
        Geomview (1.9.4) are:\\
        \begin{center}
        \begin{tabular}{|l|p{8cm}|}
        \hline
        MODULE & DESCRIPTION \\ \hline
        Animator & flip through a sequence of objects \\ \hline
        Antiprism models & Create, transform, analyse, and visualise polyhedra\\ \hline
        StageTools & CenterStage, StageManager, StageStills, StageHand - lets you create Geomview objects using mathematical formulas\\ \hline
        Clipboard & save a single OOGL object to a clipboard \\ \hline
        Clock & an animated clock \\ \hline
        Draw Boundary & \\ \hline
        Nose & debugging/example for picking (see Geomview manual)\\ \hline
        Orrery & Solar System Visualization \\ \hline
        \end{tabular}
	\end{center}
        The following modules use tcl/tk:
        \begin{center}
        \begin{tabular}{|l|p{8cm}|}
        \hline
        MODULE & DESCRIPTION \\ \hline
        StageTools & CenterStage, StageManager, StageStills, StageHand - lets you create Geomview objects using mathematical formulas\\ \hline
        \end{tabular}
	\end{center}
        The following utility programs are also included in the distribution:
        %%fd2ps fdesign oogl2vrml2 remotegv
        \begin{center}
        \begin{tabular}{|l|p{8cm}|}
        \hline
        UTILITY & DESCRIPTION \\ \hline
        anytooff & convert one or many OOGL files into a single OFF file \\ \hline
        anytoucd & convert an OOGL file to UCD (AVS) format \\ \hline
        bdy & compute boundary of an object (helper for drawbdy) \\ \hline
        bez2mesh & dice BEZ file to list of MESHes \\ \hline
        clip & clip objects against plane/sphere/cylinder (helper for ginsu) \\ \hline
        fd2ps & xforms \\ \hline
        fdesign & xforms \\ \hline
        hvectext & generate vector text object \\ \hline
        math2oogl & convert Mathematica graphics to OOGL (helper for OOGL.m) \\ \hline
        offconsol & polylist vertex consolidator \\ \hline
        oogl2rib & convert OOGL to Renderman RIB format \\ \hline
        oogl2vrml & convert OOGL to VRML 1.0 \\ \hline
        oogl2vrml2 &  \\ \hline
        polymerge & merge degenerate OFF vertices/edges/faces (to Evolver or OFF) \\ \hline
        remotegv & remotegv $--$help \\ \hline
        togeomview & send commands to geomview \\ \hline
        ucdtooff & convert UCD (AVS) format to OFF format \\ \hline
        vrml2oogl & convert VRML 1.0 to OOGL \\ \hline
        \end{tabular}
	\end{center}

\section{Using Geomview}

    \subsection{Why don't objects appear in the right places?}

        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
        like showed in \url{http://www.geomview.org/docs/html/Customization.html}
        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.

    \subsection{Why is everything centered and/or on top of each other?}

        See previous answer.

    \subsection{How can I display a collection of points?}

        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:
	\tiny
        \begin{verbatim}
        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
        \end{verbatim}
        \normalsize
        
        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.

    \subsection{How do I make the points larger?}

        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:
        \begin{verbatim}
        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
        \end{verbatim}
        The OFF object between ``geom \{'' and ``\}'' is the cube. The three lines
        after the word ``transforms'' 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:
        \begin{verbatim}
        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
        \end{verbatim}
        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.

    \subsection{How do I put text into a scene?}

        You have two options:
          \begin{itemize}
          \item 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.
          \item 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.
          \end{itemize}
        If you don't need the text to be a 3D object in the scene, you can
        create an image \url{http://www.geomview.org/FAQ/answers.shtml#images} or postscript \url{http://www.geomview.org/FAQ/answers.shtml#ps}
        file of the scene and then use an image editor such as Illustrator,
        Showcase, or XPaint to annotate it with text.

    \subsection{Can Geomview do volume visualization?}

        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 \url{http://www.vtk.org/}
        visualization toolkit has extensive support for volume visualization, as
        do commercial packages like AVS \url{http://www.avs.com}, Iris Explorer
        .............................................................\\
         \url{http://www.nag.co.uk/Welcome\_IEC.html}, or IBM Data Explorer
        ..........\\ \url{http://pic.dhe.ibm.com/infocenter/dataexpl/v8r2/index.jsp}. Volvis
        \url{http://labs.cs.sunysb.edu/labs/vislab/volvis/} is free software specifically for
        volume visualization.

    \subsection{Can Geomview do texture maps?}

        Yes, in release 1.6 and higher, but only in the OpenGL version, not in
        the X11 version.

    \subsection{Why can't Geomview read my OFF file?}

        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.
        \begin{verbatim}
        #include <stdio.h>
        #include <string.h>
        #include <stdlib.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;
        }
        \end{verbatim}

    \subsection{How can I animate a sequence of Geomview/OOGL files?}

        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 \footnote{Note added by Jorge Barros de Abreu: the VCR
        changes to avifile \url{http://avifile.sourceforge.net/}. We have also kino and muan.}.

        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
        man page (by typing man animate).

\section{Output}

    \subsection{How can I create a video animation (MPEG/\\ QuickTime/animated GIF)?}

There are several variants of this question:

        \begin{itemize}

        \item first variant \\
    	    \tiny
    	    \begin{verbatim}
            > 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?
	    \end{verbatim}
	    \normalsize
            Two options:
              \begin{itemize}
              \item If the motion is axis-aligned, it's pretty easy to use the
                rotate and snapshot GCL commands together:

                (snapshot targetcam /tmp/foo\%03d.rgb)
                (transform world world world rotate .1 0 0)
                (snapshot targetcam /tmp/foo\%03d.rgb)
                (transform world world world rotate .1 0 0)

                and so on. The snapshot commanad auto-increments the filename.

              \item But for a more complex motion than the simple rotation around
                the x axis that I have above, consider using StageTools, which
                is a suite of tools designed to help people easily make
                animations from Geomview. StageTools is included as a module in
                recent versions, but if you need to download it is available at
                \url{http://www.geom.umn.edu/software/StageTools/}.
              \end{itemize}

        \item second variant \\
    	    \tiny
	    \begin{verbatim}
            > 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?
	    \end{verbatim}
	    \normalsize
	    
            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''.
        \end{itemize}

    \subsection{How can I save a picture of exactly what I see in a camera window?}

        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.

    \subsection{How can I make a true PostScript file that looks good at multiple resolutions instead of just converting a bitmap into PostScript?}

        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.

    \subsection{Why does my PostScript snapshot look wrong?}

        See previous answer.

    \subsection{How can I make a high quality image with RenderMan?}

        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.

\section{X Specific Questions}

    \subsection{How do I speed up the X11 version?}

        See the discussion of rendering options in the next question.

    \subsection{What do the Z-Buffer and Dithering controls in the Cameras panel do?}

        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.

    \subsection{What does ``Not enough colors available. Using private colormap'' mean?}

        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.

    \subsection{What does ``Shared memory unavailable, using fallback display method'' mean?}

        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.

    \subsection{Why do I get compiler errors about including files Xm/*.h?}

        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.

\end{document}