Provided by: geomview_1.9.4-3_amd64 bug


       Geomview - interactive geometry viewer


       geomview [-b r g b] [-c commandfile] [-wins #windows] [-noinit] [-nopanels] [-noopengl]
            [-wpos xmin ymin xsize ysize] [-wpos xsize,ysize[@xmin,ymin]] [-e external-module-
            name] [-M[cg][sp] pipename] [-start external-module-name [arg ...] --]
            [-run external-module-path [arg ...] --] [file ...]


       Geomview is an interactive geometry viewer written at the Geometry  Center.   It  displays
       the  objects  in  the  files  given  on  the  command line and allows the user to view and
       manipulate them interactively.

       The present version (1.7) of geomview runs on Silicon Graphics Irises, and X Window System
       workstations.  We are very interested in hearing about any problems you may have using it;
       see below for information on how to contact us.

       In addition to providing interactive control over a world of objects  via  the  mouse  and
       keyboard,  geomview  has  an interpreted language of commands for controlling almost every
       aspect of its display.  It can execute files containing statements in this  language,  and
       it can communicate with other programs using the language.  See geomview(5), e.g. the file
       man/cat5/geomview.5 in the geomview distribution, for more details of the language.


       This manual page serves only as a (very) terse  reference  manual  for  geomview.   For  a
       gentler  introduction  to  the  program  and the format of the data files it can read, see
       "overview" and "oogltour" in the "doc" directory of the geomview distribution, or  better,
       see  the  full  manual: "geomview.tex" or "", also in the "doc" directory.  The
       source distribution also includes a tutorial for how to  write  external  modules  in  the
       "src/bin/example" directory.


       -b     Set the window background color to the given r g b values.

       -c     Interpret  the commands in commandfile, which may be ``-'' for standard input.  The
              command language is described in geomview(5).  Commands may be supplied  literally,
              as  in  ``-c  "(ui-panel main off)"''; since they include parentheses, they must be

       -wins  Causes geomview to initially display #windows camera windows.

       -wpos  Specifies the initial location and size of the first camera  window.   With  ``-'',
              you are prompted for window placement.

       -M objname
               Display   (possibly   dynamically   changing)  geometry  (or  commands)  sent  via
              ``togeomview -g  objname  [geomview-shell-command]''  or  ``geomstuff objname  file
              ...''.  The data appears as a geomview object named objname.

              Actually  listens  to the named pipe ``/tmp/geomview/objname''; you can achieve the
              same effect with the shell commands:
                  mkdir /tmp/geomview;
                  mknod /tmp/geomview/objname p
              (assuming the directory and named pipe don't already  exist),  then  executing  the
              geomview command:
                  (geometry objname  < /tmp/geomview/objname)

       -M[cg][ps[un|in|in6]] PIPENAME|TCPPORT

              The  -M option accepts modifiers: a 'g' suffix expects geometry data (the default),
              while a 'c' suffix expects GCL commands.  A 'p' implies the connection should use a
              named  pipe (the default on everything except on the NeXT), while 's' implies using
              a UNIX-domain socket (the default on the  NeXT).  Since  version  1.9  of  Geomview
              internet  domain  sockets  are also supported; use 'sin' to make Geomview listen on
              the IPv4 port given by TCPPORT, or use 'sin6' to make Geomview listen  on  an  IPv6
              port  (also as specified by TCPPORT). 'sun' is a synonym for 's', i.e. use the Unix
              domain socket with the name PIPENAME. If PIPENAME starts with a slash  ('/'),  then
              it  is  assumed  to  be an absolute pathname, otherwise the named pipe or socket is
              created below ${TMPDIR}/geomview/.

              So  -Mcs  fred  selects  reading  commands  from  the  UNIX-domain   socket   named
              /tmp/geomview/fred,  -Mcsin  40000  selects  reading  commands  from  the IPv4 port

              Disable the use of OpenGL for (possibly) hardware accelerated  rendering,  even  if
              the  Geomview  binary  has  support  for OpenGL compiled in. This also disables the
              support for transparency and and textures

              Start up displaying no panels, only graphics windows.  Panels may be invoked  later
              as usual with the "Px" keyboard shortcuts or "(ui-panel ...)"  command.

              Read   no  initialization  files.   By  default,  geomview  reads  the  system-wide
              ".geomview" file, followed by those in $HOME/.geomview and ./.geomview.

       -e modulename
              Start an external module; modulename  is  the  name  associated  with  the  module,
              appearing  in  the  main  panel's  Applications browser, as defined by the emodule-
              define command (see geomview(5) for details).

       -start modulename arguments ... --
              Like -e but allows you to pass arguments to the external module.  "--" signals  the
              end  of the argument list; the "--" may be omitted if it would be the last argument
              on the geomview command line.

       -run shell-command arguments ...
              Like -start but takes the pathname of executable of the external module instead  of
              the module's name.


       The  format  of  the files read by geomview is described in oogl(5); type "man 5 oogl", or
       see the file man/cat5/oogl.5 in the geomview distribution, for details.

       Note to users of MinneView (the precursor to geomview): geomview can read MinneView files,
       but MinneView cannot read all geomview files.


       Immediately  upon  starting up geomview reads and executes the commands in the system-wide
       .geomview file in the "data" subdirectory of the geomview directory.  Then, if there is  a
       file  named .geomview in the current directory, it executes the commands in that file.  If
       no in the user's home directory, and  executes  it  if  found.  The  startup  file  of  an
       individual  user  overrides  the systemwide defaults, since later commands take precedence
       over earlier ones.


       Geomview has the ability to interact via its command language with other programs,  called
       "external  modules".   Many such modules have been written and appear in the "Application"
       browser in the main geomview panel.  To invoke  a  module  you  click  the  mouse  on  the
       module's  entry  in  this browser.  This starts the module and adds an additional entry to
       the browser, beginning with a number in square  brackets  as  in  ``[1]  Crayola'',  which
       represents  the running instance of that module.  You can terminate the module by clicking
       on the numbered entry.  Modules are documented separately from geomview.  See  the  manual
       page for each module for details.


       Geomview  looks  for external modules in a special directory for modules.  In the geomview
       distribution tree this is the "bin/$MACHTYPE" subdirectory.   A  module  consists  of  two
       files:  the  executable  program,  and  a  "module  init  file",  which is a whose name is
       ".geomview-" followed by the module name.  The module init file tells geomview how to  run
       that  program.   Be  sure  to always keep these two files together; geomview needs both of
       them in order to run the module.  To  install  a  new  module,  simply  put  the  module's
       executable  file and its init file in your geomview's module directory.  The next time you
       run geomview, it will know about that module.

       Geomview can actually looks for modules in a list of  directories;  by  default  only  the
       "bin/$MACHTYPE"   directory  is  on  this  list.   See  the  set-emodule-path  command  in
       geomview(5) for details.

       There is a tutorial for how to write external modules in the "src/bin/example" directory.


       An external module init file is the file that tells geomview how to run that module.   Its
       name  must  be ".geomview-" followed by the name of the module, e.g. ".geomview-foo".   It
       should contain geomview commands;  typically  it  will  contain  a  single  emodule-define
       command which enters the module into geomview's application browser:

               (emodule-define "Foo" "foo")

       The  first  string  is  the  name  that  appears in the browser.  The second string is the
       command to invoke the module.  It may contain arguments; in fact it can  be  an  arbitrary
       shell command.


       Many  geomview  operations are available from the keyboard.  Hitting the "?" button on the
       main panel, or typing "?"  with the cursor in any  window,  causes  geomview  to  print  a
       message on standard output listing all the keyboard shortcuts.

       Keyboard commands apply while cursor is in any graphics window and most
       control panels. Most commands allow one of the following selection prefixes
       (if none is provided the command applies to the current object):
          g  world geom    g#  #'th geom  g*  All geoms
          c  current camera     c#  #'th camera     c*  All cameras
       Many allow a numeric prefix:  if none they toggle or reset current value.
        Draw:              Shading:       Other:
         af  Faces         0as Constant    av  eVert normals: always face viewer
         ae  Edges         1as Flat  #aw  Line Width (pixels)
         an  Normals       2as Smooth     #ac  edges Closer than faces(try 5-100)
         ab  Bounding Boxes     3as Smooth, non-lighted  al  Shade lines
         aV  Vectors       aT  allow transparency   at  Texture-mapping
        Color:             aC  allow concave polygons
         Cf Ce Cn Cb CB   face/edge/normal/bbox/backgnd
       Motions:                       Viewing:
         r rotate        [ Leftmouse=X-Y plane,     0vp Orthographic view
         t translate       Middle=Z axis,      1vp Perspective view
         z zoom FOV        Shift=slow motion,        vd Draw other views' cameras
         f fly             in r/t modes.      ]     #vv field of View
         o orbit           [Left=steer, Middle=speed ]   #vn near clip distance
         s scale                     #vf far clip distance
         w/W recenter/all                  v+ add new camera
         h/H halt/halt all                 vx cursor on/off
         @  select center of motion (e.g. g3@)       vb backfacing poly cull on/off
                                     #vl focal length
         L  Look At object                 v~ Software shading on/off
       show Panel:    Pm Pa Pl Po    main/appearance/lighting/obscure
                 Pt Pc PC Pf    tools/cameras/Commands/file-browser
                 Ps P-          saving/read commands from tty
       Lights:  ls le      Show lights / Edit Lights
       Metric:  me mh ms   Euclidean Hyperbolic Spherical
       Model:   mv mp mc   Virtual Projective Conformal
         N normalization < Pf  load geom/command file
          0N none       > Ps  save something to file     ui  motion has inertia
          1N each       TV NTSC mode toggle    uc  constrained (X/Y) motion
          2N all                     uo  motion in Own coord system
         Rightmouse-doubleclick  pick as current target object
         Shift-Rightmouse        pick interest (center) point
         RR send RIB output to <fileprefix>NNN.rib (default fileprefix == "geom")
         RC Emulate lines using cylinders (default)
         RP Emulate lines using polygons
         Ra choose ASCII RIB format (default)
         Rb choose BINARY RIB format
         Rt choose Display token to specify .tiff file (default)
         Rf choose Display token to specify framebuffer
         Rs Simulate background color with Polygon (default)
         Rx No background simulation - fully transparent (alpha) background


       The  "geomview" command is actually a shell script that sets various environment variables
       which tell geomview about your local setup,  and  then  invokes  the  geomview  executable
       program "gvx" (or "gvx.OGL").  Do not run "gvx" by itself; always invoke geomview with the
       "geomview" shell script.


       oogl(5) - OOGL geometric file formats and conventions
       geomview(5) - geomview command language reference


       data/.geomview - default initialization file in geomview command language
       data/geom - sample data files


       The ``geomview'' shell script sets these internally by default; if  you  set  them  before
       invoking geomview, the values you set will be used instead of the built-in defaults.
       GEOMVIEW_GVX - geomview executable
       GEOMVIEW_DATA_DIR - default directory for data files
       GEOMVIEW_LOAD_PATH - colon-separated search path for data files
       GEOMVIEW_EMODULE_DIR - default directory for external emodules
       GEOMVIEW_EMODULE_PATH - colon-separated search path for external modules
       GEOMVIEW_SYSTEM_INITFILE - system-wide GCL initialization script
       GEOMDATA - top directory of the default data tree, used by some modules
       GEOMVIEW_DOC_DIR - path to the user manual
       WEBBROWSER  -  executable  for  viewing  the  HTML version of the manual when invoking the
            `Manual (HTML)' menu item
       PDFVIEWER - executable for viewing the PDF version of the manual when invoking the `Manual
            (PDF)' menu item


          Stuart Levy              Tamara Munzner         Mark Phillips
                    Celeste Fowler              Nathaniel Thurston
                     Daniel Krech                   Scott Wisdom
                     Daeron Meyer                  Timothy Rowley

              The National Science and Technology Research Center for
               Computation and Visualization of Geometric Structures
                               (The Geometry Center)
                              University of Minnesota



       Sometimes core dumps on bad input files.

       Zoom and scale have no inertia.

       Virtual spherical mode doesn't work on VGXes.