Name: AXIS3D  23
The routine AXIS3D defines the lengths of the 3-D box.  For  the
lengths, any positive  values can be specified; DISLIN uses only
the ratio of the values to calculate the axis lengths.
The call is:  CALL AXIS3D (X3AXIS, Y3AXIS, Z3AXIS) level 1, 2, 3
         or:  void axis3d (float x3axis, float y3axis, 
                                                  float z3axis);
X3AXIS        is the length of the  X-axis in absolute 3-D coor-
              dinates (> 0).
Y3AXIS        is the length of the  Y-axis in absolute 3-D coor-
              dinates (> 0).
Z3AXIS        is the length of the  Z-axis in absolute 3-D coor-
              dinates (> 0).
                                           Default: (2., 2., 2.)
Note:         The lower left corner of the 3-D box is the  point
              (-X3AXIS/2, -Y3AXIS/2, -Z3AXIS/2); the upper right
              corner is the point (X3AXIS/2, Y3AXIS/2, Z3AXIS/2)
              The centre point is (0., 0., 0.).
Name: VIEW3D  23
The routine VIEW3D defines the viewpoint.
The call is:    CALL VIEW3D (XVU, YVU, ZVU, CVU)   level 1, 2, 3
         or:    void view3d (float xvu, float yvu, float zvu,
                                                     char *cvu);
XVU, YVU, ZVU   define the position  of the viewpoint.  If CVU =
                'ABS', the parameters must contain  absolute 3-D
                coordinates, if CVU = 'USER', they must  contain
                user coordinates and if CVU = 'ANGLE', the view-
                point must be specified by two angles  and a ra-
                dius.  In the  latter case,  XVU  is a  rotation
                angle,  YVU is the  angle  between the line from
                the  viewpoint  to the centre of the 3-D box and
                the horizontal direction and ZVU is the distance
                of the viewpoint from the centre of the 3-D box.
                XVU and YVU must be specified in degrees and ZVU
                in absolute 3-D coordinates.
CVU             is a  character string  defining  the meaning of
                XVU, YVU and ZVU.
                Def.:  (2*X3AXIS, -2.5*Y3AXIS, 2*Z3AXIS, 'ABS').
Note:           The viewpoint  must be  placed  outside the  3-D
                box. If the point lies inside, DISLIN will print
                a warning and use the default viewpoint.
Name: VFOC3D  23
The routine  VFOC3D  defines  the focus point.  It specifies the
location in the 3-D box that the camera points to.
The call is:  CALL VFOC3D (XFC, YFC, ZFC, CVU)     level 1, 2, 3
         or:  void vfoc3d (float xfc, float yfc, float zfc,
                                                      char *cvu)
XFC, YFC, ZFC define the position  of  the focus point.  If  CVU
              = 'ABS', the parameters must contain  absolute 3-D
              coordinates,  if CVU = 'USER',  they  must contain
              user coordinates.
CVU           is a character string defining the meaning of XFC,
              YFC and ZFC.
                                   Default: (0., 0., 0., 'ABS').
Name: VUP3D   23
The rotation  of the camera  around the  viewing axis is defined
by an angle.
The call is:  CALL VUP3D (ANG)                     level 1, 2, 3
         or:  void vup3d (float ang);
ANG           defines the rotation angle in degrees.  The camera
              is rotated in a clockwise direction.
                                               Default: ANG = 0.

Name: VANG3D  23
VANG3D  defines  the  view angle. It specifies the field of view
of the lens.
The call is:  CALL VANG3D (ANG)                    level 1, 2, 3
         or:  void vang3d (float ang);
ANG           defines the view angle in degrees.
                                              Default: ANG = 28.
Name: GRAF3D  23
The routine  GRAF3D plots a three-dimensional axis system.  This
routine must be called  before any objects can be plotted in the
3-D box.
The call is:  CALL GRAF3D (XA, XE, XOR, XSTEP, YA, YE, YOR, 
                           YSTEP, ZA, ZE, ZOR, ZSTEP)    level 1
         or:  void graf3 (
                    float xa, float xe, float xor, float xstep,
                    float ya, float ye, float yor, float ystep,
                    float za, float ze, float zor, float zstep); 
XA, XE        are the lower and upper limits of the X-axis.
XOR, XSTEP    are the first  X-axis label  and the step  between
              labels.
YA, YE        are the lower and upper limits of the Y-axis.
YOR, YSTEP    are the first  Z-axis label  and the step  between
              labels.
ZA, ZE        are the lower and upper limits of the Z-axis.
ZOR, ZSTEP    are the first  Z-axis label  and the step  between
              labels.
Notes:      - GRAF3D must  be called  from  level 1 and sets the
              level to 3.
            - To avoid overwriting labels, GRAF3D suppresses the
              plotting of certain start labels.  This option can
              be disabled with the statement CALL FLAB3D.
            - The user is referred to the notes on GRAF.
Name: FLAB3D  23
To avoid overwriting labels,  GRAF3D suppresses  the plotting of
certain start labels.  This option can be be disabled with FLAB-
3D.
The call is:   CALL FLAB3D                         level 1, 2, 3
         or:   void flab3d ();
Name: CURV3D  23
The routine CURV3D is similar to  CURVE and connects data points
with lines or marks them with symbols.
The call is:  CALL CURV3D (XRAY, YRAY, ZRAY, N)          level 3
         or:  void curv3d (float *xray, float *yray,
                                            float *zray, int n);
XRAY          is an array  containing the  X-coordinates of data
              points.
YRAY          is an array  containing the  Y-coordinates of data
              points.
ZRAY          is an array  containing the  Z-coordinates of data
              points.
N             is the number of data points.
Note:         Data points  will be  interpolated  linearly.  The
              user is referred to the notes on CURVE.
Name: SURFUN  23
The routine  SURFUN  plots  a surface  of the  three-dimensional
function Z = F(X,Y).
The call is: CALL SURFUN (ZFUN, IXP, XDEL, IYP, YDEL)    level 3
         or: void surfun (float (*zfun)(), int ixp, float xdel, 
                                           int iyp, float ydel);
ZFUN         is the name of a  FUNCTION subroutine  that returns
             the function value for a given X- and Y-coordinate.
             ZFUN must be declared  EXTERNAL in the calling pro-
             gram.
XDEL, YDEL   are the distances  between grid lines in user coor-
             dinates. XDEL and YDEL determine the density of the
             surface plotted by SURFUN.
IXP, IYP     are the number of  points between grid lines inter-
             polated by SURFUN (>= 0). If IXP = 0, surface lines
             in the X-direction will be suppressed;  if IYP = 0,
             surface lines  in the Y-direction  will be suppres-
             sed.
Name: SURMAT  23
The routine  SURMAT  plots  a  surface  of the three-dimensional
function Z = F(X,Y).  The function values  must be  given in the
form of a matrix.
The call is:  CALL SURMAT (ZMAT, IXDIM, IYDIM, IXPTS, IYPTS)
                                                         level 3
         or:  void surmat (float *zmat, int ixdim, int iydim,
                                          int ixpts, int iypts);
ZMAT          is a matrix with the dimension (IXDIM, IYDIM) con-
              taining the function values.
IXDIM, IYDIM  are the dimensions of ZMAT, XRAY and YRAY (>= 2).
IXPTS, IYPTS  are the number of points interpolated between grid
              lines in the X- and  Y-direction. These parameters
              determine the density  of surfaces plotted by SUR-
              MAT.  For positive  values,  the surface  will  be
              interpolated linearly.  For a negative value,  the
              absolute  value will be used as a step for plotted
              surface lines.  If IXPTS = 0, surface lines in the
              Y-direction will be suppressed; if IYPTS = 0, sur-
              face lines in the X-direction will be suppressed.
Notes:      - The routines  SURMAT and SURFCE suppress automati-
              cally  hidden lines.  The suppression  can be dis-
              abled with the statement CALL NOHIDE.
            - SURMAT and SURFCE use a horizon line algorithm for
              suppressing hidden lines.  This algorithm is effi-
              cient but  may fail for  some  complex data struc-
              tures. An alternate method for suppressing  hidden
              lines  can be used with the routine SURSHD if only
              mesh lines  are enabled  with the statement   CALL 
              SURMSH ('ONLY'). 
            - Surfaces can be  protected from  overwriting  with
              CALL SHLSUR  if the hidden-line  algorithm  is not
              disabled.
            - If XA, XE, YA and YE are the axis limits in GRAF3D
              or defined with the routine SURSZE, the connection
              of  grid points and matrix elements can be descri-
              bed by the formula: ZMAT(I,J) = F(X,Y) where

                    X = XA + (I - 1) * (XE - XA) / (IXDIM - 1),
                                                 I = 1,..,IXDIM 
                    Y = YA + (J - 1) * (YE - YA) / (IYDIM - 1),
                                                 J = 1,..,IYDIM.
Name: SHLSUR  23
Surfaces  can be  protected  from  overwriting  with the routine
SHLSUR if the hidden-line algorithm is not disabled.
The call is:  CALL SHLSUR                          level 1, 2, 3
         or:  void shlsur ();
Name: SURFCE  23
The routine  SURFCE  plots  a  surface  of the three-dimensional
function  Z = F(X,Y).  This routine  can be used with non linear
grids.
The call is:  CALL SURFCE (XRAY, IXDIM, YRAY, IYDIM, ZMAT)
                                                         level 3
         or:  void surfce (float *xray, int ixdim, float *yray,
                                        int iydim, float *zmat);
ZMAT          is a matrix with the dimension (IXDIM, IYDIM) con-
              taining the function values.
IXDIM, IYDIM  are the dimensions of ZMAT, XRAY and YRAY (>= 2).
XRAY, YRAY    are arrays  containing the X- and Y-user coordina-
              tes.
Name: SURSHD  23
The routine  SURSHD  plots  a  coloured  surface  of the  three-
dimensional function Z = F(X,Y). 
The call is:  CALL SURSHD (XRAY, IXDIM, YRAY, IYDIM, ZMAT)
                                                         level 3
         or:  void surshd (float *xray, int ixdim, float *yray,
                                        int iydim, float *zmat);
ZMAT          is a matrix with the dimension (IXDIM, IYDIM) con-
              taining the function values.
IXDIM, IYDIM  are the dimensions of ZMAT, XRAY and YRAY (>= 2).
XRAY, YRAY    are arrays  containing the X- and Y-user coordina-
              tes.
Notes:      - Colour values are calculated from the Z-scaling in
              the routine  GRAF3D or from the  parameters of the
              routine ZSCALE.
           -  A flat shading or a smooth shading can be selected
              with  the routine SHDMOD. The default is flat sha-
              ding. If smooth shading is selected, a Z-buffer is
              used for hidden-surface elimination. In this case,
              a raster format is needed for the graphics  output
              format      (for example METAFL ('XWIN') or METAFL
              ('TIFF')).
            - Additional  grid lines  can be  enabled  with  the
              routine  SURMSH.  SURSHD  can generate  only  mesh 
              lines if the keyword  'ONLY' is used in SURMSH.
            - Lighting can be enabled for  SURSHD  with the rou-
              tine LIGHT.
Name: SURFCP  23
A three-dimensional  parametric  function  is a function  of the
form   (x(t,u), y(t,u), z(t,u))  where   tmin <= t <= tmax   and
umin <= u <= umax.  The routine  SURFCP  plots a  shaded surface
from a parametric function.  The colours of the surface are cal-
culated  from the  Z-scaling  in the routine  GRAF3D or from the
parameters of the routine ZSCALE.
The call is:  CALL SURFCP (ZFUN, TMIN, TMAX, TSTEP, 
                                     UMIN, UMAX, USTEP)  level 3
         or:  void surfcp (float (*zfun)(), 
                           float tmin, float tmax, float tstep,
                           float umin, float umax, float ustep);
ZFUN          is the  name of a  FUNCTION  subroutine  with  the
              formal parameters X, Y and IOPT. If IOPT = 1, ZFUN
              should  return  the X-coordinate of the parametric
              function, if IOPT = 2, ZFUN should  return  the Y-
              coordinate and if IOPT = 3, ZFUN should return the
              Z-coordinate.
TMIN, TMAX,   define  the  range  and  step  size  of  the first
       TSTEP  parameter. 
UMIN, UMAX,   define the  range  and  step  size  of  the second
       USTEP  parameter.
Notes:     -  A flat shading or a smooth shading can be selected
              with  the routine SHDMOD. The default is flat sha-
              ding. If smooth shading is selected, a Z-buffer is
              used for hidden-surface elimination. In this case,
              a raster format is needed for the graphics  output
              format      (for example METAFL ('XWIN') or METAFL
              ('TIFF')).
            - Additional grid lines can be enabled with the rou-
              tine SURMSH.
Name: SURTRI  23
The routine  SURTRI  plots  a shaded surface  from  triangulated
data that  can be calculated by the routine TRIANG from a set of 
irregularily distributed data points.
The call is:  CALL SURTRI (XRAY, YRAY, ZRAY, N, I1RAY, I2RAY,
                           I3RAY, NTRI)                  level 3
         or:  void surtri (float *zray, float *yray, 
                           float *zray, int n, int *i1ray, 
                           int *i2ray, int *i3ray, int ntri);
XRAY          is an array  containing the  X-coordinates of data
              points.
YRAY          is an array  containing the  Y-coordinates of data
              points.
ZRAY          is an array  containing the  Z-coordinates of data
              points.
N             is the number of data points.
I1RAY, I2RAY, is  the  Delaunay  triangulation  of  the   points
    I3RAY     (XRAY, YRAY) calculated  by the routine TRIANG.
NTRI          is the number of  triangles in  I1RAY,  I2RAY  and 
              I3RAY.
Name: SURISO  23
The routine SURISO plots isosurfaces of the form f(x,y,z) = con-
stant.
The call is:  CALL SURISO (XRAY, NX, YRAY, NY, ZRAY, NZ, 
                           WMAT, WLEV)                   level 3
         or:  void suriso (float *xray, int nx, float *yray,
                           int ny, float *zray, int nz, 
                           float *wmat, float wlev); 
XRAY, YRAY,   are arrays containing the  X-, Y- and Z-user coor- 
       ZRAY   dinates.
WMAT          is a matrix with the dimension  (NX, NY, NZ)  con-
              taining the function values.
NX, NY, NZ    are the dimensions of  WMAT, XRAY, YRAY  and  ZRAY 
              (>= 2).
Notes:      - The  algorithm  used  in  SURISO  is based  on the
              Marching Cubes method. 
              Reference: Lorensen, W.E. and Cline, H.E., 
              Marching Cubes: a high resolution  3D  surface re-
              construction algorithm,
              Computer Graphics, Vol. 21, No. 4, pp 163-169 
              (Proc. of SIGGRAPH), 1987.
            - SURISO  can plot  flat or smooth surface triangles 
              defined by the routine SHDMOD.  For smooth triang-
              les, a Z-buffer is used for hidden-surface  elimi-
              nation.  In that case,  a raster format  is needed 
              for the graphics output format. 
            - Lighting can be enabled for  SURSIO  with the rou-
              tine LIGHT.
            - Additional grid  lines  can be  enabled  with  the
              routine SURMSH.
Name: ZSCALE  23
The routine  ZSCALE  defines a Z-scaling  that will be used from
the routine SURSHD to calculate colour values.
The call is:  CALL ZSCALE (ZMIN, ZMAX)             level 1, 2, 3
         or:  void zscale (float zmin, float zmax);
ZMIN, ZMAX    are minimum  and maximum  of the Z-scaling in user
              coordinates.  For a logarithmic scaling, the para-
              meters must be exponents of base 10.
Name: NOHIDE  23
The routine NOHIDE disables the hidden-line algorithm.
The call is   CALL NOHIDE                          level 1, 2, 3
         or:  void nohide ();
Name: SUROPT  23
Surface lines plotted  with the routine SURFCE can be suppressed
for the X- and Y-directions. 
The call is:  CALL SUROPT (COPT)                   level 1, 2, 3
         or:  void suropt (char *copt);
COPT          is a character string  that  can  have the  values
              'XISO', 'YISO' and 'BOTH'.  If COPT = 'XISO', sur-
              face lines in the  Y-direction will be  suppressed
              by SURFCE.  If COPT = 'YISO', surface lines in the
              X-direction will be suppressed.
                                         Default: COPT = 'BOTH'.
Name: SURVIS  23
This routine defines the visible part of an surface.
The call is:  CALL SURVIS (CVIS)                   level 1, 2, 3
         or:  void survis (char *cvis);
CVIS          is a character  string  that  can have  the values
              'TOP', 'BOTTOM', and 'BOTH'. 
                                         Default: CVIS = 'BOTH'.
Name: SURCLR  23
The routine SURCLR defines colours for  the upper and lower side
of a surface.
The call is:  CALL SURCLR (ICTOP, ICBOT)           level 1, 2, 3
         or:  void surclr (int ictop, int icbot);
ICTOP, ICBOT  are colour numbers in the range -1 to 255. For the
              value -1, the current colour will be used.
                                              Default: (-1, -1).
Name: SURSZE  23
The limits of  the base grid used  for surfaces and contours can
be altered with the routine SURSZE.  By default, the scaling va-
lues in GRAF are used.
The call is:  CALL SURSZE (XMIN, XMAX, YMIN, YMAX) level 1, 2, 3
         or:  void sursze (float xmin, float xmax, float ymin, 
                                                    float ymax);
XMIN, XMAX    are user coordinates for the X-direction.
YMIN, YMAX    are user coordinates for the Y-direction.
Note:         For a logarithmic scaling,  the parameters must be
              exponents of base 10.
Name: SURMSH  23
The routine  SURMSH  can enable  additional  grid lines  for the
routines SURSHD and SURFCP.
The call is:  CALL SURMSH (COPT)                   level 1, 2, 3
         or:  void surmsh (char *copt);
COPT          is a character string  that  can  have  the values 
              'ON',  'OFF'  and 'ONLY'.  For  COPT = 'ONLY', the
              shading  of the surfaces  are suppressed  and only
              mesh lines will be displayed.
                                          Default: COPT = 'OFF'.
Name: MSHCLR  23
The routine MSHCLR sets the colour for grid lines.
The call is:  CALL MSHCLR (ICLR)                   level 1, 2, 3
ICLR          is a colour value in the range -1 to 255 where the 
              value -1 means  that the current colour is used.
                                             Default: ICLR = -1.
Name: LIGHT   23
The routine  LIGHT enables lighting for shading routines such as
SURSHD, SURFCP and SURISO.
The call is:  CALL LIGHT (CMODE)                   level 1, 2, 3
         or:  void light (char *cmode);
CMODE         is a  character  string  that can have  the values
              'ON' and 'OFF'.            Default: CMODE = 'OFF'.
Name: LITMOD  23 
Up to  8  light sources  can be defined in  DISLIN.  The routine 
LITMOD enables or disables single light sources.
The call is:  CALL LITMOD (ID, CMODE)              level 1, 2, 3
         or:  void litmod (int id, char *cmode);
ID            is the ID of the light source in the range 1 to 8. 
CMODE         is a  character string  that can have  the  values 
              'ON'  and  'OFF'.  The default  values are CMODE = 
              'ON' for light source 1 and  CMODE = 'OFF' for the
              other light sources.
Name: LITPOS  23
The routine LITPOS defines the position of light sources.
The call is:  CALL LITPOS (ID, XP, YP, ZP, COPT)   level 1, 2, 3
         or:  void litpos (int id, float xp, float yp, float zp,
                                                    char *copt);
ID            is the ID of the light source in the range 1 to 8. 
XP, YP, ZP    define the position of the light source.
              If COPT = 'ABS', the parameters must contain abso-
              lute  3-D coordinates, if COPT = 'USER', they must
              contain  user  coordinates and if  COPT = 'ANGLE',
              the position must be specified by two angles and a
              radius (see VIEW3D). 
COPT          is a character string defining  the meaning of XP,
              YP and ZP.
              Default: (2*X3AXIS, -2.5*Y3AXIS, 2*Z3AXIS, 'ABS').
Name: LITOPT  23
The routine  LITOPT modifies the ambient,  diffuse  and specular
intensities  and the constant, linear and quadratic attentuation
factors of light sources.
The call is:  CALL LITOPT (ID, XVAL, COPT)         level 1, 2, 3
         or:  void litopt (int id, float xval, char *copt);  
ID            is the ID of the light source in the range 1 to 8. 
XVAL          is  a  floatingpoint  number  containing  the  new
              lighting parameter. 
COPT          is a  character  string  that can have  the values
              'AMBIENT',   'DIFFUSE',   'SPECULAR',  'CONSTANT', 
              'LINEAR' and 'QUADRATIC'.
                     Defaults: (0., 'AMBIENT'), (1., 'DIFFUSE'), 
                             (1., 'SPECULAR'), (1., 'CONSTANT'), 
                              (0., 'LINEAR'), (0., 'QUADRATIC').
Name: MATOPT  23
The routine MATOPT modifies material parameters such as ambient,
diffuse and  specular colour.  The specular exponent can also be
modified. 
The call is:  CALL MATOPT (XVAL, COPT)             level 1, 2, 3
         or:  void matopt (float xval, char *copt);
XVAL          is  a  floatingpoint  number  containing  the  new
              material parameter. 
COPT          is  a  character string  that can have  the values 
              'AMBIENT',  'DIFFUSE',  'SPECULAR' and 'EXPONENT'.
                   Defaults: (0.2, 'AMBIENT'), (0.8, 'DIFFUSE'), 
                             (0., 'SPECULAR'), (0., 'EXPONENT').
Name: GETLIT  23
The routine GETLIT calculates colour values for given points and
their normals. 
The call is:  CALL GETLIT (XP, YP, ZP, XN, YN, ZN, ICLR) 
                                                   level 1, 2, 3
         or:  int  getlit (float xp, float yp, float zp,
                           float xn, float yn, float zn);
XP, YP, ZP    are the  X-,  Y-  and  Z-user  coordinates  of the 
              point.
XN, YN, ZN    are the  X-,  Y-  and  Z-coordinates  of the point
              normal.
ICLR          is the returned colour value.  
Name: CLIP3D  23
The routine CLIP3D defines 3-D clipping in the  world coordinate
system or in the eye coordinate system.
The call is:  CALL CLIP3D (COPT)                   level 1, 2, 3
         or:  void clip3d (char *copt);
COPT          is a character string  that  can  have  the values
              'WORLD' and 'EYE'.
                                        Default: COPT = 'WORLD'.
Name: VCLP3D  23
If 3-D clipping is done in the eye coordinate system,  front and
back clipping planes can be defined with the routine VCLP3D.
The call is:   CALL VCLP3D (XFRONT, XBACK)         level 1, 2, 3
         or:   void vlcp3d (float xfront, float xback);
XFRONT, XBACK  are  the distances from the viewpoint in absolute
               3-D coordinates. A negative value means infinity.
                                             Default: (1., -1.).
Name: GETMAT  23
The  routine  GETMAT calculates a  function matrix  for randomly
data points.                                                     
The call is:  CALL GETMAT (XRAY, YRAY, ZRAY, N, ZMAT, NX, NY, 
                           ZVAL, IMAT, WMAT)          level 2, 3
         or:  void getmat (float *xray, float *yray, 
                           float *zray, int n, float *zmat[],
                           int nx, int ny, int *imat[], 
                                                 float *wmat[]);  
XRAY, YRAY,   are  arrays  containing  the  randomly distributed
    ZRAY      data points.
N             is the number of points.
ZMAT          is the  function matrix  of the dimension (NX, NY)
              calculated by GETMAT.  The matrix elements corres-
              pond to a linear grid in the XY-plane whose limits
              are determined by the scaling values  in GRAF3D or
              SURSZE.
NX, NY        are the dimensions of ZMAT, IMAT and WMAT.
ZVAL          will be used  as a value  for matrix elements when
              no data points can be found in an area around  the
              corresponding grid points.  In general,  the start
              scaling of the Z-axis will be used for ZVAL.
IMAT          is a  working  matrix  of the dimension  (NX, NY).
              After  a call to  GETMAT,  IMAT(I, J) contains the
              number  of  random  data  points  found in an area
              around the grid points. The value -1  means that a
              random data value lies at a grid point.
WMAT          is a working matrix of the dimension (NX, NY).
Name: MDFMAT  23
The routine MDFMAT modifies the algorithm in GETMAT.
The call is:  CALL MDFMAT (IX, IY, W)              level 1, 2, 3
         or:  void mdfmat (int ix, int iy, float w);
IX, IY        are  the  number  of grid lines  in the X-  and Y-
              direction which determine the size  of the  region
              around data points.
W             is a weighting number.
                                           Default: (2, 2, 2.0).
Name: BOX3D   23
The routine BOX3D plots a border around the 3-D box.
The call is:  CALL BOX3D                                 level 3
         or:  void box3d (); 
Name: GRID3D  23
The routine GRID3D plots a grid in the 3-D box.
The call is:  CALL GRID3D (IGRID, JGRID, COPT)           level 3
         or:  void grid3d (int igrid, int jgrid, char *copt);
IGRID         is the number of grid lines between labels  in the
              X-direction (or Y-direction for the YZ-plane).
JGRID         is the number of grid lines between labels  in the
              Z-direction (or Y-direction for the XY-plane).
COPT          is a character string which defines where the grid
              will be plotted.
  = 'ALL'     will plot a grid in the XY-, XZ- and YZ-plane.
  = 'BACK'    will plot a grid in the XZ- and YZ-plane.
  = 'BOTTOM'  will plot a grid in the XY-plane.
Name: GRFINI  23
The routine GRFINI defines a plane in the 3-D box onto which all
plot vectors will be projected. The plane in the 3-D box corres-
ponds to a region in the  XY-plane which is determined by AXSPOS
and AXSLEN. GRFINI sets the level to 1.
The call is:  CALL GRFINI (X1, Y1, Z1, X2, Y2, Z2, X3, Y3, Z3)
                                                         level 3
         or:  void grfini (float x1, float x2, float x3,
                           float y1, float y2, float y3,
                           float z1, float z2, float z3);  
X1, Y1, Z1    are the absolute 3-D coordinates of the lower left
              corner of the 3-D plane.
X2, Y2, Z2    are  the  absolute  3-D  coordinates  of the lower
              right corner of the 3-D plane.
X3, Y3, Z3    are  the  absolute  3-D  coordinates  of the upper
              right corner of the 3-D plane.
Note:         If  (NXA,NYA)  is the lower  left corner,  NXL the
              width  and NYL the height of the region determined
              by  the  routines  AXSPOS  and  AXSLEN,  the point
              (X1,Y1,Z1)  corresponds to  (NXA,NYA),  (X2,Y2,Z2) 
              to  (NXA+NXL-1,NYA) and (X3,Y3,Z3) to  (NXA+NXL-1,
              NYA-NYL+1), respectively.
Name: GRFFIN  23
The routine GRFFIN terminates a  projection  into 3-D space. The
level will be set back to 3.
The call is:  CALL GRFFIN                          level 1, 2, 3
         or:  void grffin (); 
Name: ZBFINI  23
The routine ZBFINI creates a Z-buffer.  The graphics output for-
mat must be set to a raster format  (for example METAFL ('XWIN')
or METAFL ('TIFF')).
The call is:  CALL ZBFINI (IRET)                     level 1,2,3
         or:  int  zbfini ();
IRET          is the returned status (0: no errors).
Name: ZBFFIN  23
The routine  ZBFFIN terminates writing  to a Z-buffer  and frees
the allocated space.
The call is:  CALL ZBFFIN                            level 1,2,3
         or:  void zbffin ();
Name: ZBFTRI  23
The routine  ZBFTRI plots a smooth triangle where hidden-surface
elimination is done with the Z-buffer.
The call is:  CALL ZBFTRI (XRAY, YRAY, ZRAY, IRAY)       level 3
         or:  void zbftri (float *xray, float *yray, 
                                        float *zray, int *iray);
XRAY, YRAY,   are the  X-, Y-,  and  Z-coordinates  of the three
       ZRAY   corners of the triangle in user coordinates.
IRAY          is an integer array  containing  the  three colour
              values of the triangle corners.          
Name: ZBFLIN  23
The routine ZBFLIN  plots a line in the current colour where the
Z-buffer  is used  for hiddenline elimination.  This routine  is 
used by SURSHD and SURFCP for drawing surface grids.
The call is:  CALL ZBFLIN (X1, Y1, Z1, X2, Y2, Z2)       level 3
         or:  void zbflin (float x1, float y1, float z1,
                           float x2, float y2, float z2);   
X1, Y1, Z1    are the user coordinates of the start point.
X2, Y2, Z2    are the user coordinates of the end point.
Name: STRT3D  23
The routine STRT3D moves the pen to a three-dimensional point.
The call is:  CALL STRT3D (X, Y, Z)                      level 3
         or:  void strt3d (float x, float y, float z);
X, Y, Z       are the absolute 3-D coordinates of the point.
Name: CONN3D  23
The routine CONN3D plots a line from the current pen position to
a three-dimensional point.  The line will be cut off at the sides
of the 3-D box. Different line styles can be used.
The call is:  CALL CONN3D (X, Y, Z)                      level 3
         or:  void conn3d (float x, float y, float z);
X, Y, Z       are the absolute 3-D coordinates of the point.
Name: VECTR3  23
The routine VECTR3 plots a vector in the 3-D box.
The call is:  CALL VECTR3 (X1, Y1 ,Z1, X2, Y2, Z2, IVEC) level 3
         or:  void vectr3 (float x1, float y1, float z1,
                        float x2, float y2, float z2, int ivec);
X1, Y1, Z1    are  the  absolute 3-D coordinates  of  the  start
              point.
X2, Y2, Z2    are the absolute 3-D coordinates of the end point.
IVEC          defines the arrow head (see VECTOR).
Name: SPHE3D  23
The routine SPHE3D plots a sphere.
The call is:  CALL SPHE3D (XM, YM ,ZM, R, N, M)          level 3
         or:  void sphe3d (float xm, float ym, float zm, 
                           float r, int n, int m);
XM, YM, ZM    are the user coordinates of the center point.
R             is  the radius of the sphere in user coordinates.
N, M          defines the horizontal and vertical resolution  of
              the sphere.
Notes:      - Lighting can  be enabled for  SPHE3D  with the
              routine LIGHT.
            - Additional grid lines can be enabled  with the
              routine SURMSH.
Name: POS3PT  23
The routine POS3PT converts three-dimensional  user  coordinates
to absolute 3-D coordinates.
The call is:  CALL POS3PT (X, Y, Z, XP, YP, ZP)          level 3
         or:  void pos3pt (float  x , float  y , float  z ,
                           float *xp, float *yp, float *zp);
X, Y, Z       are the user coordinates.
XP, YP, ZP    are  the  absolute  3-D  coordinates calculated by
POS3PT.
Name: X3DPOS  23
The function  X3DPOS  calculates from user coordinates  absolute
3-D X-coordinates.
The call is:  XP  =  X3DPOS (X, Y, Z)                    level 3
         or:  float  x3dpos (float x, float y, float z);
XP            is the absolute X-coordinate calculated by X3DPOS.
X, Y, Z       are the user coordinates.
Name: Y3DPOS  23
The function  Y3DPOS  calculates from user coordinates  absolute
3-D Y-coordinates.
The call is:  YP  =  Y3DPOS (X, Y, Z)                    level 3
         or:  float  y3dpos (float x, float y, float z);
YP            is the absolute Y-coordinate calculated by Y3DPOS.
X, Y, Z       are the user coordinates.
Name: Z3DPOS  23
The function  Z3DPOS  calculates  from user coordinates absolute
3-D Z-coordinates.
The call is:  ZP  =  Z3DPOS (X, Y, Z)                    level 3
         or:  float  z3dpos (float x, float y, float z);
ZP            is the absolute Z-coordinate calculated by Z3DPOS.
X, Y, Z       are the user coordinates.
Name: REL3PT  23
The routine  REL3PT  converts  user coordinates  to plot coordi-
nates.
The call is:  CALL REL3PT (X, Y, Z, XP, YP)              level 3
         or:  void rel3pt (float x, float  y , float z,
                                    float *xp, float *yp);
X, Y, Z       are the user coordinates.
XP, YP        are the plot coordinates calculated by REL3PT.
Name: X3DREL  23
The function  X3DREL  converts  user coordinates to plot coordi-
nates.
The call is:  XP =  X3DREL (X, Y, Z)                     level 3
         or:  float x3drel (float x, float  y , float z);
XP            is the plot coordinate calculated by X3DREL.
X, Y, Z       are the user coordinates.
Name: Y3DREL  23
The function  Y3DREL  converts user coordinates  to plot coordi-
nates.
The call is:  YP  = Y3DREL (X, Y, Z)                     level 3
         or:  float y3drel (float x, float  y , float z);
YP            is the plot coordinate calculated by Y3DREL.
X, Y, Z       are the user coordinates.
Name: ABS3PT  23
The routine  ABS3PT  converts  absolute 3-D coordinates  to plot
coordinates.
The call is:  CALL ABS3PT (X, Y, Z, XP, YP)              level 3
         or:  void abs3pt (float x, float  y , float z,
                                    float *xp, float *yp);
X, Y, Z       are the absolute 3-D coordinates.
XP, YP        are the plot coordinates calculated by ABS3PT.
Name: X3DABS  23
The function X3DABS  converts absolute  3-D coordinates  to plot
coordinates.
The call is:  XP  = X3DABS (X, Y, Z)                     level 3
         or:  float x3dabs (float x, float y, float z);
XP            is the plot coordinate calculated by X3DABS.
X, Y, Z       are the absolute 3-D coordinates.
Name: Y3DABS  23
The function Y3DABS  converts absolute  3-D coordinates to  plot
coordinates.
The call is:  YP  = Y3DABS (X, Y, Z)                     level 3
         or:  float y3dabs (float x, float y, float z);
YP            is the plot coordinate calculated by Y3DABS.
X, Y, Z       are the absolute 3-D coordinates.
