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: PROJ3D  23
The routine  PROJ3D defines perspective or orthographic project-
ion.
The call is:    CALL PROJ3D (COPT)                       level 1
         or:    void proj3d (const char *copt);
COPT            is a  character string  that can have the values
                'PERSPECTIVE' and 'ORTHO'.
                                  Default: COPT = 'PERSPECTIVE'.
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,
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,
                                               const 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 for a perspective view. It speci-
fies 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: VSCL3D  23
For an orthographic view the size  of the projected 3-D box  can
be scaled by a factor defined with VSCL3D.
The call is:  CALL VSCL3D (XFAC)                   level 1, 2, 3
         or:  void vxscl3d (float xfac);
XFAC          defines the scaling factor.
                                             Default: XFAC = 1.0
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 graf3d (
                    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.
           -  By default,  the labels and axis titles on the 3-D
              box are also plotted  with a perspective projecti-
              on.  This default mode does not allow the plotting
              of hardware  fonts  and switches  automatically to
              the DISLIN vector font  COMPLX  if a hardware font
              is enabled.  Other modes for plotting  labels  and
              axis titles that allow using of hardware fonts can
              be defined with the routine LABL3D. 
           -  In default mode, GRAF3D suppresses the plotting of
              certain  start labels to avoid overplotting of la-
              bels.  This option can be disabled with the state-
              ment 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 (const float *xray, const float *yray,
                                      const 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.
Notes:      - Data points  will be  interpolated  linearly.  The
              user is referred to the notes on CURVE.
            - CURV3D  can  plot  2-D or 3-D symbols. By default,
              CURV3D plots 2-D symbols.  3-D symbols are plotted
              after  CALL SHDMOD  ('3D', 'SYMBOL')  or if the Z-
              buffer is enabled before.  
            - CURV3D  can  plot true 3-D  curves  (tube segments
              instead of line segments), if the option CALL SHD-
              MOD ('3D', 'CURVE') is enabled before.  
              The thickness of 3-D curves and the resolution  of
              the used mesh  can be  modified  with the routines
              THKC3D and MSHCRV.
Name: CRVT3D  23
CRVT3D is a similar routine to  CURV3D, but can show more attri-
butes.
The call is:  CALL CRVT3D (XRAY, YRAY, ZRAY, RRAY, ICRAY, N)
                                                         level 3
         or:  void crvt3d (const float *xray, const float *yray,
                           const float *zray, const float *rray, 
                           const int *icray, 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.
RRAY          is an array describing  the thickness of the curve
              at each data point. The elements of RRAY must con-
              tain absolute 3-D coordinates.
ICRAY         is an integer array with colour values that define
              the colour of each curve segment. 
N             is the dimension of the arrays above.
Name: CURV4D  23
The routine CURV4D plots coloured 3-D symbols.
The call is:  CALL CURV4D (XRAY, YRAY, ZRAY, WRAY, N)    level 3
         or:  void curv3d (const float *xray, const float *yray,
                           const float *zray, const float *wray, 
                           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.
WRAY          is an  array containing sone intensities. The min-
              imum and maximum of WRAY  are used for the  colour
              scaling.
N             is the number of data points.
Notes:      - The statement  CALL ZSCALE (ZMIN, ZMAX) defines an
              alternate  range for calculating colours.
            - The used  3-D symbol can be selected with the rou-
              tine MARKER. The symbol numbers corresponds to the
              numbers in SYMB3D. 
Name: FIELD3D 23
The routine FIELD3D plots a vector field where the start and end
points  of the vectors  are already calculated.  The vectors are
displayed as arrows.
The call is:  CALL FIELD3D (X1RAY, Y1RAY, Z1RAY, X2RAY,
                            Y2RAY, Z2RAY, N, IVEC)       level 3
         or:  void field3d (const float *x1ray, 
                         const float *y1ray, const float *z1ray, 
                         const float *x2ray, const float *y2ray,
                         const float *z2ray, int n, int ivec); 
X1RAY, Y1RAY, are arrays that contain the X-,  Y- and  Z-coordi-
   Z1RAY      nates of the start points. 
X2RAY, Y2RAY, are arrays that contain the X-,  Y- and  Z-coordi-
   Z2RAY      nates of the end points. 
N             is the number of vectors.
IVEC          is an integer  that specifies  the form of the ar-
              rows (see VECTR3).
Name: VECF3D  23
The routine  VECF3D  plots a vector field  of given vectors  and
positions. The vectors are displayed as arrows.
The call is:  CALL VECF3D (XVRAY, YVRAY, ZVRAY, 
                           XPRAY, YPRAY, ZPRAY, N, IVEC) level 3
         or:  void vecf3d (const float *xvray, 
                         const float *yvray, const float *zvray, 
                         const float *xpray, const float *ypray,
                         const float *zpray, int n, int ivec); 
XVRAY, YVRAY, are arrays that contain  the  X-, Y- and Z-coordi-
    ZVRAY     nates of the vectors. 
XPRAY, YPRAY, are arrays that contain  the  X-, Y- and Z-coordi-
    ZPRAY     nates  of the start points. 
N             is the number of vectors.
IVEC          is an integer that  specifies  the form of the ar-
              rows (see VECTR3).
Notes:      - The length  of the arrows is automatically  scaled
              by  DISLIN in the routine  VECF3D.  This behaviour
              can be changed with the routine  VECOPT,  that may
              also modify the appearance of arrows.
            - The vectors  can be scaled with different  colours
              if the routine  VECCLR  is called  before with the
              parameter -2. Colour values are scaled between the
              minimum  and  maximum  of  the vector lengths,  or
              scaled between  the values specified with the rou-
              tine ZSCALE. 
Name: VECMAT3D 23
The routine VECMAT3D plots a vector field on a regular grid.
The call is:  CALL VECMAT3D (XV, YV, ZV, NX, NY, NZ, XP, YP, ZP,
                                     IVEC)            level 2, 3
         or:  void vecmat3d (const float *xv, const float *yv, 
                        const float *zv, int nx, int ny, int nz, 
                        const float *xp, const float *yp, 
                        const float *zp, int ivec);
XV, YV, ZV    are arrays of the dimension (NX, NY, NZ) that con-
              tain the X-, Y- and Z-coordinates  of the vectors. 
NX, NY, NZ    define the dimension of XV, YV and ZV.
XP, YP, ZP    are arrays  of the dimensions  NX,  NY and NZ that
              define the grid in space.
IVEC          is an integer  that specifies  the form of the ar-
              rows (see VECTR3).
Note:         See the notes for VECF3D.
Name: STREAM3D 23
The routine STREAM3D  plots streamlines  of a  vector field on a 
regular grid.
The call is:  CALL STREAM3D (XV, YV, ZV, NX, NY, NZ, XP, YP, ZP,
                             XS, YS, ZS, N)           level 2, 3
         or:  void stream3d (const float *xv, const float *yv, 
                       const float *zv, int nx, int ny, int nz, 
                       const float *xp, const float *yp, 
                       const float *zp, const float *xs, 
                       const float *ys, const float *zs, int n);
XV, YV, ZV    are arrays of the dimension (NX, NY, NZ) that con-
              tain  the X-, Y- and Z-coordinates of the vectors. 
NX, NY, NZ    define the dimension of XV, YV and ZV.
XP, YP, ZP    are arrays  of the dimensions  NX,  NY and NZ that
              define the grid in space.
XS, YS, ZS    are arrays of the dimension N that  contain start-
              ing  points  of the streamlines.  If  no  starting
              points  are given,  evenly-spaced  streamlines are
              automatically plotted by DISLIN. 
N             is the number of statrting points (N >= 0).
Note:         See the notes for STREAM.
Name: STMPTS3D 23
The routine STMPTS3D returns a calculated streamline of a vector
field on a regular grid.
The call is:  CALL STMPTS3D (XV, YV, ZV, NX, NY, NZ, XP, YP, ZP, 
                             X0, Y0, Z0, XRAY, YRAY, ZRAY, NMAX, 
                             N)                       level 2, 3
         or:  void stmpts3d (const float *xv, const float *yv, 
                   const float *zv, int nx, int ny, int nz, 
                   const float *xp, const float *ypray, 
                   float x0, float y0, float z0, float *xray,
                   float *yray, float *zray,  int nmax, int *n);
XV, YV, ZV    are arrays of the dimension (NX, NY, NZ) that con-
              tain the X-, Y- and Z-coordinates of the vectors. 
NX, NY, NZ    define the dimension of XV, YV and ZV.
XP, YP, ZP    are  arrays of the dimensions  NX,  NY and NZ that
              define the grid in space.
X0, Y0, Z0    define the starting point.
XRAY, YRAY,   are arrays of the dimension NMAX that will contain
   ZRAY       the calculated streamline.
NMAX          is the dimension of XRAY, YRAY and ZRAY.
N             is the returned number of points in XRAY, YRAY and
              ZRAY.
Note:         See the notes for STREAM.
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 (const 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 (const float *xray, int ixdim, 
                           const float *yray, int iydim,
                           const 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 (const float *xray, int ixdim, 
                           const float *yray, int iydim, 
                           const 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. For logarithmic scaling of the  Z-
              axis, ZMIN and ZMAX must be exponents of base 10. 
              If SHDMOD ('OFF', 'ZSCALE') is used before SURSHD,
              the  calculating of colour values is  disabled and
              the  current  colour  and  material  settings  are 
              applied to the surface.   
            - A flat shading or a smooth shading can be selected
              with  the routine SHDMOD. The default is flat sha-
              ding. SURSHD uses automatically a  depth sort  for
              flat shading  and a Z-buffer for smooth shading to
              eliminate hidden surfaces  if these algorithms are
              not  already enabled  with the routines DBFINI and
              ZBFINI.  If  smooth  shading is selected, a raster
              format is  needed  for the graphics  output format
              (for example  METAFL ('XWIN') or METAFL ('TIFF')). 
            - By default, SURSHD plots first the bottom and then
              the top of the surface  where backface culling  is
              enabled.  Backface culling means that single poly-
              gons  that  are not facing  the viewpoint  are re-
              moved. This is done by comparing the polygons sur-
              face normal with the position of the viewpoint. 
              This  behaviour can be  modified with the routines
              SURVIS and SHDMOD.
            - 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: SURSHC  23
The routine  SURSHC is a similar routine to SURSHD with an extra
 matrix which is used for calculating surface colours.

The call is:  CALL SURSHC (XRAY, IXDIM, YRAY, IYDIM, ZMAT, WMAT)
                                                         level 3
         or:  void surshd (const float *xray, int ixdim, 
                           const float *yray, int iydim, 
                          const float *zmat, const float *wmat);
XRAY, YRAY    are arrays  containing the X- and Y-user coordina-
              tes.
IXDIM, IYDIM  are the  dimensions of  ZMAT,  WMAT, XRAY and YRAY 
              (>= 2).
ZMAT          is a matrix with the dimension  (IXDIM,IYDIM) con-
              taining the function values.
WMAT          is a matrix with the dimension (IXDIM,IYDIM) which
              is used to calculate surface colours.
Notes:        see SURSHD.
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.
Note:         The user is referred to the notes on SURSHD.
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 
irregularly distributed data points.
The call is:  CALL SURTRI (XRAY, YRAY, ZRAY, N, I1RAY, I2RAY,
                           I3RAY, NTRI)                  level 3
         or:  void surtri (const float *zray, const float *yray, 
                           const float *zray, int n, 
                           const int *i1ray, const int *i2ray, 
                           const 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.
Note:         The user is referred to the notes on SURSHD.
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 (const float *xray, int nx, 
                           const float *yray, int ny, 
                           const float *zray, int nz, 
                           const 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).
WLEV          defines the level of the isosurface.
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.
            - The user is referred to the notes on SURSHD.
XRAY, YRAY,   are arrays containing the  X-, Y- and Z-user coor- 
Name: ISOPTS  23
The routine  ISOPTS  calculates  an isosurface  of the form
f(x,y,z) = constant.  A triangulation of the calculated iso-
surface is returned.
The call is:  CALL ISOPTS (XRAY, NX, YRAY, NY, ZRAY, NZ,  
                           WMAT, WLEV, XTRI, YTRI, ZTRI, 
                           NMAX, NTRI)                   level 3
         or:  void isopts (const float *xray, int nx, 
                           const float *yray, int ny,
                           const  float *zray, int nz, 
                           const float *wmat, float wlev, 
                           float *xtri, float *ytri, 
                           float *ztri, int nmax, int *ntri); 
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).
WLEV          defines the level of the isosurface.
XTRI, YTRI,   are arrays  containing  the  calculated triangles.
       ZTRI   The first three coordinates contain the first tri-
              angle,  the next three coordinates the second tri-
              angle and so on.  The triangles  are   returned in
              anti-clockwise orientation. 
NMAX          is the maximal number  of elements for  the arrays
              XTRI, YTRI and ZTRI.
NTRI          is the returned number of calculated triangles. 
Name: BARS3D  23
BARS3D plots three-dimensional bars.
The call is:  CALL BARS3D (XRAY, YRAY, Z1RAY, Z2RAY, XWRAY, 
                           YWRAY, ICRAY, N)              level 3
         or:  void bars3d (const float *xray, const float *yray, 
                         const float *z1ray, const float *z2ray, 
                         const float *xwray, const float *ywray, 
                         const int *icray, int n);
XRAY          is an array of  user coordinates  defining the 
              position of the bars on the X-axis.
YRAY          is an array of  user coordinates  defining the
              position of the bars on the Y-axis.
Z1RAY         is an array of user coordinates containing the
              start points of the bars on the Z-axis.
Z2RAY         is an array of user coordinates containing the
              end points of the bars on the Z-axis.
XWRAY         is an array of  user coordinates  defining the 
              width of the bars in X-direction.
YWRAY         is an array of  user coordinates  defining the
              width of the bars in Y-direction.
ICRAY         is an array  of colour  values  used  for  the
              bars.  The foreground  colour  is used for the 
              value  -1.
N             is the number of bars.
Note:         Legends are supported for 3-D bar graphs.
              Legend entries are done for each new colour in
              ICRAY.
Name: CONSHD3D 23
The routine CONSHD3D plots a  shaded surface from a matrix where
colour values are connected with contours.
The call is:  CALL CONSHD3D (XRAY, IXDIM, YRAY, IYDIM, ZMAT,
                                         ZLVRAY, NLEV)   level 3

XRAY, YRAY    are arrays containing the X- and  Y-user coordina-
              tes.
ZMAT          is a matrix with the dimension (IXDIM,IYDIM)
              containing the function values.
IXDIM, IYDIM  are the  dimensions of ZMAT, XRAY and YRAY (>= 2).
ZLVRAY        is an array containing the levels. 
NLEV          is the number of levels.
Note:         The user  is referred  to the notes on  SURSHD and
              CONSHD.
Name: LABL3D  23
The routine LABL3D  modifies  the appearance  of labels and axis
titles plotted on the 3-D box.
The call is:  CALL LABL3D (COPT)                   level 1, 2, 3
         or:  void labl3d (const char *copt);
COPT          is a  character  string  that can have  the values 
              'STANDARD', 'HORIZONTAL', 'PARALLEL'  and 'OTHER'.
              For the default mode  'STANDARD',  hardware  fonts
              cannot  be  used for plotting labels and axis tit-
              les. For that case, DISLIN will switch to the vec-
              tor font COMPLX.
                                     Default: COPT = 'STANDARD'.
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 (const 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
The routine  SURVIS  determines which part of a surface is plot-
ted.
The call is:  CALL SURVIS (CVIS)                   level 1, 2, 3
         or:  void survis (const char *cvis);
CVIS          is a  character  string that  can have  the values
              'AUTO',  'TOP',  'BOTTOM' and 'BOTH'. 'AUTO' means
              that the value 'TOP'  is used for closed  surfaces
              such as a sphere and that  'BOTH' is  used for non
              closed surfaces  such  as surfaces plotted by SUR-
              SHD, SURFCP and SURTRI.
                                         Default: CVIS = 'AUTO'.
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 values.  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 surfa-
ces, or disable the shading of a surface.
The call is:  CALL SURMSH (COPT)                   level 1, 2, 3
         or:  void surmsh (const char *copt);
COPT          is a  character string  that  can have  the values
              'ON',  'OFF',  'ONLY',  'LINES'  and 'POINTS'. For
              COPT = 'ONLY',  the shading of the surface is done
              in background colour to allow hidden line  removal
              for the mesh lines.
                                          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
         or:  void mshclr (int iclr);
ICLR          is a colour  value  where the value -1 means  that
              the current colour is used.
                                             Default: ICLR = -1.
Name: SETFCE  23
The routine  SETFCE  selects  the  surface  side  for which mesh
colours or material parameters  are applied by the routines MSH-
CLR and MATOP3.
The call is:  CALL SETFCE (COPT)                   level 1, 2, 3
         or:  void setfce (const char *copt);   
COPT          is a  character string  that  can have  the values
              'TOP', 'BOTTOM' and 'BOTH'.
                                          Default: COPT = 'TOP'.
Name: HSYM3D  23
The routine  HSYM3D sets the symbol size for 3-D symbols plotted
by SYMB3D, CURV3D and CURV4D.
The call is:  CALL HSYM3D (H)                      level 1, 2, 3
H             is the symbol height in absolute 3-D coordinates.
                                               Default: H = 0.08
Name: SETRES3D  23
The routine  SETRES3D  sets the  symbol size  for the 3-D symbol 
with the number 0 (cube) plotted by SYMB3D, CURV3D and CURV4D.
The call is:  CALL SETRES3D (XL, YL, ZL)           level 1, 2, 3
XL, YL, ZL    is the cube size in absolute 3-D coordinates.
                                     Default: (0.08, 0.08, 0.08)
Name: AUTRES3D  23
The routine  AUTRES3D  calculates the symbol size for cubes from
the number of data points.
The call is:  CALL AUTRES3D (IXDIM, IYDIM, IZDIM)  level 1, 2, 3
IXDIM, IYDIM, are the number of data points  in the  X-,  Y- and
    IZDIM     Z-directions.
Note:         HSYM3D,  SETRES3D  and AUTRES3D can overwrite each 
              other for the symbol 'cube'. 
Name: ROT3D  23
The routine  ROT3D  sets rotation angles for 3-D symbols and so-
lids.
The call is:  CALL ROT3D (AX, AY, AZ)              level 1, 2, 3
         or:  void rot3d (float ax, float ay, float az); 
AX, AY, AZ    are rotation angles in degrees for rotations about
              the  X-, Y-, and Z-axes. Rotation is done   around
              the centre point of symbols in a counter-clockwise
              direction when looking from a positive axis toward
              the origin of the axis.
                                           Default: (0., 0., 0.)
Name: THKC3D 23
The routine THKC3D sets the thickness of 3-D curves. 
The call is:  CALL THKC3D (XTHK)                   level 1, 2, 3
         or:  void thkc3d (float xthk);
XTHK          is the thickness in absolute 3-D coordinates.
                                            Default: XTHK = 0.04
Name: MSHCRV 23
The routine  MSHCRV  sets the  resolution  of the  mesh used for 
3-D curves. 
The call is:  CALL MSHCRV (N)                      level 1, 2, 3
         or:  void mshcrv (int n);
N             is the number of mesh lines  around the curve.  If
              N = 0,  the number of mesh lines  is automatically
              calculated by DISLIN. 
                                                 Default: N = 0.
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 (const 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, const 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,
                                              const 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: LITOP3  23
The routine  LITOP3  modifies  the ambient, diffuse and specular
intensities of light sources.
The call is:  CALL LITOP3 (ID, XR, XG, XB, COPT)   level 1, 2, 3
         or:  void litop3 (int id, float xr, float xg, float xb,
                                              const char *copt);  
ID            is the ID of the light source in the range 1 to 8. 
XR, XG, XB    are floating point numbers in the range 0 to 1 for
              R, G and B.
COPT          is a  character  string  that can have  the values
              'AMBIENT',   'DIFFUSE' and 'SPECULAR'.
                             Defaults: (0., 0., 0., 'AMBIENT'), 
                                       (1., 1., 1., 'DIFFUSE'), 
                                       (1., 1., 1., 'SPECULAR').
Name: LITOPT  23
The routine LITOPT modifies the constant, linear and quadratic
attenuation factors of light sources.
The call is:  CALL LITOPT (ID, XVAL, COPT)         level 1, 2, 3
         or:  void litopt (int id, float xval, 
                                              const char *copt);  
ID            is the ID of the light source in the range 1 to 8. 
XVAL          is  a floating point  number  containing  the  new
              lighting parameter. 
COPT          is a  character  string  that can have  the values
              'CONSTANT', 'LINEAR' and 'QUADRATIC'.
                     Defaults: (1., 'CONSTANT'), (0., 'LINEAR'),
                                              (0., 'QUADRATIC').
Name: MATOP3  23
The routine MATOP3 modifies material parameters such as ambient,
diffuse and specular colour.  Material parameters can be defined
for different sides  of a surface if the routine  SETFCE is used
before.
The call is:  CALL MATOP3 (XR, XG, XB, COPT)       level 1, 2, 3
         or:  void matop3 (float xr, float xg, float xb, 
                                              const char *copt);
XR, XG, XB    are  floating  point  numbers  in the range 0 to 1
              containing  the new material  parameters for R,  G
              and B.
COPT          is  a  character string  that can have  the values 
              'AMBIENT',  'DIFFUSE' and 'SPECULAR'.
                          Defaults: (0.2, 0.2, 0.2, 'AMBIENT'), 
                                    (0.8, 0.8, 0.8, 'DIFFUSE'), 
                                    (0.0, 0.0, 0.0, 'SPECULAR').
Name: MATOPT  23
The routine MATOPT modifies material parameters.
The call is:  CALL MATOPT (XVAL, COPT)             level 1, 2, 3
         or:  void matopt (float xval, const char *copt);
XVAL          is  a floating point  number  containing  the  new
              material parameter. 
COPT          is  a  character  string  that can have  the value
              'EXPONENT'.
                                      Default: (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.  ICLR contains  an
              explicit RGB value. 
Name: CLIP3D  23
The routine  CLIP3D defines 3-D clipping in the world coordinate
system  or in the eye coordinate system,  or disables clipping.
The call is:  CALL CLIP3D (COPT)                   level 1, 2, 3
         or:  void clip3d (const char *copt);
COPT          is a  character string  that  can have  the values
              'WORLD', 'EYE' and 'NONE'.
                                        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 (const float *xray, const float *yray, 
                           const 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, 
                                              const 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: GRFIMG  23
The routine  GRFIMG  includes a PNG,  BMP, TIFF or GIF file into
a 3-D plane defined by GRFINI.  This routine can only be used if
the  output  format is a  raster format (screen  or image file). 
The call is:  CALL GRFIMG (CFIL)                   level 1, 2, 3 
CFIL          is a character string  that contains the filename.

Name: ZBFINI  23
The routine  ZBFINI creates a Z-buffer. The graphics output for-
mat must be set to a raster format,  or to PDF.  For PDF output,
an internal image is created for raster operations.  The resolu-
tion of the internal image can be modified with the routine ZBF-
SCL. 
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. For screen output,  the internal frame buf-
fer is copied back to the graphics window.  For PDF output,  the
internal  image  is copied to the PDF file in transparency mode.
The call is:  CALL ZBFFIN                            level 1,2,3
         or:  void zbffin ();
Name: ZBFMOD  23
The routine ZBFMOD can disable the Z-buffer in DISLIN.
The call is:  CALL ZBFMOD (COPT)                   level 1, 2, 3
         or:  void zbfmod (const char *copt);
COPT          is  a character  string  that can  have the values
              'ON'  and  'OFF'.  The keyword  'OFF' disables the
              Z-buffer  in routines  that  automatically use it.
              A call to ZBFINI has also no affect for if  the Z-
              buffer is disabled.
                                           Default: COPT = 'ON'.
Name: ZBFRES  23
The routine  ZBFRES  resets the  Z-buffer to it's initial values
without changing a corresponding frame buffer. 
The call is:  CALL ZBFRES                            level 1,2,3
         or:  void zbfres ();
Name: ZBFERS  23
The routine  ZBFERS erases the frame buffer  connected with a Z-
buffer.
The call is:  CALL ZBFERS                            level 1,2,3
         or:  void zbfers ();
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 (const float *xray, const float *yray, 
                           const float *zray, const 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: ZBFSCL  23
The routine  ZBFSCL  changes the resolution of an internal image
which is used for raster operations for PDF output.  The resolu-
tion of the internal image corresponds to the  DISLIN  plot page
converted to points,  where 1 point = 1 / 72 inch.  This resolu-
tion  is multiplied with the value in ZBFSCL.  
For example:  the internal  image corresponding  to the  default
page 'DA4L' has the resolution 1263 x 892 points.
The call is:  CALL ZBFSCL (X)                        level 1,2,3
         or:  void zbfscl (float x);
X             is a scaling factor for the resolution
              (1 <= x <= 10).
                                                    Default: 1.5
Name: DBFINI  23
The routine  DBFINI  initializes a depth sort for polygon faces.
A depth sort  is useful  for hidden-surface  elimination  if the
output format is no raster format so that the Z-buffer cannot be
used.
The call is:  CALL DBFINI (IRET)                     level 1,2,3
         or:  int  dbfini ();
IRET          is the returned status (0: no errors).
Name: DBFFIN  23
The routine  DBFFIN terminates the depth sort. All polygon faces
are sorted  and plotted.  The polygon  faces  with  the greatest
distance from the viewpoint are plotted first. 
The call is:  CALL DBFFIN                            level 1,2,3
         or:  void dbffin ();
Name: DBFMOD  23
The routine DBFMOD can disable the depth sort.
The call is:  CALL DBFMOD (COPT)                   level 1, 2, 3
         or:  void dbfmod (const char *copt); 
COPT          is  a character  string that  can have  the values
              'ON'  and  'OFF'.  The keyword  'OFF' disables the
              depth  in routines  that automatically  use it.  A
              call to DBFINI has also no affect for that case.
                                           Default: COPT = 'ON'.
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. If IVEC = -2,  a 3-D cone
              is used  for the  arrow head.  Otherwise, IVEC has
              the same meaning as in VECTOR.
Name: TRIA3D  23
The routine TRIA3D plots a triangle.
The call is:  CALL TRIA3D (XRAY, YRAY, ZRAY)             level 3
         or:  void tria3d (const float *xray, const float *yray, 
                           const float *zray); 
XRAY, YRAY,   are the  X-,  Y-  and Z-coordinates  of the  three
      ZRAY    vertices of the triangle  in user coordinates. The
              vertices  should be specified  in a counter-clock-
              wise orientation from the viewpoint since backface
              culling is enabled in DISLIN by default.
Note:         If lighting  is enabled,  a normal  vector  of the
              triangle is automatically generated  by DISLIN for
              calculating colours.
Name: VTX3D   23
The routine VTX3D  plots lines,  points, curves, triangles, qua-
drilaterals or polygons from a set of vertices.
The call is:  CALL VTX3D (XRAY, YRAY, ZRAY, N, COPT)     level 3
         or:  void vtx3d (const float *xray, const float *yray,
                    const float *zray, int n, const char *copt);
XRAY, YRAY,   define vertices in user coordinates.
      ZRAY
N             is the number of vertices.
COPT          is a  character string  that defines  how vertices
              are plotted:
 = 'POINTS'   The  vertices  are  plotted with a small '+' sign,
              where the size of the symbol  can be modified with
              HSYMBL.
 = 'LINES'    Separated  lines are plotted,  each specified by a
              pair of vertices.
 = 'CURVE'    A series of connected lines is plotted.
 = 'PLINE'    The same as 'CURVE' except that the last vertex is
              connected with the first vertex.
 = 'TRIANG'   Separate shaded triangles are plotted for each set
              of three vertices.
 = 'TSTRIPS'  A series of triangles  is  plotted connected along
              shared edges.  The triangles are (1, 2, 3), (3, 2,
              4), (3, 4, 5), (5, 4, 6), ...., where the vertices
              are numbered by 1, 2, 3, ..., n.
 = 'QUADS'    Separate shaded quads are plotted for each set  of
              four vertices.
 = 'QSTRIPS'  A series  of  quads  is  plotted  connected  along 
              shared edges.  The quads are (1, 2, 4, 3),  (3, 4,
              6, 5), (5, 6, 8, 7), ....,  where the vertices are
              numbered by 1, 2, 3, ..., n.
 = 'POLYGON'  A shaded  polygon  is  plotted  where  the polygon
              should  be  convex.  The polygon  is rendered by a
              series of triangles.
Note:         If lighting  is enabled,  normal  vectors for cal-
              culating colour values are automatically generated
              by DISLIN.
Name: VTXC3D  23
The routine  VTXC3D is a similar routine to VTX3D except that an
user can  specify additional colour values for the vertices.
The call is:  CALL VTXC3D (XRAY, YRAY, ZRAY, ICRAY, N, COPT)
                                                         level 3
         or:  void vtxc3d (const float *xray, const float *yray, 
                           const float *zray, const int *icray,
                           int n, const char *copt); 
XRAY, YRAY,   define vertices in user coordinates.
      ZRAY
ICRAY         contains the colour values of vertices. 
N             is the number of vertices.
COPT          is a character  string  that defines  how vertices
              are plotted (see VTX3D).
Name: VTXN3D  23
The routine  VTXN3D  is a similar routine to VTX3D except that a 
normal vector can be specified for each vertex.
The call is:  CALL VTXN3D (XRAY,  YRAY,  ZRAY, XNRAY, YNRAY,
                           ZNRAY, N, COPT)           level 3
         or:  void vtxn3d (const float *xray, const float *yray, 
                         const float *zray, const float *xnray, 
                         const float *ynray, const float *znray,
                         int n, const char *copt);
XRAY, YRAY,   define vertices in user coordinates.
      ZRAY
XNRAY, YNRAY, contain the normal vectors for each vertex.
      ZNRAY
N             is the number of vertices.
COPT          is a character string  that defines how vertices
              are plotted (see VTX3D).
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 centre 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: CONE3D  23
The routine CONE3D plots a cone or a truncated cone.
The call is:  CALL CONE3D (XM, YM, ZM, R, H1, H2, N, M)  level 3
         or:  void cone3d (float xm, float ym, float zm, 
                           float r, float h1, float h2, 
                           int n, int m);
XM, YM, ZM    are  the  user  coordinates  of the  lower  centre
              point.
R             is the radius of the cone in user coordinates.
H1, H2        are the heights of the truncated cone. If H1 = H2,
              the cone is not truncated. 
N, M          define the horizontal  and vertical resolution  of
              the cone.
Name: PIKE3D  23
The routine PIKE3D plots a cone specified by two points.
The call is:  CALL PIKE3D (X1, Y1, Z1, X2, Y2, Z2, R, N, M)
                                                         level 3
X1, Y1, Z1    are the user coordinates  of  the  starting centre
              point.
X2, Y2, Z2    are the user coordinates of the ending point.
R             is the radius of the cone in user coordinates.
N, M          define the horizontal  and vertical resolution  of
              the cone.
Name: CYLI3D  23
The routine CYLI3D plots a cylinder.
The call is:  CALL CYLI3D (XM, YM, ZM, H, R, N, M)       level 3
         or:  void cyli3d (float xm, float ym, float zm, 
                           float h, float r, int n, int m);
XM, YM, ZM    are  the  user coordinates  of  the  lower  centre
              point.
R             is the radius of the cylinder in user coordinates.
H             is the height of the cylinder in user coordinates.
N, M          define the horizontal  and vertical resolution  of
              the cylinder.
Name: TUBE3D  23
The routine TUBE3D plots a tube.
The call is:  CALL TUBE3D (X1, Y1, Z1, X2, Y2, Z2, R, N, M) 
                                                         level 3
         or:  void tube3d (float x1, float y1, float z1, 
                           float x2, float y2, float z2,
                           float r, int n, int m);
X1, Y1, Z1    are  the user coordinates  of the  starting centre
              point.
X2, Y2, Z2    are  the  user coordinates  of the  ending  centre 
              point.
R             is the radius of the tube in user coordinates.
N, M          define the horizontal  and vertical resolution  of
              the tube.
Name: DISK3D  23
The routine DISK3D plots a disk.
The call is:  CALL DISK3D (XM, YM, ZM, R1, R2, N, M)     level 3
         or:  void disk3d (float xm, float ym, float zm, 
                           float r1, float r2, int n, int m);
XM, YM, ZM    are the user coordinates  of the centre point.
R1, R2        are the inner and outer radii in user coordinates.
N, M          define the horizontal  and vertical resolution  of
              the disk.
Name: QUAD3D  23
The routine QUAD3D plots a quad.
The call is:  CALL QUAD3D (XM, YM, ZM, XL, YL, ZL)       level 3
         or:  void quad3d (float xm, float ym, float zm, 
                           float xl, float yl, float zl);
XM, YM, ZM    are the user coordinates of the centre point.
XL, YL, ZL    are the  length  of the edges in X-, Y- and Z-
              direction in user coordinates.
Name: PYRA3D  23
The routine PYRA3D plots a pyramid or a truncated pyramid.
The call is:  CALL PYRA3D (XM, YM, ZM, XL, H1, H2, N)    level 3
         or:  void pyra3d (float xm, float ym, float zm, 
                           float xl, float h1, float h2, int n);
XM, YM, ZM    are  the  user  coordinates  of  the  lower centre
              point.
XL            is the length of the pyramid in user coordinates.
H1, H2        are the heights of the  truncated  pyramid in user
              coordinates.  If H1 = H2, the pyramid is not trun-
              cated.
N             can have the values 3 and 4 and defines the number
              of sides.  
Name: PLAT3D  23
The routine PLAT3D plots a Platonic solid. The 5 Platonic solids
are tetrahedron, cube, octahedron, dodecahedron and icosahedron.  
The call is:  CALL PLAT3D (XM, YM, ZM, XL, COPT)         level 3
         or:  void plat3d (float xm, float ym, float zm, 
                           float xl, const char *copt);
XM, YM, ZM    are the user coordinates of the centre point.
XL            is the length of an edge in user coordinates.
COPT          is a character string that can have the values
              'TETR', 'CUBE', 'OCTA'', 'DODE' and 'ICOS'.
Name: SYMB3D  23
The routine SYMB3D plots a 3-D symbol.
The call is:  CALL SYMB3D (N, XM, YM, ZM)                level 3
         or:  void symb3d (int n, float xm, float ym, float zm); 
N             is the symbol number between 0 and 5.  The symbols
              are cube,  tetrahedron, octahedron,  dodecahedron,
              icosahedron and sphere.  
XM, YM, ZM    are the user coordinates of the centre point.
Note:         The size  of  3-D symbols  can be defined with the
              routine HSYM3D.
Name: TORUS3D 23
The routine TORUS3D plots a torus.
The call is:  CALL TORUS3D (XM, YM, ZM, R1, R2, H, A1, A2, N, M)
                                                         level 3
         or:  void torus3d (float xm, float ym, float zm, 
                            float r1, float r2, float h,
                            float a1, float a2, int n, int m);
XM, YM, ZM    are the user coordinates of the centre point.
R1, R2        are the inner and outer radii in user coordinates.
H             is the height of the torus  in user coordinates.
A1, A2        are the starting and end angles in degrees.
N, M          define the horizontal  and vertical resolution  of
              the torus.
Name: PLYINI  23
The routine PLYINI  initializes  the output of polygons to a PLY
file.  The polygons are sent to the output device and to the PLY
file.
The call is:  CALL PLYINI (COPT)                         level 3
         or:  void plyini (const char *copt);
COPT          is a character  string that defines the format  of 
              the PLY file. COPT can have the value 'STANDARD'. 
Name: PLYFIN  23
The routine PLYFIN  terminates  the output  of polygons to a PLY
file.
The call is:  CALL PLYFIN (CFIL, CSTR)                   level 3
         or:  void plyfin (const char *cfil, const char *cstr);
CFIL          is a character  string that contains  the name  of
              the PLY file.
CSTR          is a character string that is written as a comment
              to the PLY file.
Note:         Backface culling should be disabled  with the rou-
              tine  SHDMOD.  Otherwise,  polygons written to the 
              PLY file depend on the viwepoint.
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.
Name: TR3SHF  23
The routine  TR3SHF defines a shifting of user 3-D coordinates.
The call is:  CALL TR3SHF (XSHF, YSHF, ZSHF)             level 3
         or:  void tr3shf (float xshf, float yshf, float zshf);
XSHF, YSHF,   are user coordinates that define the magnitude  of 
       ZSHF   shifting in X-, Y- and Z-direction
Name: TR3SCL  23
The routine  TR3SCL  defines a scaling of user 3-D coordinates.
The call is:  CALL TR3SCL (XSCL, YSCL, ZSCL)             level 3
         or:  void tr3scl (float xscl, float yscl, float zscl);
XSCL, YSCL,   are  scaling  factors  for  the X-,  Y- and Z-
       ZSCL   direction
Name: TR3ROT  23T
The routine  TR3ROT  defines a rotation  about an axis. The axes
of the 3-D box are used as rotation axes where the origin of the
axis system is located in the centre of the  3-D box (see Figure
12.1). 
The call is:  CALL TR3ROT (XROT, YROT, ZROT)             level 3
         or:  void tr3rot (float xrot, float yrot, float zrot);
XROT, YROT,   are rotation angles in degrees for rotations about
       ZROT   the  X-,  Y-  and Z-axes.  Rotation  is done  in a 
              counter-clockwise direction  when  looking  from a
              positive axis  toward the origin of the axis.
Note:         The order  of rotations is X-axis, Y-axis and then
              Z-axis.  This means that TR3ROT (A, B, C) has  the
              same affect  as TR3ROT (A, 0., 0.), TR3ROT (0., B,
              0.) and TR3ROT (0., 0., C).
Name: TR3AXS  23
The routine  TR3AXS  defines a rotation about an arbitrary axis.
The call is:  CALL TR3AXS (X, Y, Z, A)                   level 3
         or:  void tr3axs (float x, float y, float z, float a);
X, Y, Z       defines the axis which goes from the origin to the
              point (X, Y, Z).
A             is a  rotation  angle in degrees. Rotation is done
              in a counter-clockwise direction when looking from
              the point (X, Y, Z) toward the origin.
Name: TR3RES  23
The routine TR3RES resets 3-D transformations.
The call is:  CALL TR3RES                                level 3
         or:  void tr3res ();
