NDIM_IN = INTEGER (Given)
The number of dimensions in the input grid. This will be at
LBND_IN( NDIM_IN ) = INTEGER (Given)
containing the coordinates of the centre of the first pixel
in the input grid along each dimension.
UBND_IN( NDIM_IN ) = INTEGER (Given)
containing the coordinates of the centre of the last pixel in
the input grid along each dimension.
Note that LBND_IN and UBND_IN together define the shape,
size and coordinate system of the input grid in the same
way as they do in AST_RESAMPLEX.
IN( ) = Xtype (Given)
An array, with one element for each pixel in the
input grid, containing the input data. This will be the same
array as was passed to AST_RESAMPLEX via the IN argument.
The numerical type of this array should match that of the
data being processed.
IN_VAR( ) = Xtype (Given)
An optional second array with the same size and type as the
IN array. This will only be given if the AST__USEVAR flag is
set via the FLAGS argument (below). If given, it will contain
the set of variance values associated with the input data and
will be the same array as was passed to AST_RESAMPLEX via
the IN_VAR argument.
If the AST__USEVAR flag is not set, then no variance values
are being processed. In this case, this array of variance
values may be a dummy (e.g. one-element) array and should not
NPOINT = INTEGER (Given)
The number of points at which the input grid is to be
interpolated. This will be at least one.
OFFSET( NPOINT ) = INTEGER (Given)
For each interpolation point, this array will contain the
offset from the start of the OUT (and OUT_VAR) array(s) at
which the interpolated value (and its variance, if required)
should be stored. For example, the interpolated value for
point number POINT should be stored in OUT(1OFFSET(POINT)).
COORDS( NPOINT, NDIM_IN ) = DOUBLE PRECISION (Given)
A 2-dimensional array containing the coordinates of the
points at which interpolation should be performed. These will
be stored so that coordinate number COORD for interpolation
point number POINT is found in element COORDS(POINT,COORD).
If any interpolation point has any of its coordinates equal
to the value AST__BAD (as defined in the AST_PAR include
file), then the corresponding output data (and variance)
should either be set to the value given by BADVAL,
or left unchanged, depending on whether the AST__NOBAD flag is
specified by FLAGS.
PARAMS( ) = DOUBLE PRECISION (Given)
This will be the same array as was given via the
PARAMS argument of AST_RESAMPLEX. You may use this to
pass any additional parameter values required by your
FLAGS = INTEGER (Given)
This will be the same value as was given via the FLAGS
argument of AST_RESAMPLEX. You may test this value to
provide additional control over the operation of your
resampling algorithm. Note that the special flag values
AST__URESAMP1, 2, 3 & 4 are reserved for you to use for your
own purposes and will not clash with other pre-defined flag
values (see AST_RESAMPLEX).
BADVAL = Xtype (Given)
This will be the same value as was given for the BADVAL
argument of AST_RESAMPLEX, and will have the same numerical
type as the data being processed (i.e. as elements of the IN
array). It should be used to test for bad pixels in the
input grid (but only if the AST__USEBAD flag is set via the
FLAGS argument) and (unless the AST__NOBAD flag is set in
FLAGS) for identifying bad output values in the OUT (and
OUT( ) = Xtype (Returned)
An array with the same numerical type as the IN
array, into which the interpolated data values should be
returned. Note that details of the storage order and number
of dimensions of this array are not required, since the
OFFSET array contains all necessary information about where
each returned value should be stored.
In general, not all elements of this array (or the OUT_VAR
array below) may be used in any particular invocation of the
routine. Those which are not used should be returned
OUT_VAR( ) = Xtype (Returned)
An optional array with the same type and size as the OUT
array, into which variance estimates for the resampled values
should be returned. This array will only be given if the
AST__USEVAR flag is set via the FLAGS argument.
If given, it is addressed in exactly the same way (via the
OFFSET array) as the OUT array. The values returned should be
estimates of the statistical variance of the corresponding
values in the OUT array, on the assumption that all errors in
input data values are statistically independent and that
their variance estimates may simply be summed (with
appropriate weighting factors).
If the AST__USEVAR flag is not set, then variance values are
not being processed. In this case, this array may be a dummy
(e.g. one-element) array and should not be used.
NBAD = INTEGER (Returned)
This should return the number of interpolation points at
which no valid interpolated value could be obtained. The maximum
value that should be returned is NPOINT, and the minimum is
zero (indicating that all output values were successfully
STATUS = INTEGER (Given and Returned)
The global status.