Introduction
This appendix includes a list of all the PGPLOT subroutines, and then gives detailed instructions for the use of each routine in Fortran programs. The subroutine descriptions are in alphabetical order.See PGplot's home base https://astro.caltech.edu/~tjp/pgplot/
Arguments
The subroutine descriptions indicate the data type of each argument. When arguments are described as ``input'', they may be replaced with constants or expressions in theCALL
statement, but make sure that the constant or expression has the
correct data type.
INTEGERarguments:- these should be declared
INTEGERorINTEGER*4in the calling program, notINTEGER*2. REALarguments:- these should be declared
REALorREAL*4in the calling program, notREAL*8orDOUBLE PRECISION. LOGICALarguments:- these should be declared
LOGICALorLOGICAL*4in the calling program. CHARACTERarguments:- any valid Fortran
CHARACTERvariable may be used (declaredCHARACTER*nfor some integern).
Index of Routines
Version 5.2
- PGARRO -- draw an arrow
- PGASK -- control new page prompting
- PGAXIS -- draw an axis
- PGBAND -- read cursor position, with anchor
- PGBBUF -- begin batch of output (buffer)
- PGBEG -- open a graphics device
- PGBIN -- histogram of binned data
- PGBOX -- draw labeled frame around viewport
- PGCIRC -- draw a circle, using fill-area attributes
- PGCLOS -- close the selected graphics device
- PGCONB -- contour map of a 2D data array, with blanking
- PGCONF -- fill between two contours
- PGCONL -- label contour map of a 2D data array
- PGCONS -- contour map of a 2D data array (fast algorithm)
- PGCONT -- contour map of a 2D data array (contour-following)
- PGCONX -- contour map of a 2D data array (non rectangular)
- PGCTAB -- install the color table to be used by PGIMAG
- PGCURS -- read cursor position
- PGDRAW -- draw a line from the current pen position to a point
- PGEBUF -- end batch of output (buffer)
- PGEND -- close all open graphics devices
- PGENV -- set window and viewport and draw labeled frame
- PGERAS -- erase all graphics from current page
- PGERR1 -- horizontal or vertical error bar
- PGERRB -- horizontal or vertical error bar
- PGERRX -- horizontal error bar
- PGERRY -- vertical error bar
- PGETXT -- erase text from graphics display
- PGFUNT -- function defined by X = F(T), Y = G(T)
- PGFUNX -- function defined by Y = F(X)
- PGFUNY -- function defined by X = F(Y)
- PGGRAY -- gray-scale map of a 2D data array
- PGHI2D -- cross-sections through a 2D data array
- PGHIST -- histogram of unbinned data
- PGIDEN -- write username, date, and time at bottom of plot
- PGIMAG -- color image from a 2D data array
- PGLAB -- write labels for x-axis, y-axis, and top of plot
- PGLCUR -- draw a line using the cursor
- PGLDEV -- list available device types on standard output
- PGLEN -- find length of a string in a variety of units
- PGLINE -- draw a polyline (curve defined by line-segments)
- PGMOVE -- move pen (change current pen position)
- PGMTXT -- write text at position relative to viewport
- PGNCUR -- mark a set of points using the cursor
- PGNUMB -- convert a number into a plottable character string
- PGOLIN -- mark a set of points using the cursor
- PGOPEN -- open a graphics device
- PGPAGE -- advance to new page
- PGPANL -- switch to a different panel on the view surface
- PGPAP -- change the size of the view surface
- PGPIXL -- draw pixels
- PGPNTS -- draw several graph markers, not all the same
- PGPOLY -- draw a polygon, using fill-area attributes
- PGPT -- draw several graph markers
- PGPT1 -- draw one graph marker
- PGPTXT -- write text at arbitrary position and angle
- PGQAH -- inquire arrow-head style
- PGQCF -- inquire character font
- PGQCH -- inquire character height
- PGQCI -- inquire color index
- PGQCIR -- inquire color index range
- PGQCLP -- inquire clipping status
- PGQCOL -- inquire color capability
- PGQCR -- inquire color representation
- PGQCS -- inquire character height in a variety of units
- PGQDT -- inquire name of nth available device type
- PGQFS -- inquire fill-area style
- PGQHS -- inquire hatching style
- PGQID -- inquire current device identifier
- PGQINF -- inquire PGPLOT general information
- PGQITF -- inquire image transfer function
- PGQLS -- inquire line style
- PGQLW -- inquire line width
- PGQNDT -- inquire number of available device types
- PGQPOS -- inquire current pen position
- PGQTBG -- inquire text background color index
- PGQTXT -- find bounding box of text string
- PGQVP -- inquire viewport size and position
- PGQVSZ -- inquire size of view surface
- PGQWIN -- inquire window boundary coordinates
- PGRECT -- draw a rectangle, using fill-area attributes
- PGRND -- find the smallest `round' number greater than x
- PGRNGE -- choose axis limits
- PGSAH -- set arrow-head style
- PGSAVE -- save PGPLOT attributes
- PGSCF -- set character font
- PGSCH -- set character height
- PGSCI -- set color index
- PGSCIR -- set color index range
- PGSCLP -- enable or disable clipping at edge of viewport
- PGSCR -- set color representation
- PGSCRL -- scroll window
- PGSCRN -- set color representation by name
- PGSFS -- set fill-area style
- PGSHLS -- set color representation using HLS system
- PGSHS -- set hatching style
- PGSITF -- set image transfer function
- PGSLCT -- select an open graphics device
- PGSLS -- set line style
- PGSLW -- set line width
- PGSTBG -- set text background color index
- PGSUBP -- subdivide view surface into panels
- PGSVP -- set viewport (normalized device coordinates)
- PGSWIN -- set window
- PGTBOX -- draw frame and write (DD) HH MM SS.S labelling
- PGTEXT -- write text (horizontal, left-justified)
- PGTICK -- draw a single tick mark on an axis
- PGUNSA -- restore PGPLOT attributes
- PGUPDT -- update display
- PGVECT -- vector map of a 2D data array, with blanking
- PGVSIZ -- set viewport (inches)
- PGVSTD -- set standard (default) viewport
- PGWEDG -- annotate an image plot with a wedge
- PGWNAD -- set window and adjust viewport to same aspect ratio
- PGADVANCE -- non-standard alias for PGPAGE
- PGBEGIN -- non-standard alias for PGBEG
- PGCURSE -- non-standard alias for PGCURS
- PGLABEL -- non-standard alias for PGLAB
- PGMTEXT -- non-standard alias for PGMTXT
- PGNCURSE -- non-standard alias for PGNCUR
- PGPAPER -- non-standard alias for PGPAP
- PGPOINT -- non-standard alias for PGPT
- PGPTEXT -- non-standard alias for PGPTXT
- PGVPORT -- non-standard alias for PGSVP
- PGVSIZE -- non-standard alias for PGVSIZ
- PGVSTAND -- non-standard alias for PGVSTD
- PGWINDOW -- non-standard alias for PGSWIN
PGARRO -- draw an arrow
SUBROUTINE PGARRO (X1, Y1, X2, Y2)
REAL X1, Y1, X2, Y2
Draw an arrow from the point with world-coordinates (X1,Y1) to
(X2,Y2). The size of the arrowhead at (X2,Y2) is determined by
the current character size set by routine PGSCH.
The default size is 1/40th of the smaller of the width or height
of the view surface. The appearance of the arrowhead (shape and
solid or open) is controlled by routine PGSAH.
Arguments:
X1, Y1 (input) : world coordinates of the tail of the arrow
X2, Y2 (input) : world coordinates of the head of the arrow
PGASK -- control new page prompting
SUBROUTINE PGASK (FLAG)
LOGICAL FLAG
Change the 'prompt state' of PGPLOT. If the prompt state is ON,
PGPAGE will type 'Type RETURN for next page:' and will wait
for the user to type a carriage-return before starting a new page.
The initial prompt state (after the device has been opened) is ON
for interactive devices. Prompt state is always OFF for
non-interactive devices.
Arguments:
FLAG (input) : if .TRUE., and if the device is an interactive
device, the prompt state will be set to ON
if .FALSE., the prompt state will be set to OFF
PGAXIS -- draw an axis
SUBROUTINE PGAXIS (OPT, X1, Y1, X2, Y2, V1, V2, STEP, NSUB,
DMAJL, DMAJR, FMIN, DISP, ORIENT)
CHARACTER*(*) OPT
REAL X1, Y1, X2, Y2, V1, V2, STEP, DMAJL, DMAJR, FMIN, DISP
REAL ORIENT
INTEGER NSUB
Draw a labelled graph axis from world-coordinate position (X1,Y1)
to (X2,Y2).
Normally, this routine draws a standard LINEAR axis with equal
subdivisions. The quantity described by the axis runs from V1 to V2;
this may be, but need not be, the same as X or Y.
If the 'L' option is specified, the routine draws a LOGARITHMIC axis.
In this case, the quantity described by the axis runs from 10**V1
to 10**V2. A logarithmic axis always has major, labeled, tick marks
spaced by one or more decades. If the major tick marks are spaced
by one decade (as specified by the STEP argument), then minor
tick marks are placed at 2, 3, .., 9 times each power of 10;
otherwise minor tick marks are spaced by one decade. If the axis
spans less than two decades, numeric labels are placed at 1, 2,
and 5 times each power of ten.
If the axis spans less than one decade, or if it spans many decades,
it is preferable to use a linear axis labeled with the logarithm of
the quantity of interest.
Arguments:
OPT (input) : a string containing single-letter codes for
various options. The options currently
recognized are:
L : draw a logarithmic axis
N : write numeric labels
1 : force decimal labelling, instead of automatic
choice (see PGNUMB
2 : force exponential labelling, instead of
automatic
X1, Y1 (input) : world coordinates of one endpoint of the axis.
X2, Y2 (input) : world coordinates of the other endpoint of the
axis
V1 (input) : axis value at first endpoint
V2 (input) : axis value at second endpoint
STEP (input) : major tick marks are drawn at axis value 0.0 plus
or minus integer multiples of STEP. If STEP=0.0,
a value is chosen automatically
NSUB (input) : minor tick marks are drawn to divide the major
divisions into NSUB equal subdivisions (ignored
if STEP=0.0). If NSUB <= 1, no minor tick
marks are drawn. NSUB is ignored for a
logarithmic axis
DMAJL (input) : length of major tick marks drawn to left of axis
(as seen looking from first endpoint to second),
in units of the character height
DMAJR (input) : length of major tick marks drawn to right of axis,
in units of the character height
FMIN (input) : length of minor tick marks, as fraction of major
DISP (input) : displacement of baseline of tick labels to
right of axis, in units of the character height
ORIENT (input) : orientation of label text, in degrees; angle
between baseline of text and direction of axis
(0-360°)
PGBAND -- read cursor position, with anchor
INTEGER FUNCTION PGBAND (MODE, POSN, XREF, YREF, X, Y, CH)
INTEGER MODE, POSN
REAL XREF, YREF, X, Y
CHARACTER*(*) CH
Read the cursor position and a character typed by the user.
The position is returned in world coordinates. PGBAND positions
the cursor at the position specified (if POSN=1), allows the user
to move the cursor using the mouse or arrow keys or whatever is
available on the device. When he has positioned the cursor, the
user types a single character on the keyboard; PGBAND then returns
this character and the new cursor position (in world coordinates).
Some interactive devices offer a selection of cursor types,
implemented as thin lines that move with the cursor, but without
erasing underlying graphics. Of these types, some extend between
a stationary anchor-point at XREF,YREF, and the position of the
cursor, while others simply follow the cursor without changing
shape or size. The cursor type is specified with one of the
following MODE values. Cursor types that are not supported by a
given device, are treated as MODE=0.
-- If MODE=0, the anchor point is ignored and the routine behaves
like PGCURS.
-- If MODE=1, a straight line is drawn joining the anchor point
and the cursor position.
-- If MODE=2, a hollow rectangle is extended as the cursor is
moved, with one vertex at the anchor point and the opposite
vertex at the current cursor position; the edges of the
rectangle are horizontal and vertical.
-- If MODE=3, two horizontal lines are extended across the width
of the display, one drawn through the anchor point and the
other through the moving cursor position. This could be used
to select a Y-axis range when one end of the range is known.
-- If MODE=4, two vertical lines are extended over the height of
the display, one drawn through the anchor point and the other
through the moving cursor position. This could be used to
select an X-axis range when one end of the range is known.
-- If MODE=5, a horizontal line is extended through the cursor
position over the width of the display. This could be used to
select an X-axis value such as the start of an X-axis range.
The anchor point is ignored.
-- If MODE=6, a vertical line is extended through the cursor
position over the height of the display. This could be used to
select a Y-axis value such as the start of a Y-axis range.
The anchor point is ignored.
-- If MODE=7, a cross-hair, centered on the cursor, is extended
over the width and height of the display. The anchor point is
ignored.
Returns:
PGBAND : 1 if the call was successful; 0 if the device has no
cursor or some other error occurs
Arguments:
MODE (input) : display mode (0, 1, ..7: see above)
POSN (input) : if POSN=1, PGBAND attempts to place the cursor
at point (X,Y); if POSN=0, it leaves the cursor
at its current position (on some devices this
request may be ignored)
XREF (input) : the world x-coordinate of the anchor point
YREF (input) : the world y-coordinate of the anchor point
X (in/out) : the world x-coordinate of the cursor
Y (in/out) : the world y-coordinate of the cursor
CH (output) : the character typed by the user; if the device
has no cursor or if some other error occurs,
the value CHAR(0) [ASCII NUL character] is
returned
Note: The cursor coordinates (X,Y) may be changed by PGBAND even if
the device has no cursor or if the user does not move the cursor.
Under these circumstances, the position returned in (X,Y) is that
of the pixel nearest to the requested position.
PGBBUF -- begin batch of output (buffer)
SUBROUTINE PGBBUF Begin saving graphical output commands in an internal buffer; the commands are held until a matching PGEBUF call (or until the buffer is emptied by PGUPDT). This can greatly improve the efficiency of PGPLOT. PGBBUF increments an internal counter, while PGEBUF decrements this counter and flushes the buffer to the output device when the counter drops to zero. PGBBUF and PGEBUF calls should always be paired. Arguments: none
PGBEG -- open a graphics device
INTEGER FUNCTION PGBEG (UNIT, FILE, NXSUB, NYSUB)
INTEGER UNIT
CHARACTER*(*) FILE
INTEGER NXSUB, NYSUB
Note: new programs should use PGOPEN rather than PGBEG.
PGOPEN is retained for compatibility with existing programs.
Unlike PGOPEN, PGBEG closes any graphics devices that are already
open, so it cannot be used to open devices to be used in parallel.
PGBEG opens a graphical device or file and prepares it for
subsequent plotting. A device must be opened with PGBEG or PGOPEN
before any other calls to PGPLOT subroutines for the device.
If any device is already open for PGPLOT output, it is closed
before the new device is opened.
Returns:
PGBEG : a status return value
a value of 1 indicates successful completion, any other
value indicates an error; in the event of error a
message is written on the standard error unit
to test the return value, call PGBEG as a function,
e.g. IER=PGBEG (...)
note that PGBEG must be declared INTEGER in the calling
program
some Fortran compilers allow you to use CALL PGBEG (...)
and discard the return value, but this is not standard
Fortran
Arguments:
UNIT (input) : this argument is ignored by PGBEG (use zero)
FILE (input) : the "device specification" for the plot device.
(for explanation, see description of PGOPEN)
NXSUB (input) : the number of subdivisions of the view surface
in X (>0 or <0)
NYSUB (input) : the number of subdivisions of the view surface
in Y (>0)
PGPLOT puts NXSUB x NYSUB graphs on each plot
page or screen; when the view surface is sub-
divided in this way, PGPAGE moves to the next
panel, not the next physical page. If
NXSUB >0, PGPLOT uses the panels in row
order; if <0, PGPLOT uses them in column order
PGBIN -- histogram of binned data
SUBROUTINE PGBIN (NBIN, X, DATA, CENTER)
INTEGER NBIN
REAL X(*), DATA(*)
LOGICAL CENTER
Plot a histogram of NBIN values with X(1..NBIN) values along
the ordinate, and DATA(1...NBIN) along the abscissa. Bin width is
spacing between X values.
Arguments:
NBIN (input) : number of values
X (input) : abscissae of bins
DATA (input) : data values of bins
CENTER (input) : if .TRUE., the X values denote the center of the
bin; if .FALSE., the X values denote the lower
edge (in X) of the bin
PGBOX -- draw labeled frame around viewport
SUBROUTINE PGBOX (XOPT, XTICK, NXSUB, YOPT, YTICK, NYSUB)
CHARACTER*(*) XOPT, YOPT
REAL XTICK, YTICK
INTEGER NXSUB, NYSUB
Annotate the viewport with frame, axes, numeric labels, etc.
PGBOX is called by on the user's behalf by PGENV, but may also be
called explicitly.
Arguments:
XOPT (input) : string of options for X (horizontal) axis of
plot; options are single letters, and may be in
any order (see below)
XTICK (input) : world coordinate interval between major tick
marks on X axis. If XTICK=0.0, the interval is
chosen by PGBOX, so that there will be at east
3 major tick marks along the axis
NXSUB (input) : the number of subintervals to divide the major
coordinate interval into. If XTICK=0.0 or
NXSUB=0, the number is chosen by PGBOX
YOPT (input) : string of options for Y (vertical) axis of plot;
coding is the same as for XOPT
YTICK (input) : like XTICK for the Y axis
NYSUB (input) : like NXSUB for the Y axis
Options (for parameters XOPT and YOPT):
A : draw Axis (X axis is horizontal line Y=0, Y axis is vertical
line X=0)
B : draw Bottom (X) or left (Y) edge of frame
C : draw top (X) or right (Y) edge of frame
G : draw Grid of vertical (X) or horizontal (Y) lines
I : Invert the tick marks; ie draw them outside the viewport
instead of inside
L : Label axis Logarithmically (see below)
N : write Numeric labels in the conventional location below the
viewport (X) or to the left of the viewport (Y)
P : extend ("Project") major tick marks outside the box (ignored
if option I is specified)
M : write numeric labels in the unconventional location above the
viewport (X) or to the right of the viewport (Y)
T : draw major Tick marks at the major coordinate interval
S : draw minor tick marks (Subticks)
V : orient numeric labels Vertically (only applicable to Y)
the default is to write Y-labels parallel to the axis
1 : force decimal labelling, instead of automatic choice
(see PGNUMB)
2 : force exponential labelling, instead of automatic
To get a complete frame, specify BC in both XOPT and YOPT.
Tick marks, if requested, are drawn on the axes or frame or both,
depending which are requested. If none of ABC is specified,
tick marks will not be drawn. When PGENV calls PGBOX, it sets both
XOPT and YOPT according to the value of its parameter AXIS:
-1: 'BC', 0: 'BCNST', 1: 'ABCNST', 2: 'ABCGNST'.
For a logarithmic axis, the major tick interval is always 1.0. The
numeric label is 10**(x) where x is the world coordinate at the
tick mark. If subticks are requested, 8 subticks are drawn between
each major tick at equal logarithmic intervals.
To label an axis with time (days, hours, minutes, seconds) or
angle (degrees, arcmin, arcsec), use routine PGTBOX.
PGCIRC -- draw a circle, using fill-area attributes
SUBROUTINE PGCIRC (XCENT, YCENT, RADIUS)
REAL XCENT, YCENT, RADIUS
Draw a circle. The action of this routine depends on the setting
of the Fill-Area Style attribute. If Fill-Area Style is SOLID
(the default), the interior of the circle is solid-filled using
the current Color Index. If Fill-Area Style is HOLLOW, the
outline of the circle is drawn using the current line attributes
(color index, line-style, and line-width).
Arguments:
XCENT (input) : world x-coordinate of the center of the circle
YCENT (input) : world y-coordinate of the center of the circle
RADIUS (input) : radius of circle (world coordinates)
PGCLOS -- close the selected graphics device
SUBROUTINE PGCLOS Close the currently selected graphics device. After the device has been closed, either another open device must be selected with PGSLCT or another device must be opened with PGOPEN before any further plotting can be done. If the call to PGCLOS is omitted, some or all of the plot may be lost. This routine was added to PGPLOT in Version 5.1.0. Older programs use PGEND instead. Arguments: none
PGCONB -- contour map of a 2D data array, with blanking
SUBROUTINE PGCONB (A, IDIM, JDIM, I1, I2, J1, J2, C, NC, TR, BLANK)
INTEGER IDIM, JDIM, I1, I2, J1, J2, NC
REAL A(IDIM,JDIM), C(*), TR(6), BLANK
Draw a contour map of an array. This routine is the same as PGCONS,
except that array elements that have the "magic value" defined by
argument BLANK are ignored, making gaps in the contour map. The
routine may be useful for data measured on most but not all of the
points of a grid.
Arguments:
A (input) : data array
IDIM (input) : first dimension of A
JDIM (input) : second dimension of A
I1,I2 (input) : range of first index to be contoured (inclusive)
J1,J2 (input) : range of second index to be contoured (inclusive)
C (input) : array of contour levels (in the same units as the
data in array A); dimension at least NC
NC (input) : number of contour levels (less than or equal to
dimension of C). The absolute value of this
argument is used (for compatibility with PGCONT,
where the sign of NC is significant)
TR (input) : array defining a transformation between the I,J
grid of the array and the world coordinates; the
world coordinates of the array point A(I,J) are
given by:
X = TR(1) + TR(2)*I + TR(3)*J
Y = TR(4) + TR(5)*I + TR(6)*J
usually TR(3) and TR(5) are zero - unless the
coordinate transformation involves a rotation
or shear
BLANK (input) : elements of array A that are exactly equal to
this value are ignored (blanked)
PGCONF -- fill between two contours
SUBROUTINE PGCONF (A, IDIM, JDIM, I1, I2, J1, J2, C1, C2, TR)
INTEGER IDIM, JDIM, I1, I2, J1, J2
REAL A(IDIM,JDIM), C1, C2, TR(6)
Shade the region between two contour levels of a function defined
on the nodes of a rectangular grid. The routine uses the current
fill attributes, hatching style (if appropriate), and color index.
If you want to both shade between contours and draw the contour
lines, call this routine first (once for each pair of levels) and
then call PGCONT (or PGCONS) to draw the contour lines on top of
the shading.
Note 1: This routine is not very efficient: it generates a polygon
fill command for each cell of the mesh that intersects the desired
area, rather than consolidating adjacent cells into a single polygon.
Note 2: If both contours intersect all four edges of a particular
mesh cell, the program behaves badly and may consider some parts
of the cell to lie in more than one contour range.
Note 3: If a contour crosses all four edges of a cell, this
routine may not generate the same contours as PGCONT or PGCONS
(these two routines may not agree either). Such cases are always
ambiguous and the routines use different approaches to resolving
the ambiguity.
Arguments:
A (input) : data array
IDIM (input) : first dimension of A
JDIM (input) : second dimension of A
I1,I2 (input) : range of first index to be contoured (inclusive)
J1,J2 (input) : range of second index to be contoured (inclusive)
C1, C2 (input) : contour levels; note that C1 must be less than C2
TR (input) : array defining a transformation between the I,J
grid of the array and the world coordinates; the
world coordinates of the array point A(I,J) are
given by:
X = TR(1) + TR(2)*I + TR(3)*J
Y = TR(4) + TR(5)*I + TR(6)*J
usually TR(3) and TR(5) are zero - unless the
coordinate transformation involves a rotation
or shear
PGCONL -- label contour map of a 2D data array
SUBROUTINE PGCONL (A, IDIM, JDIM, I1, I2, J1, J2, C, TR, LABEL,
INTVAL, MININT)
INTEGER IDIM, JDIM, I1, J1, I2, J2, INTVAL, MININT
REAL A(IDIM,JDIM), C, TR(6)
CHARACTER*(*) LABEL
Label a contour map drawn with routine PGCONT. Routine PGCONT
should be called first to draw the contour lines, then this
routine should be called to add the labels. Labels are written at
intervals along the contour lines, centered on the contour lines
with lettering aligned in the up-hill direction. Labels are opaque,
so a part of the underlying contour line is obscured by the label.
Labels use the current attributes (character height, line width,
color index, character font).
The first 9 arguments are the same as those supplied to PGCONT, and
should normally be identical to those used with PGCONT. Note that
only one contour level can be specified; tolabel more contours,
call PGCONL for each level.
The Label is supplied as a character string in argument LABEL.
The spacing of labels along the contour is specified by parameters
INTVAL and MININT. The routine follows the contour through the
array, counting the number of cells that the contour crosses. The
first label will be written in the MININT'th cell, and additional
labels will be written every INTVAL cells thereafter. A contour
that crosses less than MININT cells will not be labelled. Some
experimentation may be needed to get satisfactory results; a good
place to start is INTVAL=20, MININT=10.
Arguments:
A (input) : data array
IDIM (input) : first dimension of A
JDIM (input) : second dimension of A
I1, I2 (input) : range of first index to be contoured (inclusive)
J1, J2 (input) : range of second index to be contoured (inclusive)
C (input) : the level of the contour to be labelled (one of the
values given to PGCONT)
TR (input) : array defining a transformation between the I,J
grid of the array and the world coordinates; the
world coordinates of the array point A(I,J) are
given by:
X = TR(1) + TR(2)*I + TR(3)*J
Y = TR(4) + TR(5)*I + TR(6)*J
usually TR(3) and TR(5) are zero - unless the
coordinate transformation involves a rotation or
shear
LABEL (input) : character strings to be used to label the specified
contour. Leading and trailing blank spaces are
ignored
INTVAL (input) : spacing along the contour between labels, in
grid cells
MININT (input) : contours that cross less than MININT cells
will not be labelled
PGCONS -- contour map of a 2D data array (fast algorithm)
SUBROUTINE PGCONS (A, IDIM, JDIM, I1, I2, J1, J2, C, NC, TR)
INTEGER IDIM, JDIM, I1, I2, J1, J2, NC
REAL A(IDIM,JDIM), C(*), TR(6)
Draw a contour map of an array. The map is truncated if necessary
at the boundaries of the viewport. Each contour line is drawn
with the current line attributes (color index, style, and width).
This routine, unlike PGCONT, does not draw each
contour as a continuous line, but draws the straight line segments
composing each contour in a random order. It is thus not suitable
for use on pen plotters, and it usually gives unsatisfactory
results with dashed or dotted lines. It is, however, faster than
PGCONT, especially if several contour levels are drawn with one
call of PGCONS.
Arguments:
A (input) : data array
IDIM (input) : first dimension of A
JDIM (input) : second dimension of A
I1,I2 (input) : range of first index to be contoured (inclusive)
J1,J2 (input) : range of second index to be contoured (inclusive)
C (input) : array of contour levels (in the same units as the
data in array A); dimension at least NC
NC (input) : number of contour levels (less than or equal to
dimension of C); the absolute value of this
argument is used (for compatibility with PGCONT,
where the sign of NC is significant)
TR (input) : array defining a transformation between the I,J
grid of the array and the world coordinates; the
world coordinates of the array point A(I,J) are
given by:
X = TR(1) + TR(2)*I + TR(3)*J
Y = TR(4) + TR(5)*I + TR(6)*J
usually TR(3) and TR(5) are zero - unless the
coordinate transformation involves a rotation
or shear
PGCONT -- contour map of a 2D data array (contour-following)
SUBROUTINE PGCONT (A, IDIM, JDIM, I1, I2, J1, J2, C, NC, TR)
INTEGER IDIM, JDIM, I1, J1, I2, J2, NC
REAL A(IDIM,JDIM), C(*), TR(6)
Draw a contour map of an array. The map is truncated if necessary
at the boundaries of the viewport. Each contour line is drawn
with the current line attributes (color index, style, and width);
except that if argument NC is positive (see below), the line style
is set by PGCONT to 1 (solid) for positive contours or 2 (dashed)
for negative contours.
Arguments:
A (input) : data array
IDIM (input) : first dimension of A
JDIM (input) : second dimension of A
I1, I2 (input) : range of first index to be contoured (inclusive)
J1, J2 (input) : range of second index to be contoured (inclusive)
C (input) : array of NC contour levels; dimension at least NC
NC (input) : +/- number of contour levels (less than or equal
to dimension of C)
if NC is positive, it is the number of contour
levels, and the line-style is chosen
automatically as described above
if NC is negative, it is minus the number of
contour levels, and the current setting of
line-style is used for all the contours
TR (input) : array defining a transformation between the I,J
grid of the array and the world coordinates; the
world coordinates of the array point A(I,J) are
given by:
X = TR(1) + TR(2)*I + TR(3)*J
Y = TR(4) + TR(5)*I + TR(6)*J
usually TR(3) and TR(5) are zero - unless the
coordinate transformation involves a rotation
or shear
PGCONX -- contour map of a 2D data array (non rectangular)
SUBROUTINE PGCONX (A, IDIM, JDIM, I1, I2, J1, J2, C, NC, PLOT)
INTEGER IDIM, JDIM, I1, J1, I2, J2, NC
REAL A(IDIM,JDIM), C(*)
EXTERNAL PLOT
Draw a contour map of an array using a user-supplied plotting
routine. This routine should be used instead of PGCONT when the
data are defined on a non-rectangular grid. PGCONT permits only
a linear transformation between the (I,J) grid of the array
and the world coordinate system (x,y), but PGCONX permits any
transformation to be used, the transformation being defined by a
user-supplied subroutine. The nature of the contouring algorithm,
however, dictates that the transformation should maintain the
rectangular topology of the grid, although grid-points may be
allowed to coalesce. As an example of a deformed rectangular
grid, consider data given on the polar grid theta=0.1n(pi/2),
for n=0,1,...,10, and r=0.25m, for m=0,1,..,4. This grid contains
55 points, of which 11 are coincident at the origin. The input
array for PGCONX should be dimensioned (11,5), and data values
should be provided for all 55 elements. PGCONX can also be used
for special applications in which the height of the contour
affects its appearance, e.g., stereoscopic views.
The map is truncated if necessary at the boundaries of the viewport.
Each contour line is drawn with the current line attributes (color
index, style, and width); except that if argument NC is positive
(see below), the line style is set by PGCONX to 1 (solid) for
positive contours or 2 (dashed) for negative contours. Attributes
for the contour lines can also be set in the user-supplied
subroutine, if desired.
Arguments:
A (input) : data array
IDIM (input) : first dimension of A
JDIM (input) : second dimension of A
I1, I2 (input) : range of first index to be contoured (inclusive)
J1, J2 (input) : range of second index to be contoured (inclusive)
C (input) : array of NC contour levels; dimension at least NC
NC (input) : +/- number of contour levels (less than or equal
to dimension of C)
if NC is positive, it is the number of contour
levels, and the line-style is chosen
automatically as described above
if NC is negative, it is minus the number of
contour levels, and the current setting of
line-style is used for all the contours
PLOT (input) : the address (name) of a subroutine supplied by
the user, which will be called by PGCONX to do
the actual plotting; this must be declared
EXTERNAL in the program unit calling PGCONX
The subroutine PLOT will be called with four arguments:
CALL PLOT(VISBLE,X,Y,Z)
where X,Y (input) are real variables corresponding to I,J indices
of the array A. If VISBLE (input, integer) is 1, PLOT should draw
a visible line from the current pen position to the world coordinate
point corresponding to (X,Y); if it is 0, it should move the pen to
(X,Y). Z is the value of the current contour level, and may be used
by PLOT if desired.
Example:
SUBROUTINE PLOT (VISBLE,X,Y,Z)
REAL X, Y, Z, XWORLD, YWORLD
INTEGER VISBLE
XWORLD = X*COS(Y) ! this is the user-defined
YWORLD = X*SIN(Y) ! transformation
IF (VISBLE.EQ.0) THEN
CALL PGMOVE(XWORLD, YWORLD)
ELSE
CALL PGDRAW(XWORLD, YWORLD)
END IF
END
PGCTAB -- install the color table to be used by PGIMAG
SUBROUTINE PGCTAB(L, R, G, B, NC, CONTRA, BRIGHT)
INTEGER NC
REAL L(NC), R(NC), G(NC), B(NC), CONTRA, BRIGHT
Use the given color table to change the color representations of
all color indexes marked for use by PGIMAG. To change which
color indexes are thus marked, call PGSCIR before calling PGCTAB
or PGIMAG. On devices that can change the color representations
of previously plotted graphics, PGCTAB will also change the colors
of existing graphics that were plotted with the marked color
indexes. This feature can then be combined with PGBAND to
interactively manipulate the displayed colors of data previously
plotted with PGIMAG.
Limitations:
1. Some devices do not propagate color representation changes
to previously drawn graphics.
2. Some devices ignore requests to change color representations.
3. The appearance of specific color representations on grey-scale
devices is device-dependent.
Notes:
To reverse the sense of a color table, change the chosen contrast
and brightness to -CONTRA and 1-BRIGHT.
In the following, the term 'color table' refers to the input
L,R,G,B arrays, whereas 'color ramp' refers to the resulting
ramp of colors that would be seen with PGWEDG.
Arguments:
L (input) : array of NC normalized ramp-intensity levels
corresponding to the RGB primary color intensities
in R(),G(),B(). Colors on the ramp are linearly
interpolated from neighbouring levels
levels must be sorted in increasing order.
0.0 places a color at the beginning of the ramp
1.0 places a color at the end of the ramp
colors outside these limits are legal, but will
not be visible if CONTRA=1.0 and BRIGHT=0.5
R (input) : array of NC normalized red intensities
G (input) : array of NC normalized green intensities
B (input) : array of NC normalized blue intensities
NC (input) : number of color table entries
CONTRA (input) : contrast of the color ramp (normally 1.0)
negative values reverse the direction of the
ramp
BRIGHT (input) : brightness of the color ramp; this is normally
0.5, but can sensibly hold any value between
0.0 and 1.0; values at or beyond the latter two
extremes, saturate the color ramp with the
colors of the respective end of the color table
PGCURS -- read cursor position
INTEGER FUNCTION PGCURS (X, Y, CH)
REAL X, Y
CHARACTER*(*) CH
Read the cursor position and a character typed by the user.
The position is returned in world coordinates. PGCURS positions
the cursor at the position specified, allows the user to move the
cursor using the joystick or arrow keys or whatever is available on
the device. When he has positioned the cursor, the user types a
single character on the keyboard; PGCURS then returns this
character and the new cursor position (in world coordinates).
Returns:
PGCURS : 1 if the call was successful
0 if the device has no cursor or some other error occurs.
Arguments:
X (in/out) : the world x-coordinate of the cursor
Y (in/out) : the world y-coordinate of the cursor
CH (output) : the character typed by the user; if the device has
no cursor or if some other error occurs, the value
CHAR(0) (ASCII NUL character) is returned
Note: The cursor coordinates (X,Y) may be changed by PGCURS even
if the device has no cursor or if the user does not move the cursor.
Under these circumstances, the position returned in (X,Y) is that
of the pixel nearest to the requested position.
PGDRAW -- draw a line from the current pen position to a point
SUBROUTINE PGDRAW (X, Y)
REAL X, Y
Draw a line from the current pen position to the point with
world-coordinates (X,Y). The line is clipped at the edge of the
current window. The new pen position is (X,Y) in world coordinates.
Arguments:
X (input) : world x-coordinate of the end point of the line
Y (input) : world y-coordinate of the end point of the line
PGEBUF -- end batch of output (buffer)
SUBROUTINE PGEBUF A call to PGEBUF marks the end of a batch of graphical output begun with the last call of PGBBUF. PGBBUF and PGEBUF calls should always be paired. Each call to PGBBUF increments a counter, while each call to PGEBUF decrements the counter. When the counter reaches 0, the batch of output is written on the output device. Arguments: none
PGEND -- close all open graphics devices
SUBROUTINE PGEND Close and release any open graphics devices. All devices must be closed by calling either PGCLOS (for each device) or PGEND before the program terminates. If a device is not closed properly, some or all of the graphical output may be lost. Arguments: none
PGENV -- set window and viewport and draw labeled frame
SUBROUTINE PGENV (XMIN, XMAX, YMIN, YMAX, JUST, AXIS)
REAL XMIN, XMAX, YMIN, YMAX
INTEGER JUST, AXIS
Set PGPLOT "Plotter Environment". PGENV establishes the scaling
for subsequent calls to PGPT, PGLINE, etc. The plotter is
advanced to a new page or panel, clearing the screen if necessary.
If the "prompt state" is ON (see PGASK), confirmation is
requested from the user before clearing the screen. If requested,
a box, axes, labels, etc. are drawn according to the setting of
argument AXIS.
Arguments:
XMIN (input) : the world x-coordinate at the bottom left corner
of the viewport
XMAX (input) : the world x-coordinate at the top right corner
of the viewport (note XMAX may be less than XMIN)
YMIN (input) : the world y-coordinate at the bottom left corner
of the viewport
YMAX (input) : the world y-coordinate at the top right corner
of the viewport (note YMAX may be less than YMIN)
JUST (input) : if JUST=1, the scales of the x and y axes (in
world coordinates per inch) will be equal,
otherwise they will be scaled independently
AXIS (input) : controls the plotting of axes, tick marks, etc:
AXIS = -2 : draw no box, axes or labels
AXIS = -1 : draw box only
AXIS = 0 : draw box and label it with coordinates
AXIS = 1 : same as AXIS=0, but also draw the
coordinate axes (X=0, Y=0)
AXIS = 2 : same as AXIS=1, but also draw grid lines
at major increments of the coordinates
AXIS = 10 : draw box and label X-axis logarithmically
AXIS = 20 : draw box and label Y-axis logarithmically
AXIS = 30 : draw box and label both axes logarithmically
For other axis options, use routine PGBOX. PGENV can be
persuaded to call PGBOX with additional axis options by defining
an environment parameter PGPLOT_ENVOPT containing the required
option codes.
Examples:
PGPLOT_ENVOPT=P : draw Projecting tick marks
PGPLOT_ENVOPT=I : Invert the tick marks
PGPLOT_ENVOPT=IV : Invert tick marks and label y Vertically
PGERAS -- erase all graphics from current page
SUBROUTINE PGERAS Erase all graphics from the current page (or current panel, if the view surface has been divided into panels with PGSUBP). Arguments: none
PGERR1 -- horizontal or vertical error bar
SUBROUTINE PGERR1 (DIR, X, Y, E, T)
INTEGER DIR
REAL X, Y, E
REAL T
Plot a single error bar in the direction specified by DIR.
This routine draws an error bar only; to mark the data point at
the start of the error bar, an additional call to PGPT is required.
To plot many error bars, use PGERRB.
Arguments:
DIR (input) : direction to plot the error bar relative to the
data point
one-sided error bar:
DIR is 1 for +X (X to X+E)
2 for +Y (Y to Y+E)
3 for -X (X to X-E)
4 for -Y (Y to Y-E)
two-sided error bar:
DIR is 5 for +/-X (X-E to X+E)
6 for +/-Y (Y-E to Y+E)
X (input) : world X-coordinate of the data
Y (input) : world Y-coordinate of the data
E (input) : value of Error bar distance to be added to the
data position in world coordinates
T (input) : length of Terminals to be drawn at the ends of
the error bar, as a multiple of the default
length; if T = 0.0, no terminals will be drawn
PGERRB -- horizontal or vertical error bar
SUBROUTINE PGERRB (DIR, N, X, Y, E, T)
INTEGER DIR, N
REAL X(*), Y(*), E(*)
REAL T
Plot error bars in the direction specified by DIR.
This routine draws an error bar only; to mark the data point at
the start of the error bar, an additional call to PGPT is required.
Arguments:
DIR (input) : direction to plot the error bar relative to the
data point
one-sided error bar:
DIR is 1 for +X (X to X+E)
2 for +Y (Y to Y+E)
3 for -X (X to X-E)
4 for -Y (Y to Y-E)
two-sided error bar:
DIR is 5 for +/-X (X-E to X+E)
6 for +/-Y (Y-E to Y+E)
N (input) : Number of error bars to plot
X (input) : world X-coordinates of the data
Y (input) : world Y-coordinates of the data
E (input) : value of Error bar distance to be added to the
data position in world coordinates
T (input) : length of Terminals to be drawn at the ends of
the error bar, as a multiple of the default
length; if T = 0.0, no terminals will be drawn
Note: the dimension of arrays X, Y, and E must be greater than
or equal to N. If N is 1, X, Y, and E may be scalar variables,
or expressions.
PGERRX -- horizontal error bar
SUBROUTINE PGERRX (N, X1, X2, Y, T)
INTEGER N
REAL X1(*), X2(*), Y(*)
REAL T
Plot horizontal error bars.
This routine draws an error bar only; to mark the data point in
the middle of the error bar, an additional call to PGPT or PGERRY
is required.
Arguments:
N (input) : Number of error bars to plot
X1 (input) : world X-coordinates of lower end of the error bars
X2 (input) : world X-coordinates of upper end of the error bars
Y (input) : world Y-coordinates of the data
T (input) : length of Terminals to be drawn at the ends of the
error bar, as a multiple of the default length;
if T = 0.0, no terminals will be drawn
Note: the dimension of arrays X1, X2, and Y must be greater than
or equal to N. If N is 1, X1, X2, and Y may be scalar variables,
or expressions.
Example:
CALL PGERRX(1,X-SIGMA,X+SIGMA,Y)
PGERRY -- vertical error bar
SUBROUTINE PGERRY (N, X, Y1, Y2, T)
INTEGER N
REAL X(*), Y1(*), Y2(*)
REAL T
Plot vertical error bars.
This routine draws an error bar only; to mark the data point in
the middle of the error bar, an additional call to PGPT or PGERRX
is required.
Arguments:
N (input) : Number of error bars to plot
X (input) : world X-coordinates of the data
Y1 (input) : world Y-coordinates of top end of the error bars
Y2 (input) : world Y-coordinates of bottom end of the error bars
T (input) : length of Terminals to be drawn at the ends of the
error bar, as a multiple of the default length;
if T = 0.0, no terminals will be drawn
Note: the dimension of arrays X, Y1, and Y2 must be greater than
or equal to N. If N is 1, X, Y1, and Y2 may be scalar variables or
expressions.
Example:
CALL PGERRY(1,X,Y+SIGMA,Y-SIGMA)
PGETXT -- erase text from graphics display
SUBROUTINE PGETXT Some graphics terminals display text (the normal interactive dialog) on the same screen as graphics. This routine erases the text from the view surface without affecting the graphics. It does nothing on devices which do not display text on the graphics screen, and on devices which do not have this capability. Arguments: none
PGFUNT -- function defined by X = F(T), Y = G(T)
SUBROUTINE PGFUNT (FX, FY, N, TMIN, TMAX, PGFLAG)
REAL FX, FY
EXTERNAL FX, FY
INTEGER N
REAL TMIN, TMAX
INTEGER PGFLAG
Draw a curve defined by parametric equations X = FX(T), Y = FY(T).
Arguments:
FX (external real function): supplied by the user, evaluates
X-coordinate
FY (external real function): supplied by the user, evaluates
Y-coordinate
N (input) : the number of points required to define the
curve; the functions FX and FY will each be
called N+1 times
TMIN (input) : the minimum value for the parameter T
TMAX (input) : the maximum value for the parameter T
PGFLAG (input) : if PGFLAG = 1, the curve is plotted in the
current window and viewport; if PGFLAG = 0,
PGENV is called automatically by PGFUNT to
start a new plot with automatic scaling
Note: The functions FX and FY must be declared EXTERNAL in the
Fortran program unit that calls PGFUNT.
PGFUNX -- function defined by Y = F(X)
SUBROUTINE PGFUNX (FY, N, XMIN, XMAX, PGFLAG)
REAL FY
EXTERNAL FY
INTEGER N
REAL XMIN, XMAX
INTEGER PGFLAG
Draw a curve defined by the equation Y = FY(X), where FY is a
user-supplied subroutine.
Arguments:
FY (external real function): supplied by the user, evaluates
Y value at a given X-coordinate
N (input) : the number of points required to define the
curve. The function FY will be called N+1 times
if PGFLAG=0 and N is greater than 1000, 1000
will be used instead
if N is less than 1, nothing will be drawn
XMIN (input) : the minimum value of X
XMAX (input) : the maximum value of X
PGFLAG (input) : if PGFLAG = 1, the curve is plotted in the
current window and viewport; if PGFLAG = 0,
PGENV is called automatically by PGFUNX to
start a new plot with X limits (XMIN, XMAX)
and automatic scaling in Y
Note: The function FY must be declared EXTERNAL in the Fortran
program unit that calls PGFUNX. It has one argument, the
x-coordinate at which the y value is required.
Example:
REAL FUNCTION FY(X)
REAL X
FY = ...
END
PGFUNY -- function defined by X = F(Y)
SUBROUTINE PGFUNY (FX, N, YMIN, YMAX, PGFLAG)
REAL FX
EXTERNAL FX
INTEGER N
REAL YMIN, YMAX
INTEGER PGFLAG
Draw a curve defined by the equation X = FX(Y), where FY is a
user-supplied subroutine.
Arguments:
FX (external real function): supplied by the user, evaluates
X value at a given Y-coordinate
N (input) : the number of points required to define the
curve. The function FX will be called N+1 times.
if PGFLAG=0 and N is greater than 1000, 1000
will be used instead
if N is less than 1, nothing will be drawn
YMIN (input) : the minimum value of Y
YMAX (input) : the maximum value of Y
PGFLAG (input) : if PGFLAG = 1, the curve is plotted in the
current window and viewport; if PGFLAG = 0,
PGENV is called automatically by PGFUNY to
start a new plot with Y limits (YMIN, YMAX)
and automatic scaling in X
Note: The function FX must be declared EXTERNAL in the Fortran
program unit that calls PGFUNY. It has one argument, the
y-coordinate at which the x value is required.
Example:
REAL FUNCTION FX(Y)
REAL Y
FX = ...
END
PGGRAY -- gray-scale map of a 2D data array
SUBROUTINE PGGRAY (A, IDIM, JDIM, I1, I2, J1, J2,
FG, BG, TR)
INTEGER IDIM, JDIM, I1, I2, J1, J2
REAL A(IDIM,JDIM), FG, BG, TR(6)
Draw gray-scale map of an array in current window. The subsection
of the array A defined by indices (I1:I2, J1:J2) is mapped onto
the view surface world-coordinate system by the transformation
matrix TR. The resulting quadrilateral region is clipped at the
edge of the window and shaded with the shade at each point
determined by the corresponding array value. The shade is a
number in the range 0 to 1 obtained by linear interpolation
between the background level (BG) and the foreground level (FG),
i.e.,
shade = [A(i,j) - BG] / [FG - BG]
The background level BG can be either less than or greater than the
foreground level FG. Points in the array that are outside the
range BG to FG are assigned shade 0 or 1 as appropriate.
PGGRAY uses two different algorithms, depending how many color
indices are available in the color index range specified for images.
(This range is set with routine PGSCIR, and the current or default
range can be queried by calling routine PGQCIR).
If 16 or more color indices are available, PGGRAY first assigns
color representations to these color indices to give a linear ramp
between the background color (color index 0) and the foreground
color (color index 1), and then calls PGIMAG to draw the image
using these color indices. In this mode, the shaded region is
"opaque": every pixel is assigned a color.
If less than 16 color indices are available, PGGRAY uses only
color index 1, and uses a "dithering" algorithm to fill in pixels,
with the shade (computed as above) determining the faction of pixels
that are filled. In this mode the shaded region is "transparent"
and allows previously-drawn graphics to show through.
The transformation matrix TR is used to calculate the world
coordinates of the center of the "cell" that represents each
array element. The world coordinates of the center of the cell
corresponding to array element A(I,J) are given by:
X = TR(1) + TR(2)*I + TR(3)*J
Y = TR(4) + TR(5)*I + TR(6)*J
Usually TR(3) and TR(5) are zero -- unless the coordinate
transformation involves a rotation or shear. The corners of the
quadrilateral region that is shaded by PGGRAY are given by
applying this transformation to (I1-0.5,J1-0.5), (I2+0.5, J2+0.5).
Arguments:
A (input) : the array to be plotted
IDIM (input) : the first dimension of array A
JDIM (input) : the second dimension of array A
I1, I2 (input) : the inclusive range of the first index (I) to
be plotted
J1, J2 (input) : the inclusive range of the second index (J) to
be plotted
FG (input) : the array value which is to appear with the
foreground color (corresponding to color index 1)
BG (input) : the array value which is to appear with the
background color (corresponding to color index 0)
TR (input) : transformation matrix between array grid and
world coordinates
PGHI2D -- cross-sections through a 2D data array
SUBROUTINE PGHI2D (DATA, NXV, NYV, IX1, IX2, IY1, IY2, X, IOFF,
BIAS, CENTER, YLIMS)
INTEGER NXV, NYV, IX1, IX2, IY1, IY2
REAL DATA(NXV,NYV)
REAL X(IX2-IX1+1), YLIMS(IX2-IX1+1)
INTEGER IOFF
REAL BIAS
LOGICAL CENTER
Plot a series of cross-sections through a 2D data array.
Each cross-section is plotted as a hidden line histogram. The plot
can be slanted to give a pseudo-3D effect - if this is done, the
call to PGENV may have to be changed to allow for the increased X
range that will be needed.
Arguments:
DATA (input) : the data array to be plotted
NXV (input) : the first dimension of DATA
NYV (input) : the second dimension of DATA
IX1 (input)
IX2 (input)
IY1 (input)
IY2 (input) : PGHI2D plots a subset of the input array DATA
this subset is delimited in the first (x)
dimension by IX1 and IX2 and the 2nd (y) by IY1
and IY2, inclusively
note: IY2 < IY1 is permitted, resulting in a plot
with the cross-sections plotted in reverse Y order;
however, IX2 must be => IX1
X (input) : the abscissae of the bins to be plotted; that is,
X(1) should be the X value for DATA(IX1,IY1), and
X should have (IX2-IX1+1) elements; the program
has to assume that the X value for DATA(x,y) is
the same for all y
IOFF (input) : an offset in array elements applied to successive
cross-sections to produce a slanted effect; a plot
with IOFF > 0 slants to the right, one with
IOFF < 0 slants left
BIAS (input) : a bias value applied to each successive cross-
section in order to raise it above the previous
cross-section; this is in the same units as the
data
CENTER (input) : if .true., the X values denote the center of the
bins; if .false. the X values denote the lower
edges (in X) of the bins
YLIMS (input) : workspace; should be an array of at least
(IX2-IX1+1) elements
PGHIST -- histogram of unbinned data
SUBROUTINE PGHIST(N, DATA, DATMIN, DATMAX, NBIN, PGFLAG)
INTEGER N
REAL DATA(*)
REAL DATMIN, DATMAX
INTEGER NBIN, PGFLAG
Draw a histogram of N values of a variable in array DATA(1...N)
in the range DATMIN to DATMAX using NBIN bins. Note that array
elements which fall exactly on the boundary between two bins
will be counted in the higher bin rather than the lower one;
and array elements whose value is less than DATMIN or greater
than or equal to DATMAX will not be counted at all.
Arguments:
N (input) : the number of data values
DATA (input) : the data values
note: the dimension of array DATA must be
greater than or equal to N; the first N
elements of the array are used
DATMIN (input) : the minimum data value for the histogram
DATMAX (input) : the maximum data value for the histogram
NBIN (input) : the number of bins to use: the range DATMIN to
DATMAX is divided into NBIN equal bins and
the number of DATA values in each bin is
determined by PGHIST
NBIN may not exceed 200
PGFLAG (input) : if PGFLAG = 1, the histogram is plotted in the
current window and viewport; if PGFLAG = 0,
PGENV is called automatically by PGHIST to start
a new plot (the x-limits of the window will be
DATMIN and DATMAX; the y-limits will be chosen
automatically
if PGFLAG = 2,3 the histogram will be in the
same window and viewport but with a filled area
style
if PGFLAG = 4,5 as for PGFLAG = 0,1, but simple
line drawn as for PGBIN
PGIDEN -- write username, date, and time at bottom of plot
SUBROUTINE PGIDEN Write username, date, and time at bottom of plot. Arguments: none.
PGIMAG -- color image from a 2D data array
SUBROUTINE PGIMAG (A, IDIM, JDIM, I1, I2, J1, J2, A1, A2, TR)
INTEGER IDIM, JDIM, I1, I2, J1, J2
REAL A(IDIM,JDIM), A1, A2, TR(6)
Draw a color image of an array in current window. The subsection
of the array A defined by indices (I1:I2, J1:J2) is mapped onto
the view surface world-coordinate system by the transformation
matrix TR. The resulting quadrilateral region is clipped at the
edge of the window. Each element of the array is represented in
the image by a small quadrilateral, which is filled with a color
specified by the corresponding array value.
The subroutine uses color indices in the range C1 to C2, which can
be specified by calling PGSCIR before PGIMAG. The default values
for C1 and C2 are device-dependent; these values can be determined
by calling PGQCIR. Note that color representations should be
assigned to color indices C1 to C2 by calling PGSCR before calling
PGIMAG. On some devices (but not all), the color representation
can be changed after the call to PGIMAG by calling PGSCR again.
Array values in the range A1 to A2 are mapped on to the range of
color indices C1 to C2, with array values <= A1 being given color
index C1 and values >= A2 being given color index C2. The mapping
function for intermediate array values can be specified by
calling routine PGSITF before PGIMAG; the default is linear.
On devices which have no available color indices (C1 > C2), PGIMAG
will return without doing anything. On devices with only one color
index (C1=C2), all array values map to the same color which is
rather uninteresting. An image is always "opaque", i.e., it
obscures all graphical elements previously drawn in the region.
The transformation matrix TR is used to calculate the world
coordinates of the center of the "cell" that represents each array
element. The world coordinates of the center of the cell
corresponding to array element A(I,J) are given by:
X = TR(1) + TR(2)*I + TR(3)*J
Y = TR(4) + TR(5)*I + TR(6)*J
Usually TR(3) and TR(5) are zero -- unless the coordinate
transformation involves a rotation or shear. The corners of the
quadrilateral region that is shaded by PGIMAG are given by
applying this transformation to (I1-0.5,J1-0.5), (I2+0.5, J2+0.5).
Arguments:
A (input) : the array to be plotted
IDIM (input) : the first dimension of array A
JDIM (input) : the second dimension of array A
I1, I2 (input) : the inclusive range of the first index (I) to
be plotted
J1, J2 (input) : the inclusive range of the second index (J) to
be plotted
A1 (input) : the array value which is to appear with shade C1
A2 (input) : the array value which is to appear with shade C2
TR (input) : transformation matrix between array grid and
world coordinates
PGLAB -- write labels for x-axis, y-axis, and top of plot
SUBROUTINE PGLAB (XLBL, YLBL, TOPLBL)
CHARACTER*(*) XLBL, YLBL, TOPLBL
Write labels outside the viewport. This routine is a simple
interface to PGMTXT, which should be used if PGLAB is inadequate.
Arguments:
XLBL (input) : a label for the x-axis (centered below the
viewport)
YLBL (input) : a label for the y-axis (centered to the left
of the viewport, drawn vertically)
TOPLBL (input) : a label for the entire plot (centered above the
viewport)
PGLCUR -- draw a line using the cursor
SUBROUTINE PGLCUR (MAXPT, NPT, X, Y)
INTEGER MAXPT, NPT
REAL X(*), Y(*)
Interactive routine for user to enter a polyline by use of
the cursor. Routine allows user to Add and Delete vertices;
vertices are joined by straight-line segments.
Arguments:
MAXPT (input) : maximum number of points that may be accepted
NPT (in/out) : number of points entered; should be zero on
first call
X (in/out) : array of x-coordinates (dimension at least MAXPT)
Y (in/out) : array of y-coordinates (dimension at least MAXPT)
Notes:
(1) On return from the program, cursor points are returned in the
order they were entered. Routine may be (re-)called with points
already defined in X,Y (# in NPT), and they will be plotted
first, before editing.
(2) User commands: the user types single-character commands after
positioning the cursor: the following are accepted:
A (Add) : add point at current cursor location
D (Delete) : delete last-entered point
X (eXit) : leave subroutine
PGLDEV -- list available device types on standard output
SUBROUTINE PGLDEV Writes (to standard output) a list of all device types available in the current PGPLOT installation. Arguments: none.
PGLEN -- find length of a string in a variety of units
SUBROUTINE PGLEN (UNITS, STRING, XL, YL)
REAL XL, YL
INTEGER UNITS
CHARACTER*(*) STRING
Work out length of a string in x and y directions
Arguments:
UNITS (input) : 0 answer in normalized device coordinates
1 answer in inches
2 answer in mm
3 answer in absolute device coordinates (dots)
4 answer in world coordinates
5 answer as a fraction of the current viewport size
STRING (input) : string of interest
XL (output) : length of string in x direction
YL (output) : length of string in y direction
PGLINE -- draw a polyline (curve defined by line-segments)
SUBROUTINE PGLINE (N, XPTS, YPTS)
INTEGER N
REAL XPTS(*), YPTS(*)
Primitive routine to draw a Polyline. A polyline is one or more
connected straight-line segments. The polyline is drawn using
the current setting of attributes color-index, line-style, and
line-width. The polyline is clipped at the edge of the window.
Arguments:
N (input) : number of points defining the line; the line
consists of (N-1) straight-line segments
N should be greater than 1 (if it is 1 or less,
nothing will be drawn)
XPTS (input) : world x-coordinates of the points
YPTS (input) : world y-coordinates of the points
The dimension of arrays X and Y must be greater than or equal to N.
The "pen position" is changed to (X(N),Y(N)) in world coordinates
(if N > 1).
PGMOVE -- move pen (change current pen position)
SUBROUTINE PGMOVE (X, Y)
REAL X, Y
Primitive routine to move the "pen" to the point with world
coordinates (X,Y). No line is drawn.
Arguments:
X (input) : world x-coordinate of the new pen position
Y (input) : world y-coordinate of the new pen position
PGMTXT -- write text at position relative to viewport
SUBROUTINE PGMTXT (SIDE, DISP, COORD, FJUST, TEXT)
CHARACTER*(*) SIDE, TEXT
REAL DISP, COORD, FJUST
Write text at a position specified relative to the viewport
(outside or inside). This routine is useful for annotating graphs.
It is used by routine PGLAB. The text is written using the current
values of attributes color-index, line-width, character-height,
and character-font.
Arguments:
SIDE (input) : must include one of the characters 'B', 'L', 'T',
or 'R' signifying the Bottom, Left, Top, or Right
margin of the viewport
if it includes 'LV' or 'RV', the string is written
perpendicular to the frame rather than parallel
to it
DISP (input) : the displacement of the character string from the
specified edge of the viewport, measured outwards
from the viewport in units of the character
height; use a negative value to write inside the
viewport, a positive value to write outside
COORD (input) : the location of the character string along the
specified edge of the viewport, as a fraction of
the length of the edge
FJUST (input) : controls justification of the string parallel to
the specified edge of the viewport
if FJUST = 0.0, the left-hand end of the string
will be placed at COORD
if JUST = 0.5, the center of the string will be
placed at COORD
if JUST = 1.0, the right-hand end of the string
will be placed at at COORD
other values between 0 and 1 give intermediate
placing, but they are not very useful
TEXT (input) : the text string to be plotted; trailing spaces
are ignored when justifying the string, but
leading spaces are significant.
PGNCUR -- mark a set of points using the cursor
SUBROUTINE PGNCUR (MAXPT, NPT, X, Y, SYMBOL)
INTEGER MAXPT, NPT
REAL X(*), Y(*)
INTEGER SYMBOL
Interactive routine for user to enter data points by use of the
cursor. Routine allows user to Add and Delete points. The points
are returned in order of increasing x-coordinate, not in the
order they were entered.
Arguments:
MAXPT (input) : maximum number of points that may be accepted
NPT (in/out) : number of points entered; should be zero on first
call
X (in/out) : array of x-coordinates
Y (in/out) : array of y-coordinates
SYMBOL (input) : code number of symbol to use for marking
entered points (see PGPT)
Notes:
(1) The dimension of arrays X and Y must be greater than or
equal to MAXPT.
(2) On return from the program, cursor points are returned in
increasing order of X. Routine may be (re-)called with points
already defined in X,Y (number in NPT), and they will be
plotted first, before editing.
(3) User commands: the user types single-character commands after
positioning the cursor: the following are accepted:
A (Add) : add point at current cursor location
D (Delete) : delete nearest point to cursor
X (eXit) : leave subroutine
PGNUMB -- convert a number into a plottable character string
SUBROUTINE PGNUMB (MM, PP, FORM, STRING, NC)
INTEGER MM, PP, FORM
CHARACTER*(*) STRING
INTEGER NC
This routine converts a number into a decimal character
representation. To avoid problems of floating-point roundoff,
the number must be provided as an integer (MM) multiplied by a
power of 10 (10**PP). The output string retains only significant
digits of MM, and will be in either integer format (123), decimal
format (0.0123), or exponential format (1.23x10**5). Standard
escape sequences \u, \d raise the exponent and \x is used for the
multiplication sign. This routine is used by PGBOX to create
numeric labels for a plot.
Formatting rules:
(a) Decimal notation (FORM=1):
- Trailing zeros to the right of the decimal sign are
omitted
- The decimal sign is omitted if there are no digits to the
right of it
- When the decimal sign is placed before the first digit
of the number, a zero is placed before the decimal sign
- The decimal sign is a period (.)
- No spaces are placed between digits (ie digits are not
grouped in threes as they should be)
- A leading minus (-) is added if the number is negative
(b) Exponential notation (FORM=2):
- The exponent is adjusted to put just one (non-zero)
digit before the decimal sign
- The mantissa is formatted as in (a), unless its value is
1 in which case it and the multiplication sign are omitted
- If the power of 10 is not zero and the mantissa is not
zero, an exponent of the form \x10\u[-]nnn is appended,
where \x is a multiplication sign (cross), \u is an escape
sequence to raise the exponent, and as many digits nnn
are used as needed
(c) Automatic choice (FORM=0):
Decimal notation is used if the absolute value of the
number is less than 10000 or greater than or equal to
0.01. Otherwise exponential notation is used.
Arguments:
MM (input)
PP (input) : the value to be formatted is MM*10**PP.
FORM (input) : controls how the number is formatted:
FORM = 0 use either decimal or exponential
FORM = 1 use decimal notation
FORM = 2 use exponential notation
STRING (output) : the formatted character string, left justified
if the length of STRING is insufficient, a
single asterisk is returned, and NC=1
NC (output) : the number of characters used in STRING:
the string to be printed is STRING(1:NC)
PGOLIN -- mark a set of points using the cursor
SUBROUTINE PGOLIN (MAXPT, NPT, X, Y, SYMBOL)
INTEGER MAXPT, NPT
REAL X(*), Y(*)
INTEGER SYMBOL
Interactive routine for user to enter data points by use of the
cursor. Routine allows user to Add and Delete points. The points
are returned in the order that they were entered (unlike PGNCUR).
Arguments:
MAXPT (input) : maximum number of points that may be accepted
NPT (in/out) : number of points entered; should be zero on
first call
X (in/out) : array of x-coordinates
Y (in/out) : array of y-coordinates
SYMBOL (input) : code number of symbol to use for marking
entered points (see PGPT)
Notes:
(1) The dimension of arrays X and Y must be greater than or
equal to MAXPT.
(2) On return from the program, cursor points are returned in the
order they were entered. Routine may be (re-)called with
points already defined in X,Y (number in NPT), and they will
be plotted first, before editing.
(3) User commands: the user types single-character commands after
positioning the cursor: the following are accepted:
A (Add) : add point at current cursor location
D (Delete) : delete the last point entered
X (eXit) : leave subroutine
PGOPEN -- open a graphics device
INTEGER FUNCTION PGOPEN (DEVICE)
CHARACTER*(*) DEVICE
Open a graphics device for PGPLOT output. If the device is
opened successfully, it becomes the selected device to which
graphics output is directed until another device is selected
with PGSLCT or the device is closed with PGCLOS.
The value returned by PGOPEN should be tested to ensure that
the device was opened successfully.
Example:
ISTAT = PGOPEN ('plot.ps/PS')
IF (ISTAT .LE. 0 ) STOP
Note that PGOPEN must be declared INTEGER in the calling program.
The DEVICE argument is a character constant or variable; its value
should be one of the following:
(1) A complete device specification of the form 'device/type' or
'file/type', where 'type' is one of the allowed PGPLOT device
types (installation-dependent) and 'device' or 'file' is the
name of a graphics device or disk file appropriate for this
type. The 'device' or 'file' may contain '/' characters; the
final '/' delimits the 'type'. If necessary to avoid ambiguity,
the 'device' part of the string may be enclosed in double
quotation marks.
(2) A device specification of the form '/type', where 'type' is one
of the allowed PGPLOT device types. PGPLOT supplies a default
file or device name appropriate for this device type.
(3) A device specification with '/type' omitted; in this case
the type is taken from the environment variable PGPLOT_TYPE,
if defined (e.g., setenv PGPLOT_TYPE PS). Because of possible
confusion with '/' in file-names, omitting the device type
in this way is not recommended.
(4) A blank string (' '); in this case, PGOPEN will use the value
of environment variable PGPLOT_DEV as the device specification,
or '/NULL' if the environment variable is undefined.
(5) A single question mark, with optional trailing spaces ('?');
in this case, PGPLOT will prompt the user to supply the device
specification, with a prompt string of the form:
Graphics device/type (? to see list, default XXX):
where XXX is the default (value of environment variable
PGPLOT_DEV).
(6) A non-blank string in which the first character is a question
mark (e.g., '?Device: '); in this case, PGPLOT will prompt the
user to supply the device specification, using the supplied
string as the prompt (without the leading question mark but
including any trailing spaces).
In cases (5) and (6), the device specification is read from the
standard input. The user should respond to the prompt with a device
specification of the form (1), (2), or (3). If the user types a
question-mark in response to the prompt, a list of available device
types is displayed and the prompt is re-issued. If the user supplies
an invalid device specification, the prompt is re-issued. If the
user responds with an end-of-file character, e.g., ctrl-D in UNIX,
program execution is aborted; this avoids the possibility of an
infinite prompting loop. A programmer should avoid use of
PGPLOT-prompting if this behavior is not desirable.
The device type is case-insensitive (e.g., '/ps' and '/PS' are
equivalent). The device or file name may be case-sensitive in some
operating systems.
Examples of valid DEVICE arguments:
(1) 'plot.ps/ps', 'dir/plot.ps/ps', '"dir/plot.ps"/ps',
'user:[tjp.plots]plot.ps/PS'
(2) '/ps' (PGPLOT interprets this as 'pgplot.ps/ps')
(3) 'plot.ps' (if PGPLOT_TYPE is defined as 'ps', PGPLOT
interprets this as 'plot.ps/ps')
(4) ' ' (if PGPLOT_DEV is defined)
(5) '? '
(6) '?Device specification for PGPLOT: '
This routine was added to PGPLOT in Version 5.1.0. Older programs
use PGBEG instead.
Returns:
PGOPEN : returns either a positive value, the identifier of the
graphics device for use with PGSLCT, or a 0 or negative
value indicating an error. In the event of error a
message is written on the standard error unit.
Arguments:
DEVICE (input) : the 'device specification' for the plot device
(see above).
PGPAGE -- advance to new page
SUBROUTINE PGPAGE Advance plotter to a new page or panel, clearing the screen if necessary. If the "prompt state" is ON (see PGASK), confirmation is requested from the user before clearing the screen. If the view surface has been subdivided into panels with PGBEG or PGSUBP, then PGPAGE advances to the next panel, and if the current panel is the last on the page, PGPAGE clears the screen or starts a new sheet of paper. PGPAGE does not change the PGPLOT window or the viewport (in normalized device coordinates); but note that if the size of the view-surface is changed externally (e.g., by a workstation window manager) the size of the viewport is changed in proportion. Arguments: none
PGPANL -- switch to a different panel on the view surface
SUBROUTINE PGPANL(IX, IY)
INTEGER IX, IY
Start plotting in a different panel. If the view surface has been
divided into panels by PGBEG or PGSUBP, this routine can be used
to move to a different panel. Note that PGPLOT does not remember
what viewport and window were in use in each panel; these should
be reset if necessary after calling PGPANL. Nor does PGPLOT clear
the panel: call PGERAS after calling PGPANL to do this.
Arguments:
IX (input) : the horizontal index of the panel (in the range
1 <= IX <= number of panels in horizontal
direction)
IY (input) : the vertical index of the panel (in the range
1 <= IY <= number of panels in horizontal
direction)
PGPAP -- change the size of the view surface
SUBROUTINE PGPAP (WIDTH, ASPECT)
REAL WIDTH, ASPECT
This routine changes the size of the view surface ("paper size")
to a specified width and aspect ratio (height/width), in so far as
this is possible on the specific device. It is always possible to
obtain a view surface smaller than the default size; on some
devices (e.g., printers that print on roll or fan-feed paper) it
is possible to obtain a view surface larger than the default.
This routine should be called either immediately after PGBEG or
immediately before PGPAGE. The new size applies to all subsequent
images until the next call to PGPAP.
Arguments:
WIDTH (input) : the requested width of the view surface in
inches; if WIDTH=0.0, PGPAP will obtain the
largest view surface available consistent with
argument ASPECT(1 inch = 25.4 mm)
ASPECT (input) : the aspect ratio (height/width) of the view
surface; e.g., ASPECT=1.0 gives a square view
surface, ASPECT=0.618 gives a horizontal
rectangle, ASPECT=1.618 gives a vertical
rectangle
PGPIXL -- draw pixels
SUBROUTINE PGPIXL (IA, IDIM, JDIM, I1, I2, J1, J2, X1, X2, Y1, Y2)
INTEGER IDIM, JDIM, I1, I2, J1, J2
INTEGER IA(IDIM,JDIM)
REAL X1, X2, Y1, Y2
Draw lots of solid-filled (tiny) rectangles aligned with the
coordinate axes. Best performance is achieved when output is
directed to a pixel-oriented device and the rectangles coincide
with the pixels on the device. In other cases, pixel output is
emulated.
The subsection of the array IA defined by indices (I1:I2, J1:J2) is
mapped onto world-coordinate rectangle defined by X1, X2, Y1 and Y2.
This rectangle is divided into (I2 - I1 + 1) * (J2 - J1 + 1) small
rectangles. Each of these small rectangles is solid-filled with
the color index specified by the corresponding element of IA.
On most devices, the output region is "opaque", i.e., it obscures
all graphical elements previously drawn in the region. But on
devices that do not have erase capability, the background shade
is "transparent" and allows previously-drawn graphics to show
through.
Arguments:
IA (input) : the array to be plotted
IDIM (input) : the first dimension of array A
JDIM (input) : the second dimension of array A
I1, I2 (input) : the inclusive range of the first index(I)
to be plotted
J1, J2 (input) : the inclusive range of the second index (J)
to be plotted
X1, Y1 (input) : world coordinates of one corner of the output
region
X2, Y2 (input) : world coordinates of the opposite corner of the
output region
PGPNTS -- draw several graph markers, not all the same
SUBROUTINE PGPNTS (N, X, Y, SYMBOL, NS)
INTEGER N, NS
REAL X(*), Y(*)
INTEGER SYMBOL(*)
Draw Graph Markers. Unlike PGPT, this routine can draw a different
symbol at each point. The markers are drawn using the current values
of attributes color-index, line-width, and character-height
(character-font applies if the symbol number is >31). If the point
to be marked lies outside the window, no marker is drawn. The "pen
position" is changed to (XPTS(N),YPTS(N)) in world coordinates
(if N > 0).
Arguments:
N (input) : number of points to mark.
X (input) : world x-coordinate of the points.
Y (input) : world y-coordinate of the points.
SYMBOL (input) : code number of the symbol to be plotted at each
point (see PGPT)
NS (input) : number of values in the SYMBOL array
if NS <= N, then the first NS points are drawn
using the value of SYMBOL(I) at (X(I), Y(I)) and
SYMBOL(1) for all the values of (X(I), Y(I))
where I > NS
Note: the dimension of arrays X and Y must be greater than or equal
to N and the dimension of the array SYMBOL must be greater than or
equal to NS. If N is 1, X and Y may be scalars (constants or
variables). If NS is 1, then SYMBOL may be a scalar. If N is
less than 1, nothing is drawn.
PGPOLY -- draw a polygon, using fill-area attributes
SUBROUTINE PGPOLY (N, XPTS, YPTS)
INTEGER N
REAL XPTS(*), YPTS(*)
Fill-area primitive routine: shade the interior of a closed
polygon in the current window. The action of this routine depends
on the setting of the Fill-Area Style attribute (see PGSFS). The
polygon is clipped at the edge of the window. The pen position is
changed to (XPTS(1),YPTS(1)) in world coordinates (if N > 1).
If the polygon is not convex, a point is assumed to lie inside the
polygon if a straight line drawn to infinity intersects and odd
number of the polygon's edges.
Arguments:
N (input) : number of points defining the polygon; the line
consists of N straight-line segments, joining
points 1 to 2, 2 to 3,... N-1 to N, N to 1
N should be greater than 2 (if it is 2 or less,
nothing will be drawn)
XPTS (input) : world x-coordinates of the vertices
YPTS (input) : world y-coordinates of the vertices
note: the dimension of arrays XPTS and YPTS must
be greater than or equal to N
PGPT -- draw several graph markers
SUBROUTINE PGPT (N, XPTS, YPTS, SYMBOL)
INTEGER N
REAL XPTS(*), YPTS(*)
INTEGER SYMBOL
Primitive routine to draw Graph Markers (polymarker). The markers
are drawn using the current values of attributes color-index,
line-width, and character-height (character-font applies if the
symbol number is >31). If the point to be marked lies outside
the window, no marker is drawn. The "pen position" is changed to
(XPTS(N),YPTS(N)) in world coordinates (if N > 0).
Arguments:
N (input) : number of points to mark
XPTS (input) : world x-coordinates of the points
YPTS (input) : world y-coordinates of the points
SYMBOL (input) : code number of the symbol to be drawn at each
point:
-1, -2 : a single dot (diameter = current
line width)
-3..-31 : a regular polygon with ABS(SYMBOL)
edges (style set by current fill style).
0..31 : standard marker symbols
32..127 : ASCII characters (in current font)
e.g. to use letter F as a marker, let
SYMBOL = ICHAR('F')
> 127 : a Hershey symbol number
Note: the dimension of arrays X and Y must be greater than or equal
to N. If N is 1, X and Y may be scalars (constants or variables).
If N is less than 1, nothing is drawn.
PGPT1 -- draw one graph marker
SUBROUTINE PGPT1 (XPT, YPT, SYMBOL)
REAL XPT, YPT
INTEGER SYMBOL
Primitive routine to draw a single Graph Marker at a specified
point. The marker is drawn using the current values of attributes
color-index, line-width, and character-height (character-font
applies if the symbol number is >31). If the point to be marked
lies outside the window, no marker is drawn. The "pen position" is
changed to (XPT,YPT) in world coordinates.
To draw several markers with coordinates specified by X and Y
arrays, use routine PGPT.
Arguments:
XPT (input) : world x-coordinate of the point
YPT (input) : world y-coordinate of the point
SYMBOL (input) : code number of the symbol to be drawn:
-1, -2 : a single dot (diameter = current
line width)
-3..-31 : a regular polygon with ABS(SYMBOL)
edges (style set by current fill style)
0..31 : standard marker symbols
32..127 : ASCII characters (in current font)
e.g. to use letter F as a marker, let
SYMBOL = ICHAR('F')
> 127 : a Hershey symbol number
PGPTXT -- write text at arbitrary position and angle
SUBROUTINE PGPTXT (X, Y, ANGLE, FJUST, TEXT)
REAL X, Y, ANGLE, FJUST
CHARACTER*(*) TEXT
Primitive routine for drawing text. The text may be drawn at any
angle with the horizontal, and may be centered or left- or right-
justified at a specified position. Routine PGTEXT provides a
simple interface to PGPTXT for horizontal strings. Text is drawn
using the current values of attributes color-index, line-width,
character-height, and character-font. Text is NOT subject to
clipping at the edge of the window.
Arguments:
X (input) : world x-coordinate
Y (input) : world y-coordinate; the string is drawn with the
baseline of all the characters passing through
point (X,Y); the positioning of the string along
this line is controlled by argument FJUST
ANGLE (input) : angle, in degrees, that the baseline is to make
with the horizontal, increasing counter-clockwise
(0.0 is horizontal)
FJUST (input) : controls horizontal justification of the string
if FJUST = 0.0, the string will be left-justified
at the point (X,Y)
if FJUST = 0.5, it will be centered
if FJUST = 1.0, it will be right justified
other values of FJUST give other justifications
TEXT (input) : the character string to be plotted
PGQAH -- inquire arrow-head style
SUBROUTINE PGQAH (FS, ANGLE, BARB)
INTEGER FS
REAL ANGLE, BARB
Query the style to be used for arrowheads drawn with routine PGARRO.
Argument:
FS (output) : FS = 1 filled
FS = 2 outline
ANGLE (output) : the acute angle of the arrow point, in degrees
BARB (output) : the fraction of the triangular arrow-head that
is cut away from the back
PGQCF -- inquire character font
SUBROUTINE PGQCF (FONT)
INTEGER FONT
Query the current Character Font set by routine PGSCF.
Argument:
FONT (output) : the current font number (in range 1-4)
PGQCH -- inquire character height
SUBROUTINE PGQCH (SIZE)
REAL SIZE
Query the Character Size attribute set by routine PGSCH.
Argument:
SIZE (output) : current character size (dimensionless multiple of
the default size)
PGQCI -- inquire color index
SUBROUTINE PGQCI (CI)
INTEGER CI
Query the Color Index attribute set by routine PGSCI.
Argument:
CI (output) : the current color index (in range 0-max); this is
the color index actually in use, and may differ
from the color index last requested by PGSCI if
that index is not available on the output device
PGQCIR -- inquire color index range
SUBROUTINE PGQCIR(ICILO, ICIHI)
INTEGER ICILO, ICIHI
Query the color index range to be used for producing images with
PGGRAY or PGIMAG, as set by routine PGSCIR or by device default.
Arguments:
ICILO (output) : the lowest color index to use for images
ICIHI (output) : the highest color index to use for images
PGQCLP -- inquire clipping status
SUBROUTINE PGQCLP(STATE)
INTEGER STATE
Query the current clipping status set by routine PGSCLP.
Argument:
STATE (output) : receives the clipping status (0 => disabled,
1 => enabled)
PGQCOL -- inquire color capability
SUBROUTINE PGQCOL (CI1, CI2)
INTEGER CI1, CI2
Query the range of color indices available on the current device.
Argument:
CI1 (output) : the minimum available color index. This will be
either 0 if the device can write in the
background color, or 1 if not
CI2 (output) : the maximum available color index. This will be
1 if the device has no color capability, or a
larger number (e.g., 3, 7, 15, 255)
PGQCR -- inquire color representation
SUBROUTINE PGQCR (CI, CR, CG, CB)
INTEGER CI
REAL CR, CG, CB
Query the RGB colors associated with a color index.
Arguments:
CI (input) : color index
CR (output) : red, green and blue intensities
CG (output) (in the range 0.0 to 1.0)
CB (output)
PGQCS -- inquire character height in a variety of units
SUBROUTINE PGQCS(UNITS, XCH, YCH)
INTEGER UNITS
REAL XCH, YCH
Return the current PGPLOT character height in a variety of units.
This routine provides facilities that are not available via PGQCH.
Use PGQCS if the character height is required in units other than
those used in PGSCH.
The PGPLOT "character height" is a dimension that scales with the
size of the view surface and with the scale-factor specified with
routine PGSCH. The default value is 1/40th of the height or width
of the view surface (whichever is less); this value is then
multiplied by the scale-factor supplied with PGSCH. Note that it
is a nominal height only; the actual character size depends on the
font and is usually somewhat smaller.
Arguments:
UNITS (input) : used to specify the units of the output value:
UNITS = 0 : normalized device coordinates
UNITS = 1 : inches
UNITS = 2 : millimeters
UNITS = 3 : pixels
UNITS = 4 : world coordinates
other values give an error message, and are
treated as 0.
XCH (output) : the character height for text written with a
vertical baseline.
YCH (output) : the character height for text written with a
horizontal baseline (the usual case).
The character height is returned in both XCH and YCH.
If UNITS=1 or UNITS=2, XCH and YCH both receive the same value.
If UNITS=3, XCH receives the height in horizontal pixel units, and
YCH receives the height in vertical pixel units; on devices for
which the pixels are not square, XCH and YCH will be different.
If UNITS=4, XCH receives the height in horizontal world coordinates
(as used for the x-axis), and YCH receives the height in vertical
world coordinates (as used for the y-axis). Unless special care
has been taken to achive equal world-coordinate scales on both axes,
the values of XCH and YCH will be different.
If UNITS=0, XCH receives the character height as a fraction of the
horizontal dimension of the view surface, and YCH receives the
character height as a fraction of the vertical dimension of the
view surface.
PGQDT -- inquire name of nth available device type
SUBROUTINE PGQDT(N, TYPE, TLEN, DESCR, DLEN, INTER)
INTEGER N
CHARACTER*(*) TYPE, DESCR
INTEGER TLEN, DLEN, INTER
Return the name of the Nth available device type as a character
string. The number of available types can be determined by calling
PGQNDT. If the value of N supplied is outside the range from 1 to
the number of available types, the routine returns DLEN=TLEN=0.
Arguments:
N (input) : the number of the device type (1..maximum)
TYPE (output) : receives the character device-type code of the
Nth device type; the argument supplied should
be large enough for at least 8 characterst; the
first character in the string is a '/' character
TLEN (output) : receives the number of characters in TYPE,
excluding trailing blanks
DESCR (output) : receives a description of the device type; the
argument supplied should be large enough for at
least 64 characters
DLEN (output) : receives the number of characters in DESCR,
excluding trailing blanks
INTER (output) : receives 1 if the device type is an interactive
one, 0 otherwise
PGQFS -- inquire fill-area style
SUBROUTINE PGQFS (FS)
INTEGER FS
Query the current Fill-Area Style attribute set by routine PGSFS.
Argument:
FS (output) : the current fill-area style:
FS = 1 solid (default)
FS = 2 outline
FS = 3 hatched
FS = 4 cross-hatched
PGQHS -- inquire hatching style
SUBROUTINE PGQHS (ANGLE, SEPN, PHASE)
REAL ANGLE, SEPN, PHASE
Query the style to be used hatching (fill area with fill-style 3).
Arguments:
ANGLE (output) : the angle the hatch lines make with the
horizontal, in degrees, increasing
counterclockwise (this is an angle on the
view surface, not in world-coordinate space)
SEPN (output) : the spacing of the hatch lines. The unit spacing
is 1 percent of the smaller of the height or
width of the view surface
PHASE (output) : a real number between 0 and 1; the hatch lines
are displaced by this fraction of SEPN from a
fixed reference. Adjacent regions hatched with the
same PHASE have contiguous hatch lines
PGQID -- inquire current device identifier
SUBROUTINE PGQID (ID)
INTEGER ID
This subroutine returns the identifier of the currently selected
device, or 0 if no device is selected. The identifier is assigned
when PGOPEN is called to open the device, and may be used as an
argument to PGSLCT. Each open device has a different identifier.
This routine was added to PGPLOT in Version 5.1.0.
Argument:
ID (output) : the identifier of the current device, or 0 if
no device is currently selected
PGQINF -- inquire PGPLOT general information
SUBROUTINE PGQINF (ITEM, VALUE, LENGTH)
CHARACTER*(*) ITEM, VALUE
INTEGER LENGTH
This routine can be used to obtain miscellaneous information about
the PGPLOT environment. Input is a character string defining the
information required, and output is a character string containing
the requested information.
The following item codes are accepted (note that the strings must
match exactly, except for case, but only the first 8 characters are
significant). For items marked *, PGPLOT must be in the OPEN state
for the inquiry to succeed. If the inquiry is unsuccessful, either
because the item code is not recognized or because the information
is not available, a question mark ('?') is returned.
'VERSION' version of PGPLOT software in use
'STATE' status of PGPLOT ('OPEN' if a graphics device
is open for output, 'CLOSED' otherwise)
'USER' the username associated with the calling program
'NOW' current date and time (e.g., '17-FEB-1986 10:04')
'DEVICE' * current PGPLOT device or file
'FILE' * current PGPLOT device or file
'TYPE' * device-type of the current PGPLOT device
'DEV/TYPE' * current PGPLOT device and type, in a form which is
acceptable as an argument for PGBEG
'HARDCOPY' * is the current device a hardcopy device?
('YES' or 'NO')
'TERMINAL' * is the current device the user's interactive terminal?
('YES' or 'NO')
'CURSOR' * does the current device have a graphics cursor?
('YES' or 'NO')
'SCROLL' * does current device have rectangle-scroll capability
('YES' or 'NO'); see PGSCRL
Arguments:
ITEM (input) : character string defining the information to
be returned; see above for a list of possible
values.
VALUE (output) : returns a character-string containing the
requested information, truncated to the length
of the supplied string or padded on the right with
spaces if necessary.
LENGTH (output) : the number of characters returned in VALUE
(excluding trailing blanks).
PGQITF -- inquire image transfer function
SUBROUTINE PGQITF (ITF)
INTEGER ITF
Return the Image Transfer Function as set by default or by a
previous call to PGSITF. The Image Transfer Function is used by
routines PGIMAG, PGGRAY, and PGWEDG.
Argument:
ITF (output) : type of transfer function (see PGSITF)
PGQLS -- inquire line style
SUBROUTINE PGQLS (LS)
INTEGER LS
Query the current Line Style attribute set by routine PGSLS.
Argument:
LS (output) : the current line-style attribute (in range 1-5)
PGQLW -- inquire line width
SUBROUTINE PGQLW (LW)
INTEGER LW
Query the current Line-Width attribute set by routine PGSLW.
Argument:
LW (output) : the line-width (in range 1-201)
PGQNDT -- inquire number of available device types
SUBROUTINE PGQNDT(N)
INTEGER N
Return the number of available device types. This routine is
usually used in conjunction with PGQDT to get a list of the
available device types.
Arguments:
N (output) : the number of available device types
PGQPOS -- inquire current pen position
SUBROUTINE PGQPOS (X, Y)
REAL X, Y
Query the current "pen" position in world C coordinates (X,Y).
Arguments:
X (output) : world x-coordinate of the pen position
Y (output) : world y-coordinate of the pen position
PGQTBG -- inquire text background color index
SUBROUTINE PGQTBG (TBCI)
INTEGER TBCI
Query the current Text Background Color Index set by routine
PGSTBG.
Argument:
TBCI (output) : receives the current text background color index
PGQTXT -- find bounding box of text string
SUBROUTINE PGQTXT (X, Y, ANGLE, FJUST, TEXT, XBOX, YBOX)
REAL X, Y, ANGLE, FJUST
CHARACTER*(*) TEXT
REAL XBOX(4), YBOX(4)
This routine returns a bounding box for a text string. Instead
of drawing the string as routine PGPTXT does, it returns in XBOX
and YBOX the coordinates of the corners of a rectangle parallel
to the string baseline that just encloses the string. The four
corners are in the order: lower left, upper left, upper right,
lower right (where left and right refer to the first and last
characters in the string).
If the string is blank or contains no drawable characters, all
four elements of XBOX and YBOX are assigned the starting point
of the string, (X,Y).
Arguments:
X, Y, ANGLE, FJUST, TEXT (input) : these arguments are the same
as the corrresponding arguments
in PGPTXT
XBOX, YBOX (output) : arrays of dimension 4; on output, they
contain the world coordinates of the
bounding box in (XBOX(1), YBOX(1)), ...,
(XBOX(4), YBOX(4))
PGQVP -- inquire viewport size and position
SUBROUTINE PGQVP (UNITS, X1, X2, Y1, Y2)
INTEGER UNITS
REAL X1, X2, Y1, Y2
Inquiry routine to determine the current viewport setting.
The values returned may be normalized device coordinates, inches, mm,
or pixels, depending on the value of the input parameter CFLAG.
Arguments:
UNITS (input) : used to specify the units of the output parameters:
UNITS = 0 : normalized device coordinates
UNITS = 1 : inches
UNITS = 2 : millimeters
UNITS = 3 : pixels
other values give an error message, and are
treated as 0
X1 (output) : the x-coordinate of the bottom left corner of
the viewport
X2 (output) : the x-coordinate of the top right corner of
the viewport
Y1 (output) : the y-coordinate of the bottom left corner of
the viewport
Y2 (output) : the y-coordinate of the top right corner of
the viewport
PGQVSZ -- inquire size of view surface
SUBROUTINE PGQVSZ (UNITS, X1, X2, Y1, Y2)
INTEGER UNITS
REAL X1, X2, Y1, Y2
This routine returns the dimensions of the view surface (the
maximum plottable area) of the currently selected graphics device,
in a variety of units. The size of the view surface is
device-dependent and is established when the graphics device is
opened. On some devices, it can be changed by calling PGPAP before
starting a new page with PGPAGE. On some devices, the size can be
changed (e.g., by a workstation window manager) outside PGPLOT,
and PGPLOT detects the change when PGPAGE is used. Call this
routine after PGPAGE to find the current size.
Notes:
(1) The width and the height of the view surface in normalized
device coordinates are both always equal to 1.0.
(2) When the device is divided into panels (see PGSUBP), the
view surface is a single panel.
Arguments:
UNITS (input) : 0,1,2,3 for output in normalized device
coordinates, inches, mm, or device units (pixels)
X1 (output) : always returns 0.0
X2 (output) : width of view surface
Y1 (output) : always returns 0.0
Y2 (output) : height of view surface
PGQWIN -- inquire window boundary coordinates
SUBROUTINE PGQWIN (X1, X2, Y1, Y2)
REAL X1, X2, Y1, Y2
Inquiry routine to determine the current window setting.
The values returned are world coordinates.
Arguments:
X1 (output) : the x-coordinate of the bottom left corner of the
window
X2 (output) : the x-coordinate of the top right corner of the
window
Y1 (output) : the y-coordinate of the bottom left corner of the
window
Y2 (output) : the y-coordinate of the top right corner of the
window
PGRECT -- draw a rectangle, using fill-area attributes
SUBROUTINE PGRECT (X1, X2, Y1, Y2)
REAL X1, X2, Y1, Y2
This routine can be used instead of PGPOLY for the special case of
drawing a rectangle aligned with the coordinate axes; only two
vertices need be specified instead of four. On most devices, it is
faster to use PGRECT than PGPOLY for drawing rectangles. The
rectangle has vertices at (X1,Y1), (X1,Y2), (X2,Y2), and (X2,Y1).
Arguments:
X1, X2 (input) : the horizontal range of the rectangle
Y1, Y2 (input) : the vertical range of the rectangle
PGRND -- find the smallest `round' number greater than x
REAL FUNCTION PGRND (X, NSUB)
REAL X
INTEGER NSUB
Routine to find the smallest "round" number larger than x, a
"round" number being 1, 2 or 5 times a power of 10. If X is
negative, PGRND(X) = -PGRND(ABS(X)). eg PGRND(8.7) = 10.0,
PGRND(-0.4) = -0.5. If X is zero, the value returned is zero.
This routine is used by PGBOX for choosing tick intervals.
Returns:
PGRND : the "round" number
Arguments:
X (input) : the number to be rounded
NSUB (output) : a suitable number of subdivisions for
subdividing the "nice" number: 2 or 5.
PGRNGE -- choose axis limits
SUBROUTINE PGRNGE (X1, X2, XLO, XHI)
REAL X1, X2, XLO, XHI
Choose plotting limits XLO and XHI which encompass the data
range X1 to X2.
Arguments:
X1, X2 (input) : the data range (X1<X2), ie, the min and max
values to be plotted
XLO, XHI (output) : suitable values to use as the extremes of a
graph axis (XLO <= X1, XHI >= X2)
PGSAH -- set arrow-head style
SUBROUTINE PGSAH (FS, ANGLE, BARB)
INTEGER FS
REAL ANGLE, BARB
Set the style to be used for arrowheads drawn with routine PGARRO.
Argument:
FS (input) : FS = 1 => filled; FS = 2 => outline
other values are treated as 2
default 1
ANGLE (input) : the acute angle of the arrow point, in degrees;
angles in the range 20.0 to 90.0 give reasonable
results. Default 45.0.
BARB (input) : the fraction of the triangular arrow-head that
is cut away from the back
0.0 gives a triangular wedge arrow-head
1.0 gives an open >
values 0.3 to 0.7 give reasonable results
default 0.3
PGSAVE -- save PGPLOT attributes
SUBROUTINE PGSAVE This routine saves the current PGPLOT attributes in a private storage area. They can be restored by calling PGUNSA (unsave). Attributes saved are: character font, character height, color index, fill-area style, line style, line width, pen position, arrow-head style, hatching style, and clipping state. Color representation is not saved. Calls to PGSAVE and PGUNSA should always be paired. Up to 20 copies of the attributes may be saved. PGUNSA always retrieves the last-saved values (last-in first-out stack). Note that when multiple devices are in use, PGUNSA retrieves the values saved by the last PGSAVE call, even if they were for a different device. Arguments: none
PGSCF -- set character font
SUBROUTINE PGSCF (FONT)
INTEGER FONT
Set the Character Font for subsequent text plotting. Four different
fonts are available:
1: (default) a simple single-stroke font ("normal" font)
2: roman font
3: italic font
4: script font
This call determines which font is in effect at the beginning of
each text string. The font can be changed (temporarily) within a
text string by using the escape sequences \fn, \fr, \fi, and \fs
for fonts 1, 2, 3, and 4, respectively.
Argument:
FONT (input) : the font number to be used for subsequent text
plotting (in range 1-4)
PGSCH -- set character height
SUBROUTINE PGSCH (SIZE)
REAL SIZE
Set the character size attribute. The size affects all text and
graph markers drawn later in the program. The default character
size is 1.0, corresponding to a character height about 1/40 the
height of the view surface. Changing the character size also
scales the length of tick marks drawn by PGBOX and terminals drawn
by PGERRX and PGERRY.
Argument:
SIZE (input) : new character size (dimensionless multiple of
the default size).
PGSCI -- set color index
SUBROUTINE PGSCI (CI)
INTEGER CI
Set the Color Index for subsequent plotting, if the output device
permits this. The default color index is 1, usually white on a
black background for video displays or black on a white background
for printer plots. The color index is an integer in the range 0 to
a device-dependent maximum. Color index 0 corresponds to the
background color; lines may be "erased" by overwriting them with
color index 0 (if the device permits this).
If the requested color index is not available on the selected
device, color index 1 will be substituted.
The assignment of colors to color indices can be changed with
subroutine PGSCR (set color representation). Color indices 0-15
have predefined color representations (see the PGPLOT manual),
but these may be changed with PGSCR. Color indices above 15
have no predefined representations: if these indices are used,
PGSCR must be called to define the representation.
Argument:
CI (input) : the color index to be used for subsequent plotting
on the current device (in range 0-max). If the
index exceeds the device-dependent maximum, the
default color index (1) is used.
PGSCIR -- set color index range
SUBROUTINE PGSCIR(ICILO, ICIHI)
INTEGER ICILO, ICIHI
Set the color index range to be used for producing images with
PGGRAY or PGIMAG. If the range is not all within the range
supported by the device, a smaller range will be used. The number
of different colors available for images is ICIHI-ICILO+1.
Arguments:
ICILO (input) : the lowest color index to use for images
ICIHI (input) : the highest color index to use for images
PGSCLP -- enable or disable clipping at edge of viewport
SUBROUTINE PGSCLP(STATE)
INTEGER STATE
Normally all PGPLOT primitives except text are ``clipped'' at the
edge of the viewport: parts of the primitives that lie outside
the viewport are not drawn. If clipping is disabled by calling this
routine, primitives are visible wherever they lie on the view
surface. The default (clipping enabled) is appropriate for almost
all applications.
Argument:
STATE (input) : 0 to disable clipping, or 1 to enable clipping
25-Feb-1997 [TJP] - new routine
PGSCR -- set color representation
SUBROUTINE PGSCR (CI, CR, CG, CB)
INTEGER CI
REAL CR, CG, CB
Set color representation: i.e., define the color to be associated
with a color index. Ignored for devices which do not support
variable color or intensity. Color indices 0-15 have predefined
color representations (see the PGPLOT manual), but these may be
changed with PGSCR. Color indices 16-maximum have no predefined
representations: if these indices are used, PGSCR must be called
to define the representation.
On monochrome output devices (e.g. VT125 terminals with monochrome
monitors), the monochrome intensity is computed from the specified
Red, Green, Blue intensities as 0.30*R + 0.59*G + 0.11*B, as in US
color television systems, NTSC encoding.
Note that most devices do not have an infinite range of colors or
monochrome intensities available; the nearest available color is
used.
Examples:
for black, set CR=CG=CB=0.0
for white, set CR=CG=CB=1.0
for medium gray, set CR=CG=CB=0.5
for medium yellow, set CR=CG=0.5, CB=0.0
Argument:
CI (input) : the color index to be defined, in the range 0-max
if the color index greater than the device
maximum is specified, the call is ignored
color index 0 applies to the background color
CR (input) : red, green, and blue intensities,
CG (input) in range 0.0 to 1.0.
CB (input)
PGSCRL -- scroll window
SUBROUTINE PGSCRL (DX, DY)
REAL DX, DY
This routine moves the window in world-coordinate space while
leaving the viewport unchanged. On devices that have the
capability, the pixels within the viewport are scrolled
horizontally, vertically or both in such a way that graphics
previously drawn in the window are shifted so that their world
coordinates are unchanged.
If the old window coordinate range was (X1, X2, Y1, Y2), the new
coordinate range will be approximately (X1+DX, X2+DX, Y1+DY, Y2+DY).
The size and scale of the window are unchanged.
Thee window can only be shifted by a whole number of pixels
(device coordinates). If DX and DY do not correspond to integral
numbers of pixels, the shift will be slightly different from that
requested. The new window-coordinate range, and hence the exact
amount of the shift, can be determined by calling PGQWIN after this
routine.
Pixels that are moved out of the viewport by this operation are
lost completely; they cannot be recovered by scrolling back.
Pixels that are ``scrolled into'' the viewport are filled with
the background color (color index 0).
If the absolute value of DX is bigger than the width of the window,
or the aboslute value of DY is bigger than the height of the window,
the effect will be the same as zeroing all the pixels in the
viewport.
Not all devices have the capability to support this routine. It is
only available on some interactive devices that have discrete
pixels. To determine whether the current device has scroll
capability, call PGQINF.
Arguments:
DX (input) : distance (in world coordinates) to shift the
window horizontally (positive shifts window to the
right and scrolls to the left)
DY (input) : distance (in world coordinates) to shift the
window vertically (positive shifts window up and
scrolls down)
PGSCRN -- set color representation by name
SUBROUTINE PGSCRN(CI, NAME, IER)
INTEGER CI
CHARACTER*(*) NAME
INTEGER IER
Set color representation: i.e., define the color to be associated
with a color index. Ignored for devices which do not support
variable color or intensity. This is an alternative to routine
PGSCR. The color representation is defined by name instead
of (R,G,B) components.
Color names are defined in an external file which is read the first
time that PGSCRN is called. The name of the external file is
found as follows:
1. if environment variable (logical name) PGPLOT_RGB is defined,
its value is used as the file name;
2. otherwise, if environment variable PGPLOT_DIR is defined, a
file "rgb.txt" in the directory named by this environment
variable is used;
3. otherwise, file "rgb.txt" in the current directory is used.
If all of these fail to find a file, an error is reported and
the routine does nothing.
Each line of the file defines one color, with four blank- or
tab-separated fields per line. The first three fields are the
R, G, B components, which are integers in the range 0
(zero intensity) to 255 (maximum intensity). The fourth field
is the color name. The color name may include embedded blanks.
Example:
255 0 0 red
255 105 180 hot pink
255 255 255 white
0 0 0 black
Arguments:
CI (input) : the color index to be defined, in the range 0-max
if the color index greater than the device
maximum is specified, the call is ignored
color index 0 applies to the background color
NAME (input) : the name of the color to be associated with
this color index; this name must be in the
external file; the names are not case-sensitive
if the color is not listed in the file, the
color representation is not changed
IER (output) : returns 0 if the routine was successful,
1 if an error occurred (either the external file
could not be read, or the requested color was
not defined in the file)
PGSFS -- set fill-area style
SUBROUTINE PGSFS (FS)
INTEGER FS
Set the Fill-Area Style attribute for subsequent area-fill by
PGPOLY, PGRECT, or PGCIRC. Four different styles are available:
solid (fill polygon with solid color of the current color-index),
outline (draw outline of polygon only, using current line attributes),
hatched (shade interior of polygon with parallel lines, using
current line attributes), or cross-hatched. The orientation and
spacing of hatch lines can be specified with routine PGSHS (set
hatch style).
Argument:
FS (input) : the fill-area style to be used for subsequent
plotting:
FS = 1 solid (default)
FS = 2 outline
FS = 3 hatched
FS = 4 cross-hatched
other values give an error message and are
treated as 2
PGSHLS -- set color representation using HLS system
SUBROUTINE PGSHLS (CI, CH, CL, CS)
INTEGER CI
REAL CH, CL, CS
Set color representation: i.e., define the color to be associated
with a color index. This routine is equivalent to PGSCR, but the
color is defined in the Hue-Lightness-Saturation model instead of
the Red-Green-Blue model. Hue is represented by an angle in
degrees, with red at 120, green at 240, and blue at 0 (or 360).
Lightness ranges from 0.0 to 1.0, with black at lightness 0.0 and
white at lightness 1.0. Saturation ranges from 0.0 (gray) to 1.0
(pure color). Hue is irrelevant when saturation is 0.0.
Examples: H L S R G B
black any 0.0 0.0 0.0 0.0 0.0
white any 1.0 0.0 1.0 1.0 1.0
medium gray any 0.5 0.0 0.5 0.5 0.5
red 120 0.5 1.0 1.0 0.0 0.0
yellow 180 0.5 1.0 1.0 1.0 0.0
pink 120 0.7 0.8 0.94 0.46 0.46
Reference:
SIGGRAPH Status Report of the Graphic Standards Planning
Committee, Computer Graphics, Vol.13, No.3, Association for
Computing Machinery, New York, NY, 1979
See also:
J. D. Foley et al, 'Computer Graphics: Principles and Practice',
second edition, Addison-Wesley, 1990, section 13.3.5.
Arguments:
CI (input) : the color index to be defined, in the range 0-max
if the color index greater than the device
maximum is specified, the call is ignored
color index 0 applies to the background color
CH (input) : hue, in range 0.0 to 360.0
CL (input) : lightness, in range 0.0 to 1.0
CS (input) : saturation, in range 0.0 to 1.0
PGSHS -- set hatching style
SUBROUTINE PGSHS (ANGLE, SEPN, PHASE)
REAL ANGLE, SEPN, PHASE
Set the style to be used for hatching (fill area with fill-style 3).
The default style is ANGLE=45.0, SEPN=1.0, PHASE=0.0.
Arguments:
ANGLE (input) : the angle the hatch lines make with the
horizontal, in degrees, increasing
counterclockwise (this is an angle on the
view surface, not in world-coordinate space).
SEPN (input) : the spacing of the hatch lines; the unit spacing
is 1 percent of the smaller of the height or
width of the view surface; this should not be
zero
PHASE (input) : a real number between 0 and 1; the hatch lines
are displaced by this fraction of SEPN from a
fixed reference; adjacent regions hatched with
the same PHASE have contiguous hatch lines;
to hatch a region with alternating lines of two
colors, fill the area twice, with PHASE=0.0 for
one color and PHASE=0.5 for the other color
PGSITF -- set image transfer function
SUBROUTINE PGSITF (ITF)
INTEGER ITF
Set the Image Transfer Function for subsequent images drawn by
PGIMAG, PGGRAY, or PGWEDG. The Image Transfer Function is used
to map array values into the available range of color indices
specified with routine PGSCIR or (for PGGRAY on some devices)
into dot density.
Argument:
ITF (input) : type of transfer function:
ITF = 0 : linear
ITF = 1 : logarithmic
ITF = 2 : square-root
PGSLCT -- select an open graphics device
SUBROUTINE PGSLCT(ID)
INTEGER ID
Select one of the open graphics devices and direct subsequent
plotting to it. The argument is the device identifier returned by
PGOPEN when the device was opened. If the supplied argument is not a
valid identifier of an open graphics device, a warning message is
issued and the current selection is unchanged.
This routine was added to PGPLOT in Version 5.1.0.
Argument:
ID (input, integer) : identifier of the device to be selected
PGSLS -- set line style
SUBROUTINE PGSLS (LS)
INTEGER LS
Set the line style attribute for subsequent plotting. This
attribute affects line primitives only; it does not affect graph
markers, text, or area fill. Five different line styles are
available, with the following codes:
1 full line
2 dashed
3 dot-dash-dot-dash
4 dotted
5 dash-dot-dot-dot
The default is 1 (normal full line).
Argument:
LS (input) : the line-style code for subsequent plotting
(in range 1-5)
PGSLW -- set line width
SUBROUTINE PGSLW (LW)
INTEGER LW
Set the line-width attribute. This attribute affects lines, graph
markers, and text. The line width is specified in units of 1/200
(0.005) inch (about 0.13 mm) and must be an integer in the range
1-201. On some devices, thick lines are generated by tracing each
line with multiple strokes offset in the direction perpendicular
to the line.
Argument:
LW (input) : width of line, in units of 0.005 inch (0.13 mm)
in range 1-201
PGSTBG -- set text background color index
SUBROUTINE PGSTBG (TBCI)
INTEGER TBCI
Set the Text Background Color Index for subsequent text. By
default text does not obscure underlying graphics. If the text
background color index is positive, however, text is opaque:
the bounding box of the text is filled with the color specified by
PGSTBG before drawing the text characters in the current color
index set by PGSCI. Use color index 0 to erase underlying graphics
before drawing text.
Argument:
TBCI (input) : the color index to be used for the background
for subsequent text plotting:
TBCI < 0 transparent (default)
TBCI >= 0 text will be drawn on an opaque
background with color index TBCI
PGSUBP -- subdivide view surface into panels
SUBROUTINE PGSUBP (NXSUB, NYSUB)
INTEGER NXSUB, NYSUB
PGPLOT divides the physical surface of the plotting device (screen,
window, or sheet of paper) into NXSUB x NYSUB `panels'. When the
view surface is sub-divided in this way, PGPAGE moves to the next
panel, not the next physical page. The initial subdivision of the
view surface is set in the call to PGBEG. When PGSUBP is called,
it forces the next call to PGPAGE to start a new physical page,
subdivided in the manner indicated. No plotting should be done
between a call of PGSUBP and a call of PGPAGE (or PGENV, which
calls PGPAGE).
If NXSUB > 0, PGPLOT uses the panels in row order; if <0, PGPLOT
uses them in column order, e.g.,
NXSUB=3, NYSUB=2 NXSUB=-3, NYSUB=2
+-----+-----+-----+ +-----+-----+-----+
| 1 | 2 | 3 | | 1 | 3 | 5 |
+-----+-----+-----+ +-----+-----+-----+
| 4 | 5 | 6 | | 2 | 4 | 6 |
+-----+-----+-----+ +-----+-----+-----+
PGPLOT advances from one panels to the next when PGPAGE is called,
clearing the screen or starting a new page when the last panel has
been used. It is also possible to jump from one panel to another
in random order by calling PGPANL.
Arguments:
NXSUB (input) : the number of subdivisions of the view surface
in X (>0 or <0).
NYSUB (input) : the number of subdivisions of the view surface
in Y (>0).
PGSVP -- set viewport (normalized device coordinates)
SUBROUTINE PGSVP (XLEFT, XRIGHT, YBOT, YTOP)
REAL XLEFT, XRIGHT, YBOT, YTOP
Change the size and position of the viewport, specifying the
viewport in normalized device coordinates. Normalized device
coordinates run from 0 to 1 in each dimension. The viewport is the
rectangle on the view surface "through" which one views the graph.
All the PG routines which plot lines etc. plot them within the
viewport, and lines are truncated at the edge of the viewport
(except for axes, labels etc drawn with PGBOX or PGLAB). The
region of world space (the coordinate space of the graph) which is
visible through the viewport is specified by a call to PGSWIN.
It is legal to request a viewport larger than the view surface;
only the part which appears on the view surface will be plotted.
Arguments:
XLEFT (input) : x-coordinate of left hand edge of viewport,
in NDC
XRIGHT (input) : x-coordinate of right hand edge of viewport,
in NDC
YBOT (input) : y-coordinate of bottom edge of viewport,
in NDC
YTOP (input) : y-coordinate of top edge of viewport,
in NDC
PGSWIN -- set window
SUBROUTINE PGSWIN (X1, X2, Y1, Y2)
REAL X1, X2, Y1, Y2
Change the window in world coordinate space that is to be mapped
on to the viewport. Usually PGSWIN is called automatically by
PGENV, but it may be called directly by the user.
Arguments:
X1 (input) : the x-coordinate of the bottom left corner of the
viewport
X2 (input) : the x-coordinate of the top right corner of the
viewport; note: X2 may be less than X1
Y1 (input) : the y-coordinate of the bottom left corner of the
viewport
Y2 (input) : the y-coordinate of the top right corner of the
viewport; note: Y2 may be less than Y1
PGTBOX -- draw frame and write (DD) HH MM SS.S labelling
SUBROUTINE PGTBOX (XOPT, XTICK, NXSUB, YOPT, YTICK, NYSUB)
REAL XTICK, YTICK
INTEGER NXSUB, NYSUB
CHARACTER XOPT*(*), YOPT*(*)
Draw a box and optionally label one or both axes with (DD) HH MM SS
style numeric labels (useful for time or RA - DEC plots). If this
style of labelling is desired, then PGSWIN should have been called
previously with the extrema in SECONDS of time.
In the seconds field, you can have at most 3 places after the
decimal point, so that 1 ms is the smallest time interval you can
time label.
Large numbers are coped with by fields of 6 characters long. Thus
you could have times with days or hours as big as 999999. However,
in practice, you might have trouble with labels overwriting
themselves with such large numbers unless you (a) use a small time
INTERVAL, (b) use a small character size or (c) choose your own
sparse ticks in the call to PGTBOX.
PGTBOX will attempt, when choosing its own ticks, not to overwrite
the labels, but this algorithm is not very bright and may fail.
Note that small intervals but large absolute times such as
TMIN = 200000.0 s and TMAX=200000.1 s will cause the algorithm
to fail. This is inherent in PGPLOT's use of single precision
and cannot be avoided. In such cases, you should use relative
times if possible.
PGTBOX's labelling philosophy is that the left-most or bottom tick
of the axis contains a full label. Thereafter, only changing
fields are labelled. Negative fields are given a '-' label,
positive fields have none. Axes that have the DD (or HH if the day
field is not used) field on each major tick carry the sign on each
field. If the axis crosses zero, the zero tick will carry a full
label and sign.
This labelling style can cause a little confusion with some
special cases, but as long as you know its philosophy, the truth
can be divined. Consider an axis with TMIN=20s, TMAX=-20s.
The labels will look like
+----------+----------+----------+----------+
0h0m20s 10s -0h0m0s 10s 20s
Knowing that the left field always has a full label and that
positive fields are unsigned, informs that time is decreasing
from left to right, not vice versa. This can become very unclear
if you have used the 'F' option, but that is your problem !
Exceptions to this labelling philosophy are when the finest time
increment being displayed is hours (with option 'Y') or days.
Then all fields carry a label. For example,
+----------+----------+----------+----------+
-10h -8h -6h -4h -2h
PGTBOX can be used in place of PGBOX; it calls PGBOX and only
invokes time labelling if requested. Other options are passed
intact to PGBOX.
Arguments:
XOPT (input) : X-options for PGTBOX; same as for PGBOX plus
'Z' for (DD) HH MM SS.S time labelling
'Y' means don't include the day field so that labels are
HH MM SS.S rather than DD HH MM SS.S The hours will
accumulate beyond 24 if necessary in this case
'X' label the HH field as modulo 24; thus, a label such
as 25h 10m would come out as 1h 10m
'H' means superscript numbers with d, h, m, & s symbols
'D' means superscript numbers with o, ', & '' symbols
'F' causes the first label (left- or bottom-most) to be
omitted; useful for sub-panels that abut each other
care is needed because first label carries sign as well.
'O' means omit leading zeros in numbers < 10, e.g.
3h 3m 1.2s rather than 03h 03m 01.2s; useful to help
save space on X-axes; the day field does not use this
facility
YOPT (input) : Y-options for PGTBOX; see above
XTICK (input) : X-axis major tick increment; 0.0 for default
YTICK (input) : Y-axis major tick increment; 0.0 for default
if the 'Z' option is used then XTICK and/or
YTICK must be in seconds
NXSUB (input) : number of intervals for minor ticks on X-axis;
0 for default
NYSUB (input) : number of intervals for minor ticks on Y-axis;
0 for default
The regular XOPT and YOPT axis options for PGBOX are
A : draw Axis (X axis is horizontal line Y=0, Y axis is
vertical line X=0)
B : draw bottom (X) or left (Y) edge of frame
C : draw top (X) or right (Y) edge of frame
G : draw Grid of vertical (X) or horizontal (Y) lines
I : Invert the tick marks; ie draw them outside the viewport
instead of inside
L : label axis Logarithmically (see below)
N : write Numeric labels in the conventional location below
the viewport (X) or to the left of the viewport (Y)
P : extend ("Project") major tick marks outside the box
(ignored if option I is specified)
M : write numeric labels in the unconventional location
above the viewport (X) or to the right of the viewport (Y)
T : draw major Tick marks at the major coordinate interval
S : draw minor tick marks (Subticks)
V : orient numeric labels Vertically; this is only applicable
to Y; the default is to write Y-labels parallel to the axis
1 : force decimal labelling, instead of automatic choice
(see PGNUMB)
2 : force exponential labelling, instead of automatic
The default is to write Y-labels parallel to the axis
****************** EXCEPTIONS *******************
Note that:
(1) PGBOX option 'L' (log labels) is ignored with option 'Z'
(2) The 'O' option will be ignored for the 'V' option as it
makes it impossible to align the labels nicely
(3) Option 'Y' is forced with option 'D'
***************************************************************
PGTEXT -- write text (horizontal, left-justified)
SUBROUTINE PGTEXT (X, Y, TEXT)
REAL X, Y
CHARACTER*(*) TEXT
Write text. The bottom left corner of the first character is placed
at the specified position, and the text is written horizontally.
This is a simplified interface to the primitive routine PGPTXT.
For non-horizontal text, use PGPTXT.
Arguments:
X (input) : world x-coordinate of start of string
Y (input) : world y-coordinate of start of string
TEXT (input) : the character string to be plotted
PGTICK -- draw a single tick mark on an axis
SUBROUTINE PGTICK (X1, Y1, X2, Y2, V, TIKL, TIKR, DISP, ORIENT, STR)
REAL X1, Y1, X2, Y2, V, TIKL, TIKR, DISP, ORIENT
CHARACTER*(*) STR
Draw and label single tick mark on a graph axis. The tick mark is
a short line perpendicular to the direction of the axis (which is
not drawn by this routine). The optional text label is drawn with
its baseline parallel to the axis and reading in the same direction
as the axis (from point 1 to point 2). Current line and text
attributes are used.
Arguments:
X1, Y1 (input) : world coordinates of one endpoint of the axis
X2, Y2 (input) : world coordinates of the other endpoint of the
axis
V (input) : draw the tick mark at fraction V (0<=V<=1)
along the line from (X1,Y1) to (X2,Y2)
TIKL (input) : length of tick mark drawn to left of axis (as
seen looking from first endpoint to second), in
units of the character height
TIKR (input) : length of major tick marks drawn to right of
axis, in units of the character height
DISP (input) : displacement of label text to right of axis,
in units of the character height
ORIENT (input) : orientation of label text, in degrees; angle
between baseline of text and direction of axis
(0-360°)
STR (input) : text of label (may be blank)
PGUNSA -- restore PGPLOT attributes
ENTRY PGUNSA This routine restores the PGPLOT attributes saved in the last call to PGSAVE. Usage: CALL PGUNSA (no arguments). See PGSAVE. Argument: none
PGUPDT -- update display
SUBROUTINE PGUPDT Update the graphics display: flush any pending commands to the output device. This routine empties the buffer created by PGBBUF, but it does not alter the PGBBUF/PGEBUF counter. The routine should be called when it is essential that the display be completely up to date (before interaction with the user, for example) but it is not known if output is being buffered. Arguments: none
PGVECT -- vector map of a 2D data array, with blanking
SUBROUTINE PGVECT (A, B, IDIM, JDIM, I1, I2, J1, J2, C, NC, TR,
BLANK)
INTEGER IDIM, JDIM, I1, I2, J1, J2, NC
REAL A(IDIM,JDIM), B(IDIM, JDIM), TR(6), BLANK, C
Draw a vector map of two arrays. This routine is similar to PGCONB
in that array elements that have the "magic value" defined by
the argument BLANK are ignored, making gaps in the vector map.
The routine may be useful for data measured on most but not all
of the points of a grid. Vectors are displayed as arrows; the
style of the arrowhead can be set with routine PGSAH, and the
size of the arrowhead is determined by the current character size,
set by PGSCH.
Arguments:
A (input) : horizontal component data array
B (input) : vertical component data array
IDIM (input) : first dimension of A and B
JDIM (input) : second dimension of A and B
I1,I2 (input) : range of first index to be mapped (inclusive)
J1,J2 (input) : range of second index to be mapped (inclusive)
C (input) : scale factor for vector lengths, if 0.0, C will be
set so that the longest vector is equal to the
smaller of TR(2)+TR(3) and TR(5)+TR(6)
NC (input) : vector positioning code
<0 vector head positioned on coordinates
>0 vector base positioned on coordinates
=0 vector centered on the coordinates
TR (input) : array defining a transformation between the I,J
grid of the array and the world coordinates;
the world coordinates of the array point A(I,J)
are given by:
X = TR(1) + TR(2)*I + TR(3)*J
Y = TR(4) + TR(5)*I + TR(6)*J
usually TR(3) and TR(5) are zero - unless the
coordinate transformation involves a rotation
or shear
BLANK (input) : elements of arrays A or B that are exactly equal
to this value are ignored (blanked)
PGVSIZ -- set viewport (inches)
SUBROUTINE PGVSIZ (XLEFT, XRIGHT, YBOT, YTOP)
REAL XLEFT, XRIGHT, YBOT, YTOP
Change the size and position of the viewport, specifying the
viewport in physical device coordinates (inches). The viewport
is the rectangle on the view surface "through" which one views
the graph. All the PG routines which plot lines etc. plot them
within the viewport, and lines are truncated at the edge of the
viewport (except for axes, labels etc drawn with PGBOX or PGLAB). The region of world space (the coordinate
space of the graph) which is visible through the viewport is
specified by a call to PGSWIN. It is legal to request a viewport
larger than the view surface; only the part which appears on the
view surface will be plotted.
Arguments:
XLEFT (input) : x-coordinate of left hand edge of viewport, in
inches from left edge of view surface.
XRIGHT (input) : x-coordinate of right hand edge of viewport, in
inches from left edge of view surface.
YBOT (input) : y-coordinate of bottom edge of viewport, in
inches from bottom of view surface.
YTOP (input) : y-coordinate of top edge of viewport, in inches
from bottom of view surface.
PGVSTD -- set standard (default) viewport
SUBROUTINE PGVSTD Define the viewport to be the standard viewport. The standard viewport is the full area of the view surface (or panel), less a margin of 4 character heights all round for labelling. It thus depends on the current character size, set by PGSCH. Arguments: none.
PGWEDG -- annotate an image plot with a wedge
SUBROUTINE PGWEDG(SIDE, DISP, WIDTH, FG, BG, LABEL)
CHARACTER *(*) SIDE,LABEL
REAL DISP, WIDTH, FG, BG
Plot an annotated grey-scale or color wedge parallel to a given
axis of the the current viewport. This routine is designed to
provide a brightness/color scale for an image drawn with PGIMAG
or PGGRAY. The wedge will be drawn with the transfer function set
by PGSITF and using the color index range set by PGSCIR.
Arguments:
SIDE (input) : the first character must be one of the characters
'B', 'L', 'T', or 'R' signifying the Bottom, Left,
Top, or Right edge of the viewport
the second character should be 'I' to use PGIMAG
to draw the wedge, or 'G' to use PGGRAY
DISP (input) : the displacement of the wedge from the specified
edge of the viewport, measured outwards from the
viewport in units of the character height
use a negative value to write inside the viewport,
a positive value to write outside
WIDTH (input) : the total width of the wedge including annotation,
in units of the character height
FG (input) : the value which is to appear with shade 1
("foreground")
use the values of FG and BG that were supplied to
PGGRAY or PGIMAG
BG (input) : the value which is to appear with shade 0
("background")
LABEL (input) : optional units label
if no label is required, use ' '
PGWNAD -- set window and adjust viewport to same aspect ratio
SUBROUTINE PGWNAD (X1, X2, Y1, Y2)
REAL X1, X2, Y1, Y2
Change the window in world coordinate space that is to be mapped
on to the viewport, and simultaneously adjust the viewport so
that the world-coordinate scales are equal in x and y. The new
viewport is the largest one that can fit within the previously
set viewport while retaining the required aspect ratio.
Arguments:
X1 (input) : the x-coordinate of the bottom left corner of the
viewport
X2 (input) : the x-coordinate of the top right corner of the
viewport (note X2 may be less than X1)
Y1 (input) : the y-coordinate of the bottom left corner of the
viewport
Y2 (input) : the y-coordinate of the top right corner of the
viewport (note Y2 may be less than Y1)
PGADVANCE -- non-standard alias for PGPAGE
SUBROUTINE PGADVANCE See description of PGPAGE.
PGBEGIN -- non-standard alias for PGBEG
INTEGER FUNCTION PGBEGIN (UNIT, FILE, NXSUB, NYSUB) INTEGER UNIT CHARACTER*(*) FILE INTEGER NXSUB, NYSUB See description of PGBEG.
PGCURSE -- non-standard alias for PGCURS
INTEGER FUNCTION PGCURSE (X, Y, CH) REAL X, Y CHARACTER*1 CH See description of PGCURS.
PGLABEL -- non-standard alias for PGLAB
SUBROUTINE PGLABEL (XLBL, YLBL, TOPLBL) CHARACTER*(*) XLBL, YLBL, TOPLBL See description of PGLAB.
PGMTEXT -- non-standard alias for PGMTXT
SUBROUTINE PGMTEXT (SIDE, DISP, COORD, FJUST, TEXT) CHARACTER*(*) SIDE, TEXT REAL DISP, COORD, FJUST See description of PGMTXT.
PGNCURSE -- non-standard alias for PGNCUR
SUBROUTINE PGNCURSE (MAXPT, NPT, X, Y, SYMBOL) INTEGER MAXPT, NPT REAL X(*), Y(*) INTEGER SYMBOL See description of PGNCUR.
PGPAPER -- non-standard alias for PGPAP
SUBROUTINE PGPAPER (WIDTH, ASPECT) REAL WIDTH, ASPECT See description of PGPAP.
PGPOINT -- non-standard alias for PGPT
SUBROUTINE PGPOINT (N, XPTS, YPTS, SYMBOL) INTEGER N REAL XPTS(*), YPTS(*) INTEGER SYMBOL See description of PGPT.
PGPTEXT -- non-standard alias for PGPTXT
SUBROUTINE PGPTEXT (X, Y, ANGLE, FJUST, TEXT) REAL X, Y, ANGLE, FJUST CHARACTER*(*) TEXT See description of PGPTXT.
PGVPORT -- non-standard alias for PGSVP
SUBROUTINE PGVPORT (XLEFT, XRIGHT, YBOT, YTOP) REAL XLEFT, XRIGHT, YBOT, YTOP See description of PGSVP.
PGVSIZE -- non-standard alias for PGVSIZ
SUBROUTINE PGVSIZE (XLEFT, XRIGHT, YBOT, YTOP) REAL XLEFT, XRIGHT, YBOT, YTOP See description of PGVSIZ.
PGVSTAND -- non-standard alias for PGVSTD
SUBROUTINE PGVSTAND See description of PGVSTD.
PGWINDOW -- non-standard alias for PGSWIN
SUBROUTINE PGWINDOW (X1, X2, Y1, Y2) REAL X1, X2, Y1, Y2 See description of PGSWIN.
» back to old software