- xpix=<int-value>
Size of the output image in the X direction in pixels.
This includes space for any axis labels, padding and other decoration outside
the plot area itself. See also
insets.
- ypix=<int-value>
Size of the output image in the Y direction in pixels.
This includes space for any axis labels, padding and other decoration outside
the plot area itself. See also
insets.
- insets=<top>,<left>,<bottom>,<right>
Defines the amount of space in pixels around the actual
plotting area. This space is used for axis labels, and other decorations and
any left over forms an empty border.
The size and position of the actual plotting area is determined by
this parameter along with xpix and ypix.
The value of this parameter is 4 comma separated integers:
<top>,<left>,<bottom>,<right>. Any or all of
these values may be left blank, in which case the corresponding margin will
be calculated automatically according to how much space is required.
- omode=swing|out|cgi|discard|auto
Determines how the drawn plot will be output, see
SUN/256.
- swing: Plot will be displayed in a window on the screen. This plot
is "live"; it can be resized and (except for old-style plots)
navigated around with mouse actions in the same way as plots in
TOPCAT.
- out: Plot will be written to a file given by out using the
graphics format given by ofmt.
- cgi: Plot will be written in a way suitable for CGI use direct from
a web server. The output is in the graphics format given by ofmt,
preceded by a suitable "Content-type" declaration.
- discard: Plot is drawn, but discarded. There is no output.
- auto: Behaves as swing or out mode depending on
presence of out parameter
- storage=simple|memory|disk|policy|cache|basic-cache|persistent|parallel
Determines the way that data is accessed when
constructing the plot. There are two main options, cached or not. If no
caching is used then rows are read sequentially from the specified input
table(s) every time they are required. This generally requires a small
resource footprint (though that can depend on how the table is specified) and
makes sense if the data only needs to be scanned once or perhaps if the table
is very large. If caching is used then the required data is read once from the
specified input table(s), then prepared and cached before any plotting is
performed, and plots are done using this cached data. This may use a
significant amount of storage for large tables but it's usually more sensible
(faster) if the data will need to be scanned multiple times. There are various
options for cache storage.
The options are:
- simple: no caching, data read directly from input table
- memory: cached to memory; OutOfMemoryError possible for very large
plots
- disk: cached to disk
- policy: cached using application-wide default storage policy, which
is usually adaptive (memory/disk hybrid)
- persistent: cached to persistent files on disk, in the system
temporary directory (defined by system property java.io.tmpdir). If
this is used, plot data will be stored on disk in a way that means they
can be re-used between STILTS invocations, so data preparation can be
avoided on subsequent runs. Note however it can leave potentially large
files in your temporary directory.
- cache: synonym for memory (backward compatibility)
- basic-cache: dumber version of memory (no optimisation for
constant-valued columns)
- parallel: experimental version of memory-based cache that reads
into the cache in parallel for large files. This will make the plot faster
to prepare, but interaction is a bit slower and sequence-dependent
attributes of the plot may not come out right. This experimental option
may be withdrawn or modified in future releases.
The default value is memory if a live plot is being
generated (omode=swing), since in that case the plot needs to be
redrawn every time the user performs plot navigation actions or resizes the
window, or if animations are being produced. Otherwise (e.g. output to a
graphics file) the default is simple.
- seq=<suffix>[,...]
Contains a comma-separated list of layer suffixes to
determine the order in which layers are drawn on the plot. This can affect
which symbol are plotted on top of, and so potentially obscure, which other
ones.
When specifying a plot, multiple layers may be specified, each
introduced by a parameter layer<N>, where <N> is a
different (arbitrary) suffix labelling the layer, and is appended to all the
parameters specific to defining that layer.
By default the layers are drawn on the plot in the order in which
the layer* parameters appear on the command line. However if this
parameter is specified, each comma-separated element is interpreted as a
layer suffix, giving the ordered list of layers to plot. Every element of
the list must be a suffix with a corresponding layer parameter, but
missing or repeated elements are allowed.
- legend=true|false
Whether to draw a legend or not. If no value is supplied,
the decision is made automatically: a legend is drawn only if it would have
more than one entry.
- legborder=true|false
If true, a line border is drawn around the legend.
- legopaque=true|false
If true, the background of the legend is opaque, and the
legend obscures any plot components behind it. Otherwise, it's transparent.
- legseq=<suffix>[,...]
Determines which layers are represented in the legend (if
present) and in which order they appear. The legend has a line for each layer
label (as determined by the
leglabelN parameter). If multiple layers
have the same label, they will contribute to the same entry in the legend,
with style icons plotted over each other. The value of this parameter is a
comma-separated sequence of layer suffixes, which determines the order in
which the legend entries appear. Layers with suffixes missing from this list
do not show up in the legend at all.
If no value is supplied (the default), the sequence is the same as
the layer plotting sequence (see seq).
- legpos=<xfrac,yfrac>
Determines the internal position of the legend on the
plot. The value is a comma-separated pair of values giving the X and Y
positions of the legend within the plotting bounds, so for instance
"
0.5,0.5" will put the legend right in the middle of the
plot. If no value is supplied, the legend will appear outside the plot
boundary.
- title=<value>
Text of a title to be displayed at the top of the plot.
If null, the default, no title is shown and there's more space for the
graphics.
- auxmap=<map-name>|<color>-<color>[-<color>...]
Color map used for Aux axis shading.
A mixed bag of colour ramps are available as listed in SUN/256:
inferno, magma, plasma, viridis, cividis,
cubehelix, sron, rainbow, rainbow2,
rainbow3, pastel, cosmic, ember, gothic,
rainforest, voltage, bubblegum, gem,
chroma, neon, tropical, accent, gnuplot,
gnuplot2, specxby, set1, paired, hotcold,
guppy, iceburn, redshift, pride, rdbu,
piyg, brbg, cyan-magenta, red-blue, brg,
heat, cold, light, greyscale, colour,
standard, bugn, bupu, orrd, pubu,
purd, painbow, huecl, infinity, hue,
intensity, rgb_red, rgb_green, rgb_blue,
hsv_h, hsv_s, hsv_v, yuv_y, yuv_u,
yuv_v, scale_hsv_s, scale_hsv_v, scale_yuv_y,
mask, blacker, whiter, transparency. Note: many
of these, including rainbow-like ones, are frowned upon by the visualisation
community.
You can also construct your own custom colour map by giving a
sequence of colour names separated by minus sign ("-")
characters. In this case the ramp is a linear interpolation between each
pair of colours named, using the same syntax as when specifying a colour
value. So for instance "yellow-hotpink-#0000ff" would shade
from yellow via hot pink to blue.
- auxclip=<lo>,<hi>
Defines a subrange of the colour ramp to be used for Aux
shading. The value is specified as a (low,high) comma-separated pair of two
numbers between 0 and 1.
If the full range 0,1 is used, the whole range of colours
specified by the selected shader will be used. But if for instance a value
of 0,0.5 is given, only those colours at the left hand end of the
ramp will be seen.
If the null (default) value is chosen, a default clip will be
used. This generally covers most or all of the range 0-1 but for colour maps
which fade to white, a small proportion of the lower end may be excluded, to
ensure that all the colours are visually distinguishable from a white
background. This default is usually a good idea if the colour map is being
used with something like a scatter plot, where markers are plotted against a
white background. However, for something like a density map when the whole
plotting area is tiled with colours from the map, it may be better to supply
the whole range 0,1 explicitly.
- auxflip=true|false
If true, the colour map on the Aux axis will be reversed.
- auxquant=<number>
Allows the colour map used for the Aux axis to be
quantised. If an integer value N is chosen then the colour map will be viewed
as N discrete evenly-spaced levels, so that only N different colours will
appear in the plot. This can be used to generate a contour-like effect, and
may make it easier to trace the boundaries of regions of interest by eye.
If left blank, the colour map is nominally continuous (though in
practice it may be quantised to a medium-sized number like 256).
- auxfunc=log|linear|histogram|histolog|sqrt|square|acos|cos
Defines the way that values in the Aux range are mapped
to the selected colour ramp.
The available options are:
- log: Logarithmic scaling
- linear: Linear scaling
- histogram: Scaling follows data distribution, with linear axis
- histolog: Scaling follows data distribution, with logarithmic
axis
- sqrt: Square root scaling
- square: Square scaling
- acos: Arccos Scaling
- cos: Cos Scaling
For all these options, the full range of data values is used, and
displayed on the colour bar if applicable. The Linear, Log,
Square and Sqrt options just apply the named function to the
full data range. The histogram options on the other hand use a scaling
function that corresponds to the actual distribution of the data, so that
there are about the same number of points (or pixels, or whatever is being
scaled) of each colour. The histogram options are somewhat more expensive,
but can be a good choice if you are exploring data whose distribution is
unknown or not well-behaved over its min-max range. The Histogram and
HistoLog options both assign the colours in the same way, but they
display the colour ramp with linear or logarithmic annotation respectively;
the HistoLog option also ignores non-positive values.
- auxmin=<number>
Minimum value of the data coordinate on the Aux axis.
This sets the value before any subranging is applied. If not supplied, the
value is determined from the plotted data.
- auxmax=<number>
Maximum value of the data coordinate on the Aux axis.
This sets the value before any subranging is applied. If not supplied, the
value is determined from the plotted data.
- auxlabel=<text>
Sets the label used to annotate the aux axis, if it is
visible.
- auxcrowd=<factor>
Determines how closely the tick marks are spaced on the
Aux axis, if visible. The default value is 1, meaning normal crowding. Larger
values result in more ticks, and smaller values fewer ticks. Tick marks will
not however be spaced so closely that the labels overlap each other, so to get
very closely spaced marks you may need to reduce the font size as well.
- auxwidth=<pixels>
Determines the lateral size of the aux colour ramp, if
visible, in pixels.
- auxvisible=true|false
Determines whether the aux axis colour ramp is displayed
alongside the plot.
If not supplied (the default), the aux axis will be visible when
aux shading is used in any of the plotted layers.
- forcebitmap=true|false
Affects whether rendering of the data contents of a plot
(though not axis labels etc) is always done to an intermediate bitmap rather
than, where possible, being painted using graphics primitives. This is a
rather arcane setting that may nevertheless have noticeable effects on the
appearance and size of an output graphics file, as well as plotting time. For
some types of plot (e.g.
shadingN=auto or
shadingN=density) it
will have no effect, since this kind of rendering happens in any case.
When writing to vector graphics formats (PDF and PostScript),
setting it true will force the data contents to be bitmapped. This may make
the output less beautiful (round markers will no longer be perfectly round),
but it may result in a much smaller file if there are very many data
points.
When writing to bitmapped output formats (PNG, GIF, JPEG, ...), it
fixes shapes to be the same as seen on the screen rather than be rendered at
the mercy of the graphics system, which sometimes introduces small
distortions.
- compositor=0..1
Defines how multiple overplotted partially transparent
pixels are combined to form a resulting colour. The way this is used depends
on the details of the specified plot.
Currently, this parameter takes a "boost" value in the
range 0..1. If the value is zero, saturation semantics are used: RGB colours
are added in proporition to their associated alpha value until the total
alpha is saturated (reaches 1), after which additional pixels have no
further effect. For larger boost values, the effect is similar, but any
non-zero alpha in the output is boosted to the given minimum value. The
effect of this is that even very slightly populated pixels can be visually
distinguished from unpopulated ones which may not be the case for saturation
composition.
- animate=<table>
If not null, this parameter causes the command to create
a sequence of plots instead of just one. The parameter value is a table with
one row for each frame to be produced. Columns in the table are interpreted as
parameters which may take different values for each frame; the column name is
the parameter name, and the value for a given frame is its value from that
row. Animating like this is considerably more efficient than invoking the
STILTS command in a loop.
The location of the animation control table. This may take one of
the following forms:
- A filename.
- A URL.
- The special value "-", meaning standard input. In this
case the input format must be given explicitly using the afmt
parameter. Note that not all formats can be streamed in this way.
- A scheme specification of the form
:<scheme-name>:<scheme-args>.
- A system command line with either a "<" character at
the start, or a "|" character at the end
("<syscmd" or "syscmd|"). This
executes the given pipeline and reads from its standard output. This will
probably only work on unix-like systems.
In any case, compressed data in one of the supported compression formats (gzip,
Unix compress or bzip2) will be decompressed transparently.
- afmt=<in-format>
Specifies the format of the animation control table as
specified by parameter
animate. The known formats are listed in
SUN/256. This flag can be used if you know what format your table is in. If it
has the special value
(auto) (the default), then an attempt will be
made to detect the format of the table automatically. This cannot always be
done correctly however, in which case the program will exit with an error
explaining which formats were attempted. This parameter is ignored for
scheme-specified tables.
- astream=true|false
If set true, the animation control table specified by the
animate parameter will be read as a stream. It is necessary to give the
afmt parameter in this case. Depending on the required operations and
processing mode, this may cause the read to fail (sometimes it is necessary to
read the table more than once). It is not normally necessary to set this flag;
in most cases the data will be streamed automatically if that is the best
thing to do. However it can sometimes result in less resource usage when
processing large files in certain formats (such as VOTable). This parameter is
ignored for scheme-specified tables.
- acmd=<cmds>
Specifies processing to be performed on the animation
control table as specified by parameter
animate, before any other
processing has taken place. The value of this parameter is one or more of the
filter commands described in SUN/256. If more than one is given, they must be
separated by semicolon characters (";"). This parameter can be
repeated multiple times on the same command line to build up a list of
processing steps. The sequence of commands given in this way defines the
processing pipeline which is performed on the table.
Commands may alteratively be supplied in an external file, by
using the indirection character '@'. Thus a value of
"@filename" causes the file filename to be read for
a list of filter commands to execute. The commands in the file may be
separated by newline characters and/or semicolons, and lines which are blank
or which start with a '#' character are ignored.
- parallel=<int-value>
Determines how many threads will run in parallel if
animation output is being produced. Only used if the
animate parameter
is supplied. The default value is the number of processors apparently
available to the JVM.
- crowd=<number>
Determines how closely tick marks are spaced on the wire
frame axes. The default value is 1, meaning normal crowding. Larger values
result in more grid lines, and smaller values in fewer grid lines.
- frame=true|false
If true, a cube wire frame with labelled axes is drawn to
indicate the limits of the plotted 3D region. If false, no wire frame and no
axes are drawn.
- minor=true|false
If true, minor tick marks are painted along the axes as
well as the major tick marks. Minor tick marks do not have associated grid
lines.
- gridaa=true|false
If true, grid lines are drawn with antialiasing.
Antialiased lines look smoother, but may take perceptibly longer to draw. Only
has any effect for bitmapped output formats.
- texttype=plain|antialias|latex
Determines how to turn label text into characters on the
plot.
Plain and
Antialias both take the text at face value, but
Antialias smooths the characters.
LaTeX interprets the text as
LaTeX source code and typesets it accordingly.
When not using LaTeX, antialiased text usually looks nicer, but
can be perceptibly slower to plot. At time of writing, on MacOS antialiased
text seems to be required to stop the writing coming out upside-down for
non-horizontal text (MacOS java bug).
- fontsize=<int-value>
Size of the text font in points.
- fontstyle=standard|serif|mono
Font style for text.
The available options are:
- fontweight=plain|bold|italic|bold_italic
Font weight for text.
The available options are:
- plain
- bold
- italic
- bold_italic
- cx=<number>
Gives the central coordinate in the X dimension. This
will be determined from the data range if not supplied.
- cy=<number>
Gives the central coordinate in the Y dimension. This
will be determined from the data range if not supplied.
- cz=<number>
Gives the central coordinate in the Z dimension. This
will be determined from the data range if not supplied.
- scale=<number>
The length of the cube sides in data coordinates. This
will be determined from the data range if not supplied.
- phi=<degrees>
First of the Euler angles, in the ZXZ sequence, defining
the rotation of the plotted 3d space. Units are degrees. This is the rotation
around the initial Z axis applied before the plot is viewed.
- theta=<degrees>
Second of the Euler angles, in the ZXZ sequence, defining
the rotation of the plotted 3d space. Units are degrees. This is the rotation
towards the viewer.
- psi=<degrees>
Second of the Euler angles, in the ZXZ sequence, defining
the rotation of the plotted 3d space. Units are degrees.
- zoom=<factor>
Sets the magnification factor at which the the plotted 3D
region itself is viewed, without affecting its contents. The default value is
1, which means the cube fits into the plotting space however it is rotated.
Much higher zoom factors will result in parts of the plotting region and axes
being drawn outside of the plotting region (so invisible).
- xoff=<pixels>
Shifts the whole plot within the plotting region by the
given number of pixels in the horizontal direction.
- yoff=<pixels>
Shifts the whole plot within the plotting region by the
given number of pixels in the vertical direction.
- zoomfactor=<number>
Sets the amount by which the plot view zooms in or out
for each unit of mouse wheel movement. A value of 1 means that mouse wheel
zooming has no effect. A higher value means that the mouse wheel zooms faster
and a value nearer 1 means it zooms slower. Values below 1 are not permitted.
- leglabelN=<text>
Sets the presentation label for the layer with a given
suffix. This is the text which is displayed in the legend, if present.
Multiple layers may use the same label, in which case they will be combined to
form a single legend entry.
If no value is supplied (the default), the suffix itself is used
as the label.
- layerN=<layer-type>
<layerN-specific-params>
Selects one of the available plot types for layerN. A
plot consists of a plotting surface, set up using the various unsuffixed
parameters of the plotting command, and zero or more plot layers. Each layer
is introduced by a parameter with the name
layer<N> where the
suffix "
<N>" is a label identifying the layer and is
appended to all the parameter names which configure that layer. Suffixes may
be any string, including the empty string.
This parameter may take one of the following values, described in
more detail in SUN/256:
- mark
- size
- sizexy
- link2
- mark2
- poly4
- mark4
- polygon
- area
- central
- label
- arealabel
- line3d
- contour
- spheregrid
Each of these layer types comes with a list of type-specific
parameters to define the details of that layer, including some or all of the
following groups:
- input table parameters (e.g. inN, icmdN)
- coordinate params referring to input table columns (e.g. xN,
yN)
- layer style parameters (e.g. shadingN, colorN)
Every parameter notionally carries the same suffix N.
However, if the suffix is not present, the application will try looking for
a parameter with the same name with no suffix instead. In this way, if
several layers have the same value for a given parameter (for instance input
table), you can supply it using one unsuffixed parameter to save having to
supply several parameters with the same value but different suffixes.