The Toolchest

     In this month's toolchest we discuss some tools for visualizing
3 dimensional hyperbolic geometry.  For 
mathematicians using computers to study hyperbolic space, it is often
easiest to use the projective model of hyperbolic space.  In this
model, hyperbolic space is still represented as the inside of the
3 dimensional unit ball, but the metric is such that geodesics
are straight lines (in the Euclidean sense).  Moreover, metric
preserving transformations can be represented as 4x4 (homogeneous)
matrix multiplication.   These two facts allow structures of interest,
such as Dirichlet domains, to be drawn and hyperbolically manipulated
in real time on Silicon Graphics workstations.

    Despite these advantages it is still desirable to be able
to visualize hyperbolic structures in the usual conformal (or poincare) model.
One reaon for this is purely aesthetic- the curved surfaces which
appear in the conformal model can be quite beautiful.  Another reason
is that geometry near the boundary of hyperbolic space take up more
space (in the Euclidean sense) in the conformal than in the
projective model.  This means that more detail can be displayed in
one picture in the conformal model, and also contributes to the
aesthetic quality of conformal tilings of hyperbolic space. 
    
     To help construct and view geometry in the conformal model
of hyperbolic space we have developed several programs.  The programs
are described below, together with the usage message obtained by
running the program with no arguments.   As usual, the software
is available via anonymous ftp from our site poincare.geom.umn.edu.
Login with user name ftp and your site's path as password.
The source code, Makefile, and documentation for these programs are
contained in the compressed tar file hyper.tar.Z.  Remember to switch
to binary mode in ftp.

pnt2poinc

    This program takes a list of points in the projective model
and outputs the corresponding points in the poincare model.

   Usage: pnt2poinc infile outfile.
     where infile is a list of 3d points.
     if infile = '-' then stdin is used.
     if outfile = '-' then stdout is used.

(There is also a corresponding program poinc2proj, which takes a list
of points in the poincare model and outputs a list of points in the
projective model.)


arc2poinc

     This program takes a list of edges in the projective model
and outputs the corresponding circular arcs in the poincare model.
Each edge in the input is represented as a pair of (three dimensional) points,
and is represented in the output file by a list of points linearly 
approximating the circular arc.  The fineness of the approximation
is controlled by a command line option -size, and the output point
list is preceded by an integer indicating the number of points
to follow.  (Arguably, a better way to do this would be to have arc2poinc
output the arc as three points, representing the center,  beginning
and ending points of the arc, and supply a utility program to
convert a list of circular arcs to approximating polylists.  
If desired, a user could easily link the two together via unix pipes.) 

Usage arc_proj2poinc <options> infile outfile.
  where infile is a list of 3d arcs.
  options:  -size <size>  where size is 
      maximal angular size of polygonalization
      (in radians.  default = 0.05)
  if infile = '-' then stdin is used.
  if outfile = '-' then stdout is used.

tri2poinc

     This program takes a list of triangles in the projective model
and outputs the corresponding sections of spheres in the poincare model.
Each triangle in the input list is represented as a triplet of
(three dimensional) points, and the output is represented by a 
list of quadrilaterals approximating the spherical patches.  Once again,
the fineness of the approximation is controlled by the command line
option -size.  For convenience, the output file is printed in the
MinneView NQUAD format.  (Once again, its arguable whether or not its
such a good idea to so completely flatten the output file in one step.)

 Usage: tri2poinc [-s size] infile outfile 
        takes a list of triangles and produces a NQUAD file 
          (quads with normals). 
        if infile = '-' then stdin is used. 
        if outfile = '-' then stdout is used. 
        -s specifies size of arc (default is .1) 


quad2tri

     This is a utility program for converting MinneView quad
files to a list of triangles (suitable for input to tri2poinc).
The program outputs only non-degenerate triangles, so that an
input quadrilateral with two coincident vertices will be output
as a single triangle.

Usage: quad2tri [-s float] input output 
       converts a QUAD file into a list of triangles.
       if infile = '-' then stdin is used. 
       if outfile = '-' then stdout is used. 
       -s specifies a scaling factor (default is 1)  


tri2edge

     This is a utility program for converting a list of triangles
into a list of edges, suitable for input to arc2poinc.  This is
used in the examples below to create the conformal hyperbolic
"frames".

Usage: tri2edge input output 
       converts a list of triangles to a list of edges. 
       if infile = '-' then stdin is used. 
       if outfile = '-' then stdout is used. 

