All Classes and Interfaces
Class
Description
Wrapping TupleSequence that tries to give up when a condition
becomes true.
Abstract superclass for DataSpec implementations.
Parameter used to select a table for input.
Abstract superclass for a plotter that plots something that looks like
a kernel density estimate.
Style subclass for kernel density plots.
Encapsulates the details of smoothing kernel construction.
Abstract superclass for tasks performing plot2 plots using STILTS.
Partial PlotLayer implementation.
Skeleton implementation of Plotter.
BinList implementation that starts off using a hash-based implementation,
but switches to an array-based implementation if the hash gets full
enough to make it worth while.
Table filter for adding a single synthetic column.
Wrapper table which adds another table to it by placing all the
columns of the added table together with the existing columns.
Environment implementation which wraps a base environment instance and
adds some extra entries as specified by a given map.
Filter used for converting sky coordinates from one system to another.
ReportCode implementation which can be created at runtime.
Defines an aggregation operation.
Can accumulate multiple data items of a consistent type and
yield an aggregate value corresponding to the set.
Object that can manage aggregation for a given type of input data.
Provides instances of the Aggregator interface.
StarTable implementation which can read data from the AllWise data
release.
TableBuilder implementation for the ASCII files comprising the AllWise
data release.
Input handler which reads AllWise ASCII files and does count the
rows first.
Input handler which reads AllWise ASCII files and does not count
the rows first.
Defines the family relationships of an ElementHandler.
Positioning constraint for plotted text.
Anchor for drawing horizontal text.
Defines units in which angular extents can be specified.
Defines a unit of angle measurement.
Find an appropriate delta to use for getting grid intervals.
PlanePlotter implementation that sets up a plot explicitly.
Coordinate value representing a two-dimensional shaped area.
Available shape types.
Coord implementation for Area (shape) values.
Domain representing two-dimensional regions on a common surface.
ShapeForm that can plot Area coordinates as shapes on a plane or sky plot.
DomainMapper for AreaDomain.
Checked exception thrown when arguments encountered on the command
line are illegal.
Standard arithmetic functions including things like rounding,
sign manipulation, and maximum/minimum functions.
Abstract subclass of BinList suitable for implementations based
on arrays.
Task to add the contents of an external table for each row of
an input table as array-valued columns.
PlotData implementation which stores its data in an array of
PointData objects.Reads values from a typed numeric array.
Functions which operate on array-valued cells.
ShapePlotter subclass that plots multiple shapes for each row,
based on array-valued coordinates.
Checks on arraysize attribute.
IOException which results from the failure of a user-level assertion.
Filter for making algebraic (JEL) assertions about table data contents.
Defines an interface and some implementations for a family of
(potentially) strange attractors.
Defines an unbounded sequence of points, that may represent an attractor.
TableScheme that can produce tables representing a sequence of 2d or 3d
points in space corresponding to iterated sequence that follow
(strange) attractors.
StarTable implementation based on an Attractor.
Defines how to perform checks on attributes.
Encapsulates information about how to colour data points for
Aux-like shading.
Displays a legend for an auxiliary (colour) axis.
LineStyle subclass that can vary the line's colour along its length.
Extracts range information from plot data.
Represents a ranged value that can differ according to the content
of a plot.
Does geometry and drawing for a straight line axis.
Defines text labelling to decorate a plot.
Assigns and draws axis labels.
Defines tick mark annotation styles.
Contains labels for an axis.
Represents one of the available plot axes.
Filter for replacing magic values with blanks.
Decoration subclass that also provides a target rectangle.
Defines a style for plotting a bar in a histogram.
Describes the form of a bar style, that is what each bar looks like.
Describes bar placement, that is how multiple bars covering the same
data range are to be arranged.
StyleFactory for BarStyle objects suitable for use with a histogram.
Provides several factory methods for constructing StyleSets
which dispense
BarStyles.Captioner implementation that uses Swing text drawing classes.
Basic implementation of ProcessingFilter methods.
This is a basic interactive GUI plotter.
Ranger implementation that just keeps track of high and low values.
Minimal synchronous implementation of TapRunner.
Partial Ticker implementation based on a rule defining a sequence of ticks.
Defines a specific rule for generating major and minor axis tick marks.
XYShape implementation that can produce shapes of variable line thickness.
Element handler for BINARY elements.
Data model for a one-dimensional histogram.
Describes the extent of a bin and the value it contains.
Stores a grid of bins which contain sums, which may be simple counts or
weighted sums.
Represents a bounded list of bins.
Accessor for the results of accumulating values in a bit list.
Partial SplitCollector implementation for accumulating data in BinLists.
Maps axis values to bin indices.
Stores and dispenses binned data for a histogram.
Represents a single bin.
Accumulates counts in an array of bins.
Drawing plan object for counting the number of hits to each bin in
a grid.
ColumnData implementation that presents the values from a
BinList.Result object, assuming bin index is the row number.
Determines 1-d histogram bin widths from data bounds.
Specifier for BinSizer values.
PlotVolume implementation which accumulates all points to plot and then
draws them in a way suitable for a bitmap-type context.
Opaque workspace object for use with BitmapSortPlotVolume instances.
Bit manipulation functions.
Pixellator built on a bit vector.
Works with an UploadMatcher dividing the input table into chunks and
uploading them separately to produce an arbitrarily large result
while each upload/match operation is of a limited size.
Config key for boolean values.
Coord implementation for single boolean values.
ColumnFactory that stores column data in ByteStores.
Defines storage for a vector of data.
Defines a capability for storing vectors of typed data.
DataStoreFactory implementation that reads columns and caches them
for later use.
Accessor for stored values.
TupleSequence implementation based on CachedColumns.
Processing step which caches the current table in a disk or memory
cache (according to the default
StoragePolicy).RowPipe implementation which caches the data to provide a random-access
StarTable.
Task to do static calculations.
Minimal example of invoking a stilts task programmatically
using the parameter system.
ColumnSupplement whose columns are derived by calculating values
based on all the columns of another table.
Provides TAP service capability information.
Stage for checking content of TAPRegExt capability metadata.
Content of textual item to be rendered somewhere on a plot.
Can paint a text caption onto a graphics context in horizontal orientation.
ConfigKeySet for specifying a captioner.
MultiPointCoordSet for bidirectional errors in Cartesian data coordinates.
MultiPointCoordSet sub-interface for Cartesian geometry.
MultiPointForm for use with Cartesian coordinates.
Plot3D which works with Cartesian coordinates.
PlotData concrete subclass for Cartesian data.
Class used for JEL manipulations.
MultiPointCoordSet for vectors in Cartesian data coordinates.
TableMapper which concatenates tables top to bottom.
Healpix implementation for use with the MOC library based on
F-X Pineau's cds-healpix-java library.
Utilities for working with the cds-healpix-java library in sky plots.
UploadMatcher implementation for the CDS Xmatch service.
Metadata provided for Vizier tables by the CDS Xmatch service.
Upload matcher that uses CDS's Xmatch service.
Class which defines schema-specific details of a CEA configuration file
to be written by a
CeaWriter object.Encapsulates the metadata required for a CEA application description.
Represents a parameter of a CEA task.
Represents a task suitable for use in the CEA interface of STILTS.
Writes an application description file suitable for use with
the AstroGrid Common Execution Architecture.
ShapeForm that plots the central point of an Area.
Output mode for writing the table as a stream with CGI headers.
Processing step which runs the
Tables.checkTable(uk.ac.starlink.table.StarTable) diagnostic.Processing mode for calculating a checksum of table data.
ConfigKey that allows named choices from a given list,
and optionally provides other ways of specifying values
from string descriptions.
Output mode which can be used to give the user, via the parameter
system, the choice about what mode to use.
SpecifierPanel subclass that uses a JColorChooser to specify a colour.
Filter which removes parameters from a table.
Callable client implementation which can watch for registration of a
given named application.
Aggregates a Shader with a Subrange.
Table filter for collapsing multiple scalar columns into an array column.
Combo box for selecting colours.
ConfigKey for selecting colours.
Rule for colouring points according to data values.
Interface defining how a colour is changed from some input colour to
some output colour.
Accumulates statistics for the values in a given column.
Defines an object which can calculate new columns for a table given
a fixed set of input columns and some additional configuration.
ProcessingFilter implementation superclass which adds to a table
columns produced by a ColumnCalculator.
DataSpec implementation that simply selects columns by index from
an input table.
Can identify columns of a table using string identifiers.
Filter to alter metadata of one or more columns.
Validation stage which checks all actual results (SELECT *) against
declared metadata.
Describes the arrangement of columns in the output table based on
the columns in the upload and raw result tables.
ConeQueryRowSequence implementation which extracts values based on
supplied column indices.
Mapper which operates on a user-supplied selection of the columns of
the input table.
Arranges for storage of column data (arrays of typed values)
in byte buffers.
Defines additional column metadata and data for supplementing the
existing columns in a StarTable.
Config key that can select zero or more items from a short fixed list.
Partial Plotter implementation for plot types that combine multiple
all the array-valued X and Y coordinates in a data set, and make
some plot from the resulting combination.
Partial Style implementation for use with this class.
Describes an output column formed by aggregation of values from an
input expression.
Defines the combination mode for accumulating values into a bin.
Defines an object that can be used to accumulate values and
retrieve a result.
Defines the scaling properties of a combiner.
Typed specifier for selecting options from a combo box.
Validation stage for checking that two sets of table metadata
(presumably obtained via different routes) are equivalent to each other.
Bitmapped 2D PaperType which can render any combination of coloured,
opaque and transparent pixels.
Represents an algorithm for combining multiple RGBA values to produce
a single RGBA value.
Compositor with boosted saturation.
Buffer of pixels on which compositing operations can be performed.
Parameter for selecting a Compositor.
Defines how errors are treated during a multiple cone search operation.
Parameter for selecting
ConeErrorPolicy objects.TableProducer which does the work for a multiple cone search-type
sky crossmatch operation.
Object which produces the result table.
Coverage implementation giving the area defined by a sequence of
positional (cone search-like) queries.
RowSequence sub-interface which additionally defines methods for
retrieving RA, Dec search radius and row index for each row.
Defines a service which can perform cone search-like operations.
ConeQueryRowSequence sub-interface which additionally defines a method
for retrieving the result of the cone search itself.
Coner implementation which uses remote
Cone Search services or similar.
Object which can perform repeated sky cone searches.
Abstract class for an object which can make a JDBC SELECT query
corresponding to cone searches.
Exception thrown when a configuration input value is not suitable.
Typed key for use in a ConfigMap.
Map containing typed configuration keys.
Contains metadata about configuration items.
Typed parameter subclass intended to get the value for a ConfigKey.
Provides a mapping from ConfigKeys to Parameters.
Parameter for acquiring a connection to a database using JDBC.
Defines a typed value.
Filter for identifying and removing columns with constant content.
Abstract task which takes an input table and disposes of it.
Parameter for configuring HTTP-level compression.
Defines a permitted class of MIME types.
Plotter implementation that draws contours for a density map of points.
Style for contour plots.
Utility functions for converting between value types.
Functions for converting between strings and numeric values.
Specifier implementation that adapts an existing one to dispense
values of a different parameterised type.
Defines a coordinate quantity in terms of both the user's view of it
and its representation for use in plotting.
Expresses the content of a set of coordinates used for a plot layer,
and how to find the values of these coordinates from a corresponding
DataSpec.
Functions for angle transformations and manipulations, with angles
generally in degrees.
Interface for iterating over coordinates.
Characterises information about a coordinate value.
Characterises a coordinate specification in sufficient detail
to recreate it as part of a STILTS plotting command.
Reads a data value object.
Functions for angle transformations and manipulations, based on
radians rather than degrees.
Aggregates a coordinate specification and the expression strings
that give its values.
Processing mode which writes out a table.
Describes the corners of a 3-dimensional cube.
Processing mode which just counts the number of rows and columns and
writes a summary to the output stream.
Scales integer count values according to a supplied Scaler object.
Defines coverage of a sky positional search service.
Functions related to coverage and footprints.
Describes a type of coverage.
Wrapper QuerySequenceFactory that filters out elements outside of
a given coverage object.
Defines the credibility of a value.
Aggregates a string value and a credibility assessment.
Defines the data range covered by a CubeSurface.
Defines positional data coordinates used by a 3-D Cartesian plot.
Output mode for generating an N-dimensional histogram of data points
from a selection of N columns of the input table.
Navigator for use with cube plot.
Task for cube-type plots.
Defines the characteristics of a plot in 3-dimensional
anisotropic space.
Surface implementation for 3-d plotting.
Surface factory for 3-d plotting.
Profile class which defines fixed configuration items for
an isotropic or non-isotropic CubeSurface.
TableConsumer implementation which constructs and outputs a histogram
data cube for an input table.
Cumulative mode for histogram-like plots.
Specialised subclass of JEL's CompilationException.
Utility class to aid with implementation of ConeSearcher classes
based on contact with remote Data Access Layer-type services.
Combo box for selecting dash patterns.
ConfigKey for selecting line dash types.
Parameter for selecting line dash types.
Encapsulates what is known about the ranges along each axis of a data set.
ColorTweaker which can adjust plotting colours on the
basis of a supplied array of values (auxiliary data coordinates).
Translates the coordinates found in a Tuple to data space coordinates.
Element handler for DATA elements.
Enumerates known ReportCode instances for Datalink validation.
Enumerates standards documents.
DataLink validator task.
Performs validation of DataLink documents.
Splittable iterator over the data positions in a list of PositionClouds.
Adaptor interface defining a cloud of positions for use with
DataPosSequence.
Defines the table-like data that is required for a certain plot.
Contains all the actual data required for a plot.
Provides a data-bearing object capable of providing the actual data
for a number of data specifications.
Parameter to control the way that plot data is cached prior to
performing one or more plots.
Like an Icon but less complicated.
Positioned icon, with equality semantics.
Convenience partial implementation of Style which has a defined colour
and stroke style, with other attributes given by a single object.
Table filter for deleting a single column.
Component which can display a density plot, which is to say, a
two-dimensional histogram.
PlotEvent for density plots.
PlotState specialist subclass used for density maps.
Style for the way that a density map (2d histogram) is plotted.
Enumeration class which describes a colour channel.
Plots a histogram-like density map - a one-dimensional colour bar
indicating density on the horizontal axis.
Plotting style for this class.
Performs checking on attributes which are deprecated by the standard.
Represents a persistent cache based on named files in a given
directory of a filesystem.
Functions for converting between different measures of cosmological
distance.
Serializes text obtained from javadocs to some specific output format.
Characterises a method parameter.
Utility class containing API-independent helper functions for
writing doclets.
Static methods to give the locations of run-time javadocs.
Attempts to check that a DOCTYPE declaration is present in an
input stream representing XML.
Utilities used for automatically-generated documentation.
Config key for a list of floating point values.
Parameter for acquiring a fixed-length array of floating point values.
Config key for double precision values.
Provides drawing primitives on a pixel map.
Does the work of drawing graphics onto a given Paper object.
Abstract Glyph subclass that uses a PixelDrawing.
JELRowReader which can't actually read any rows.
Extends the Task interface by methods which allow task parameters to be
queried based on a (at least partially) populated Environment.
Encapsulates the declaration of an XML element.
Provides checking of a VOTable element during a SAX parse.
Provides a description of an element.
PlanePlotter implementation that uses the name/value pairs in the
same way as the STILTS application command-line interface to set
up a plot.
Validation stage for testing EPN-TAP data model metadata and content.
Indicates that an object must have the
Object.equals(java.lang.Object) and
Object.hashCode()
methods implemented intelligently.Form for drawing an array of error bars per row, given array-valued
X, Y and X/Y error offsets.
StyleSet which wraps an existing one to give it a different error renderer.
Enumeration class which describes, for each dimension, what is the
error reporting regime.
Enumeration class which lists the distance quantities used by different
error modes.
Supplies an ErrorMode.
Renders error bars.
Wrapper table which looks at only every n'th row.
Validation stage for testing TAP /examples document.
Table filter for replacing every N-element array valued column in
a table with N scalar-valued columns.
Table filter for replacing selected N-element array-valued columns
with N scalar-valued columns.
Defines Aladin's idea of a co-operating tool.
Debugging mode for testing TOPCAT's ExtApp functionality.
IText FontMapper implementation that works with externally supplied
TTF files.
Interface which defines additional information available from a Parameter.
XYShape for drawing thick lines that start at the origin and terminate
at the given X,Y displacement.
MarkerShape implementations based on line drawings (open shapes,
crosses etc; not filled shapes) which have lines that are
thicker than the single-pixel traditionally provided.
ElementHandler for FIELD elements.
Attribute checker for ref attributes that point to FIELDs.
Describes how a region above the axis is represented visually.
Pixer that iterates over all points inside a polygon.
Plan object for fill plots.
Plotter that fills the area under (or above, or to the left/right)
the curve defined by a set of X,Y points.
Style for fill plot.
Writes a section of XML text documenting all the known ProcessingFilters.
Parameter which contains a value representing one or more
ProcessingSteps.Parameter for choosing table pair match mode.
Element handler for FITS elements.
Enumerates known ReportCode instances.
Trivial ColorKit implementation that always returns the same colour.
Constant implementation which always has the same value.
Graphics2D implementation which can write to Encapsulated PostScript.
Kernel density plotter that uses fixed-width kernels.
SkyviewProjection subclass that does not use mouse gestures to
rotate the sky, only to pan and zoom over the projected plane.
TablesInput which has a fixed number of input tables.
Filter to normalise syntax of column and parameter names so they
are legal java identifiers.
Coord implementation for a variable-length array of floating point values.
Domain for numeric array values.
Coord implementation for floating point values.
AuxReader implementation that extends ranges simply by sampling
a given scalar floating coordinate for all plottable points.
Functions for conversion between flux and magnitude values.
Defines how colours are changed at different depths (distances away from
the viewer) by interposing a 'fog' which makes the colours gloomier the
further away you go.
Parameter for font selection.
Functions for formatting numeric values.
Assists in formatting text for output on the terminal.
This class provides a hack so that XSD validation can work even
when the wrong namespace is declared in the source document.
Dataless plotter that plots an analytic function.
Defines the geometric role of the dependent and independent variables
for a function.
Style class associated with this plotter.
Functions related to astrometry suitable for use with data from the
Gaia astrometry mission.
Defines how a set of related plot zones is presented together on a
graphics plane.
Supplies additional plot-time information about multi-zone requirements.
Defines how multiple plots can be presented together
as a gang of non-overlapping plotting zones.
Generates Ganger instances for a particular purpose,
for instance a particular type of plot,
taking account of supplied user preferences.
Generic plot2 task for STILTS.
Experimental GeoJSON table input handler.
Enumerates mouse gestures used to perform navigation actions.
An implementation of the quantile
sketch of Greenwald and Khanna.
Quantiler based on the method of Greenwald and Kanna,
via the implementation in
https://github.com/DataDog/sketches-java.
Represents an uncoloured shape to be drawn, typically a small point marker.
Translates Glyph paint operations into pixel iterators.
Type of paper used by this object.
Extends Point2D.Double to include a Z coordinate.
Exports painted graphics to an output file in some graphics format.
Allows one to draw 1-bit graphcs onto a graphics context and to retrieve
the resulting bitmap in the form of a Pixellator.
Glyph implementation whose Pixer is generated by drawing onto a bitmap.
Plotting surface for drawing graphs on.
A greyscale image backed by a a byte buffer.
Calculates optionally weighted density maps/histograms on an N-dimensional
grid and outputs them in table form.
Maps positions on a 2-d grid to a 1-d index.
This class is used to lines and text to draw coordinate grid
grid overlays.
Plotter that plots a genuine density map (2-d histogram) on a regular grid.
Style for configuring the grid plot.
Filter version of TGROUP task.
Form for drawing markers to identify X/Y array data.
Writes auto-generated documentation XML files for STIL I/O handlers.
Data structure which keeps track of the elements currently in scope
during the SAX parse.
BinList implementation based on a hash.
Minimal example of invoking a stilts table processing task
programmatically using the parameter system.
Filter for picking only the first few rows of a table.
Enumeration class describing the function categories used by the
JEL-accessible methods.
Wrapper table implementation which only contains the first N rows of
its base table.
DataGeom implementation for HEALPix indices.
Filter to manipulate HEALPix-specific metadata of a table
supposed to contain HEALPix pixel data.
Plotter for plotting lists of HEALPix tiles.
Style for configuring the HEALPix plot.
QuerySequenceFactory that presorts rows according to HEALPix pixel index.
Maps between plotting (
SkySys)
and Healpix (HealpixTableInfo.HpxCoordSys)
coordinate system identifiers.Tiling implementation based on the HEALPix scheme.
Toy projection class that provides a rotatable sphere.
ConfigKey implementation which is not available for manipulation in
the user interface.
Indicates that a class, method or field is to be excluded from the
auto-documentation made available to application users.
Icon used for point highlighting.
Component which draws a histogram.
Specialisation of PlotState for use with histograms.
PlotStateFactory for a histogram plot.
Plotter for 1-dimensional histograms.
Style subclass for histogram plots.
Histogram-capable Ranger implementation.
Reporter implementation that records reports, and can dump them
on request to another Reporter instance.
TablesInput which has a variable number of input tables,
treating them all the same as each other.
DocletOutput implementation for writing basic HTML,
with one file per class, method and field.
Attribute checker for processing ID attributes.
CeaWriter implementation which writes an XML document giving
CEA Implementation instance.
Represents a row from a dataset in relation to a reference position.
Characterises a coordinate value as specified by the user.
Parameter for selecting input table format.
Contains user-directed metadata to describe
user-supplied input data coordinate values used for plots.
Parameter for specifying a single input table.
Parameter for specifying an indeterminate number of input tables.
Provides the specifications for a single input table.
Config key for integer values.
Coord implementation for integer values.
Enumerates the avaialable integer types.
Converts between Strings in ISO-8601 format and some kind of numeric date.
Helper class which contains all the items which are potentially
expensive to produce but cannot be shared by different threads.
Converts between Strings in ISO-8601 format and numeric date as a
Decimal Year.
Converts between Strings in ISO-8601 format and numeric date as a
Julian Year.
ResourceResolver implementation used for validating documents against
XSD schemas relating to known IVOA standards.
Coner implementation which works by performing SELECT statements over a
JDBC database connection.
ConeSearcher implementation using JDBC access to an SQL database.
Table consumer which disposes of a table by writing it as a new
table in a SQL database using JDBC.
Mode for writing a table as a new table in a JDBC-connected database.
Doclet for documenting user-visible JEL library classes,
based on the jdk.javadoc.doclet API.
Class for use with
javadoc tool that writes
MethodBrowser-friendly HTML output.Class for use with
javadoc tool that writes
SUN-friendly XML output.Provides an array->array function in which input elements are
mapped to output elements by use of a given JEL expression.
This public class is an implementation detail,
not intended for external use.
ColumnSupplement that generates new columns based on JEL expressions.
DataSpec implementation that works with JEL expressions.
Provides a double precision function of one double precision
variable which can be evaluated using JEL.
This public class is an implementation detail,
not intended for external use.
Aggregates a compiled expression and a metadata object.
QuerySequenceFactory which uses JEL expressions for RA, Dec and SR.
An object which is able to read cell values by column name or number.
Sequential table which selects rows on the basis of a JEL-interpreted
expression.
Wrapper table which is constructed entirely of columns defined by
JEL expressions based on the base table.
This class provides some utility methods for use with the JEL
expression compiler.
TapLint stage which submits and manipulates UWS jobs, mostly to check
that the UWS operations are performing correctly.
Parameter which can control how column names are renamed if they would
otherwise be duplicated in an output table.
TableMapper which joins tables side-by-side.
Parameter which can select a
JoinType.OutputReporter implementation for exporting JSON structured output.
Outputs an object as JSON.
Manages export of a list of lines to the JSON format used for
serialization of Jupyter notebooks (.ipynb files).
Writes a Jython module which facilitates use of STILTS functionality
from Jython.
Functions for calculating K-corrections.
Table filter for selecting a number of columns and discarding the rest.
Defines a smoothing function used for smoothing 1-dimensional
uniformly gridded data represented by an array.
Factory interface for for Kernel1d smoothing functional forms.
Aggregates a set of config keys which are used together to specify
an object.
Kernel Density Plotter that uses a variable-width kernel whose width
is assigned using K-Nearest-Neighbours counting.
Aggregates a line in graphics coordinates and its annotation.
Plotter that writes a text label at each graphics position.
Style for LabelPlotter.
Utility class for working with units for labelling extents.
Captioner implementation based on LaTeX text rendering.
Defines characteristics of a plot layer that may enable plotting
optimisations.
Specifies a plot layer in sufficient detail to recreate it as
part of a STILTS plotting command.
Write XML text describing LayerTypes available to given TypedPlot2Tasks.
Represents the type of a plot layer as selected by the user.
Writes XML text documenting known plot2 LayerTypes.
Parameter that specifies a LayerType to be used for a plot layer.
Draws the legend for identifying points on a plot.
Aggregates a plot style or group of styles and a label to be
paired together as one entry in a plot legend.
Icon containing legend information for a plot.
Defines a strategy for calculating contour level values from an
array of data.
TableSink wrapper implementation that truncates the row stream
at a given maximum.
Plots lines joining data points in three dimensions.
Fits a set of 2-d points to a linear equation, and plots the line.
Form for drawing one line per row, given array-valued X and Y
coordinates.
CombineArrayPlotter that plots a line between aggregated positions.
Style for use with this plotter.
Defines how line endings are handled when formatting stilts commands.
Glyph partial implementation that facilitates making drawings with
variable-thickness lines.
Invokes the Stilts tasks using a
LineTableEnvironment.Plotter that plots a line between data points.
Style for line plotter.
Component which paints a stack of line plots.
PlotState subclass for use with stacked line plots.
Plotting style for continuous lines.
Execution environment suitable for use with the TTOOLS package.
Draws lines composed of a sequence of points, submitted one at a time.
Draws lines composed of a sequence of points onto a 3d plotting surface.
XYShape for drawing lines that start at the origin and terminate
at the given X,Y displacement.
Functions which operate on lists of values.
ConfigMap wrapper that issues a logging message for each item that
is queried.
Coord implementation for long values.
Acquires a lookup table by scraping pixels from a colour ramp icon.
BinnedData implementation that uses a map.
Defines the mapping of numerical values to map keys.
Environment which allows use of ttools tasks from an in-memory context.
Task which maps one or more input tables to an output table.
Form for drawing an array of markers per row, given array-valued X and Y
coordinates.
CombineArrayPlotter that plots a marker at each aggregated position.
Style for use with this plotter.
Defines the abstract shape of a MarkerStyle.
Defines a style of marker for plotting in a scatter plot.
ShapeForm implementation that just draws a fixed-size marker for each
position.
Defines the abstract shape of a MarkStyle.
Defines a style of marker for plotting in a scatter plot.
Enumeration class describing the types of line which can be drawn
in association with markers.
StyleFactory for obtaining
MarkStyle
instances suitable for use with a scatter plot.Provides several factory methods for constructing StyleSets
which dispense
MarkStyles.Contains some utility methods for generating selectors for plot
style elements.
Characterises information about a data inclusion mask.
Reads a flag.
SingleTableMapping whose result is generated by performing an
internal crossmatch on the input table.
Parameter subclass whose value is a
Match1Type object.TableMapper which does the work for pair matching (tmatch2).
TableMapping implementation which does the work of matching two tables.
Parameter for acquiring a
MatchEngine.TableMapper which implements multi-table crossmatches.
Standard mathematical and trigonometric functions.
Utility class for linear algebra in 3-dimensional space.
Defines which cells from a matrix are included.
Ganger for use with a square matrix of Plane plots.
GangerFactory for use with a square matrix of Plane plots.
Plot task for matrix plot.
PlotType for a grid of plots.
Defines the shape of an ordered list of cells from a square matrix,
and a mapping between an index and the cells.
Represents one cell in a 2x2 matrix.
Set of identifiers used for class members during documentation.
CachedColumnFactory implementation that stores data in arrays in memory.
Filter for extracting column metadata.
Provides table metadata.
Processing mode which summarises table metadata.
Component displaying the static public members of a set of classes.
ConfigMeta implementation that conforms minimally to the requirements.
Write some miscallaneous auto-documentation files for ingestion
in the user document.
Abstract superclass for Coverage implementations based on MOC
(HEALPix Multi-Order Coverage) objects.
Defines a MOC serialization format.
Turns a table into a Multi-Order Coverage map.
Writes a section of XML text documenteding all the known ProcessingModes.
Plotter sub-interface that marks a family of plotters as having
similar characteristics.
Marker interface for an object that is shared between plotters
sharing characteristics that make it useful to group them.
Marker interface for an object that is shared between plotters
sharing characteristics that make it useful to group them.
Bitmapped PaperType which can paint transparent or opaque pixels
as long as they are all the same colour.
ByteStore that stores data in a named file which appears completely
populated in the filesystem.
SkyConeMatch2 implementation which uses an external Cone Search service.
Task to copy multiple homogeneously acquired tables to an output
container file.
Task to add multiple tables, perhaps with different formats and
preprocessing, to an output container file.
Parameter to hold an output format capable of writing multiple tables.
Task which writes multiple tables to a single output file.
PlotData implementation which aggregates a set of constituent PlotDatas.
Config key that specifies a multi-point shape.
Defines non-central coordinates used by a MultiPointPlotter.
ShapeForm implementation that draws shapes based on a single main
position, and a number of additional positions supplied as
extra coordinates.Defines data reading behaviour for use by a MultiPointForm.
Reads the non-central data positions for a MultiPointCoordSet.
Knows how to turn a number of offset points to a drawable glyph.
Defines a graphical shape with coordinates supplied by a number of
offset points.
Uncoloured icon suitable for legends representing multi-position plot types.
ColumnCalculator implementation which works by invoking a service for
each row.
SpecifierPanel subclass that puts a number of alternative
SpecifierPanels alongside each other and lets the user interact
with any one of them to perform a selection.
Attribute checker for VOTable name elements.
ColorChooserPanel implementation that provides a scrollable JList
of named colours.
Defines a set of colours with associated names.
Parameter subclass for selecting named options.
Filter which renames a table.
Describes the result of a navigation request from the GUI.
Utility class supplying visual feedback decorations for
two-dimensional plot navigation.
Utility class supplying visual feedback decorations for
three-dimensional plot navigation.
Listener that receives mouse events and uses them in conjunction with
a supplied navigator to feed navigation actions to a set of one or
more plot surfaces.
A navigator controls how user gestures affect a plot surface.
Defines normalisation modes for histogram-like plots.
Wrapper implementation of BinnedData which normalises bins so that
the total value of all bins in a given subset is unity.
Captioner implementation that writes no text.
Processing mode which reads all data and disposes of it.
Abstracts a readable array of numeric values.
Validation stage for testing ObsLocTAP data model metadata and content.
Validation stage for testing ObsCore data model metadata and content.
Config key for use with items that can be chosen from a list of options.
Defines text orientation for axis labelling.
Wrapper Captioner implementation that draws an outline around the
caption bounding box as well as actually drawing it.
Paints the shape of per-point markers.
Captures the output of a java main() method, wraps it in a CDATA marked
section, and outputs it.
Parameter to hold the format of a table for output.
Parameter for table output mode.
Interface for application-level logging of validation messages.
Parameter for selecting an OutputReporter for use with taplint.
Parameter to hold an output table.
Bitmapped 2D PaperType which just plots graphics over the top of any
previously plotted data.
Defines user preferences for padding a rectangular area.
Parameter for receiving a Padding specification.
Interface for plot output.
Defines a mode for disposing of a plot.
Writes a section of XML text documenting all the known
PaintModes.Parameter which obtains a Painter object.
Vector paper type abstract superclass.
PaintPaperType for 2-dimensional plots.
Draws a line between two related positions.
Custom chooser panel implementation that lets you choose from
a number of pre-configured palettes.
Marker interface labelling objects which are used to store rendering
data specific to a given PaperType.
Abstracts the graphic substrate that datasets can be plotted on.
PaperType sub-interface for making 2-dimensional plots.
PaperType sub-interface for making 3-dimensional plots.
Provides interface and logic for determining what PaperType
(rendering machinery) to use to render a given selection of
plot layers to a given output medium.
ConeResultRowSequence implementation which uses a fixed number of
worker threads to dispatch cone queries in parallel.
ParameterFinder<P extends uk.ac.starlink.task.Parameter<?>>
Used for obtaining a parameter qualified by an optional suffix.
Element handler for elements which describe values - this is FIELD
and PARAM type ones.
Attribute checker which can check attributes which contain strings
of the type described by this element.
GraphicExporter implementation that exports to PDF format.
ColumnSupplement implementation which contains a selection of the
columns in the base table.
DataStoreFactory implementation that will store cached columns
in the file system.
ConfigKey for unit selection.
Interface for a self-contained object which can paint itself on a
graphics context.
Adapter class that makes a Picture usable as an Icon, suitable for
use in a pixel (non-vector) context.
Abstract superclass for histogram-like plotters that have pixel-sized
bins with optional smoothing.
Data object storing counts per pixel.
Plot plan implementation for this class.
Provides drawing primitives on a pixel map.
Aggregates information for painting a colour-mapped image.
Reusable iterator over pixel positions.
Adapts a Pixellator to generate Pixer instances.
2-dimensional bit mask.
Bitmapped 3d PaperType which can render any combination of coloured,
opaque and transparent pixels.
Iterator over pixels.
Issues copies of a Pixer.
Utility class for use with Pixers.
Constructs and writes a Multi-Order Coverage map.
Partial Outliner implementation which calculates its bin plan
simply by using the
create2DPainter method.Samples data from a HEALPix pixel file.
Interface to turn input coordinate values into coordinate values
suitable for pixel sampling.
Filter for sampling pixel data from a HEALPix all-sky table file.
Interrogates a HEALPix all-sky map to sample pixel data.
Defines how statistics are to be acquired from a pixel or set of pixels.
Sub-interface of Surface for surface types that are
basically two-dimensional and Cartesian.
Defines the data range covered by a PlaneSurface.
AxisAnnotation implementation for 2D surfaces.
MultiPointCoordSet for 2-d ellipses defined by coordinate errors
and a correlation.
Defines positional data coordinates used by a 2-D Cartesian plot.
MultiPointCoordSet for ellipses on a plane.
Navigator for use with plane plot.
Task for Plane-type plots.
Defines the characteristics of a plot on a 2-dimensional plane.
Surface implementation for flat 2-d plotting.
Surface factory for flat 2-d plotting.
Specifies configuration options for the PlaneSurfaceFactory.
Profile class which defines fixed configuration items for
a PlaneSurface.
Instances of this class represent a given figure plotted using
the plot2 plotting classes and some externally supplied data.
Utility methods for writing JupyterNotebooks that can be used with
the plot server.
Component which paints a 3d plot.
Interface for checking that a 3-d coordinate is in range.
Transforms points in 3d data space to points in 3d graphics space.
PlotState subclass which has specific features for specifying the
state of 3D scatter plots.
PlotStateFactory for 3D plots.
Encapsulates some choices about what caching is performed when
preparing a plot.
Object capable of executing a static or interactive plot.
Aggregates some miscellaneous information required for a plot task
that may not be available until execution time.
Describes the point data to be plotted, including information about
different data subsets and corresponding plotting styles.
Exception used for exporting errors from the plot system.
PointIterator implementation based on a
PlotData object.Graphical component which displays a gang of one or more plots.
Event sent to a
PlotListener when a plot has been completed.Programmatically generates example text and images for STILTS plotting tasks.
Defines the geometry of a screen area to contain plot content.
Convenience class for generating plots.
Represents a layered element of the plot.
Interface for objects which wish to be informed when a plot has been
completed.
Calculates distances in data space between points on a plot surface.
Aggregates a Surface and the Rectangle that it is placed within.
Contains the state of a plot, which can be painted to a graphics context.
Specifies a plot in sufficient detail to recreate it as a STILTS
command.
Characterises the details of how a plot is to be done.
ValueInfo implementation which ignores information that's not
relevant to plotting.
Defines a surface onto which plots are made.
Abstract superclass for tasks which generate plots from table data.
A Plotter can produce PlotLayers given data and appropriate configuration.
High-level description of a type of plot that can be drawn.
Miscellaneous utilities for use with the plotting classes.
Plots 3D points on a 2D graphics context.
Object which represents a point to be plotted on a PlotVolume.
Pixellator based on an array of
Point objects.Represents an unordered set of data positions forming part of a plot.
Contains data for a single point in a
PointSequence.Iterates over the points which have actually been plotted to the screen.
Maps a data point onto a screen point.
Describes the result of an attempt to select a data point on a plot.
Listens for events representing the selection of a data point in a plot.
Iterator over point data described by
PlotData.ShapeForm implementations for plotting filled or outline polygons.
Outliner implementations for plotting shapes defined by listing
three or more vertices in data space.
Object that knows how to draw a polygon.
StarTable implementation which reads data from a pipe-separated-value
file.
Partial Ticker implementation for major tick labels with prefixes.
Defines a specific rule for generating tick marks with prefixes.
SaxMessager implementation that writes messages to a given print stream.
Defines a type of filter-like processing which can be done on a StarTable.
Interface defining the final element of a table processing pipeline -
the one which disposes of the generated table in some way.
Represents one step of a table processing pipeline.
Processing step which writes table progress to the terminal.
Parameter for getting a ProgressIndicator.
Sky projection.
PlotSurface implementation which uses Ptplot classes for axis plotting
Writes entity definitions for the purposes of all the known STILTS tasks.
Combiner implementation that accumulates all input points per pixel
for custom combination by a user-supplied object.
Defines the calculation of the combined result from submitted
data values.
Calculates quantile values given a sequence of data samples.
Object which can generate an iterator over cone search specifiers.
Validation stage which performs some ADQL queries on data tables.
KeySet for defining the characteristics of a colour ramp.
Defines ramp characteristics by aggregating a Shader and a Scaling.
Processing step which calls the
Tables.randomTable(uk.ac.starlink.table.StarTable) utility.Random-access evaluator for JEL expressions evaluated against tables.
Provides JELRowReader functionality for a random access table.
Functions concerned with random number generation.
Processing filter that makes sure any RowSequence taken out on a
table uses calls to random table access methods.
Describes a one-dimensional range.
Partial SplitCollector implementation for accumulating range data.
Filter for selecting a contiguous range of rows.
Accumulates a set of data values to provide range information.
An extension of JSlider to select a range of values using two thumb controls.
Utility classes for JSlider components that can define a range.
Attribute checker for checking XML IDREF type attributes.
Performs a registry query.
Filter for repeating a table's rows multiple times.
Wrapper table which repeats the rows of the base table multiple times.
Filter for replacing a given value with another one in a list of columns.
Wrapper table which makes replacements of named values with other
named values in some of its columns.
Labels a taplint report.
Basic interface for logging validation messages.
SAX ErrorHandler implementation based on a Reporter.
SaxMessager implementation which delivers its output via
a TapLint-style reporter.
Typed key for use in a ReportMap.
Map containing typed entries generated as a result of plotting.
Contains documentation metadata describing a plot report item.
Message types for use with a reporter.
Filter which adds RA, Dec coordinate columns by performing name resolution
using an external service.
Stores icons used by the ttools package.
JELRowReader for accessing JDBC
ResultSet objects.An efficiently stored RGB or RGBA image backed by an int buffer.
Abstract bitmapped PaperType which uses an RgbImage to store graphics.
Paper for use by this type.
Abstract RgbPaperType subclass for 2-dimensional plots.
Paper for use by this type.
Abstract RgbPaperType subclass for 3-dimensional plots.
Paper for use by this type.
Rotates vectors between sky systems.
Provides round numbers.
Defines a policy for coming up with round numbers.
Defines a mapping between objects of some given type and table row index.
Parameter for acquiring a RowRunner.
Processing mode for sending the table to other subscribed clients
using the SAMP tool interop protocol.
Defines how parsing messages are reported.
Defines the levels of severity at which messages can be reported.
Defines the mapping of an input value to the range 0..1.
Defines a policy for scaling values to a fixed interval.
Marker interface for Scaling instances that create Scalers based
on a histogram assembled from data.
Interface for Scaling instances that can create Scalers from
a lower and upper bound.
Implementation class for functions to do with Scaling instances.
Component which can display a scatter plot of points.
PlotEvent for scatter plots.
Writes a section of XML text documenting the details of TableSchemes
available within the STILTS application.
Column calculator which interrogates the IPAC Dust Extinction map service.
Enumerates physical values available from the IPAC dust service.
Specifies the dust query to be made.
Enumerates statistics available from the IPAC dust service.
Filter that applies the SchlegelCalculator.
Table filter for selecting only certain rows using a JEL expression.
StarTable implementation which concatenates a list of compatible
constituent tables in sequence.
Implements JELRowReader for sequential access to a table.
Straightforward implementation of ConeResultRowSequence based on a
ConeQueryRowSequence.
Processing filter that makes sure any table filtered by it does not
have random access.
CeaWriter implementation which writes a registry record document
describing a CEA Service instance.
ConeSearcher implementation using a VO
Cone Search service.
Enumeration of ways to submit an upload match to a service.
Defines an operation which turns an input tuple into an output tuple.
Filter which sets a parameter on the table.
Defines a key-value pair for use in a stilts command line.
Represents a set of parameter-value pairs to be grouped together
for display purposes.
Converts between Strings in sexagesimal format and numeric values in
degrees.
Graphical representation of aux shading range which can be placed
near the plot.
Defines how to get a ShadeAxis for a shader range.
Aggregates information required for generating an Aux colour axis.
Defines an object which can modify an sRGB colour as defined by a scalar
parameter.
ConfigKey for selecting shader objects.
Generates a graphic in SVG format showing labelled colourmaps.
ListCellRenderer suitable for a combo box containing
Shaders.Parameter for choosing
Shader objects.Provides some implementations of the
Shader interface.DataColorTweaker implementation which uses an array of Shader objects.
Specifies a shade axis in sufficient detail to recreate it as part of
a STILTS plotting command.
LayerType that represents a family of ShapeModePlotters.
Plotter Form sub-interface for use with ShapeMode.
Defines how outlines defined by a ShapeForm are coloured in a plot.
Stamper implementation for auto transparency.
Stamper implementation for density mode.
Stamper implementation for flat colouring.
Stamper implementation for use with AuxShadingMode.
Stamper implementation for use with WeightedShadingMode.
Writes XML text documenting known plot2 ShapeModes (shading modes).
ModePlotter subclass with ShapeForm for form and ShapeMode for mode.
Interface to define the actual shape drawing done by an Outliner.
Plotter that plots shapes at each data point.
Functions useful for working with shapes in the (X, Y) plane.
Style that combines information from a ShapeForm and a ShapeMode.
Aggregates two short integer values.
Task for browsing available algebraic functions.
ConeSearcher implementation using a VO
Simple Image Access service.
Encapsulates four boolean flags, one for each side of a rectangle.
DataStoreFactory implementation that does no caching.
Abstract Plotter implementation that does all its painting using a Decal,
no Glyphs.
Minimal Domain implementation with only one mapper.
Simple mapper implementation.
LayerType representing a single Plotter.
Sine (Orthographic) projecter implementation.
Example programmatic use of stilts plot2 classes.
Abstracts the way that the table is turned into a 2d plot component.
Partial Coord implementation for quantities that are represented
as scalars both to the user and internally.
GangerFactory implementation for single-zone gangs.
MapperTask which has a single input table.
Interface that defines mapping one table to another.
Sine (orthographic) projection.
ShapeForm implementation that draws shaped markers of a size
given by an additional data coordinate.
Outliner implementation for use with SizeForm.
ShapeForm implementation that draws shaped markers with their horizontal
and vertical dimensions independently determined by two additional
data coordinates.
Outliner implementation for use with SizeXyForm.
Functions useful for working with shapes on a sphere.
Defines the view of a SkySurface.
Performs axis labelling for a sky plot.
Implementation class containing SkyAxisLabeller implementations.
Defines a region of the celestial sphere which is rectangular in
Right Ascension and Declination coordinates.
Crossmatcher which works by performing one cone-search type query
for each row of an input table on an external service of some kind.
Coord implementation for sky positions.
Controls the interpretation of sky vectors, either fixed to the
surface of the unit sphere or not.
Utilities for sky coordinate parameters.
MultiPointCoordSet for ellipses on the sky defined by lon/lat errors
and a correlation.
Defines positional data coordinates used by a sky plot.
Calculates sky density maps and outputs them as tables.
Plotter that plots a genuine density map on a SkySurface.
Style for configuring with the sky density plot.
Encapsulates a distance on the sky and a label for its magnitude.
MultiPointCoordSet for ellipses on a sphere.
Characterises a field of view on the sky for presentation to the user.
Plotter that can draw a sky axis grid on a sky surface.
Style for configuring the grid plot.
Task implementation for simplified sky matching task.
TableMapper which does the work for sky-specific pair matching (tskymatch2).
Match2Mapping subclass specific to sky matching.
MultiPointCoordSet sub-interface for coordinates on the sky.
MultiPointForm for use with sky coordinates.
Navigator for use with sky plot.
Maps positions on the unit sphere to pixel indices using a given pixel
scheme.
Task for Sky-type plots.
Defines the characteristics of a plot on the surface of the
celestial sphere.
Stores information required to simulate a sky catalogue.
Defines an object that can return a sample value for a given region.
TableScheme that can provide a simulated view of the sky.
Surface implementation for plotting on the celestial sphere.
Surface factory for plotting on the surface of the celestial sphere.
Profile class which defines fixed configuration items for a SkySurface.
Understands the geometry of HEALPix tiles on a given SkySurface.
Sky coordinate system definition.
ConfigKey for selecting sky coordinate systems.
Represents a sky coordinate system.
Defines the strategy for rendering HEALPix tiles to a graphics context.
Defines a pixellation scheme which maps sky positions to long integers.
Class defining units used for a two-coordinate sky coordinate system.
MultiPointCoordSet for vectors on the sky.
Partial projection implementation based on classes from the Skyview package.
Ticker implementation that provides ticks for a supplied function
based on a separate master axis.
DataGeom implementation that reads positions corresponding to some,
but not all, orthogonal data position coordinates.
Double value specifier that uses a slider to choose a value in the
range betwen two given values.
Specifies whether and how a text display field should appear alongside
the slider for user entry.
Indicates that a method may take a non-negligable amount of time.
CachedColumnFactory implementation that is able to spot non-varying
columns and represent them efficiently.
Unit for solid angle quantities.
PaintPaperType for 3-dimensional plots.
Processing filter which sorts on one or more JEL expressions.
Filter for returning the first (or last) few rows of a sorted table.
Quantiler that retains all data samples, sorts them when ready,
and uses the sorted array to answer questions about quantiles.
Characterises the extent and possibly the distribution of a dataset.
Can acquire a typed value from the GUI.
Partial Specifier implementation.
Plotter for spectrograms.
Defines the spectrum frequency channels.
Style subclass for SpectrogramPlotter.
Represents the range of angular coordinates that are covered
by a given region.
Defines positional data coordinates used by an isotropic spherical
polar 3-D plot.
Plotter that can draw a spherical grid around the origin of
a CubeSurface.
Style class for sphere grid plotter.
Calculates line segments forming longitude and latitude lines
for a sphere around the data origin of a cube surface.
Represents a set of 3-d points that can be joined together to
make a grid line.
Task for sphere (isotropic 3D)-type plots.
Defines the characteristics of plot in 3-dimensional isotropic space.
Plot3D which works with spherical polar coordinates.
PlotState specific to spherical 3D plots.
Utility class for making use of SplitProcessor instances.
Fairly minimal example plotter implementation.
LayerType corresponding to SpotPlotter.
Style implementation for spots.
SQL command-line client.
Multiple cone match task which works by doing SQL queries using JDBC.
JDBC table column writer task.
SAX content handler which mostly copies events to text,
but eliminates a given attribute from the root element.
ConeSearcher implementation using a VO
Simple Spectral Access service.
Ganger implementation for a vertically stacked gang of plots,
all sharing the same horizontal axis.
Represents a stage of validator processing.
Performs colouring of an outline.
Implementation class for Kernel1dShapes based on evaluating
symmetric functions over a limited extent.
JELRowReader subclass for access to StarTables.
Indicates that a public static method is to be evalated by JEL
at runtime not compile time, even if its arguments can be determined
at compile time.
Plotter to calculate and display univariate statistics
of histogram-like data.
Style class associated with this plotter.
Filter which can calculate statistical quantities.
Processing mode for calculating statistics on a table.
Wrapper data store implementation that dispenses all column data
as evenly spaced subsamples by row.
Factory which can create ProcessingStep objects from strings which
represent the filter specifications.
Top-level class for invoking tasks in the STILTS package.
Represents an abstract model of a STILTS command line.
Handles export of StiltsPlot objects to external serialization formats.
Enumerates the possibilities for internal storage of coordinate data
for presentation to the plotting classes.
Handler for STREAM elements.
Abstract handler superclass for elements with STREAM children
(BINARY or FITS).
Config key for use with String values.
Coord implementation for String values.
Convenience parameter subclass for getting a sequence of string values.
String manipulation and query functions.
Supplier for drawing strokes.
XYShape that draws a line using a Stroke object.
Defines a style for marking a set of data.
Defines an object which can obtain a
Style
object from the environment.Contains many common config keys and associated utility methods.
ChoiceParameter subclass suitable for use with plotting style configuration.
Utility class relating to the
StyleSet interface.Defines a sequence of styles intended for use within a single plot.
Aggregates the DataGeom and the geometry-specific parts of the
DataSpec for a layer.
Designates a sub-range.
Config key that specifies a Subrange.
PlotData wrapper implementation which rearranges subset indexes.
Object that defines how groups of (parameter) suffixes are constructed.
Doclet for documenting user-visible JEL classes,
based on the com.sun.javadoc API.
Class for use with
javadoc tool that writes
MethodBrowser-friendly HTML output.Class for use with
javadoc tool that writes
SUN-friendly XML output.Accessor for the data supplied by columns in an associated ColumnSupplement.
Defines the graphical area on which plots are painted.
Generates members of a family of Surface objects.
Abstract superclass for plot components which display on a
PlotSurface.Describes the area outside a rectangle reserved for annotations.
Represents the space taken along one side of a rectangle.
Processing mode for displaying the table in a scrollable Swing window.
Painter subclass which can paint to the screen.
Supplies selected mask and coordinate data relating to a single table.
Concatenates multiple homogeneous tables top-to-bottom.
Concatenates two tables top to bottom.
Concatenates N tables top to bottom.
Executes a single cone-search-like query to an external DAL service.
Disposes of a table.
Defines an object (probably a parameter) which can return a
TableConsumer.
Task which copies a single table from input to output.
Task implementation for the histogram array creation task.
Contains the data from a table in easy to digest form (no IOExceptions).
Environment subinterface which provides additional functionality
required for table-aware tasks.
Parameter whose value is a StarTableFactory.
Task for performing aggregation operations on groups of rows of an
input table.
Defines the aggregation that should be done to form an output column.
ElementHandler for TABLE elements.
Attribute checker which checks a TABLE's nrows attribute.
Task for performing a 1D histogram.
Joins N tables side-to-side.
JELRowReader implementation which has no columns.
Interface which describes turning a string into a StarTable object.
Creates a single-column table with values dispensed from a for loop.
Interface for an operation which takes zero or more tables as input
and produces one table as output.
Defines an operation which maps zero or more tables on input to a table
on output.
Performs an internal (single-table) crossmatch.
Task implementation for generic pair matching task.
Permforms a multi-table crossmatch.
Validation stage for checking the content of parsed Table metadata.
General purpose task for copying multiple input tables to an output
table container.
Defines how Setting string values are generated from input values
which refer to tables.
TableMapper which does the work for the tpipe command.
Superclass for all components which draw plots from table data.
Task for performing a 2D scatter plot.
Task for performing a 3D scatter plot.
Abstract superclass for PlotData implementation representing
the data from a single table with associated expressions describing
coordinate selections etc.
PointSequence abstract superclass implementation for getting sequential
plot data from a table.
Provides a table.
Validation stage for checking table metadata from the /tables endpoint
(as defined by the VODataService schema).
Interface for an object which can acquire multiple input tables.
Aggregates column statistics for a table.
Filter for picking only the last few rows of a table.
Wrapper table implementation which only contains the last N rows of
its base table.
Performs normalised 3D coordinate transformations equivalent
to displacements from the origin in the tangent plane.
TAP Validator task.
Organises validation stages for TAP validator.
Mapper that does the work for
TapQuerier.Performs a TAP query.
Object which can get the output table from a TapQuery.
Aggregates parameters used for recovering and delivering the result
of a TAP query.
Enumeration of UWS job deletion modes.
Resumes an existing TAP query.
Executes TAP queries for the validator.
MetadataHolder implementation which supplies metadata based on the
assumed (mandated) form of the TAP_SCHEMA tables which a TAP service
is required to supply.
Validation stage for checking table metadata from the TAP_SCHEMA tables.
Manages a collection of parameters used to generate a TapService.
UploadMatcher implementation for a TAP service.
Upload matcher that uses an external TAP service.
Writes SQL ResultSets to VOTable with the INFO elements appropriate
for TAP output.
Element handler for TD elements.
JSlider that displays the currently selected value when the slider
is being dragged.
SpecifierPanel subclass that uses a text field for input.
OutputReporter implementation for logging plain text to a print stream.
JComboBox for selecting line thickness.
Defines a tick on an axis.
Provides tick marks to label plot axes.
Defines the appearance of tick marks on a plot axis.
Partial SkyAxisLabeller implementation that labels axes with positioned
numeric labels.
Aggregates a line label, graphics position and text anchor.
Parameter for specifying SkyTiling values.
Pixel tiling functions for the celestial sphere.
Defines the data range covered by a TimeSurface.
Config key for values in the time domain.
Defines positional data coordinates used by a 2-D time plot.
Formats numeric values to strings to provide axis ticks and
user-viewable coordinate readouts.
Function operating on a time value as used in a Time plot.
Defines a quantity representing time that can be used in expressions
supplied to this class.
This public class is an implementation detail,
not intended for external use.
Navigator for use with time plot.
Task for time plots.
Defines the characteristics of a 2-d plot with a horizontal time axis.
Functions for conversion of time values between various forms.
Ganger that stacks time plots vertically with a shared time axis.
Surface implementation for time-series plotting.
Surface factory for time plots.
Profile class which defines fixed configuration items for a TimeSurface.
Unit implementations representing time intervals measured in seconds.
Wraps a supplied ConfigKey to provide one that will also allow
selection of the null value.
Specifier that decorates another one with a toggle button for
selection of a fixed value.
Utility class to help with tokenizing strings.
Processing mode for displaying the streamed table in TOPCAT.
Plots a line through a cloud of points in 2d, tracing a given
quantile or pair of quantiles at each column (or row) of pixels.
Defines the graphial style for joining sparse samples.
Style for trace plot.
Pixellator which modifies the behaviour of a base Pixellator by translating
it on the XY plane.
Processing filter which transposes a table.
Element handler for TR element.
Standard trigonometric functions with angles in degrees.
Aggregates static items that decorate a rectangular plotting area.
Specifies trimming items in sufficient detail to recreate them as part of
a STILTS plotting command.
Specification for legend display options.
Defines a tuple of typed values for plotting.
SplitRunner subclass for use with TupleSequences.
Interface for iterating over points to plot.
TableBuilder implementation for the ASCII files distributed on the
2MASS catalogue DVD set.
Plot2 task specialised for a fixed PlotType.
Filters out rows which are identical in some or all columns.
Defines a numeric factor corresponding to an extent on an axis.
Trivial ColumnSupplement implementation which contains all the
columns of a base table unchanged.
Specifier for acquiring range for which both bounds fall between 0 and 1.
Calculates univariate statistics for a variable.
Aggregates statistics acquired from a column whose values are
fixed-length numeric arrays.
Convenience partial implementation of Drawing where no plan is used.
Table suitable for uploading based on a sequence of positional queries
and an RowMapper.
Defines a service that can perform sky position crossmatches by taking
a sequence of cone-like positions for input and submitting them as a
block to a remote execution matching service.
TapLint stage which attempts table uploads.
MOC coverage implementation which reads a MOC from a given URL.
Functions that construct URLs for external services.
Write usage paragraphs specific to the STILTS tasks.
Reader that can interrogate a RowData to return the coordinate and
mask values specified by a DataSpec.
Mode for upload crossmatches corresponding to the user options.
Defines a conversion from one data type to another.
StarTable implementation built on a MapGroup whose keys are
ValueInfo objects representing columns of the table.
Object which knows how to interpret the values associated with a
FIELD or PARAM object.
TablesInput which allows a variable number of input tables, fixed at
runtime using an integer parameter.
PlotVolume implementation which accumulates all points to plot and then
plots them by drawing, suitable for a vector-like context.
Attribute checker for the VOTABLE element's version attribute.
Contains VOTable version-specific validation logic.
Determines the version of a VOTable document.
Checks an attribute whose content is defined by the content of
an IVOA Vocabulary.
Checks values that are defined by the content of an IVOA Vocabulary.
Callback interface for reporting vocabulary interrogation results.
Task which Copies a VOTable XML document intact but with control over the
DATA encoding type.
SAX content handler which takes SAX events and converts them to
an output stream in a VOTable-sensitive way.
Task which performs VOTable checking.
Provides a label for a message passed to a VotLint context.
SAX ContentHandler used for linting VOTables.
Context for a VOTLint process.
Provides entity resolution for the VOTable linter.
Main class for performing a VOTable lint.
TapRunner implementation which uses the VotLint validation classes
to check the query's result VOTable.
Object that can map some particular sort of string to a URL
referencing a web page.
Defines a parser which can turn a string into some other value.
Parameter which can split its value up into an array of words,
each parsed as a parameterised type.
DataStoreFactory implementation which allows decoration of the tables
used to obtain the data, by providing a custom wrapper for their
RowSequence objects.
PlotData implementation based on an existing PlotData object.
PlotLayer implementation that delegates all its behaviour to a
base instance.
PointSequence implementation based on an existing PointSequence object.
ConeQueryRowSequence implementation which delegates all methods to
a supplied instance.
Tuple implementation that delegates all methods to a base instance.
DocletOutput implementation for writing SUN-friendly XML.
Parameter which describes one of the available XML encodings
(UTF-8 etc).
Validation stage for validating a document against a given XML schema.
Utility task for XML Schema validation.
Methods to perform validation against XSD schemas.
Enumerates possible results of the parse.
Defines a matched pair of vectors.
Defines how to map an XYArrayData object to a definite position
in data space.
Represents a pair of configuration keys that apply to the X and Y
axes of a plane plot.
Abstract superclass for shapes characterised by a pair of short integer
values.
Calculates X-Y correlation statistics.
Bitmapped 3D PaperType for opaque pixels only.
PlotVolume which uses a Z-buffer to keep track of which pixels are in
front.
Opaque workspace object for use with ZBufferPlotVolume instances.
Gives the layer content and surface construction details
for one zone of a Gang.