Plot (Starlink-UK API)

java.lang.Object
- uk.ac.starlink.ast.AstObject
- - uk.ac.starlink.ast.Mapping
  - - uk.ac.starlink.ast.Frame
    - - uk.ac.starlink.ast.FrameSet
      - uk.ac.starlink.ast.Plot

```
public class Plot
extends FrameSet
```
Java interface to the AST Plot class - provide facilities for 2D graphical output. This class provides facilities for producing 2D graphical output. A Plot is a specialised form of FrameSet, in which the base Frame describes a "graphical" coordinate system and is associated with a rectangular plotting area in the underlying graphics system. This plotting area is where graphical output appears. It is defined when the Plot is created.
The current Frame of a Plot describes a "physical" coordinate system, which is the coordinate system in which plotting operations are specified. The results of each plotting operation are automatically transformed into graphical coordinates so as to appear in the plotting area (subject to any clipping which may be in effect).
Because the Mapping between physical and graphical coordinates may often be non-linear, or even discontinuous, most plotting does not result in simple straight lines. The basic plotting element is therefore not a straight line, but a geodesic curve (see astCurve, astGenCurve and astPolyCurve). A Plot also provides facilities for drawing markers or symbols (astMark), text (astText) and grid lines (astGridLine). It is also possible to draw curvilinear axes with optional coordinate grids (astGrid). A range of Plot attributes is available to allow precise control over the appearance of graphical output produced by these functions.
You may select different physical coordinate systems in which to plot (including the native graphical coordinate system itself) by selecting different Frames as the current Frame of a Plot, using its Current attribute. You may also set up clipping (see astClip) to limit the extent of any plotting you perform, and this may be done in any of the coordinate systems associated with the Plot, not necessarily the one you are plotting in.
Like any FrameSet, a Plot may also be used as a Frame. In this case, it behaves like its current Frame, which describes the physical coordinate system.
When used as a Mapping, a Plot describes the inter-relation between graphical coordinates (its base Frame) and physical coordinates (its current Frame). It differs from a normal FrameSet, however, in that an attempt to transform points which lie in clipped areas of the Plot will result in bad coordinate values (AST__BAD).
Graphical Elements
The colour index, character font, character size, line style and line width used for plotting can be set independently for various elements of the graphical output produced by a Plot. The different graphical elements are identified by appending the strings listed below as subscripts to the Plot attributes Colour(element), Font(element), Size(element), Style(element) and Width(element). These strings are case-insensitive and unambiguous abbreviations may be used. Elements of the graphical output which relate to individual axes can be referred to either independently (e.g. "(Grid1)" and "(Grid2)" ) or together (e.g. "(Grid)"):

- Axes: Axis lines drawn through tick marks using astGrid
- Axis1: Axis line drawn through tick marks on axis 1 using astGrid
- Axis2: Axis line drawn through tick marks on axis 2 using astGrid
- Border: The Plot border drawn using astBorder or astGrid
- Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
- Grid: Grid lines drawn using astGridLine or astGrid
- Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
- Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
- Markers: Graphical markers (symbols) drawn using astMark
- NumLab: Numerical axis labels drawn using astGrid
- NumLab1: Numerical labels for axis 1 drawn using astGrid
- NumLab2: Numerical labels for axis 2 drawn using astGrid
- Strings: Text strings drawn using astText
- TextLab: Descriptive axis labels drawn using astGrid
- TextLab1: Descriptive label for axis 1 drawn using astGrid
- TextLab2: Descriptive label for axis 2 drawn using astGrid
- Ticks: Tick marks (both major and minor) drawn using astGrid
- Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
- Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
- Title: The Plot title drawn using astGrid
Licence
This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public Licence as published by the Free Software Foundation; either version 2 of the Licence, or (at your option) any later version.
This program is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public Licence for more details.
You should have received a copy of the GNU General Public Licence along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street,Fifth Floor, Boston, MA 02110-1301, USA

Usage
Normally a Plot will be an object owned by a JComponent (i.e. some object in a subclass of JComponent). In this case, the Plot's paint method should be called in the JComponent's paintComponent method. A minimal Plot-containing JComponent might look like this:
```
          class PlotHolder extends JPanel {
              public Plot plot;
              protected void paintComponent( Graphics g ) {
                  super.paintComponent( g );
                  plot.paint( g );
              }
          }
       
```
See Also:

AST Plot

Nested Class Summary
- Nested classes/interfaces inherited from class uk.ac.starlink.ast.Mapping
  Mapping.Interpolator, Mapping.Spreader

Field Summary
- Fields inherited from class uk.ac.starlink.ast.FrameSet
  AST__BASE, AST__CURRENT, AST__NOFRAME
- Fields inherited from class uk.ac.starlink.ast.Mapping
  LINEAR_INTERPOLATOR, LINEAR_SPREADER, NEAREST_INTERPOLATOR, NEAREST_SPREADER
- Fields inherited from class uk.ac.starlink.ast.AstObject
  AST__BAD, AST__TUNULL, pointer

Constructor Summary

Constructors
Constructor and Description
`Plot(Frame frame, Rectangle2D graphrect, double[] basebox)` Creates a Plot which plots onto a given rectangle.
`Plot(Frame frame, Rectangle2D graphrect, double[] basebox, int lgap, int rgap, int bgap, int tgap)` Creates a Plot which plots onto a given rectangle with specified proportional spaces round the edge.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`border()` Draw a border around valid regions of a Plot.
`Rectangle2D`	`boundingBox()` Return a bounding box for previously drawn graphics.
`void`	`clear()` Clears the component.
`void`	`clip(int iframe, double[] lbnd, double[] ubnd)` Set up or remove clipping for a Plot.
`AstObject`	`copy()` Returns a fairly deep copy of this object.
`void`	`curve(double[] start, double[] finish)` Draw a geodesic curve.
`void`	`genCurve(Mapping map)` Draw a generalized curve.
`boolean`	`getBorder()` Get draw a border around valid regions of a Plot.
`String`	`getC(String attrib)` Get a character attribute value by name.
`int`	`getClip()` Get clip lines and/or markers at the Plot boundary.
`boolean`	`getClipOp()` Get combine Plot clipping limits using a boolean OR.
`int`	`getColour(String element)` Get colour index for a Plot element by graphical element.
`double`	`getD(String attrib)` Get a double precision attribute value by name.
`boolean`	`getDrawAxes()` Get draw axes for a Plot.
`boolean`	`getDrawAxes(int axis)` Get draw axes for a Plot by axis.
`boolean`	`getDrawTitle()` Get draw a title for a Plot.
`String`	`getEdge(int axis)` Get which edges to label in a Plot by axis.
`boolean`	`getEscape()` Get allow changes of character attributes within strings.
`float`	`getF(String attrib)` Get a floating point attribute value by name.
`int`	`getFont()` Get character font for a Plot element.
`int`	`getFont(String element)` Get character font for a Plot element by graphical element.
`double`	`getGap(int axis)` Get interval between linearly spaced major axis values of a Plot by axis.
`Grf`	`getGrf()` Gets the Grf object which implements the graphics.
`boolean`	`getGrid()` Get draw grid lines for a Plot.
`int`	`getI(String attrib)` Get a integer attribute value by name.
`boolean`	`getInvisible()` Get draw graphics using invisible ink.
`long`	`getL(String attrib)` Get a long integer attribute value by name.
`double`	`getLabelAt(int axis)` Get where to place numerical labels for a Plot by axis.
`String`	`getLabelling()` Get label and tick placement option for a Plot.
`boolean`	`getLabelUnits(int axis)` Get use axis unit descriptions in a Plot by axis.
`boolean`	`getLabelUp(int axis)` Get draw numerical Plot labels upright by axis.
`double`	`getLogGap(int axis)` Get interval between major axis values of a Plot by axis.
`boolean`	`getLogLabel(int axis)` Get use exponential format for numerical axis labels by axis.
`boolean`	`getLogPlot(int axis)` Get map the plot logarithmically onto the screen by axis.
`boolean`	`getLogTicks(int axis)` Get space the major tick marks logarithmically by axis.
`double`	`getMajTickLen(int axis)` Get length of major tick marks for a Plot by axis.
`int`	`getMinTick(int axis)` Get density of minor tick marks for a Plot by axis.
`double`	`getMinTickLen(int axis)` Get length of minor tick marks for a Plot by axis.
`boolean`	`getNumLab(int axis)` Get draw numerical axis labels for a Plot by axis.
`double`	`getNumLabGap(int axis)` Get spacing of numerical labels for a Plot by axis.
`double`	`getSize()` Get character size for a Plot element.
`double`	`getSize(String element)` Get character size for a Plot element by graphical element.
`int`	`getStyle(String element)` Get line style for a Plot element by graphical element.
`boolean`	`getTextLab(int axis)` Get draw descriptive axis labels for a Plot by axis.
`double`	`getTextLabGap(int axis)` Get spacing of descriptive axis labels for a Plot by axis.
`boolean`	`getTickAll()` Get draw tick marks on all edges of a Plot.
`double`	`getTitleGap()` Get vertical spacing for a Plot title.
`double`	`getTol()` Get plotting tolerance.
`double`	`getWidth(String element)` Get line width for a Plot element by graphical element.
`void`	`grid()` Draw a set of labelled coordinate axes.
`void`	`gridLine(int axis, double[] start, double length)` Draw a grid line (or axis) for a Plot.
`void`	`mark(int nmark, int ncoord, double[][] in, int type)` Draw a set of markers for a Plot.
`void`	`paint(Graphics g)` Paints the component.
`void`	`polyCurve(int npoint, int ncoord, double[][] in)` Draw a series of connected geodesic curves.
`void`	`set(String settings)` Set attribute values for an Object.
`void`	`setBorder(boolean border)` Set draw a border around valid regions of a Plot.
`void`	`setC(String attrib, String value)` Set a character attribute value by name.
`void`	`setClip(int clip)` Set clip lines and/or markers at the Plot boundary.
`void`	`setClipOp(boolean clipOp)` Set combine Plot clipping limits using a boolean OR.
`void`	`setColour(int colour)` Set colour index for a Plot element.
`void`	`setColour(String element, int colour)` Set colour index for a Plot element by graphical element.
`void`	`setD(String attrib, double value)` Set a double precision attribute value by name.
`void`	`setDrawAxes(boolean drawAxes)` Set draw axes for a Plot.
`void`	`setDrawAxes(int axis, boolean drawAxes)` Set draw axes for a Plot by axis.
`void`	`setDrawTitle(boolean drawTitle)` Set draw a title for a Plot.
`void`	`setEdge(int axis, String edge)` Set which edges to label in a Plot by axis.
`void`	`setEscape(boolean escape)` Set allow changes of character attributes within strings.
`void`	`setF(String attrib, float value)` Set a floating point attribute value by name.
`void`	`setFont(int font)` Set character font for a Plot element.
`void`	`setFont(String element, int font)` Set character font for a Plot element by graphical element.
`void`	`setGap(double gap)` Set interval between linearly spaced major axis values of a Plot.
`void`	`setGap(int axis, double gap)` Set interval between linearly spaced major axis values of a Plot by axis.
`void`	`setGrf(Grf grf)` Sets the Grf object which implements the graphics.
`void`	`setGrid(boolean grid)` Set draw grid lines for a Plot.
`void`	`setI(String attrib, int value)` Set a integer attribute value by name.
`void`	`setInvisible(boolean invisible)` Set draw graphics using invisible ink.
`void`	`setL(String attrib, long value)` Set a long integer attribute value by name.
`void`	`setLabelAt(int axis, double labelAt)` Set where to place numerical labels for a Plot by axis.
`void`	`setLabelling(String labelling)` Set label and tick placement option for a Plot.
`void`	`setLabelUnits(boolean labelUnits)` Set use axis unit descriptions in a Plot.
`void`	`setLabelUnits(int axis, boolean labelUnits)` Set use axis unit descriptions in a Plot by axis.
`void`	`setLabelUp(boolean labelUp)` Set draw numerical Plot labels upright.
`void`	`setLabelUp(int axis, boolean labelUp)` Set draw numerical Plot labels upright by axis.
`void`	`setLogGap(double logGap)` Set interval between major axis values of a Plot.
`void`	`setLogGap(int axis, double logGap)` Set interval between major axis values of a Plot by axis.
`void`	`setLogLabel(boolean logLabel)` Set use exponential format for numerical axis labels.
`void`	`setLogLabel(int axis, boolean logLabel)` Set use exponential format for numerical axis labels by axis.
`void`	`setLogPlot(boolean logPlot)` Set map the plot logarithmically onto the screen.
`void`	`setLogPlot(int axis, boolean logPlot)` Set map the plot logarithmically onto the screen by axis.
`void`	`setLogTicks(boolean logTicks)` Set space the major tick marks logarithmically.
`void`	`setLogTicks(int axis, boolean logTicks)` Set space the major tick marks logarithmically by axis.
`void`	`setMajTickLen(double majTickLen)` Set length of major tick marks for a Plot.
`void`	`setMajTickLen(int axis, double majTickLen)` Set length of major tick marks for a Plot by axis.
`void`	`setMinTick(int minTick)` Set density of minor tick marks for a Plot.
`void`	`setMinTick(int axis, int minTick)` Set density of minor tick marks for a Plot by axis.
`void`	`setMinTickLen(double minTickLen)` Set length of minor tick marks for a Plot.
`void`	`setMinTickLen(int axis, double minTickLen)` Set length of minor tick marks for a Plot by axis.
`void`	`setNumLab(boolean numLab)` Set draw numerical axis labels for a Plot.
`void`	`setNumLab(int axis, boolean numLab)` Set draw numerical axis labels for a Plot by axis.
`void`	`setNumLabGap(double numLabGap)` Set spacing of numerical labels for a Plot.
`void`	`setNumLabGap(int axis, double numLabGap)` Set spacing of numerical labels for a Plot by axis.
`void`	`setSize(double size)` Set character size for a Plot element.
`void`	`setSize(String element, double size)` Set character size for a Plot element by graphical element.
`void`	`setStyle(int style)` Set line style for a Plot element.
`void`	`setStyle(String element, int style)` Set line style for a Plot element by graphical element.
`void`	`setTextLab(boolean textLab)` Set draw descriptive axis labels for a Plot.
`void`	`setTextLab(int axis, boolean textLab)` Set draw descriptive axis labels for a Plot by axis.
`void`	`setTextLabGap(double textLabGap)` Set spacing of descriptive axis labels for a Plot.
`void`	`setTextLabGap(int axis, double textLabGap)` Set spacing of descriptive axis labels for a Plot by axis.
`void`	`setTickAll(boolean tickAll)` Set draw tick marks on all edges of a Plot.
`void`	`setTitleGap(double titleGap)` Set vertical spacing for a Plot title.
`void`	`setTol(double tol)` Set plotting tolerance.
`void`	`setWidth(double width)` Set line width for a Plot element.
`void`	`setWidth(String element, double width)` Set line width for a Plot element by graphical element.
`boolean`	`test(String attrib)` Test if an Object attribute value is set.
`void`	`text(String text, double[] pos, float[] up, String just)` Draw a text string for a Plot.

Methods inherited from class uk.ac.starlink.ast.FrameSet
addFrame, getBase, getCurrent, getFrame, getMapping, getNframe, remapFrame, removeFrame, setBase, setCurrent

Methods inherited from class uk.ac.starlink.ast.Frame
angle, axAngle, axDistance, axOffset, convert, distance, findFrame, format, getActiveUnit, getAlignSystem, getBottom, getDigits, getDigits, getDirection, getDomain, getDut1, getEpoch, getFormat, getLabel, getMatchEnd, getMaxAxes, getMinAxes, getNaxes, getNormUnit, getObsLat, getObsLon, getPermute, getPreserveAxes, getSymbol, getSystem, getTitle, getTop, getUnit, intersect, norm, offset, offset2, permAxes, pickAxes, resolve, setActiveUnit, setAlignSystem, setBottom, setDigits, setDigits, setDirection, setDomain, setDut1, setEpoch, setEpoch, setFormat, setLabel, setMatchEnd, setMaxAxes, setMinAxes, setObsLat, setObsLon, setPermute, setPreserveAxes, setSymbol, setSystem, setTitle, setTop, setUnit, unformat

Methods inherited from class uk.ac.starlink.ast.Mapping
decompose, getInvert, getNin, getNout, getReport, getTranForward, getTranInverse, invert, linearApprox, mapBox, mapSplit, rate, rebin, rebinD, rebinF, rebinI, resample, resampleB, resampleD, resampleF, resampleI, resampleL, resampleS, setInvert, setReport, simplify, tran1, tran2, tranGrid, tranN, tranP

Methods inherited from class uk.ac.starlink.ast.AstObject
annul, clear, delete, equals, finalize, getAstConstantI, getB, getID, getIdent, getNobject, getObjSize, getRefCount, hashCode, isThreaded, reportVersions, sameObject, setB, setID, setIdent, show, tune

Methods inherited from class java.lang.Object
clone, getClass, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Plot
```
public Plot(Frame frame,
            Rectangle2D graphrect,
            double[] basebox)
```
    Creates a Plot which plots onto a given rectangle.
    
    Parameters:
    
    frame - Pointer to a Frame describing the physical coordinate system in which to plot. A pointer to a FrameSet may also be given, in which case its current Frame will be used to define the physical coordinate system and its base Frame will be mapped on to graphical coordinates (see below).
    If a null Object pointer (AST__NULL) is given, a default 2-dimensional Frame will be used to describe the physical coordinate system. Labels, etc. may then be attached to this by setting the appropriate Frame attributes (e.g. Label(axis)) for the Plot.
    
    graphrect - the rectangle which will form the area onto which plotting is done (note this excludes the area used for graph annotation).
    
    basebox -
    an 4-element array giving the coordinates of two points in the supplied Frame (or base Frame if a FrameSet was supplied) which correspond to the bottom left and top right corners of the Rectangle graphrect. The first pair of values should give the (x,y) coordinates of the bottom left corner and the second pair the top right corner. Note that the order in which these points are given is important because it defines up, down, left and right for subsequent graphical operations.
  - Plot
```
public Plot(Frame frame,
            Rectangle2D graphrect,
            double[] basebox,
            int lgap,
            int rgap,
            int bgap,
            int tgap)
```
    Creates a Plot which plots onto a given rectangle with specified proportional spaces round the edge.
    
    Parameters:
    
    frame - Pointer to a Frame describing the physical coordinate system in which to plot. A pointer to a FrameSet may also be given, in which case its current Frame will be used to define the physical coordinate system and its base Frame will be mapped on to graphical coordinates (see below).
    If a null Object pointer (AST__NULL) is given, a default 2-dimensional Frame will be used to describe the physical coordinate system. Labels, etc. may then be attached to this by setting the appropriate Frame attributes (e.g. Label(axis)) for the Plot.
    
    graphrect - the rectangle within which both the plot and space for axis annotations etc will be drawn
    
    basebox -
    an 4-element array giving the coordinates of two points in the supplied Frame (or base Frame if a FrameSet was supplied) which correspond to the bottom left and top right corners of the Rectangle graphrect. The first pair of values should give the (x,y) coordinates of the bottom left corner and the second pair the top right corner. Note that the order in which these points are given is important because it defines up, down, left and right for subsequent graphical operations.
    
    lgap - gap in graphics coordinates (pixels) free for annotation at the left of the Rectangle
    
    rgap - gap in graphics coordinates (pixels) free for annotation at the right of the Rectangle
    
    bgap - gap in graphics coordinates (pixels) free for annotation at the bottom of the Rectangle
    
    tgap - gap in graphics coordinates (pixels) free for annotation at the top of the Rectangle
    
    Throws:
    
    AstException - if any error occurs in the AST library, or if the specified gaps don't leave enough room for any plotting
- Method Detail
  - paint
```
public void paint(Graphics g)
```
    Paints the component. This method calls the paint method of this Plot's Grf object to (re)paint all the graphics caused by any methods called on this Plot since its creation or the last call of clear. It should normally be invoked by the paintComponent method of the JComponent which holds this Plot.
    
    Parameters:
    
    g - the graphics context into which to paint the graphics
  - clear
```
public void clear()
```
    Clears the component. This method calls the clear method of this Plot's Grf to reset the list of items painted by the paint method. This method does not actually erase any graphics from the screen, but will cause an immediately following call of paint to draw nothing.
  - getGrf
```
public Grf getGrf()
```
    Gets the Grf object which implements the graphics. By default this is a DefaultGrf, but custom implementations of the Grf interface may be written and substituted if required.
    
    Returns:
    
    the Grf object which is used for plotting
  - setGrf
```
public void setGrf(Grf grf)
```
    Sets the Grf object which implements the graphics. By default this is a DefaultGrf, but custom implementations of the Grf interface may be written and substituted if required.
    
    Parameters:
    
    grf - the Grf object to use for plotting
  - copy
```
public AstObject copy()
```
    Returns a fairly deep copy of this object. The Grf of the returned copy however is a reference to the same object as the Grf of this object.
    
    Overrides:
    
    copy in class AstObject
    
    Returns:
    
    copy
  - getC
```
public String getC(String attrib)
```
    Description copied from class: AstObject
    
    Get a character attribute value by name.
    
    Overrides:
    
    getC in class AstObject
    
    Parameters:
    
    attrib - the name of the character attribute to retrieve
    
    Returns:
    
    the named attribute as a String
  - getD
```
public double getD(String attrib)
```
    Description copied from class: AstObject
    
    Get a double precision attribute value by name.
    
    Overrides:
    
    getD in class AstObject
    
    Parameters:
    
    attrib - the name of the double precision attribute to retrieve
    
    Returns:
    
    the named attribute as a double
  - getF
```
public float getF(String attrib)
```
    Description copied from class: AstObject
    
    Get a floating point attribute value by name.
    
    Overrides:
    
    getF in class AstObject
    
    Parameters:
    
    attrib - the name of the floating point attribute to retrieve
    
    Returns:
    
    the named attribute as a float
  - getL
```
public long getL(String attrib)
```
    Description copied from class: AstObject
    
    Get a long integer attribute value by name.
    
    Overrides:
    
    getL in class AstObject
    
    Parameters:
    
    attrib - the name of the long integer attribute to retrieve
    
    Returns:
    
    the named attribute as a long
  - getI
```
public int getI(String attrib)
```
    Description copied from class: AstObject
    
    Get a integer attribute value by name.
    
    Overrides:
    
    getI in class AstObject
    
    Parameters:
    
    attrib - the name of the integer attribute to retrieve
    
    Returns:
    
    the named attribute as a int
  - setC
```
public void setC(String attrib,
                 String value)
```
    Description copied from class: AstObject
    
    Set a character attribute value by name.
    
    Overrides:
    
    setC in class AstObject
    
    Parameters:
    
    attrib - the name of the character attribute to set
    
    value - the new value of the attribute
  - setD
```
public void setD(String attrib,
                 double value)
```
    Description copied from class: AstObject
    
    Set a double precision attribute value by name.
    
    Overrides:
    
    setD in class AstObject
    
    Parameters:
    
    attrib - the name of the double precision attribute to set
    
    value - the new value of the attribute
  - setF
```
public void setF(String attrib,
                 float value)
```
    Description copied from class: AstObject
    
    Set a floating point attribute value by name.
    
    Overrides:
    
    setF in class AstObject
    
    Parameters:
    
    attrib - the name of the floating point attribute to set
    
    value - the new value of the attribute
  - setL
```
public void setL(String attrib,
                 long value)
```
    Description copied from class: AstObject
    
    Set a long integer attribute value by name.
    
    Overrides:
    
    setL in class AstObject
    
    Parameters:
    
    attrib - the name of the long integer attribute to set
    
    value - the new value of the attribute
  - setI
```
public void setI(String attrib,
                 int value)
```
    Description copied from class: AstObject
    
    Set a integer attribute value by name.
    
    Overrides:
    
    setI in class AstObject
    
    Parameters:
    
    attrib - the name of the integer attribute to set
    
    value - the new value of the attribute
  - test
```
public boolean test(String attrib)
```
    Description copied from class: AstObject
    
    Test if an Object attribute value is set. This function returns a boolean result (0 or 1) to indicate whether a value has been explicitly set for one of an Object's attributes.
    Notes
    
    - Attribute names are not case sensitive and may be surrounded by white space.
    - A value of zero will be returned if this function is invoked with the AST error status set, or if it should fail for any reason.
    - A value of zero will also be returned if this function is used to test a read-only attribute, although no error will result.
    
    Overrides:
    
    test in class AstObject
    
    Parameters:
    
    attrib - Pointer to a null-terminated character string containing the name of the attribute to be tested.
  - set
```
public void set(String settings)
```
    Description copied from class: AstObject
    
    Set attribute values for an Object. This function assigns a set of attribute values to an Object, over-riding any previous values. The attributes and their new values are specified via a character string, which should contain a comma-separated list of the form:
    "attribute_1 = value_1, attribute_2 = value_2, ... "
    where "attribute_n" specifies an attribute name, and the value to the right of each "=" sign should be a suitable textual representation of the value to be assigned. This value will be interpreted according to the attribute's data type.
    The string supplied may also contain "printf"-style format specifiers, identified by "%" signs in the usual way. If present, these will be substituted by values supplied as additional optional arguments (using the normal "printf" rules) before the string is used.
    Notes
    
    - Attribute names are not case sensitive and may be surrounded by white space.
    - White space may also surround attribute values, where it will generally be ignored (except for string-valued attributes where it is significant and forms part of the value to be assigned).
    - To include a literal comma in the value assigned to an attribute, the whole attribute value should be enclosed in quotation markes. Alternatively, you can use "%s" format and supply the value as a separate additional argument to astSet (or use the astSetC function instead).
    - The same procedure may be adopted if "%" signs are to be included and are not to be interpreted as format specifiers (alternatively, the "printf" convention of writing "%%" may be used).
    - An error will result if an attempt is made to set a value for a read-only attribute.
    
    Overrides:
    
    set in class AstObject
    
    Parameters:
    
    settings - Pointer to a null-terminated character string containing a comma-separated list of attribute settings in the form described above.
  - border
```
public void border()
```
    Draw a border around valid regions of a Plot. This function draws a (line) border around regions of the plotting area of a Plot which correspond to valid, unclipped physical coordinates. For example, when plotting using an all-sky map projection, this function could be used to draw the boundary of the celestial sphere when it is projected on to the plotting surface.
    If the entire plotting area contains valid, unclipped physical coordinates, then the boundary will just be a rectangular box around the edges of the plotting area.
    If the Plot is a Plot3D, this method is applied individually to each of the three 2D Plots encapsulated within the Plot3D (each of these Plots corresponds to a single 2D plane in the 3D graphics system). In addition, if the entire plotting volume has valid coordinates in the 3D current Frame of the Plot3D, then additional lines are drawn along the edges of the 3D plotting volume so that the entire plotting volume is enclosed within a cuboid grid.
    Notes
    
    - A value of zero will be returned if this function is invoked with the AST error status set, or if it should fail for any reason.
    - An error results if either the current Frame or the base Frame of the Plot is not 2-dimensional or (for a Plot3D) 3-dimensional.
    - An error also results if the transformation between the base and current Frames of the Plot is not defined (i.e. the Plot's TranForward attribute is zero).
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - boundingBox
```
public Rectangle2D boundingBox()
```
    Return a bounding box for previously drawn graphics. This function returns the bounds of a box which just encompasess the graphics produced by the previous call to any of the Plot methods which produce graphical output. If no such previous call has yet been made, or if the call failed for any reason, then the bounding box returned by this function is undefined.
    Notes
    
    - An error results if the base Frame of the Plot is not 2-dimensional.
    
    Returns:
    
    a rectangle giving the bounds of the area affected by the previous plot call
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - clip
```
public void clip(int iframe,
                 double[] lbnd,
                 double[] ubnd)
```
    Set up or remove clipping for a Plot. This function defines regions of a Plot which are to be clipped. Any subsequent graphical output created using the Plot will then be visible only within the unclipped regions of the plotting area. See also the Clip attribute.
    Notes
    
    - Only one clipping Frame may be active at a time. This function will deactivate any previously-established clipping Frame before setting up new clipping limits.
    - The clipping produced by this function is in addition to that specified by the Clip attribute which occurs at the edges of the plotting area established when the Plot is created (see astPlot). The underlying graphics system may also impose further clipping.
    - When testing a graphical position for clipping, it is first transformed into the clipping Frame. The resulting coordinate on each axis is then checked against the clipping limits (given by "lbnd" and "ubnd"). By default, a position is clipped if any coordinate lies outside these limits. However, if a non-zero value is assigned to the Plot's ClipOp attribute, then a position is only clipped if the coordinates on all axes lie outside their clipping limits.
    - If the lower clipping limit exceeds the upper limit for any axis, then the sense of clipping for that axis is reversed (so that coordinate values lying between the limits are clipped instead of those lying outside the limits). To produce a "hole" in a coordinate space (that is, an internal region where nothing is plotted), you should supply all the bounds in reversed order, and set the ClipOp attribute for the Plot to a non-zero value.
    - Either clipping limit may be set to the value AST__BAD, which is equivalent to setting it to infinity (or minus infinity for a lower bound) so that it is not used.
    - If a graphical position results in any bad coordinate values (AST__BAD) when transformed into the clipping Frame, then it is treated (for the purposes of producing graphical output) as if it were clipped.
    - When a Plot is used as a Mapping to transform points (e.g. using astTran2), any clipped output points are assigned coordinate values of AST__BAD.
    - An error results if the base Frame of the Plot is not 2-dimensional.
    
    Parameters:
    
    iframe - The index of the Frame within the Plot to which the clipping limits supplied in "lbnd" and "ubnd" (below) refer. Clipping may be applied to any of the coordinate systems associated with a Plot (as defined by the Frames it contains), so this index may take any value from 1 to the number of Frames in the Plot (Nframe attribute). In addition, the values AST__BASE and AST__CURRENT may be used to specify the base and current Frames respectively.
    For example, a value of AST__CURRENT causes clipping to be performed in physical coordinates, while a value of AST__BASE would clip in graphical coordinates. Clipping may also be removed completely by giving a value of AST__NOFRAME. In this case any clipping bounds supplied (below) are ignored.
    
    lbnd - An array with one element for each axis of the clipping Frame (identified by the index "iframe"). This should contain the lower bound, on each axis, of the region which is to remain visible (unclipped).
    
    ubnd - An array with one element for each axis of the clipping Frame (identified by the index "iframe"). This should contain the upper bound, on each axis, of the region which is to remain visible (unclipped).
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - curve
```
public void curve(double[] start,
                  double[] finish)
```
    Draw a geodesic curve. This function draws a geodesic curve between two points in the physical coordinate system of a Plot. The curve drawn is the path of shortest distance joining the two points (as defined by the astDistance function for the current Frame of the Plot). For example, if the current Frame is a basic Frame, then the curve joining the two points will be a straight line in physical coordinate space. If the current Frame is more specialised and describes, for instance, a sky coordinate system, then the geodesic curve would be a great circle in physical coordinate space passing through the two sky positions given.
    Note that the geodesic curve is transformed into graphical coordinate space for plotting, so that a straight line in physical coordinates may result in a curved line being drawn if the Mapping involved is non-linear. Any discontinuities in the Mapping between physical and graphical coordinates are catered for, as is any clipping established using astClip.
    If you need to draw many geodesic curves end-to-end, then the astPolyCurve function is equivalent to repeatedly using astCurve, but will usually be more efficient.
    If you need to draw curves which are not geodesics, see astGenCurve or astGridLine.
    Notes
    
    - No curve is drawn if either of the "start" or "finish" arrays contains any coordinates with the value AST__BAD.
    - An error results if the base Frame of the Plot is not 2-dimensional.
    - An error also results if the transformation between the current and base Frames of the Plot is not defined (i.e. the Plot's TranInverse attribute is zero).
    
    Parameters:
    
    start - An array, with one element for each axis of the Plot, giving the physical coordinates of the first point on the geodesic curve.
    
    finish - An array, with one element for each axis of the Plot, giving the physical coordinates of the second point on the geodesic curve.
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - genCurve
```
public void genCurve(Mapping map)
```
    Draw a generalized curve. This function draws a general user-defined curve defined by the supplied Mapping. Note that the curve is transformed into graphical coordinate space for plotting, so that a straight line in physical coordinates may result in a curved line being drawn if the Mapping involved is non-linear. Any discontinuities in the Mapping between physical and graphical coordinates are catered for, as is any clipping established using astClip.
    If you need to draw simple straight lines (geodesics), astCurve or astPolyCurve will usually be easier to use and faster.
    Notes
    
    - An error results if the base Frame of the Plot is not 2-dimensional.
    - An error also results if the transformation between the current and base Frames of the Plot is not defined (i.e. the Plot's TranInverse attribute is zero).
    
    Parameters:
    
    map - Pointer to a Mapping. This Mapping should have 1 input coordinate representing offset along the required curve, normalized so that the start of the curve is at offset 0.0, and the end of the curve is at offset 1.0. Note, this offset does not need to be linearly related to distance along the curve. The number of output coordinates should equal the number of axes in the current Frame of the Plot. The Mapping should map a specified offset along the curve, into the corresponding coordinates in the current Frame of the Plot. The inverse transformation need not be defined.
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - grid
```
public void grid()
```
    Draw a set of labelled coordinate axes. This function draws a complete annotated set of coordinate axes for a Plot with (optionally) a coordinate grid superimposed. Details of the axes and grid can be controlled by setting values for the various attributes defined by the Plot class (q.v.).
    Notes
    
    - If the supplied Plot is a Plot3D, the axes will be annotated using three 2-dimensional Plots, one for each 2D plane in the 3D current coordinate system. The plots will be "pasted" onto 3 faces of the cuboid graphics volume specified when the Plot3D was constructed. The faces to be used can be controlled by the "RootCorner" attribute.
    - An error results if either the current Frame or the base Frame of the Plot is not 2-dimensional or (for a Plot3D) 3-dimensional.
    - An error also results if the transformation between the base and current Frames of the Plot is not defined in either direction (i.e. the Plot's TranForward or TranInverse attribute is zero).
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - gridLine
```
public void gridLine(int axis,
                     double[] start,
                     double length)
```
    Draw a grid line (or axis) for a Plot. This function draws a curve in the physical coordinate system of a Plot by varying only one of the coordinates along the length of the curve. It is intended for drawing coordinate axes, coordinate grids, and tick marks on axes (but note that these are also available via the more comprehensive astGrid function).
    The curve is transformed into graphical coordinate space for plotting, so that a straight line in physical coordinates may result in a curved line being drawn if the Mapping involved is non-linear. Any discontinuities in the Mapping between physical and graphical coordinates are catered for, as is any clipping established using astClip.
    Notes
    
    - No curve is drawn if the "start" array contains any coordinates with the value AST__BAD, nor if "length" has this value.
    - An error results if the base Frame of the Plot is not 2-dimensional.
    - An error also results if the transformation between the current and base Frames of the Plot is not defined (i.e. the Plot's TranInverse attribute is zero).
    
    Parameters:
    
    axis - The index of the Plot axis whose physical coordinate value is to be varied along the length of the curve (all other coordinates will remain fixed). This value should lie in the range from 1 to the number of Plot axes (Naxes attribute).
    
    start - An array, with one element for each axis of the Plot, giving the physical coordinates of the start of the curve.
    
    length - The length of curve to be drawn, given as an increment along the selected physical axis. This may be positive or negative.
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - mark
```
public void mark(int nmark,
                 int ncoord,
                 double[][] in,
                 int type)
```
    Draw a set of markers for a Plot. This function draws a set of markers (symbols) at positions specified in the physical coordinate system of a Plot. The positions are transformed into graphical coordinates to determine where the markers should appear within the plotting area.
    Notes
    
    - Markers are not drawn at positions which have any coordinate equal to the value AST__BAD (or where the transformation into graphical coordinates yields coordinates containing the value AST__BAD).
    - If any marker position is clipped (see astClip), then the entire marker is not drawn.
    - An error results if the base Frame of the Plot is not 2-dimensional.
    - An error also results if the transformation between the current and base Frames of the Plot is not defined (i.e. the Plot's TranInverse attribute is zero).
    
    Parameters:
    
    nmark - The number of markers to draw. This may be zero, in which case nothing will be drawn.
    
    ncoord - The number of coordinates being supplied for each mark (i.e. the number of axes in the current Frame of the Plot, as given by its Naxes attribute).
    
    in - The address of the first element of a 2-dimensional array of shape "[ncoord][indim]" giving the physical coordinates of the points where markers are to be drawn. These should be stored such that the value of coordinate number "coord" for input mark number "mark" is found in element "in[coord][mark]".
    
    type - a value specifying the type (e.g. shape) of the marker to be drawn. The available types are defined by the Grf object which implements the graphics (by default this is DefaultGrf, which uses the types defined by DefaultGrfMarker).
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - polyCurve
```
public void polyCurve(int npoint,
                      int ncoord,
                      double[][] in)
```
    Draw a series of connected geodesic curves. This function joins a series of points specified in the physical coordinate system of a Plot by drawing a sequence of geodesic curves. It is equivalent to making repeated use of the astCurve function (q.v.), except that astPolyCurve will generally be more efficient when drawing many geodesic curves end-to-end. A typical application of this might be in drawing contour lines.
    As with astCurve, full account is taken of the Mapping between physical and graphical coordinate systems. This includes any discontinuities and clipping established using astClip.
    Notes
    
    - No curve is drawn on either side of any point which has any coordinate equal to the value AST__BAD.
    - An error results if the base Frame of the Plot is not 2-dimensional.
    - An error also results if the transformation between the current and base Frames of the Plot is not defined (i.e. the Plot's TranInverse attribute is zero).
    
    Parameters:
    
    npoint - The number of points between which geodesic curves are to be drawn.
    
    ncoord - The number of coordinates being supplied for each point (i.e. the number of axes in the current Frame of the Plot, as given by its Naxes attribute).
    
    in - The address of the first element in a 2-dimensional array of shape "[ncoord][indim]" giving the physical coordinates of the points which are to be joined in sequence by geodesic curves. These should be stored such that the value of coordinate number "coord" for point number "point" is found in element "in[coord][point]".
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - text
```
public void text(String text,
                 double[] pos,
                 float[] up,
                 String just)
```
    Draw a text string for a Plot. This function draws a string of text at a position specified in the physical coordinate system of a Plot. The physical position is transformed into graphical coordinates to determine where the text should appear within the plotting area.
    Notes
    
    - The Plot3D class currently does not interpret graphical escape sequences contained within text displayed using this method.
    - Text is not drawn at positions which have any coordinate equal to the value AST__BAD (or where the transformation into graphical coordinates yields coordinates containing the value AST__BAD).
    - If the plotting position is clipped (see astClip), then no text is drawn.
    - An error results if the base Frame of the Plot is not 2-dimensional or (for a Plot3D) 3-dimensional.
    - An error also results if the transformation between the current and base Frames of the Plot is not defined (i.e. the Plot's TranInverse attribute is zero).
    
    Parameters:
    
    text - Pointer to a null-terminated character string containing the text to be drawn. Trailing white space is ignored.
    
    pos - An array, with one element for each axis of the Plot, giving the physical coordinates of the point where the reference position of the text string is to be placed.
    
    up - An array holding the components of a vector in the "up" direction of the text (in graphical coordinates). For example, to get horizontal text, the vector {0.0f,1.0f} should be supplied. For a basic Plot, 2 values should be supplied. For a Plot3D, 3 values should be supplied, and the actual up vector used is the projection of the supplied up vector onto the text plane specified by the current value of the Plot3D's Norm attribute.
    
    just - Pointer to a null-terminated character string identifying the reference point for the text being drawn. The first character in this string identifies the reference position in the "up" direction and may be "B" (baseline), "C" (centre), "T" (top) or "M" (bottom). The second character identifies the side-to-side reference position and may be "L" (left), "C" (centre) or "R" (right ). The string is case-insensitive, and only the first two characters are significant.
    For example, a value of "BL" means that the left end of the baseline of the original (un-rotated) text is to be drawn at the position given by "pos".
    
    Throws:
    
    AstException - if an error occurred in the AST library
  - getBorder
```
public boolean getBorder()
```
    Get draw a border around valid regions of a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether a border is drawn around regions corresponding to the valid physical coordinates of a Plot (c.f. astBorder).
    If the Border value of a Plot is non-zero, then this border will be drawn as part of the grid. Otherwise, the border is not drawn (although axis labels and tick marks will still appear, unless other relevant Plot attributes indicate that they should not). The default behaviour is to draw the border if tick marks and numerical labels will be drawn around the edges of the plotting area (see the Labelling attribute), but to omit it otherwise.
    
    Returns:
    
    this object's Border attribute
  - setBorder
```
public void setBorder(boolean border)
```
    Set draw a border around valid regions of a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether a border is drawn around regions corresponding to the valid physical coordinates of a Plot (c.f. astBorder).
    If the Border value of a Plot is non-zero, then this border will be drawn as part of the grid. Otherwise, the border is not drawn (although axis labels and tick marks will still appear, unless other relevant Plot attributes indicate that they should not). The default behaviour is to draw the border if tick marks and numerical labels will be drawn around the edges of the plotting area (see the Labelling attribute), but to omit it otherwise.
    
    Parameters:
    
    border - the Border attribute of this object
  - getClip
```
public int getClip()
```
    Get clip lines and/or markers at the Plot boundary. This attribute controls whether curves and markers are clipped at the boundary of the graphics box specified when the Plot was created. A value of 3 implies both markers and curves are clipped at the Plot boundary. A value of 2 implies markers are clipped, but not curves. A value of 1 implies curves are clipped, but not markers. A value of zero implies neither curves nor markers are clipped. The default value is 1. Note, this attributes controls only the clipping performed internally within AST. The underlying graphics system may also apply clipping. In such cases, removing clipping using this attribute does not guarantee that no clipping will be visible in the final plot.
    The astClip function can be used to establish generalised clipping within arbitrary regions of the Plot.
    
    Returns:
    
    this object's Clip attribute
  - setClip
```
public void setClip(int clip)
```
    Set clip lines and/or markers at the Plot boundary. This attribute controls whether curves and markers are clipped at the boundary of the graphics box specified when the Plot was created. A value of 3 implies both markers and curves are clipped at the Plot boundary. A value of 2 implies markers are clipped, but not curves. A value of 1 implies curves are clipped, but not markers. A value of zero implies neither curves nor markers are clipped. The default value is 1. Note, this attributes controls only the clipping performed internally within AST. The underlying graphics system may also apply clipping. In such cases, removing clipping using this attribute does not guarantee that no clipping will be visible in the final plot.
    The astClip function can be used to establish generalised clipping within arbitrary regions of the Plot.
    
    Parameters:
    
    clip - the Clip attribute of this object
  - getClipOp
```
public boolean getClipOp()
```
    Get combine Plot clipping limits using a boolean OR. This attribute controls how the clipping limits specified for each axis of a Plot (using the astClip function) are combined. This, in turn, determines which parts of the graphical output will be visible.
    If the ClipOp attribute of a Plot is zero (the default), graphical output is visible only if it satisfies the clipping limits on all the axes of the clipping Frame (a boolean AND). Otherwise, if ClipOp is non-zero, output is visible if it satisfies the clipping limits on one or more axes (a boolean OR).
    An important use of this attribute is to allow areas of a Plot to be left clear (e.g. as a background for some text). To achieve this, the lower and upper clipping bounds supplied to astClip should be reversed, and the ClipOp attribute of the Plot should be set to a non-zero value.
    
    Returns:
    
    this object's ClipOp attribute
  - setClipOp
```
public void setClipOp(boolean clipOp)
```
    Set combine Plot clipping limits using a boolean OR. This attribute controls how the clipping limits specified for each axis of a Plot (using the astClip function) are combined. This, in turn, determines which parts of the graphical output will be visible.
    If the ClipOp attribute of a Plot is zero (the default), graphical output is visible only if it satisfies the clipping limits on all the axes of the clipping Frame (a boolean AND). Otherwise, if ClipOp is non-zero, output is visible if it satisfies the clipping limits on one or more axes (a boolean OR).
    An important use of this attribute is to allow areas of a Plot to be left clear (e.g. as a background for some text). To achieve this, the lower and upper clipping bounds supplied to astClip should be reversed, and the ClipOp attribute of the Plot should be set to a non-zero value.
    
    Parameters:
    
    clipOp - the ClipOp attribute of this object
  - getColour
```
public int getColour(String element)
```
    Get colour index for a Plot element by graphical element. This attribute determines the colour index used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Colour(title)=2" causes the Plot title to be drawn using colour index 2. The synonym "Color" may also be used.
    The range of integer colour indices available and their appearance is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default colour index supplied by this graphics system (normally, this is likely to result in white plotting on a black background, or vice versa).
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Colour" instead of "Colour(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Colour(TextLab) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    The mapping of an integer value to a colour is done by the Grf object which implements the graphics. By default this is a DefaultGrf object, which interprets the value like the result of a Color.getRGB() call on the Color object which represents the colour to use. This means the top 8 bits of the integer represent alpha blending (0xff means opaque and 0x00 means transparent) and the bottom 24 bits represent RGB intensity. For example opaque (i.e. normal) light grey would be 0xffc0c0c0 and semi-transparent light grey would be 0x80c0c0c0.
    Note that this means using a simple 24-bit RGB representation will give you a transparent colour, which is probably not what you want. Assuming you want to be able to see the results you should do setColour(java.awt.Color.LIGHT_GRAY.getRGB()) or setColour(0xffc0c0c0), and not setColour(0xc0c0c0).
    Parameters:
    
    element - name of the graphical element for which the attribute is to be got
    
    Returns:
    
    the Colour attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setColour
```
public void setColour(String element,
                      int colour)
```
    Set colour index for a Plot element by graphical element. This attribute determines the colour index used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Colour(title)=2" causes the Plot title to be drawn using colour index 2. The synonym "Color" may also be used.
    The range of integer colour indices available and their appearance is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default colour index supplied by this graphics system (normally, this is likely to result in white plotting on a black background, or vice versa).
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Colour" instead of "Colour(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Colour(TextLab) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    The mapping of an integer value to a colour is done by the Grf object which implements the graphics. By default this is a DefaultGrf object, which interprets the value like the result of a Color.getRGB() call on the Color object which represents the colour to use. This means the top 8 bits of the integer represent alpha blending (0xff means opaque and 0x00 means transparent) and the bottom 24 bits represent RGB intensity. For example opaque (i.e. normal) light grey would be 0xffc0c0c0 and semi-transparent light grey would be 0x80c0c0c0.
    Note that this means using a simple 24-bit RGB representation will give you a transparent colour, which is probably not what you want. Assuming you want to be able to see the results you should do setColour(java.awt.Color.LIGHT_GRAY.getRGB()) or setColour(0xffc0c0c0), and not setColour(0xc0c0c0).
    Parameters:
    
    element - name of the graphical element for which the attribute is to be set
    
    colour - the Colour attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setColour
```
public void setColour(int colour)
```
    Set colour index for a Plot element. This attribute determines the colour index used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Colour(title)=2" causes the Plot title to be drawn using colour index 2. The synonym "Color" may also be used.
    The range of integer colour indices available and their appearance is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default colour index supplied by this graphics system (normally, this is likely to result in white plotting on a black background, or vice versa).
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Colour" instead of "Colour(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Colour(TextLab) value.
    The mapping of an integer value to a colour is done by the Grf object which implements the graphics. By default this is a DefaultGrf object, which interprets the value like the result of a Color.getRGB() call on the Color object which represents the colour to use. This means the top 8 bits of the integer represent alpha blending (0xff means opaque and 0x00 means transparent) and the bottom 24 bits represent RGB intensity. For example opaque (i.e. normal) light grey would be 0xffc0c0c0 and semi-transparent light grey would be 0x80c0c0c0.
    Note that this means using a simple 24-bit RGB representation will give you a transparent colour, which is probably not what you want. Assuming you want to be able to see the results you should do setColour(java.awt.Color.LIGHT_GRAY.getRGB()) or setColour(0xffc0c0c0), and not setColour(0xc0c0c0).
    
    Parameters:
    
    colour - the Colour attribute of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - getDrawAxes
```
public boolean getDrawAxes(int axis)
```
    Get draw axes for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether curves representing coordinate axes should be drawn. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "DrawAxes(2)=0" specifies that no axis should be drawn for the second axis.
    If drawn, these axis lines will pass through any tick marks associated with numerical labels drawn to mark values on the axes. The location of these tick marks and labels (and hence the axis lines) is determined by the Plot's LabelAt(axis) attribute.
    If the DrawAxes value of a Plot is non-zero (the default), then axis lines will be drawn, otherwise they will be omitted.
    Notes
    
    - Axis lines are drawn independently of any coordinate grid lines (see the Grid attribute) so grid lines may be used to substitute for axis lines if required.
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the DrawAxes attribute is ignored.
    - If no axis is specified, (e.g. "DrawAxes" instead of "DrawAxes(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the DrawAxes(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the DrawAxes attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setDrawAxes
```
public void setDrawAxes(int axis,
                        boolean drawAxes)
```
    Set draw axes for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether curves representing coordinate axes should be drawn. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "DrawAxes(2)=0" specifies that no axis should be drawn for the second axis.
    If drawn, these axis lines will pass through any tick marks associated with numerical labels drawn to mark values on the axes. The location of these tick marks and labels (and hence the axis lines) is determined by the Plot's LabelAt(axis) attribute.
    If the DrawAxes value of a Plot is non-zero (the default), then axis lines will be drawn, otherwise they will be omitted.
    Notes
    
    - Axis lines are drawn independently of any coordinate grid lines (see the Grid attribute) so grid lines may be used to substitute for axis lines if required.
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the DrawAxes attribute is ignored.
    - If no axis is specified, (e.g. "DrawAxes" instead of "DrawAxes(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the DrawAxes(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    drawAxes - the DrawAxes attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - getDrawAxes
```
public boolean getDrawAxes()
```
    Get draw axes for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether curves representing coordinate axes should be drawn. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "DrawAxes(2)=0" specifies that no axis should be drawn for the second axis.
    If drawn, these axis lines will pass through any tick marks associated with numerical labels drawn to mark values on the axes. The location of these tick marks and labels (and hence the axis lines) is determined by the Plot's LabelAt(axis) attribute.
    If the DrawAxes value of a Plot is non-zero (the default), then axis lines will be drawn, otherwise they will be omitted.
    Notes
    
    - Axis lines are drawn independently of any coordinate grid lines (see the Grid attribute) so grid lines may be used to substitute for axis lines if required.
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the DrawAxes attribute is ignored.
    - If no axis is specified, (e.g. "DrawAxes" instead of "DrawAxes(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the DrawAxes(1) value.
    
    Returns:
    
    this object's DrawAxes attribute
  - setDrawAxes
```
public void setDrawAxes(boolean drawAxes)
```
    Set draw axes for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether curves representing coordinate axes should be drawn. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "DrawAxes(2)=0" specifies that no axis should be drawn for the second axis.
    If drawn, these axis lines will pass through any tick marks associated with numerical labels drawn to mark values on the axes. The location of these tick marks and labels (and hence the axis lines) is determined by the Plot's LabelAt(axis) attribute.
    If the DrawAxes value of a Plot is non-zero (the default), then axis lines will be drawn, otherwise they will be omitted.
    Notes
    
    - Axis lines are drawn independently of any coordinate grid lines (see the Grid attribute) so grid lines may be used to substitute for axis lines if required.
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the DrawAxes attribute is ignored.
    - If no axis is specified, (e.g. "DrawAxes" instead of "DrawAxes(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the DrawAxes(1) value.
    
    Parameters:
    
    drawAxes - the DrawAxes attribute of this object
  - getDrawTitle
```
public boolean getDrawTitle()
```
    Get draw a title for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether a title is drawn.
    If the DrawTitle value of a Plot is non-zero (the default), then the title will be drawn, otherwise it will be omitted.
    Notes
    
    - The text used for the title is obtained from the Plot's Title attribute.
    - The vertical placement of the title can be controlled using the TitleGap attribute.
    
    Returns:
    
    this object's DrawTitle attribute
  - setDrawTitle
```
public void setDrawTitle(boolean drawTitle)
```
    Set draw a title for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether a title is drawn.
    If the DrawTitle value of a Plot is non-zero (the default), then the title will be drawn, otherwise it will be omitted.
    Notes
    
    - The text used for the title is obtained from the Plot's Title attribute.
    - The vertical placement of the title can be controlled using the TitleGap attribute.
    
    Parameters:
    
    drawTitle - the DrawTitle attribute of this object
  - getEdge
```
public String getEdge(int axis)
```
    Get which edges to label in a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining which edges of a Plot are used for displaying numerical and descriptive axis labels. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "Edge(2)=left" specifies which edge to use to display labels for the second axis.
    The values "left", "top", "right" and "bottom" (or any abbreviation) can be supplied for this attribute. The default is usually "bottom" for the first axis and "left" for the second axis. However, if exterior labelling was requested (see the Labelling attribute) but cannot be produced using these default Edge values, then the default values will be swapped if this enables exterior labelling to be produced.
    Notes
    
    - In some circumstances, numerical labels will be drawn along internal grid lines instead of at the edges of the plotting area (see the Labelling attribute). In this case, the Edge attribute only affects the placement of the descriptive labels (these are drawn at the edges of the plotting area, rather than along the axis lines).
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the Edge attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setEdge
```
public void setEdge(int axis,
                    String edge)
```
    Set which edges to label in a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining which edges of a Plot are used for displaying numerical and descriptive axis labels. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "Edge(2)=left" specifies which edge to use to display labels for the second axis.
    The values "left", "top", "right" and "bottom" (or any abbreviation) can be supplied for this attribute. The default is usually "bottom" for the first axis and "left" for the second axis. However, if exterior labelling was requested (see the Labelling attribute) but cannot be produced using these default Edge values, then the default values will be swapped if this enables exterior labelling to be produced.
    Notes
    
    - In some circumstances, numerical labels will be drawn along internal grid lines instead of at the edges of the plotting area (see the Labelling attribute). In this case, the Edge attribute only affects the placement of the descriptive labels (these are drawn at the edges of the plotting area, rather than along the axis lines).
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    edge - the Edge attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - getEscape
```
public boolean getEscape()
```
    Get allow changes of character attributes within strings. This attribute controls the appearance of text strings and numerical labels drawn by the astGrid and (for the Plot class) astText functions, by determining if any escape sequences contained within the strings should be used to control the appearance of the text, or should be printed literally. Note, the Plot3D class only interprets escape sequences within the astGrid function.
    If the Escape value of a Plot is one (the default), then any escape sequences in text strings produce the effects described below when printed. Otherwise, they are printed literally.
    See also the GrfEscape.setEscapes(boolean) function.
    Escape Sequences
    Escape sequences are introduced into the text string by a percent "%" character. Any unrecognised, illegal or incomplete escape sequences are printed literally. The following escape sequences are currently recognised ("..." represents a string of one or more decimal digits):
    %% - Print a literal "%" character.
    %^...+ - Draw subsequent characters as super-scripts. The digits "..." give the distance from the base-line of "normal" text to the base-line of the super-script text, scaled so that a value of "100" corresponds to the height of "normal" text. %^+ - Draw subsequent characters with the normal base-line.
    %v...+ - Draw subsequent characters as sub-scripts. The digits "..." give the distance from the base-line of "normal" text to the base-line of the sub-script text, scaled so that a value of "100" corresponds to the height of "normal" text.
    %v+ - Draw subsequent characters with the normal base-line (equivalent to %^+).
    %>...+ - Leave a gap before drawing subsequent characters. The digits "..." give the size of the gap, scaled so that a value of "100" corresponds to the height of "normal" text.
    %<...+ - Move backwards before drawing subsequent characters. The digits "..." give the size of the movement, scaled so that a value of "100" corresponds to the height of "normal" text.
    %s...+ - Change the Size attribute for subsequent characters. The digits "..." give the new Size as a fraction of the "normal" Size, scaled so that a value of "100" corresponds to 1.0;
    %s+ - Reset the Size attribute to its "normal" value.
    %w...+ - Change the Width attribute for subsequent characters. The digits "..." give the new width as a fraction of the "normal" Width, scaled so that a value of "100" corresponds to 1.0;
    %w+ - Reset the Size attribute to its "normal" value.
    %f...+ - Change the Font attribute for subsequent characters. The digits "..." give the new Font value.
    %f+ - Reset the Font attribute to its "normal" value.
    %c...+ - Change the Colour attribute for subsequent characters. The digits "..." give the new Colour value.
    %c+ - Reset the Colour attribute to its "normal" value.
    %t...+ - Change the Style attribute for subsequent characters. The digits "..." give the new Style value.
    %t+ - Reset the Style attribute to its "normal" value.
    %h+ - Remember the current horizontal position (see "%g+")
    %g+ - Go to the horizontal position of the previous "%h+" (if any).
    %- - Push the current graphics attribute values onto the top of the stack (see "%+").
    %+ - Pop attributes values of the top the stack (see "%-"). If the stack is empty, "normal" attribute values are restored.
    
    Returns:
    
    this object's Escape attribute
    
    See Also:
    
    GrfEscape
  - setEscape
```
public void setEscape(boolean escape)
```
    Set allow changes of character attributes within strings. This attribute controls the appearance of text strings and numerical labels drawn by the astGrid and (for the Plot class) astText functions, by determining if any escape sequences contained within the strings should be used to control the appearance of the text, or should be printed literally. Note, the Plot3D class only interprets escape sequences within the astGrid function.
    If the Escape value of a Plot is one (the default), then any escape sequences in text strings produce the effects described below when printed. Otherwise, they are printed literally.
    See also the GrfEscape.setEscapes(boolean) function.
    Escape Sequences
    Escape sequences are introduced into the text string by a percent "%" character. Any unrecognised, illegal or incomplete escape sequences are printed literally. The following escape sequences are currently recognised ("..." represents a string of one or more decimal digits):
    %% - Print a literal "%" character.
    %^...+ - Draw subsequent characters as super-scripts. The digits "..." give the distance from the base-line of "normal" text to the base-line of the super-script text, scaled so that a value of "100" corresponds to the height of "normal" text. %^+ - Draw subsequent characters with the normal base-line.
    %v...+ - Draw subsequent characters as sub-scripts. The digits "..." give the distance from the base-line of "normal" text to the base-line of the sub-script text, scaled so that a value of "100" corresponds to the height of "normal" text.
    %v+ - Draw subsequent characters with the normal base-line (equivalent to %^+).
    %>...+ - Leave a gap before drawing subsequent characters. The digits "..." give the size of the gap, scaled so that a value of "100" corresponds to the height of "normal" text.
    %<...+ - Move backwards before drawing subsequent characters. The digits "..." give the size of the movement, scaled so that a value of "100" corresponds to the height of "normal" text.
    %s...+ - Change the Size attribute for subsequent characters. The digits "..." give the new Size as a fraction of the "normal" Size, scaled so that a value of "100" corresponds to 1.0;
    %s+ - Reset the Size attribute to its "normal" value.
    %w...+ - Change the Width attribute for subsequent characters. The digits "..." give the new width as a fraction of the "normal" Width, scaled so that a value of "100" corresponds to 1.0;
    %w+ - Reset the Size attribute to its "normal" value.
    %f...+ - Change the Font attribute for subsequent characters. The digits "..." give the new Font value.
    %f+ - Reset the Font attribute to its "normal" value.
    %c...+ - Change the Colour attribute for subsequent characters. The digits "..." give the new Colour value.
    %c+ - Reset the Colour attribute to its "normal" value.
    %t...+ - Change the Style attribute for subsequent characters. The digits "..." give the new Style value.
    %t+ - Reset the Style attribute to its "normal" value.
    %h+ - Remember the current horizontal position (see "%g+")
    %g+ - Go to the horizontal position of the previous "%h+" (if any).
    %- - Push the current graphics attribute values onto the top of the stack (see "%+").
    %+ - Pop attributes values of the top the stack (see "%-"). If the stack is empty, "normal" attribute values are restored.
    
    Parameters:
    
    escape - the Escape attribute of this object
    
    See Also:
    
    GrfEscape
  - getFont
```
public int getFont(String element)
```
    Get character font for a Plot element by graphical element. This attribute determines the character font index used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Font(title)=2" causes the Plot title to be drawn using font number 2.
    The range of integer font indices available and the appearance of the resulting text is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default font supplied by this graphics system.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Font" instead of "Font(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Font(TextLab) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    In the default Grf implementation (DefaultGrf the submitted integer is mapped to a font using the DefaultGrfFontManager class.
    Parameters:
    
    element - name of the graphical element for which the attribute is to be got
    
    Returns:
    
    the Font attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setFont
```
public void setFont(String element,
                    int font)
```
    Set character font for a Plot element by graphical element. This attribute determines the character font index used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Font(title)=2" causes the Plot title to be drawn using font number 2.
    The range of integer font indices available and the appearance of the resulting text is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default font supplied by this graphics system.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Font" instead of "Font(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Font(TextLab) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    In the default Grf implementation (DefaultGrf the submitted integer is mapped to a font using the DefaultGrfFontManager class.
    Parameters:
    
    element - name of the graphical element for which the attribute is to be set
    
    font - the Font attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - getFont
```
public int getFont()
```
    Get character font for a Plot element. This attribute determines the character font index used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Font(title)=2" causes the Plot title to be drawn using font number 2.
    The range of integer font indices available and the appearance of the resulting text is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default font supplied by this graphics system.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Font" instead of "Font(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Font(TextLab) value.
    In the default Grf implementation (DefaultGrf the submitted integer is mapped to a font using the DefaultGrfFontManager class.
    
    Returns:
    
    this object's Font attribute
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setFont
```
public void setFont(int font)
```
    Set character font for a Plot element. This attribute determines the character font index used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Font(title)=2" causes the Plot title to be drawn using font number 2.
    The range of integer font indices available and the appearance of the resulting text is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default font supplied by this graphics system.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Font" instead of "Font(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Font(TextLab) value.
    In the default Grf implementation (DefaultGrf the submitted integer is mapped to a font using the DefaultGrfFontManager class.
    
    Parameters:
    
    font - the Font attribute of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - getGap
```
public double getGap(int axis)
```
    Get interval between linearly spaced major axis values of a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the linear interval between the "major" axis values of a Plot, at which (for example) major tick marks are drawn. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "Gap(2)=3.0" specifies the difference between adjacent major values along the second axis. The Gap attribute is only used when the LogTicks attribute indicates that the spacing between major axis values is to be linear. If major axis values are logarithmically spaced then the gap is specified using attribute LogGap.
    The Gap value supplied will usually be rounded to the nearest "nice" value, suitable (e.g.) for generating axis labels, before use. To avoid this "nicing" you should set an explicit format for the axis using the Format(axis) or Digits/Digits(axis) attribute. The default behaviour is for the Plot to generate its own Gap value when required, based on the range of axis values to be represented.
    Notes
    
    - The Gap value should use the same units as are used internally for storing coordinate values on the corresponding axis. For example, with a celestial coordinate system, the Gap value should be in radians, not hours or degrees.
    - If no axis is specified, (e.g. "Gap" instead of "Gap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the Gap(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the Gap attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setGap
```
public void setGap(int axis,
                   double gap)
```
    Set interval between linearly spaced major axis values of a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the linear interval between the "major" axis values of a Plot, at which (for example) major tick marks are drawn. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "Gap(2)=3.0" specifies the difference between adjacent major values along the second axis. The Gap attribute is only used when the LogTicks attribute indicates that the spacing between major axis values is to be linear. If major axis values are logarithmically spaced then the gap is specified using attribute LogGap.
    The Gap value supplied will usually be rounded to the nearest "nice" value, suitable (e.g.) for generating axis labels, before use. To avoid this "nicing" you should set an explicit format for the axis using the Format(axis) or Digits/Digits(axis) attribute. The default behaviour is for the Plot to generate its own Gap value when required, based on the range of axis values to be represented.
    Notes
    
    - The Gap value should use the same units as are used internally for storing coordinate values on the corresponding axis. For example, with a celestial coordinate system, the Gap value should be in radians, not hours or degrees.
    - If no axis is specified, (e.g. "Gap" instead of "Gap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the Gap(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    gap - the Gap attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setGap
```
public void setGap(double gap)
```
    Set interval between linearly spaced major axis values of a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the linear interval between the "major" axis values of a Plot, at which (for example) major tick marks are drawn. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "Gap(2)=3.0" specifies the difference between adjacent major values along the second axis. The Gap attribute is only used when the LogTicks attribute indicates that the spacing between major axis values is to be linear. If major axis values are logarithmically spaced then the gap is specified using attribute LogGap.
    The Gap value supplied will usually be rounded to the nearest "nice" value, suitable (e.g.) for generating axis labels, before use. To avoid this "nicing" you should set an explicit format for the axis using the Format(axis) or Digits/Digits(axis) attribute. The default behaviour is for the Plot to generate its own Gap value when required, based on the range of axis values to be represented.
    Notes
    
    - The Gap value should use the same units as are used internally for storing coordinate values on the corresponding axis. For example, with a celestial coordinate system, the Gap value should be in radians, not hours or degrees.
    - If no axis is specified, (e.g. "Gap" instead of "Gap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the Gap(1) value.
    
    Parameters:
    
    gap - the Gap attribute of this object
  - getGrid
```
public boolean getGrid()
```
    Get draw grid lines for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether grid lines (a grid of curves marking the "major" values on each axis) are drawn across the plotting area.
    If the Grid value of a Plot is non-zero, then grid lines will be drawn. Otherwise, short tick marks on the axes are used to mark the major axis values. The default behaviour is to use tick marks if the entire plotting area is filled by valid physical coordinates, but to draw grid lines otherwise.
    Notes
    
    - The spacing between major axis values, which determines the spacing of grid lines, may be set using the Gap(axis) attribute.
    
    Returns:
    
    this object's Grid attribute
  - setGrid
```
public void setGrid(boolean grid)
```
    Set draw grid lines for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether grid lines (a grid of curves marking the "major" values on each axis) are drawn across the plotting area.
    If the Grid value of a Plot is non-zero, then grid lines will be drawn. Otherwise, short tick marks on the axes are used to mark the major axis values. The default behaviour is to use tick marks if the entire plotting area is filled by valid physical coordinates, but to draw grid lines otherwise.
    Notes
    
    - The spacing between major axis values, which determines the spacing of grid lines, may be set using the Gap(axis) attribute.
    
    Parameters:
    
    grid - the Grid attribute of this object
  - getInvisible
```
public boolean getInvisible()
```
    Get draw graphics using invisible ink. This attribute controls the appearance of all graphics produced by Plot methods by determining whether graphics should be visible or invisible.
    If the Invisible value of a Plot is non-zero, then all the Plot methods which normally generate graphical output do not do so (you can think of them drawing with "invisible ink"). Such methods do, however, continue to do all the calculations which would be needed to produce the graphics. In particular, the bounding box enclosing the graphics is still calculated and can be retrieved as normal using astBoundingBox. The default value is zero, resulting in all methods drawing graphics as normal, using visible ink.
    
    Returns:
    
    this object's Invisible attribute
  - setInvisible
```
public void setInvisible(boolean invisible)
```
    Set draw graphics using invisible ink. This attribute controls the appearance of all graphics produced by Plot methods by determining whether graphics should be visible or invisible.
    If the Invisible value of a Plot is non-zero, then all the Plot methods which normally generate graphical output do not do so (you can think of them drawing with "invisible ink"). Such methods do, however, continue to do all the calculations which would be needed to produce the graphics. In particular, the bounding box enclosing the graphics is still calculated and can be retrieved as normal using astBoundingBox. The default value is zero, resulting in all methods drawing graphics as normal, using visible ink.
    
    Parameters:
    
    invisible - the Invisible attribute of this object
  - getLabelAt
```
public double getLabelAt(int axis)
```
    Get where to place numerical labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where numerical axis labels and associated tick marks are placed. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "LabelAt(2)=10.0" specifies where the numerical labels and tick marks for the second axis should be drawn.
    For each axis, the LabelAt value gives the value on the other axis at which numerical labels and tick marks should be placed (remember that Plots suitable for use with astGrid may only have two axes). For example, in a celestial (RA,Dec) coordinate system, LabelAt(1) gives a Dec value which defines a line (of constant Dec) along which the numerical RA labels and their associated tick marks will be drawn. Similarly, LabelAt(2) gives the RA value at which the Dec labels and ticks will be drawn.
    The default bahaviour is for the Plot to generate its own position for numerical labels and tick marks.
    Notes
    
    - The LabelAt value should use the same units as are used internally for storing coordinate values on the appropriate axis. For example, with a celestial coordinate system, the LabelAt value should be in radians, not hours or degrees.
    - Normally, the LabelAt value also determines where the lines representing coordinate axes will be drawn, so that the tick marks will lie on these lines (but also see the DrawAxes attribute).
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the LabelAt attribute is ignored.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the LabelAt attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLabelAt
```
public void setLabelAt(int axis,
                       double labelAt)
```
    Set where to place numerical labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where numerical axis labels and associated tick marks are placed. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "LabelAt(2)=10.0" specifies where the numerical labels and tick marks for the second axis should be drawn.
    For each axis, the LabelAt value gives the value on the other axis at which numerical labels and tick marks should be placed (remember that Plots suitable for use with astGrid may only have two axes). For example, in a celestial (RA,Dec) coordinate system, LabelAt(1) gives a Dec value which defines a line (of constant Dec) along which the numerical RA labels and their associated tick marks will be drawn. Similarly, LabelAt(2) gives the RA value at which the Dec labels and ticks will be drawn.
    The default bahaviour is for the Plot to generate its own position for numerical labels and tick marks.
    Notes
    
    - The LabelAt value should use the same units as are used internally for storing coordinate values on the appropriate axis. For example, with a celestial coordinate system, the LabelAt value should be in radians, not hours or degrees.
    - Normally, the LabelAt value also determines where the lines representing coordinate axes will be drawn, so that the tick marks will lie on these lines (but also see the DrawAxes attribute).
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the LabelAt attribute is ignored.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    labelAt - the LabelAt attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - getLabelUnits
```
public boolean getLabelUnits(int axis)
```
    Get use axis unit descriptions in a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the descriptive labels drawn for each axis of a Plot should include a description of the units being used on the axis. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "LabelUnits(2)=1" specifies that a unit description should be included in the label for the second axis.
    If the LabelUnits value of a Plot axis is non-zero, a unit description will be included in the descriptive label for that axis, otherwise it will be omitted. The default behaviour is to include a unit description unless the current Frame of the Plot is a SkyFrame representing equatorial, ecliptic, galactic or supergalactic coordinates, in which case it is omitted.
    Notes
    
    - The text used for the unit description is obtained from the Plot's Unit(axis) attribute.
    - If no axis is specified, (e.g. "LabelUnits" instead of "LabelUnits(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LabelUnits(1) value.
    - If the current Frame of the Plot is not a SkyFrame, but includes axes which were extracted from a SkyFrame, then the default behaviour is to include a unit description only for those axes which were not extracted from a SkyFrame.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the LabelUnits attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLabelUnits
```
public void setLabelUnits(int axis,
                          boolean labelUnits)
```
    Set use axis unit descriptions in a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the descriptive labels drawn for each axis of a Plot should include a description of the units being used on the axis. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "LabelUnits(2)=1" specifies that a unit description should be included in the label for the second axis.
    If the LabelUnits value of a Plot axis is non-zero, a unit description will be included in the descriptive label for that axis, otherwise it will be omitted. The default behaviour is to include a unit description unless the current Frame of the Plot is a SkyFrame representing equatorial, ecliptic, galactic or supergalactic coordinates, in which case it is omitted.
    Notes
    
    - The text used for the unit description is obtained from the Plot's Unit(axis) attribute.
    - If no axis is specified, (e.g. "LabelUnits" instead of "LabelUnits(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LabelUnits(1) value.
    - If the current Frame of the Plot is not a SkyFrame, but includes axes which were extracted from a SkyFrame, then the default behaviour is to include a unit description only for those axes which were not extracted from a SkyFrame.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    labelUnits - the LabelUnits attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLabelUnits
```
public void setLabelUnits(boolean labelUnits)
```
    Set use axis unit descriptions in a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the descriptive labels drawn for each axis of a Plot should include a description of the units being used on the axis. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "LabelUnits(2)=1" specifies that a unit description should be included in the label for the second axis.
    If the LabelUnits value of a Plot axis is non-zero, a unit description will be included in the descriptive label for that axis, otherwise it will be omitted. The default behaviour is to include a unit description unless the current Frame of the Plot is a SkyFrame representing equatorial, ecliptic, galactic or supergalactic coordinates, in which case it is omitted.
    Notes
    
    - The text used for the unit description is obtained from the Plot's Unit(axis) attribute.
    - If no axis is specified, (e.g. "LabelUnits" instead of "LabelUnits(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LabelUnits(1) value.
    - If the current Frame of the Plot is not a SkyFrame, but includes axes which were extracted from a SkyFrame, then the default behaviour is to include a unit description only for those axes which were not extracted from a SkyFrame.
    
    Parameters:
    
    labelUnits - the LabelUnits attribute of this object
  - getLabelUp
```
public boolean getLabelUp(int axis)
```
    Get draw numerical Plot labels upright by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the numerical labels for each axis of a Plot should be drawn upright or not. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "LabelUp(2)=1" specifies that numerical labels for the second axis should be drawn upright.
    If the LabelUp value of a Plot axis is non-zero, it causes numerical labels for that axis to be plotted upright (i.e. as normal, horizontal text), otherwise labels are drawn parallel to the axis to which they apply.
    The default is to produce upright labels if the labels are placed around the edge of the plot, and to produce labels that follow the axes if the labels are placed within the interior of the plot (see attribute Labelling).
    Notes
    
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the LabelUp attribute is ignored.
    - If no axis is specified, (e.g. "LabelUp" instead of "LabelUp(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LabelUp(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the LabelUp attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLabelUp
```
public void setLabelUp(int axis,
                       boolean labelUp)
```
    Set draw numerical Plot labels upright by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the numerical labels for each axis of a Plot should be drawn upright or not. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "LabelUp(2)=1" specifies that numerical labels for the second axis should be drawn upright.
    If the LabelUp value of a Plot axis is non-zero, it causes numerical labels for that axis to be plotted upright (i.e. as normal, horizontal text), otherwise labels are drawn parallel to the axis to which they apply.
    The default is to produce upright labels if the labels are placed around the edge of the plot, and to produce labels that follow the axes if the labels are placed within the interior of the plot (see attribute Labelling).
    Notes
    
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the LabelUp attribute is ignored.
    - If no axis is specified, (e.g. "LabelUp" instead of "LabelUp(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LabelUp(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    labelUp - the LabelUp attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLabelUp
```
public void setLabelUp(boolean labelUp)
```
    Set draw numerical Plot labels upright. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the numerical labels for each axis of a Plot should be drawn upright or not. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "LabelUp(2)=1" specifies that numerical labels for the second axis should be drawn upright.
    If the LabelUp value of a Plot axis is non-zero, it causes numerical labels for that axis to be plotted upright (i.e. as normal, horizontal text), otherwise labels are drawn parallel to the axis to which they apply.
    The default is to produce upright labels if the labels are placed around the edge of the plot, and to produce labels that follow the axes if the labels are placed within the interior of the plot (see attribute Labelling).
    Notes
    
    - In some circumstances, numerical labels and tick marks are drawn around the edges of the plotting area (see the Labelling attribute). In this case, the value of the LabelUp attribute is ignored.
    - If no axis is specified, (e.g. "LabelUp" instead of "LabelUp(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LabelUp(1) value.
    
    Parameters:
    
    labelUp - the LabelUp attribute of this object
  - getLabelling
```
public String getLabelling()
```
    Get label and tick placement option for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the strategy for placing numerical labels and tick marks for a Plot.
    If the Labelling value of a Plot is "exterior" (the default), then numerical labels and their associated tick marks are placed around the edges of the plotting area, if possible. If this is not possible, or if the Labelling value is "interior", then they are placed along grid lines inside the plotting area.
    Notes
    
    - The LabelAt(axis) attribute may be used to determine the exact placement of labels and tick marks that are drawn inside the plotting area.
    
    Returns:
    
    this object's Labelling attribute
  - setLabelling
```
public void setLabelling(String labelling)
```
    Set label and tick placement option for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the strategy for placing numerical labels and tick marks for a Plot.
    If the Labelling value of a Plot is "exterior" (the default), then numerical labels and their associated tick marks are placed around the edges of the plotting area, if possible. If this is not possible, or if the Labelling value is "interior", then they are placed along grid lines inside the plotting area.
    Notes
    
    - The LabelAt(axis) attribute may be used to determine the exact placement of labels and tick marks that are drawn inside the plotting area.
    
    Parameters:
    
    labelling - the Labelling attribute of this object
  - getLogGap
```
public double getLogGap(int axis)
```
    Get interval between major axis values of a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the logarithmic interval between the "major" axis values of a Plot, at which (for example) major tick marks are drawn. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "LogGap(2)=100.0" specifies the ratio between adjacent major values along the second axis. The LogGap attribute is only used when the LogTicks attribute indicates that the spacing between major axis values is to be logarithmic. If major axis values are linearly spaced then the gap is specified using attribute Gap.
    The LogGap value supplied will be rounded to the nearest power of 10. The reciprocal of the supplied value may be used if this is necessary to produce usable major axis values. If a zero or negative value is supplied, an error will be reported when the grid is drawn. The default behaviour is for the Plot to generate its own LogGap value when required, based on the range of axis values to be represented.
    Notes
    
    - The LogGap value is a ratio between axis values and is therefore dimensionless.
    - If no axis is specified, (e.g. "LogGap" instead of "LogGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogGap(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the LogGap attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLogGap
```
public void setLogGap(int axis,
                      double logGap)
```
    Set interval between major axis values of a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the logarithmic interval between the "major" axis values of a Plot, at which (for example) major tick marks are drawn. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "LogGap(2)=100.0" specifies the ratio between adjacent major values along the second axis. The LogGap attribute is only used when the LogTicks attribute indicates that the spacing between major axis values is to be logarithmic. If major axis values are linearly spaced then the gap is specified using attribute Gap.
    The LogGap value supplied will be rounded to the nearest power of 10. The reciprocal of the supplied value may be used if this is necessary to produce usable major axis values. If a zero or negative value is supplied, an error will be reported when the grid is drawn. The default behaviour is for the Plot to generate its own LogGap value when required, based on the range of axis values to be represented.
    Notes
    
    - The LogGap value is a ratio between axis values and is therefore dimensionless.
    - If no axis is specified, (e.g. "LogGap" instead of "LogGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogGap(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    logGap - the LogGap attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLogGap
```
public void setLogGap(double logGap)
```
    Set interval between major axis values of a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the logarithmic interval between the "major" axis values of a Plot, at which (for example) major tick marks are drawn. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "LogGap(2)=100.0" specifies the ratio between adjacent major values along the second axis. The LogGap attribute is only used when the LogTicks attribute indicates that the spacing between major axis values is to be logarithmic. If major axis values are linearly spaced then the gap is specified using attribute Gap.
    The LogGap value supplied will be rounded to the nearest power of 10. The reciprocal of the supplied value may be used if this is necessary to produce usable major axis values. If a zero or negative value is supplied, an error will be reported when the grid is drawn. The default behaviour is for the Plot to generate its own LogGap value when required, based on the range of axis values to be represented.
    Notes
    
    - The LogGap value is a ratio between axis values and is therefore dimensionless.
    - If no axis is specified, (e.g. "LogGap" instead of "LogGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogGap(1) value.
    
    Parameters:
    
    logGap - the LogGap attribute of this object
  - getLogLabel
```
public boolean getLogLabel(int axis)
```
    Get use exponential format for numerical axis labels by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the numerical axis labels should be in normal decimal form or should be represented as 10 raised to the appropriate power. That is, an axis value of 1000.0 will be drawn as "1000.0" if LogLabel is zero, but as "10^3" if LogLabel is non-zero. If graphical escape sequences are supported (see attribute Escape), the power in such exponential labels will be drawn as a small superscript instead of using a "^" character to represent exponentiation.
    The default is to produce exponential labels if the major tick marks are logarithmically spaced (see the LogTicks attribute).
    Notes
    
    - If no axis is specified, (e.g. "LogLabel" instead of "LogLabel(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogLabel(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the LogLabel attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLogLabel
```
public void setLogLabel(int axis,
                        boolean logLabel)
```
    Set use exponential format for numerical axis labels by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the numerical axis labels should be in normal decimal form or should be represented as 10 raised to the appropriate power. That is, an axis value of 1000.0 will be drawn as "1000.0" if LogLabel is zero, but as "10^3" if LogLabel is non-zero. If graphical escape sequences are supported (see attribute Escape), the power in such exponential labels will be drawn as a small superscript instead of using a "^" character to represent exponentiation.
    The default is to produce exponential labels if the major tick marks are logarithmically spaced (see the LogTicks attribute).
    Notes
    
    - If no axis is specified, (e.g. "LogLabel" instead of "LogLabel(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogLabel(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    logLabel - the LogLabel attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLogLabel
```
public void setLogLabel(boolean logLabel)
```
    Set use exponential format for numerical axis labels. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the numerical axis labels should be in normal decimal form or should be represented as 10 raised to the appropriate power. That is, an axis value of 1000.0 will be drawn as "1000.0" if LogLabel is zero, but as "10^3" if LogLabel is non-zero. If graphical escape sequences are supported (see attribute Escape), the power in such exponential labels will be drawn as a small superscript instead of using a "^" character to represent exponentiation.
    The default is to produce exponential labels if the major tick marks are logarithmically spaced (see the LogTicks attribute).
    Notes
    
    - If no axis is specified, (e.g. "LogLabel" instead of "LogLabel(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogLabel(1) value.
    
    Parameters:
    
    logLabel - the LogLabel attribute of this object
  - getLogPlot
```
public boolean getLogPlot(int axis)
```
    Get map the plot logarithmically onto the screen by axis. This attribute controls the appearance of all graphics produced by the Plot, by determining whether the axes of the plotting surface are mapped logarithmically or linearly onto the base Frame of the FrameSet supplied when the Plot was constructed. It takes a separate value for each axis of the graphics coordinate system (i.e. the base Frame in the Plot) so that, for instance, the setting "LogPlot(2)=1" specifies that the second axis of the graphics coordinate system (usually the vertical axis) should be mapped logarithmically onto the second axis of the base Frame of the FrameSet supplied when the Plot was constructed.
    If the LogPlot value of a Plot axis is non-zero, it causes that axis to be mapped logarithmically, otherwise (the default) the axis is mapped linearly.
    Notes
    
    - The setting of the LogPlot attribute provides the default value for the related LogTicks attribute. By selecting suitable values for LogPlot and LogTicks, it is possible to have tick marks which are evenly spaced in value but which are mapped logarithmically onto the screen (and vice-versa).
    - An axis may only be mapped logarithmically if the visible part of the axis does not include the value zero. The visible part of the axis is that part which is mapped onto the plotting area, and is measured within the base Frame of the FrameSet which was supplied when the Plot was constructed. Any attempt to set LogPlot to a non-zero value will be ignored (without error) if the visible part of the axis includes the value zero
    - If no axis is specified, (e.g. "LogPlot" instead of "LogPlot(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogPlot(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the LogPlot attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLogPlot
```
public void setLogPlot(int axis,
                       boolean logPlot)
```
    Set map the plot logarithmically onto the screen by axis. This attribute controls the appearance of all graphics produced by the Plot, by determining whether the axes of the plotting surface are mapped logarithmically or linearly onto the base Frame of the FrameSet supplied when the Plot was constructed. It takes a separate value for each axis of the graphics coordinate system (i.e. the base Frame in the Plot) so that, for instance, the setting "LogPlot(2)=1" specifies that the second axis of the graphics coordinate system (usually the vertical axis) should be mapped logarithmically onto the second axis of the base Frame of the FrameSet supplied when the Plot was constructed.
    If the LogPlot value of a Plot axis is non-zero, it causes that axis to be mapped logarithmically, otherwise (the default) the axis is mapped linearly.
    Notes
    
    - The setting of the LogPlot attribute provides the default value for the related LogTicks attribute. By selecting suitable values for LogPlot and LogTicks, it is possible to have tick marks which are evenly spaced in value but which are mapped logarithmically onto the screen (and vice-versa).
    - An axis may only be mapped logarithmically if the visible part of the axis does not include the value zero. The visible part of the axis is that part which is mapped onto the plotting area, and is measured within the base Frame of the FrameSet which was supplied when the Plot was constructed. Any attempt to set LogPlot to a non-zero value will be ignored (without error) if the visible part of the axis includes the value zero
    - If no axis is specified, (e.g. "LogPlot" instead of "LogPlot(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogPlot(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    logPlot - the LogPlot attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLogPlot
```
public void setLogPlot(boolean logPlot)
```
    Set map the plot logarithmically onto the screen. This attribute controls the appearance of all graphics produced by the Plot, by determining whether the axes of the plotting surface are mapped logarithmically or linearly onto the base Frame of the FrameSet supplied when the Plot was constructed. It takes a separate value for each axis of the graphics coordinate system (i.e. the base Frame in the Plot) so that, for instance, the setting "LogPlot(2)=1" specifies that the second axis of the graphics coordinate system (usually the vertical axis) should be mapped logarithmically onto the second axis of the base Frame of the FrameSet supplied when the Plot was constructed.
    If the LogPlot value of a Plot axis is non-zero, it causes that axis to be mapped logarithmically, otherwise (the default) the axis is mapped linearly.
    Notes
    
    - The setting of the LogPlot attribute provides the default value for the related LogTicks attribute. By selecting suitable values for LogPlot and LogTicks, it is possible to have tick marks which are evenly spaced in value but which are mapped logarithmically onto the screen (and vice-versa).
    - An axis may only be mapped logarithmically if the visible part of the axis does not include the value zero. The visible part of the axis is that part which is mapped onto the plotting area, and is measured within the base Frame of the FrameSet which was supplied when the Plot was constructed. Any attempt to set LogPlot to a non-zero value will be ignored (without error) if the visible part of the axis includes the value zero
    - If no axis is specified, (e.g. "LogPlot" instead of "LogPlot(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogPlot(1) value.
    
    Parameters:
    
    logPlot - the LogPlot attribute of this object
  - getLogTicks
```
public boolean getLogTicks(int axis)
```
    Get space the major tick marks logarithmically by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the major tick marks should be spaced logarithmically or linearly in axis value. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "LogTicks(2)=1" specifies that the major tick marks on the second axis should be spaced logarithmically.
    If the LogTicks value for a physical axis is non-zero, the major tick marks on that axis will be spaced logarithmically (that is, there will be a constant ratio between the axis values at adjacent major tick marks). An error will be reported if the dynamic range of the axis (the ratio of the largest to smallest displayed axis value) is less than 10.0. If the LogTicks value is zero, the major tick marks will be evenly spaced (that is, there will be a constant difference between the axis values at adjacent major tick marks). The default is to produce logarithmically spaced tick marks if the corresponding LogPlot attribute is non-zero and the ratio of maximum axis value to minimum axis value is 100 or more. If either of these conditions is not met, the default is to produce linearly spaced tick marks.
    Notes
    
    - The setting of the LogTicks attribute does not affect the mapping of the plot onto the screen, which is controlled by attribute LogPlot. By selecting suitable values for LogPlot and LogTicks, it is possible to have tick marks which are evenly spaced in value but which are mapped logarithmically onto the screen (and vica-versa).
    - An error will be reported when drawing an annotated axis grid if the visible part of the physical axis includes the value zero.
    - If no axis is specified, (e.g. "LogTicks" instead of "LogTicks(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogTicks(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the LogTicks attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLogTicks
```
public void setLogTicks(int axis,
                        boolean logTicks)
```
    Set space the major tick marks logarithmically by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the major tick marks should be spaced logarithmically or linearly in axis value. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "LogTicks(2)=1" specifies that the major tick marks on the second axis should be spaced logarithmically.
    If the LogTicks value for a physical axis is non-zero, the major tick marks on that axis will be spaced logarithmically (that is, there will be a constant ratio between the axis values at adjacent major tick marks). An error will be reported if the dynamic range of the axis (the ratio of the largest to smallest displayed axis value) is less than 10.0. If the LogTicks value is zero, the major tick marks will be evenly spaced (that is, there will be a constant difference between the axis values at adjacent major tick marks). The default is to produce logarithmically spaced tick marks if the corresponding LogPlot attribute is non-zero and the ratio of maximum axis value to minimum axis value is 100 or more. If either of these conditions is not met, the default is to produce linearly spaced tick marks.
    Notes
    
    - The setting of the LogTicks attribute does not affect the mapping of the plot onto the screen, which is controlled by attribute LogPlot. By selecting suitable values for LogPlot and LogTicks, it is possible to have tick marks which are evenly spaced in value but which are mapped logarithmically onto the screen (and vica-versa).
    - An error will be reported when drawing an annotated axis grid if the visible part of the physical axis includes the value zero.
    - If no axis is specified, (e.g. "LogTicks" instead of "LogTicks(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogTicks(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    logTicks - the LogTicks attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setLogTicks
```
public void setLogTicks(boolean logTicks)
```
    Set space the major tick marks logarithmically. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether the major tick marks should be spaced logarithmically or linearly in axis value. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "LogTicks(2)=1" specifies that the major tick marks on the second axis should be spaced logarithmically.
    If the LogTicks value for a physical axis is non-zero, the major tick marks on that axis will be spaced logarithmically (that is, there will be a constant ratio between the axis values at adjacent major tick marks). An error will be reported if the dynamic range of the axis (the ratio of the largest to smallest displayed axis value) is less than 10.0. If the LogTicks value is zero, the major tick marks will be evenly spaced (that is, there will be a constant difference between the axis values at adjacent major tick marks). The default is to produce logarithmically spaced tick marks if the corresponding LogPlot attribute is non-zero and the ratio of maximum axis value to minimum axis value is 100 or more. If either of these conditions is not met, the default is to produce linearly spaced tick marks.
    Notes
    
    - The setting of the LogTicks attribute does not affect the mapping of the plot onto the screen, which is controlled by attribute LogPlot. By selecting suitable values for LogPlot and LogTicks, it is possible to have tick marks which are evenly spaced in value but which are mapped logarithmically onto the screen (and vica-versa).
    - An error will be reported when drawing an annotated axis grid if the visible part of the physical axis includes the value zero.
    - If no axis is specified, (e.g. "LogTicks" instead of "LogTicks(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the LogTicks(1) value.
    
    Parameters:
    
    logTicks - the LogTicks attribute of this object
  - getMajTickLen
```
public double getMajTickLen(int axis)
```
    Get length of major tick marks for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the length of the major tick marks drawn on the axes of a Plot. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "MajTickLen(2)=0" specifies the length of the major tick marks drawn on the second axis.
    The MajTickLen value should be given as a fraction of the minimum dimension of the plotting area. Negative values cause major tick marks to be placed on the outside of the corresponding grid line or axis (but subject to any clipping imposed by the underlying graphics system), while positive values cause them to be placed on the inside.
    The default behaviour depends on whether a coordinate grid is drawn inside the plotting area (see the Grid attribute). If so, the default MajTickLen value is zero (so that major ticks are not drawn), otherwise the default is +0.015.
    Notes
    
    - If no axis is specified, (e.g. "MajTickLen" instead of "MajTickLen(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MajTickLen(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the MajTickLen attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setMajTickLen
```
public void setMajTickLen(int axis,
                          double majTickLen)
```
    Set length of major tick marks for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the length of the major tick marks drawn on the axes of a Plot. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "MajTickLen(2)=0" specifies the length of the major tick marks drawn on the second axis.
    The MajTickLen value should be given as a fraction of the minimum dimension of the plotting area. Negative values cause major tick marks to be placed on the outside of the corresponding grid line or axis (but subject to any clipping imposed by the underlying graphics system), while positive values cause them to be placed on the inside.
    The default behaviour depends on whether a coordinate grid is drawn inside the plotting area (see the Grid attribute). If so, the default MajTickLen value is zero (so that major ticks are not drawn), otherwise the default is +0.015.
    Notes
    
    - If no axis is specified, (e.g. "MajTickLen" instead of "MajTickLen(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MajTickLen(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    majTickLen - the MajTickLen attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setMajTickLen
```
public void setMajTickLen(double majTickLen)
```
    Set length of major tick marks for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the length of the major tick marks drawn on the axes of a Plot. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "MajTickLen(2)=0" specifies the length of the major tick marks drawn on the second axis.
    The MajTickLen value should be given as a fraction of the minimum dimension of the plotting area. Negative values cause major tick marks to be placed on the outside of the corresponding grid line or axis (but subject to any clipping imposed by the underlying graphics system), while positive values cause them to be placed on the inside.
    The default behaviour depends on whether a coordinate grid is drawn inside the plotting area (see the Grid attribute). If so, the default MajTickLen value is zero (so that major ticks are not drawn), otherwise the default is +0.015.
    Notes
    
    - If no axis is specified, (e.g. "MajTickLen" instead of "MajTickLen(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MajTickLen(1) value.
    
    Parameters:
    
    majTickLen - the MajTickLen attribute of this object
  - getMinTickLen
```
public double getMinTickLen(int axis)
```
    Get length of minor tick marks for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the length of the minor tick marks drawn on the axes of a Plot. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "MinTickLen(2)=0" specifies the length of the minor tick marks drawn on the second axis.
    The MinTickLen value should be given as a fraction of the minimum dimension of the plotting area. Negative values cause minor tick marks to be placed on the outside of the corresponding grid line or axis (but subject to any clipping imposed by the underlying graphics system), while positive values cause them to be placed on the inside.
    The default value is +0.007.
    Notes
    
    - The number of minor tick marks drawn is determined by the Plot's MinTick(axis) attribute.
    - If no axis is specified, (e.g. "MinTickLen" instead of "MinTickLen(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MinTickLen(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the MinTickLen attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setMinTickLen
```
public void setMinTickLen(int axis,
                          double minTickLen)
```
    Set length of minor tick marks for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the length of the minor tick marks drawn on the axes of a Plot. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "MinTickLen(2)=0" specifies the length of the minor tick marks drawn on the second axis.
    The MinTickLen value should be given as a fraction of the minimum dimension of the plotting area. Negative values cause minor tick marks to be placed on the outside of the corresponding grid line or axis (but subject to any clipping imposed by the underlying graphics system), while positive values cause them to be placed on the inside.
    The default value is +0.007.
    Notes
    
    - The number of minor tick marks drawn is determined by the Plot's MinTick(axis) attribute.
    - If no axis is specified, (e.g. "MinTickLen" instead of "MinTickLen(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MinTickLen(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    minTickLen - the MinTickLen attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setMinTickLen
```
public void setMinTickLen(double minTickLen)
```
    Set length of minor tick marks for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the length of the minor tick marks drawn on the axes of a Plot. It takes a separate value for each physical axis of the Plot so that, for instance, the setting "MinTickLen(2)=0" specifies the length of the minor tick marks drawn on the second axis.
    The MinTickLen value should be given as a fraction of the minimum dimension of the plotting area. Negative values cause minor tick marks to be placed on the outside of the corresponding grid line or axis (but subject to any clipping imposed by the underlying graphics system), while positive values cause them to be placed on the inside.
    The default value is +0.007.
    Notes
    
    - The number of minor tick marks drawn is determined by the Plot's MinTick(axis) attribute.
    - If no axis is specified, (e.g. "MinTickLen" instead of "MinTickLen(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MinTickLen(1) value.
    
    Parameters:
    
    minTickLen - the MinTickLen attribute of this object
  - getMinTick
```
public int getMinTick(int axis)
```
    Get density of minor tick marks for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the density of minor tick marks which appear between the major axis values of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "MinTick(2)=2" specifies the density of minor tick marks along the second axis.
    The value supplied should be the number of minor divisions required between each pair of major axis values, this being one more than the number of minor tick marks to be drawn. By default, a value is chosen that depends on the gap between major axis values and the nature of the axis.
    Notes
    
    - If no axis is specified, (e.g. "MinTick" instead of "MinTick(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MinTick(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the MinTick attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setMinTick
```
public void setMinTick(int axis,
                       int minTick)
```
    Set density of minor tick marks for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the density of minor tick marks which appear between the major axis values of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "MinTick(2)=2" specifies the density of minor tick marks along the second axis.
    The value supplied should be the number of minor divisions required between each pair of major axis values, this being one more than the number of minor tick marks to be drawn. By default, a value is chosen that depends on the gap between major axis values and the nature of the axis.
    Notes
    
    - If no axis is specified, (e.g. "MinTick" instead of "MinTick(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MinTick(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    minTick - the MinTick attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setMinTick
```
public void setMinTick(int minTick)
```
    Set density of minor tick marks for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining the density of minor tick marks which appear between the major axis values of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "MinTick(2)=2" specifies the density of minor tick marks along the second axis.
    The value supplied should be the number of minor divisions required between each pair of major axis values, this being one more than the number of minor tick marks to be drawn. By default, a value is chosen that depends on the gap between major axis values and the nature of the axis.
    Notes
    
    - If no axis is specified, (e.g. "MinTick" instead of "MinTick(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the MinTick(1) value.
    
    Parameters:
    
    minTick - the MinTick attribute of this object
  - getNumLab
```
public boolean getNumLab(int axis)
```
    Get draw numerical axis labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether labels should be drawn to represent the numerical values along each axis of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "NumLab(2)=1" specifies that numerical labels should be drawn for the second axis.
    If the NumLab value of a Plot axis is non-zero (the default), then numerical labels will be drawn for that axis, otherwise they will be omitted.
    Notes
    
    - The drawing of associated descriptive axis labels for a Plot (describing the quantity being plotted along each axis) is controlled by the TextLab(axis) attribute.
    - If no axis is specified, (e.g. "NumLab" instead of "NumLab(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the NumLab(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the NumLab attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setNumLab
```
public void setNumLab(int axis,
                      boolean numLab)
```
    Set draw numerical axis labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether labels should be drawn to represent the numerical values along each axis of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "NumLab(2)=1" specifies that numerical labels should be drawn for the second axis.
    If the NumLab value of a Plot axis is non-zero (the default), then numerical labels will be drawn for that axis, otherwise they will be omitted.
    Notes
    
    - The drawing of associated descriptive axis labels for a Plot (describing the quantity being plotted along each axis) is controlled by the TextLab(axis) attribute.
    - If no axis is specified, (e.g. "NumLab" instead of "NumLab(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the NumLab(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    numLab - the NumLab attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setNumLab
```
public void setNumLab(boolean numLab)
```
    Set draw numerical axis labels for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether labels should be drawn to represent the numerical values along each axis of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "NumLab(2)=1" specifies that numerical labels should be drawn for the second axis.
    If the NumLab value of a Plot axis is non-zero (the default), then numerical labels will be drawn for that axis, otherwise they will be omitted.
    Notes
    
    - The drawing of associated descriptive axis labels for a Plot (describing the quantity being plotted along each axis) is controlled by the TextLab(axis) attribute.
    - If no axis is specified, (e.g. "NumLab" instead of "NumLab(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the NumLab(1) value.
    
    Parameters:
    
    numLab - the NumLab attribute of this object
  - getNumLabGap
```
public double getNumLabGap(int axis)
```
    Get spacing of numerical labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where numerical axis labels are placed relative to the axes they describe. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "NumLabGap(2)=-0.01" specifies where the numerical label for the second axis should be drawn.
    For each axis, the NumLabGap value gives the spacing between the axis line (or edge of the plotting area, if appropriate) and the nearest edge of the corresponding numerical axis labels. Positive values cause the descriptive label to be placed on the opposite side of the line to the default tick marks, while negative values cause it to be placed on the same side.
    The NumLabGap value should be given as a fraction of the minimum dimension of the plotting area, the default value being +0.01.
    Notes
    
    - If no axis is specified, (e.g. "NumLabGap" instead of "NumLabGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the NumLabGap(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the NumLabGap attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setNumLabGap
```
public void setNumLabGap(int axis,
                         double numLabGap)
```
    Set spacing of numerical labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where numerical axis labels are placed relative to the axes they describe. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "NumLabGap(2)=-0.01" specifies where the numerical label for the second axis should be drawn.
    For each axis, the NumLabGap value gives the spacing between the axis line (or edge of the plotting area, if appropriate) and the nearest edge of the corresponding numerical axis labels. Positive values cause the descriptive label to be placed on the opposite side of the line to the default tick marks, while negative values cause it to be placed on the same side.
    The NumLabGap value should be given as a fraction of the minimum dimension of the plotting area, the default value being +0.01.
    Notes
    
    - If no axis is specified, (e.g. "NumLabGap" instead of "NumLabGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the NumLabGap(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    numLabGap - the NumLabGap attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setNumLabGap
```
public void setNumLabGap(double numLabGap)
```
    Set spacing of numerical labels for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where numerical axis labels are placed relative to the axes they describe. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "NumLabGap(2)=-0.01" specifies where the numerical label for the second axis should be drawn.
    For each axis, the NumLabGap value gives the spacing between the axis line (or edge of the plotting area, if appropriate) and the nearest edge of the corresponding numerical axis labels. Positive values cause the descriptive label to be placed on the opposite side of the line to the default tick marks, while negative values cause it to be placed on the same side.
    The NumLabGap value should be given as a fraction of the minimum dimension of the plotting area, the default value being +0.01.
    Notes
    
    - If no axis is specified, (e.g. "NumLabGap" instead of "NumLabGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the NumLabGap(1) value.
    
    Parameters:
    
    numLabGap - the NumLabGap attribute of this object
  - getSize
```
public double getSize(String element)
```
    Get character size for a Plot element by graphical element. This attribute determines the character size used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Size(title)=2.0" causes the Plot title to be drawn using twice the default character size.
    The range of character sizes available and the appearance of the resulting text is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default character size supplied by this graphics system.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Size" instead of "Size(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Size(TextLab) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    The implementation of this method is determined by the current Grf object.
    Parameters:
    
    element - name of the graphical element for which the attribute is to be got
    
    Returns:
    
    the Size attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setSize
```
public void setSize(String element,
                    double size)
```
    Set character size for a Plot element by graphical element. This attribute determines the character size used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Size(title)=2.0" causes the Plot title to be drawn using twice the default character size.
    The range of character sizes available and the appearance of the resulting text is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default character size supplied by this graphics system.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Size" instead of "Size(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Size(TextLab) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    The implementation of this method is determined by the current Grf object.
    Parameters:
    
    element - name of the graphical element for which the attribute is to be set
    
    size - the Size attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - getSize
```
public double getSize()
```
    Get character size for a Plot element. This attribute determines the character size used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Size(title)=2.0" causes the Plot title to be drawn using twice the default character size.
    The range of character sizes available and the appearance of the resulting text is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default character size supplied by this graphics system.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Size" instead of "Size(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Size(TextLab) value.
    The implementation of this method is determined by the current Grf object.
    
    Returns:
    
    this object's Size attribute
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setSize
```
public void setSize(double size)
```
    Set character size for a Plot element. This attribute determines the character size used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Size(title)=2.0" causes the Plot title to be drawn using twice the default character size.
    The range of character sizes available and the appearance of the resulting text is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default character size supplied by this graphics system.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Size" instead of "Size(title)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Size(TextLab) value.
    The implementation of this method is determined by the current Grf object.
    
    Parameters:
    
    size - the Size attribute of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - getStyle
```
public int getStyle(String element)
```
    Get line style for a Plot element by graphical element. This attribute determines the line style used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Style(border)=2" causes the Plot border to be drawn using line style 2 (which might result in, say, a dashed line).
    The range of integer line styles available and their appearance is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default line style supplied by this graphics system (normally, this is likely to give a solid line).
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Style" instead of "Style(border)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Style(Border) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    The available line styles are defined by the Grf object being used to implement the graphics (by default DefaultGrf).
    Parameters:
    
    element - name of the graphical element for which the attribute is to be got
    
    Returns:
    
    the Style attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setStyle
```
public void setStyle(String element,
                     int style)
```
    Set line style for a Plot element by graphical element. This attribute determines the line style used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Style(border)=2" causes the Plot border to be drawn using line style 2 (which might result in, say, a dashed line).
    The range of integer line styles available and their appearance is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default line style supplied by this graphics system (normally, this is likely to give a solid line).
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Style" instead of "Style(border)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Style(Border) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    The available line styles are defined by the Grf object being used to implement the graphics (by default DefaultGrf).
    Parameters:
    
    element - name of the graphical element for which the attribute is to be set
    
    style - the Style attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setStyle
```
public void setStyle(int style)
```
    Set line style for a Plot element. This attribute determines the line style used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Style(border)=2" causes the Plot border to be drawn using line style 2 (which might result in, say, a dashed line).
    The range of integer line styles available and their appearance is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default line style supplied by this graphics system (normally, this is likely to give a solid line).
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Style" instead of "Style(border)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Style(Border) value.
    The available line styles are defined by the Grf object being used to implement the graphics (by default DefaultGrf).
    
    Parameters:
    
    style - the Style attribute of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - getTextLab
```
public boolean getTextLab(int axis)
```
    Get draw descriptive axis labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether textual labels should be drawn to describe the quantity being represented on each axis of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "TextLab(2)=1" specifies that descriptive labels should be drawn for the second axis.
    If the TextLab value of a Plot axis is non-zero, then descriptive labels will be drawn for that axis, otherwise they will be omitted. The default behaviour is to draw descriptive labels if tick marks and numerical labels are being drawn around the edges of the plotting area (see the Labelling attribute), but to omit them otherwise.
    Notes
    
    - The text used for the descriptive labels is derived from the Plot's Label(axis) attribute, together with its Unit(axis) attribute if appropriate (see the LabelUnits(axis) attribute).
    - The drawing of numerical axis labels for a Plot (which indicate values on the axis) is controlled by the NumLab(axis) attribute.
    - If no axis is specified, (e.g. "TextLab" instead of "TextLab(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the TextLab(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the TextLab attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setTextLab
```
public void setTextLab(int axis,
                       boolean textLab)
```
    Set draw descriptive axis labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether textual labels should be drawn to describe the quantity being represented on each axis of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "TextLab(2)=1" specifies that descriptive labels should be drawn for the second axis.
    If the TextLab value of a Plot axis is non-zero, then descriptive labels will be drawn for that axis, otherwise they will be omitted. The default behaviour is to draw descriptive labels if tick marks and numerical labels are being drawn around the edges of the plotting area (see the Labelling attribute), but to omit them otherwise.
    Notes
    
    - The text used for the descriptive labels is derived from the Plot's Label(axis) attribute, together with its Unit(axis) attribute if appropriate (see the LabelUnits(axis) attribute).
    - The drawing of numerical axis labels for a Plot (which indicate values on the axis) is controlled by the NumLab(axis) attribute.
    - If no axis is specified, (e.g. "TextLab" instead of "TextLab(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the TextLab(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    textLab - the TextLab attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setTextLab
```
public void setTextLab(boolean textLab)
```
    Set draw descriptive axis labels for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether textual labels should be drawn to describe the quantity being represented on each axis of a Plot. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "TextLab(2)=1" specifies that descriptive labels should be drawn for the second axis.
    If the TextLab value of a Plot axis is non-zero, then descriptive labels will be drawn for that axis, otherwise they will be omitted. The default behaviour is to draw descriptive labels if tick marks and numerical labels are being drawn around the edges of the plotting area (see the Labelling attribute), but to omit them otherwise.
    Notes
    
    - The text used for the descriptive labels is derived from the Plot's Label(axis) attribute, together with its Unit(axis) attribute if appropriate (see the LabelUnits(axis) attribute).
    - The drawing of numerical axis labels for a Plot (which indicate values on the axis) is controlled by the NumLab(axis) attribute.
    - If no axis is specified, (e.g. "TextLab" instead of "TextLab(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the TextLab(1) value.
    
    Parameters:
    
    textLab - the TextLab attribute of this object
  - getTextLabGap
```
public double getTextLabGap(int axis)
```
    Get spacing of descriptive axis labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where descriptive axis labels are placed relative to the axes they describe. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "TextLabGap(2)=0.01" specifies where the descriptive label for the second axis should be drawn.
    For each axis, the TextLabGap value gives the spacing between the descriptive label and the edge of a box enclosing all other parts of the annotated grid (excluding other descriptive labels). The gap is measured to the nearest edge of the label (i.e. the top or the bottom). Positive values cause the descriptive label to be placed outside the bounding box, while negative values cause it to be placed inside.
    The TextLabGap value should be given as a fraction of the minimum dimension of the plotting area, the default value being +0.01.
    Notes
    
    - If drawn, descriptive labels are always placed at the edges of the plotting area, even although the corresponding numerical labels may be drawn along axis lines in the interior of the plotting area (see the Labelling attribute).
    - If no axis is specified, (e.g. "TextLabGap" instead of "TextLabGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the TextLabGap(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be got. Must be >= 1 and <= the value of the Naxes attribute.
    
    Returns:
    
    the TextLabGap attribute for the indicated axis of this object
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setTextLabGap
```
public void setTextLabGap(int axis,
                          double textLabGap)
```
    Set spacing of descriptive axis labels for a Plot by axis. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where descriptive axis labels are placed relative to the axes they describe. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "TextLabGap(2)=0.01" specifies where the descriptive label for the second axis should be drawn.
    For each axis, the TextLabGap value gives the spacing between the descriptive label and the edge of a box enclosing all other parts of the annotated grid (excluding other descriptive labels). The gap is measured to the nearest edge of the label (i.e. the top or the bottom). Positive values cause the descriptive label to be placed outside the bounding box, while negative values cause it to be placed inside.
    The TextLabGap value should be given as a fraction of the minimum dimension of the plotting area, the default value being +0.01.
    Notes
    
    - If drawn, descriptive labels are always placed at the edges of the plotting area, even although the corresponding numerical labels may be drawn along axis lines in the interior of the plotting area (see the Labelling attribute).
    - If no axis is specified, (e.g. "TextLabGap" instead of "TextLabGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the TextLabGap(1) value.
    
    Parameters:
    
    axis - index of the axis for which the attribute is to be set. Must be >= 1 and <= the value of the Naxes attribute.
    
    textLabGap - the TextLabGap attribute for the indicated axis of this object.
    
    Throws:
    
    IndexOutOfBoundsException - if axis is not in the range 1..Naxes
  - setTextLabGap
```
public void setTextLabGap(double textLabGap)
```
    Set spacing of descriptive axis labels for a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where descriptive axis labels are placed relative to the axes they describe. It takes a separate value for each physical axis of a Plot so that, for instance, the setting "TextLabGap(2)=0.01" specifies where the descriptive label for the second axis should be drawn.
    For each axis, the TextLabGap value gives the spacing between the descriptive label and the edge of a box enclosing all other parts of the annotated grid (excluding other descriptive labels). The gap is measured to the nearest edge of the label (i.e. the top or the bottom). Positive values cause the descriptive label to be placed outside the bounding box, while negative values cause it to be placed inside.
    The TextLabGap value should be given as a fraction of the minimum dimension of the plotting area, the default value being +0.01.
    Notes
    
    - If drawn, descriptive labels are always placed at the edges of the plotting area, even although the corresponding numerical labels may be drawn along axis lines in the interior of the plotting area (see the Labelling attribute).
    - If no axis is specified, (e.g. "TextLabGap" instead of "TextLabGap(2)"), then a "set" or "clear" operation will affect the attribute value of all the Plot axes, while a "get" or "test" operation will use just the TextLabGap(1) value.
    
    Parameters:
    
    textLabGap - the TextLabGap attribute of this object
  - getTickAll
```
public boolean getTickAll()
```
    Get draw tick marks on all edges of a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether tick marks should be drawn on all edges of a Plot.
    If the TickAll value of a Plot is non-zero (the default), then tick marks will be drawn on all edges of the Plot. Otherwise, they will be drawn only on those edges where the numerical and descriptive axis labels are drawn (see the Edge(axis) attribute).
    Notes
    
    - In some circumstances, numerical labels and tick marks are drawn along grid lines inside the plotting area, rather than around its edges (see the Labelling attribute). In this case, the value of the TickAll attribute is ignored.
    
    Returns:
    
    this object's TickAll attribute
  - setTickAll
```
public void setTickAll(boolean tickAll)
```
    Set draw tick marks on all edges of a Plot. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining whether tick marks should be drawn on all edges of a Plot.
    If the TickAll value of a Plot is non-zero (the default), then tick marks will be drawn on all edges of the Plot. Otherwise, they will be drawn only on those edges where the numerical and descriptive axis labels are drawn (see the Edge(axis) attribute).
    Notes
    
    - In some circumstances, numerical labels and tick marks are drawn along grid lines inside the plotting area, rather than around its edges (see the Labelling attribute). In this case, the value of the TickAll attribute is ignored.
    
    Parameters:
    
    tickAll - the TickAll attribute of this object
  - getTitleGap
```
public double getTitleGap()
```
    Get vertical spacing for a Plot title. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where the title of a Plot is drawn.
    Its value gives the spacing between the bottom edge of the title and the top edge of a bounding box containing all the other parts of the annotated grid. Positive values cause the title to be drawn outside the box, while negative values cause it to be drawn inside.
    The TitleGap value should be given as a fraction of the minimum dimension of the plotting area, the default value being +0.05.
    Notes
    
    - The text used for the title is obtained from the Plot's Title attribute.
    
    Returns:
    
    this object's TitleGap attribute
  - setTitleGap
```
public void setTitleGap(double titleGap)
```
    Set vertical spacing for a Plot title. This attribute controls the appearance of an annotated coordinate grid (drawn with the astGrid function) by determining where the title of a Plot is drawn.
    Its value gives the spacing between the bottom edge of the title and the top edge of a bounding box containing all the other parts of the annotated grid. Positive values cause the title to be drawn outside the box, while negative values cause it to be drawn inside.
    The TitleGap value should be given as a fraction of the minimum dimension of the plotting area, the default value being +0.05.
    Notes
    
    - The text used for the title is obtained from the Plot's Title attribute.
    
    Parameters:
    
    titleGap - the TitleGap attribute of this object
  - getTol
```
public double getTol()
```
    Get plotting tolerance. This attribute specifies the plotting tolerance (or resolution) to be used for the graphical output produced by a Plot. Smaller values will result in smoother and more accurate curves being drawn, but may slow down the plotting process. Conversely, larger values may speed up the plotting process in cases where high resolution is not required.
    The Tol value should be given as a fraction of the minimum dimension of the plotting area, and should lie in the range from 1.0e-7 to 1.0. By default, a value of 0.01 is used.
    
    Returns:
    
    this object's Tol attribute
  - setTol
```
public void setTol(double tol)
```
    Set plotting tolerance. This attribute specifies the plotting tolerance (or resolution) to be used for the graphical output produced by a Plot. Smaller values will result in smoother and more accurate curves being drawn, but may slow down the plotting process. Conversely, larger values may speed up the plotting process in cases where high resolution is not required.
    The Tol value should be given as a fraction of the minimum dimension of the plotting area, and should lie in the range from 1.0e-7 to 1.0. By default, a value of 0.01 is used.
    
    Parameters:
    
    tol - the Tol attribute of this object
  - getWidth
```
public double getWidth(String element)
```
    Get line width for a Plot element by graphical element. This attribute determines the line width used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Width(border)=2.0" causes the Plot border to be drawn using a line width of 2.0. A value of 1.0 results in a line thickness which is approximately 0.0005 times the length of the diagonal of the entire display surface.
    The actual appearance of lines drawn with any particular width, and the range of available widths, is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default line width supplied by this graphics system. This will not necessarily correspond to a Width value of 1.0.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Width" instead of "Width(border)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Width(Border) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    The implementation of this method is determined by the current Grf object.
    Parameters:
    
    element - name of the graphical element for which the attribute is to be got
    
    Returns:
    
    the Width attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setWidth
```
public void setWidth(String element,
                     double width)
```
    Set line width for a Plot element by graphical element. This attribute determines the line width used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Width(border)=2.0" causes the Plot border to be drawn using a line width of 2.0. A value of 1.0 results in a line thickness which is approximately 0.0005 times the length of the diagonal of the entire display surface.
    The actual appearance of lines drawn with any particular width, and the range of available widths, is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default line width supplied by this graphics system. This will not necessarily correspond to a Width value of 1.0.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Width" instead of "Width(border)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Width(Border) value.
    The available elements are:
    - Axes: Axis lines drawn through tick marks using astGrid
    - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
    - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
    - Border: The Plot border drawn using astBorder or astGrid
    - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
    - Grid: Grid lines drawn using astGridLine or astGrid
    - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
    - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
    - Markers: Graphical markers (symbols) drawn using astMark
    - NumLab: Numerical axis labels drawn using astGrid
    - NumLab1: Numerical labels for axis 1 drawn using astGrid
    - NumLab2: Numerical labels for axis 2 drawn using astGrid
    - Strings: Text strings drawn using astText
    - TextLab: Descriptive axis labels drawn using astGrid
    - TextLab1: Descriptive label for axis 1 drawn using astGrid
    - TextLab2: Descriptive label for axis 2 drawn using astGrid
    - Ticks: Tick marks (both major and minor) drawn using astGrid
    - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
    - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
    - Title: The Plot title drawn using astGrid
    The implementation of this method is determined by the current Grf object.
    Parameters:
    
    element - name of the graphical element for which the attribute is to be set
    
    width - the Width attribute for the indicated element of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)
  - setWidth
```
public void setWidth(double width)
```
    Set line width for a Plot element. This attribute determines the line width used when drawing each element of graphical output produced by a Plot. It takes a separate value for each graphical element so that, for instance, the setting "Width(border)=2.0" causes the Plot border to be drawn using a line width of 2.0. A value of 1.0 results in a line thickness which is approximately 0.0005 times the length of the diagonal of the entire display surface.
    The actual appearance of lines drawn with any particular width, and the range of available widths, is determined by the underlying graphics system. The default behaviour is for all graphical elements to be drawn using the default line width supplied by this graphics system. This will not necessarily correspond to a Width value of 1.0.
    Notes
    
    - For a list of the graphical elements available, see the description of the Plot class.
    - If no graphical element is specified, (e.g. "Width" instead of "Width(border)"), then a "set" or "clear" operation will affect the attribute value of all graphical elements, while a "get" or "test" operation will use just the Width(Border) value.
    The implementation of this method is determined by the current Grf object.
    
    Parameters:
    
    width - the Width attribute of this object
    
    See Also:
    
    DefaultGrf.attr(int, double, int)

Class Plot

Graphical Elements

Licence

Usage

Nested Class Summary

Nested classes/interfaces inherited from class uk.ac.starlink.ast.Mapping

Field Summary

Fields inherited from class uk.ac.starlink.ast.FrameSet

Fields inherited from class uk.ac.starlink.ast.Mapping

Fields inherited from class uk.ac.starlink.ast.AstObject

Constructor Summary

Method Summary

Methods inherited from class uk.ac.starlink.ast.FrameSet

Methods inherited from class uk.ac.starlink.ast.Frame

Methods inherited from class uk.ac.starlink.ast.Mapping

Methods inherited from class uk.ac.starlink.ast.AstObject

Methods inherited from class java.lang.Object

Constructor Detail

Plot

Plot

Method Detail

paint

clear

getGrf

setGrf

copy

getC

getD

getF

getL

getI

setC

setD

setF

setL

setI

test

Notes

set

Notes

border

Notes

boundingBox

Notes

clip

Notes

curve

Notes

genCurve

Notes

grid

Notes

gridLine

Notes

mark

Notes

polyCurve

Notes

text

Notes

getBorder

setBorder

getClip

setClip

getClipOp

setClipOp

getColour

Notes

setColour

Notes

setColour

Notes

getDrawAxes

Notes

setDrawAxes

Notes

getDrawAxes

Notes

setDrawAxes

Notes