void clumpinfo( int *status ) {
/*
*+
* Name:
* CLUMPINFO
* Purpose:
* Obtain information about one or more previously identified clumps.
* Language:
* C
* Type of Module:
* ADAM A-task
* Description:
* This application returns various items of information about a
* single clump, or a collection of clumps, previously identified
* using FINDCLUMPS or EXTRACTCLUMPS.
* Usage:
* clumpinfo ndf clumps quiet
* ADAM Parameters:
* CLUMPS = LITERAL (Read)
* Specifies the indices of the clumps to be included in the
* returned information. It can take any of the following values:
*
* - "ALL" or "*" -- All clumps.
*
* - "xx,yy,zz" -- A list of clump indices.
*
* - "xx:yy" -- Clump indices between xx and yy inclusively. When
* xx is omitted the range begins from one; when yy is omitted the
* range ends with the final clump index.
*
* - Any reasonable combination of above values separated by
* commas.
* FLBND( ) = _DOUBLE (Write)
* The lower bounds of the bounding box enclosing the selected
* clumps in the current WCS Frame of the input NDF. Celestial axis
* values are always in units of radians, but spectral axis units
* will be in the spectral units used by the current WCS Frame.
* FUBND( ) = _DOUBLE (Write)
* The upper bounds of the bounding box enclosing the selected
* clumps. See parameter FLBND for more details.
* LBOUND( ) = _INTEGER (Write)
* The lower pixel bounds of bounding box enclosing the selected
* clumps.
* NCLUMPS = _INTEGER (Write)
* The total number of clumps descrriptions stored within the supplied
* NDF.
* NDF = NDF (Read)
* The NDF defining the previously identified clumps. This
* should contain a CUPID extension describing all the identified
* clumps, in the format produced by FINDCLUMPS or EXTRACTCLUMPS.
* QUIET = _LOGICAL (Read)
* If TRUE, then no information is written out to the screen,
* although the output parameters are still assigned values. [FALSE]
* UBOUND( ) = _INTEGER (Write)
* The upper pixel bounds of bounding box enclosing the selected
* clumps.
* Notes:
* - It is hoped to extend the range of information reported by this
* application as new requirements arise.
* Synopsis:
* void clumpinfo( int *status );
* Copyright:
* Copyright (C) 2007 Particle Physics & Astronomy Research Council.
* All Rights Reserved.
* Licence:
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street,Fifth Floor, Boston, MA
* 02110-1301, USA
* Authors:
* DSB: David S. Berry
* {enter_new_authors_here}
* History:
* 22-MAR-2007 (DSB):
* Original version.
* {enter_further_changes_here}
* Bugs:
* {note_any_bugs_here}
*-
*/
/* Local Variables: */
AstFrame *cfrm; /* Pointer to current WCS Frame */
AstMapping *cmap; /* Pointer to PIXEL->current Frame Mapping */
CupidClumpInfo info; /* Structure holding returned information */
Grp *grp = NULL; /* GRP group holding input NDF name */
HDSLoc *aloc = NULL; /* Locator for CLUMPS array in CUPID extension */
HDSLoc *cloc = NULL; /* Locator for a single CLUMP structure */
HDSLoc *xloc = NULL; /* Locator for CUPID extension */
char *p; /* Pointer into tmpstr string */
char tmpstr[ 100 ]; /* Buffer for temporary strings */
const char *dom; /* Pointer to axis Domain name */
double flbnd[ NDF__MXDIM ]; /* Lower bounds of WCS bounding box */
double fubnd[ NDF__MXDIM ]; /* Upper bounds of WCS bounding box */
double plbnd[ NDF__MXDIM ]; /* Lower bounds of PIXEL bounding box */
double pubnd[ NDF__MXDIM ]; /* Upper bounds of PIXEL bounding box */
int *clump_flags = NULL; /* Flags indicating if each clump is to be used */
int *clump_indices = NULL;/* List of indices of clumps to be used */
int i; /* Loop count */
int iclump; /* One-based clump index */
int indf; /* NDF identifier for input NDF */
int ipix; /* Index of PIXEL Frame */
size_t nclumps; /* No. of clump descriptions within the supplied NDF */
int nuse; /* Number of clumps to be used */
int primary; /* Value for locator primary flag */
int quiet; /* Supress screen output? */
size_t size; /* Number of values in group "*grp" */
int there; /* Does the enquired object exist? */
/* Abort if an error has already occurred. */
if( *status != SAI__OK ) return;
/* Begin an AST context */
astBegin;
/* Start an NDF context */
ndfBegin();
/* Obtain the input NDF and get a locator for the array of clump
descriptions within it.
----------------------------------------------------------------- */
/* Get an identifier for the input NDF. We use NDG (via kpg1_Rgndf)
instead of calling ndfAssoc directly since NDF/HDS has problems with
file names containing spaces, which NDG does not have. */
kpg1Rgndf( "NDF", 1, 1, "", &grp, &size, status );
ndgNdfas( grp, 1, "READ", &indf, status );
grpDelet( &grp, status );
/* Check the NDF has a suitable CUPID extension containing an array of
clump cut-outs. Get an HDS locator for the array. */
ndfXstat( indf, "CUPID", &there, status );
if( !there ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
ndfMsg( "NDF", indf );
errRep( "", "The NDF \"^NDF\" does not contain a CUPID extension "
"such as created by FINDCLUMPS or EXTRACTCLUMPS.", status );
}
} else {
ndfXloc( indf, "CUPID", "READ", &xloc, status );
datThere( xloc, "CLUMPS", &there, status );
if( !there ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
ndfMsg( "NDF", indf );
errRep( "", "The CUPID extension within NDF \"^NDF\" does not "
"contain an array of clumps such as created by "
"FINDCLUMPS or EXTRACTCLUMPS.", status );
}
} else {
datFind( xloc, "CLUMPS", &aloc, status );
primary = 1;
datPrmry( 1, &aloc, &primary, status );
}
datAnnul( &xloc, status );
}
/* Abort if we have no clumps array locator, or if an error occurred. */
if( !aloc || *status != SAI__OK ) goto L999;
/* Calculate the required clump information, and store it in the "info"
structure.
----------------------------------------------------------------- */
/* Indicate that the structure holding the returned information has not
yet been initialised. */
info.init = 0;
/* Get the WCS FrameSet from the input NDF, and store a pointer to it in
the "info" structure. */
kpg1Gtwcs( indf, &(info.iwcs), status );
/* Get the number of clumps defined within the input NDF. */
datSize( aloc, &nclumps, status );
/* Get the list of clump indices to iclude in the returned information. */
clump_flags = astMalloc( sizeof( int )*nclumps );
clump_indices = astMalloc( sizeof( int )*nclumps );
kpg1Gilst( 1, (int) nclumps, (int) nclumps, "CLUMPS", clump_flags, clump_indices,
&nuse, status );
/* Loop round all clumps that are to be used. */
for( i = 0; i < nuse && *status == SAI__OK; i++ ) {
iclump = clump_indices[ i ];
/* Get a locator for this clump. */
datCell( aloc, 1, &iclump, &cloc, status );
/* Update the returned information to include this clump. */
cupidClumpInfo1( cloc, &info, status );
/* Annul the clump structure locator. */
datAnnul( &cloc, status );
}
/* Write out the information to the screen and to appropriate output
parameters.
----------------------------------------------------------------- */
/* See if screen output is required. */
parGet0l( "QUIET", &quiet, status );
if( !quiet ) msgBlank( status );
/* The number of clumps defined within the input NDF... */
parPut0i( "NCLUMPS", (int) nclumps, status );
if( ! quiet ) {
msgSeti( "NCLUMPS", (int) nclumps );
msgOut( "", " Total no. of clumps: ^NCLUMPS", status );
}
/* Pixel index bounding box... */
parPut1i( "LBOUND", info.npix, info.lbnd, status );
parPut1i( "UBOUND", info.npix, info.ubnd, status );
if( !quiet ) {
p = tmpstr + sprintf( tmpstr, "( " );
for( i = 0; i < info.npix; i++) {
p += sprintf( p, "%d:%d", info.lbnd[ i ], info.ubnd[ i ] );
if( i < info.npix - 1 ) p += sprintf( p, ", " );
}
p += sprintf( p, " )" );
msgSetc( "SECTION", tmpstr );
msgOut( "", " Pixel index bounding box: ^SECTION", status );
}
/* WCS bounding box (first convert the pixel index bounding box into WCS
coords)... */
cfrm = astGetFrame( info.iwcs, AST__CURRENT );
kpg1Asffr( info.iwcs, "PIXEL", &ipix, status );
cmap = astGetMapping( info.iwcs, ipix, AST__CURRENT );
for( i = 0; i < info.npix; i++ ) {
plbnd[ i ] = info.lbnd[ i ] - 1.0;
pubnd[ i ] = info.ubnd[ i ];
}
for( i = 0; i < info.nwcs; i++ ) {
astMapBox( cmap, plbnd, pubnd, 1, i + 1, flbnd + i, fubnd + i,
NULL, NULL);
}
astNorm( cfrm, flbnd );
astNorm( cfrm, fubnd );
parPut1d( "FLBND", info.nwcs, flbnd, status );
parPut1d( "FUBND", info.nwcs, fubnd, status );
if( !quiet ) {
msgOut( "", " WCS bounding box:", status );
for( i = 0; i < info.nwcs; i++) {
msgSetc( "L", astFormat( cfrm, i + 1, flbnd[ i ] ) );
msgSetc( "U", astFormat( cfrm, i + 1, fubnd[ i ] ) );
sprintf( tmpstr, "Domain(%d)", i + 1 );
dom = astGetC( cfrm, tmpstr );
if( dom && strcmp( dom, "SKY" ) ) {
sprintf( tmpstr, "Unit(%d)", i + 1 );
msgSetc( "UNT", astGetC( cfrm, tmpstr ) );
} else {
msgSetc( "UNT", "" );
}
sprintf( tmpstr, "Label(%d)", i + 1 );
msgSetc( "LAB", astGetC( cfrm, tmpstr ) );
msgOut( "", " ^LAB: ^L -> ^U ^UNT", status );
}
}
if( !quiet ) msgBlank( status );
/* Tidy up.
-------- */
L999:
;
/* Free resources. */
clump_flags = astFree( clump_flags );
clump_indices = astFree( clump_indices );
if( aloc ) datAnnul( &aloc, status );
/* End the NDF context */
ndfEnd( status );
/* End the AST context */
astEnd;
/* If an error has occurred, issue another error report identifying the
program which has failed (i.e. this one). */
if( *status != SAI__OK ) {
errRep( "CLUMPINFO_ERR", "CLUMPINFO: Failed to obtain information "
"about one or more previously identified clumps.", status );
}
}
void
smf_store_outputbounds (int updatepars, const int lbnd_out[3],
const int ubnd_out[3],
const AstFrameSet * wcsout,
const AstSkyFrame *oskyfrm,
const AstMapping * oskymap, int *status) {
double corner[2]; /* WCS of a corner (SKY) */
int i; /* loop counter */
double glbnd_out[ 3 ]; /* double prec Lower GRID bounds for output map */
double gubnd_out[ 3 ]; /* double prec Upper GRID bounds for output map */
double gx_in[ 4 ]; /* X Grid coordinates of four corners */
double gx_out[ 4 ]; /* X WCS coordinates of four corners */
double gy_in[ 4 ]; /* Y Grid coordinates of four corners */
double gy_out[ 4 ]; /* Y WCS coordinates of four corners */
int ndims; /* Number of active dimensions */
char tmpstr[10]; /* temporary unit string */
double wcslbnd_out[3]; /* Array of lower bounds of output cube */
double wcsubnd_out[3]; /* Array of upper bounds of output cube */
/* Parameter names associated with the bounds */
const char * bounds[] = {
"FTR", "FTL", "FBR", "FBL", NULL
};
if (*status != SAI__OK) return;
/* work out how many dimensions we have */
ndims = astGetI( wcsout, "Naxes");
/* Calculate and output the WCS bounds (matching NDFTRACE output). The bounds
are normalised. Celestial coordinates will use radians. */
for( i = 0; i < ndims; i++ ) {
glbnd_out[ i ] = 0.5;
gubnd_out[ i ] = ubnd_out[ i ] - lbnd_out[i] + 1.5;
}
for( i = 0; i < ndims; i++ ) {
astMapBox( wcsout, glbnd_out, gubnd_out, 1, i+1, &(wcslbnd_out[ i ]),
&(wcsubnd_out[ i ]), NULL, NULL );
}
astNorm( wcsout, wcslbnd_out );
astNorm( wcsout, wcsubnd_out );
/* adjust resolution of output frameset since in some cases we are interested in
sub-arcsec resolution when comparing positions with different arguments
(especially with RxA and using very small pixel sizes. Use digits() rather
than format() so that we do not have to worry about hms vs dms */
astSet( (AstFrameSet*)wcsout, "digits(1)=9,digits(2)=9" );
if (ndims == 3) {
msgOutif( MSG__NORM, "WCS_WBND1",
" Output cube WCS bounds:", status );
} else {
msgOutif( MSG__NORM, "WCS_WBND1",
" Output map WCS bounds:", status );
}
for( i = 0; i < ndims && *status == SAI__OK; i++ ) {
msgSetc( "L", astFormat( wcsout, i+1, wcslbnd_out[i]));
msgSetc( "U", astFormat( wcsout, i+1, wcsubnd_out[i]));
if( i == 2 ) {
sprintf( tmpstr, "unit(%d)", i+1 );
msgSetc( "UNT", astGetC( wcsout, tmpstr ));
} else {
msgSetc( "UNT", "" );
}
sprintf( tmpstr, "label(%d)", i + 1 );
msgSetc( "LAB", astGetC( wcsout, tmpstr ) );
msgOutif( MSG__NORM, "WCS_WBND2",
" ^LAB: ^L -> ^U ^UNT", status );
}
/* Return if we are not required to update the parameters */
if (!updatepars) return;
parPut1d( "FLBND", ndims, wcslbnd_out, status );
parPut1d( "FUBND", ndims, wcsubnd_out, status );
/* if we have a 2d frameset we can use that directly rather
than having to split the mapping or provide explicit 2d
versions. Since we know that MAKECUBE already calculates
2d mappings/frames and we also know that MAKEMAP doesn't
we provide some logic here to switch on Naxes */
if (ndims == 2) {
if (oskyfrm == NULL) oskyfrm = (AstSkyFrame*)wcsout;
if (oskymap == NULL) oskymap = (AstMapping*)wcsout;
}
/* Now also calculate the spatial coordinates of the four corners (required
for CADC science archive. First, calculate input GRID coordinates for 4
corners: TR, TL, BR, BL. Use pixel centres for reporting. This is
important for cases where the pixels are very large and we want to make
sure that we are conservative with the database reporting. */
gx_in[ 0 ] = ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1.0; /* Right */
gx_in[ 1 ] = 1.0; /* Left */
gx_in[ 2 ] = gx_in[ 0 ]; /* Right */
gx_in[ 3 ] = gx_in[ 1 ]; /* Left */
gy_in[ 0 ] = ubnd_out[ 1 ] - lbnd_out[ 1 ] + 1.0; /* Top */
gy_in[ 1 ] = gy_in[ 0 ]; /* Top */
gy_in[ 2 ] = 1.0; /* Bottom */
gy_in[ 3 ] = gy_in[ 2 ]; /* Bottom */
astTran2( oskymap, 4, gx_in, gy_in, 1, gx_out, gy_out );
/* Store the bounds in the parameters */
for (i = 0; i < 4; i++) {
corner[ 0 ] = gx_out[ i ];
corner[ 1 ] = gy_out[ i ];
astNorm( oskyfrm, corner );
parPut1d( bounds[i], 2, corner, status );
}
}
void smf_get_projpar( AstSkyFrame *skyframe, const double skyref[2],
int moving, int autogrid, int nallpos,
const double * allpos, float telres, double map_pa,
double par[7], int * issparse,int *usedefs, int *status ) {
/* Local Variables */
char reflat[ 41 ]; /* Reference latitude string */
char reflon[ 41 ]; /* Reference longitude string */
char usesys[ 41 ]; /* Output skyframe system */
const char *deflat; /* Default for REFLAT */
const char *deflon; /* Default for REFLON */
const double fbpixsize = 6.0; /* Fallback pixel size if we have no other information */
double autorot; /* Autogrid default for CROTA parameter */
double defsize[ 2 ]; /* Default pixel sizes in arc-seconds */
double pixsize[ 2 ]; /* Pixel sizes in arc-seconds */
double refpix[ 2 ]; /* New REFPIX values */
double rdiam; /* Diameter of bounding circle, in rads */
int coin; /* Are all points effectively co-incident? */
int i;
int nval; /* Number of values supplied */
int refine_crpix; /* Should the pixel ref position be updated? */
int sparse = 0; /* Local definition of sparseness */
int udefs = 0; /* Flag for defaults used or not */
/* Check inherited status. */
if( *status != SAI__OK ) return;
/* If the number of supplied positions is 0 or null pointer,
disable autogrid */
if( nallpos == 0 || !allpos ) autogrid = 0;
/* Get the output system */
one_strlcpy( usesys, astGetC( skyframe, "SYSTEM"), sizeof(usesys),
status );
/* Ensure the reference position in the returned SkyFrame is set to the
first telescope base pointing position. */
astSetD( skyframe, "SkyRef(1)", skyref[ 0 ] );
astSetD( skyframe, "SkyRef(2)", skyref[ 1 ] );
/* If the target is moving, ensure the returned SkyFrame represents
offsets from the first telescope base pointing position rather than
absolute coords. */
if( moving ) smf_set_moving( (AstFrame *) skyframe, NULL, status );
/* Set a flag indicating if all the points are co-incident. */
coin = 0;
/* Set the sky axis values at the tangent point. If the target is moving,
the tangent point is at (0,0) (i.e. it is at the origin of the offset
coordinate system). If the target is not moving, the tangent point is
at the position held in "skyref". */
if( par ) {
if( moving ){
par[ 2 ] = 0.0;
par[ 3 ] = 0.0;
} else {
par[ 2 ] = skyref[ 0 ];
par[ 3 ] = skyref[ 1 ];
}
/* If required, calculate the optimal projection parameters. If the target
is moving, these refer to the offset coordinate system centred on the
first time slice base pointing position, with north defined by the
requested output coordinate system. The values found here are used as
dynamic defaults for the environment parameter */
if( autogrid ) {
kpg1Opgrd( nallpos, allpos, strcmp( usesys, "AZEL" ), par, &rdiam,
status );
/* See if all the points are effectively co-incident (i.e. within an Airy
disk). If so, we use default grid parameters that result in a grid of
1x1 spatial pixels. The grid pixel sizes (par[4] and par[5]) are made
larger than the area covered by the points in order to avoid points
spanning two pixels. */
if( rdiam < telres || nallpos < 3 ) {
if( rdiam < 0.1*AST__DD2R/3600.0 ) rdiam = 0.1*AST__DD2R/3600.0;
par[ 0 ] = 0.0;
par[ 1 ] = 0.0;
par[ 4 ] = -rdiam*4;
par[ 5 ] = -par[ 4 ];
par[ 6 ] = 0.0;
coin = 1;
/* If the sky positions are not co-incident, and the automatic grid
determination failed, we cannot use a grid, so warn the user. */
} else if( par[ 0 ] == AST__BAD ) {
msgOutif( MSG__NORM, " ", " Automatic grid determination "
"failed: the detector samples do not form a "
"regular grid.", status );
}
}
/* If autogrid values were not found, use the following fixed default
values. Do not override extenal defaults for pixel size. */
if( !autogrid || ( autogrid && par[ 0 ] == AST__BAD ) ) {
par[ 0 ] = 0.0;
par[ 1 ] = 0.0;
if (par[4] == AST__BAD || par[5] == AST__BAD ) {
par[ 4 ] = (fbpixsize/3600.0)*AST__DD2R;
par[ 5 ] = (fbpixsize/3600.0)*AST__DD2R;
}
par[ 6 ] = map_pa;
}
/* Ensure the default pixel sizes have the correct signs. */
if( par[ 4 ] != AST__BAD ) {
if( !strcmp( usesys, "AZEL" ) ) {
par[ 4 ] = fabs( par[ 4 ] );
} else {
par[ 4 ] = -fabs( par[ 4 ] );
}
par[ 5 ] = fabs( par[ 5 ] );
}
/* See if the output cube is to include a spatial projection, or a sparse
list of spectra. Disabled if the sparse pointer is NULL. */
if (issparse) {
parDef0l( "SPARSE", ( par[ 0 ] == AST__BAD ), status );
parGet0l( "SPARSE", &sparse, status );
}
/* If we are producing an output cube with the XY plane being a spatial
projection, then get the parameters describing the projection, using the
defaults calculated above. */
if( !sparse && *status == SAI__OK ) {
const int ndigits = 8; /* Number of digits for deflat/deflon precision */
/* If the target is moving, display the tracking centre coordinates for
the first time slice. */
if( moving ) {
astClear( skyframe, "SkyRefIs" );
msgBlank( status );
msgSetc( "S1", astGetC( skyframe, "Symbol(1)" ) );
msgSetc( "S2", astGetC( skyframe, "Symbol(2)" ) );
msgOutif( MSG__NORM, " ", " Output sky coordinates are "
"(^S1,^S2) offsets from the (moving)", status );
msgSetc( "S1", astGetC( skyframe, "Symbol(1)" ) );
msgSetc( "S2", astGetC( skyframe, "Symbol(2)" ) );
msgSetc( "SREF", astGetC( skyframe, "SkyRef" ) );
msgOutif( MSG__NORM, " ", " telescope base position, which "
"started at (^S1,^S2) = (^SREF).", status );
astSet( skyframe, "SkyRefIs=Origin" );
}
/* Set up a flag indicating that the default values calculated by autogrid
are being used. */
udefs = 1;
/* Ensure we have usable CRPIX1/2 values */
if( par[ 0 ] == AST__BAD ) par[ 0 ] = 1.0;
if( par[ 1 ] == AST__BAD ) par[ 1 ] = 1.0;
/* Get the crpix1/2 (in the interim GRID frame) to use. Note if the user
specifies any values. These parameters have vpath=default (which is null)
and ppath=dynamic. */
refine_crpix = 0;
parDef0d( "REFPIX1", par[ 0 ], status );
parDef0d( "REFPIX2", par[ 1 ], status );
if( *status == SAI__OK ) {
parGet0d( "REFPIX1", refpix + 0, status );
parGet0d( "REFPIX2", refpix + 1, status );
if( *status == PAR__NULL ) {
errAnnul( status );
refine_crpix = 1;
} else {
par[ 0 ] = refpix[ 0 ];
par[ 1 ] = refpix[ 1 ];
}
}
/* Get the sky coords reference position strings. Use the returned SkyFrame
to format and unformat them. */
if( par[ 2 ] != AST__BAD ) {
int curdigits;
curdigits = astGetI( skyframe, "digits(1)" );
astSetI( skyframe, "digits(1)", ndigits );
deflon = astFormat( skyframe, 1, par[ 2 ] );
astSetI( skyframe, "digits(1)", curdigits );
parDef0c( "REFLON", deflon, status );
} else {
deflon = NULL;
}
if( par[ 3 ] != AST__BAD ) {
int curdigits;
curdigits = astGetI( skyframe, "digits(2)" );
astSetI( skyframe, "digits(2)", ndigits );
deflat = astFormat( skyframe, 2, par[ 3 ] );
astSetI( skyframe, "digits(2)", curdigits );
parDef0c( "REFLAT", deflat, status );
} else {
deflat = NULL;
}
parGet0c( "REFLON", reflon, 40, status );
parGet0c( "REFLAT", reflat, 40, status );
if( *status == SAI__OK ) {
if( ( deflat && strcmp( deflat, reflat ) ) ||
( deflon && strcmp( deflon, reflon ) ) ) udefs = 0;
if( astUnformat( skyframe, 1, reflon, par + 2 ) == 0 && *status == SAI__OK ) {
msgSetc( "REFLON", reflon );
errRep( "", "Bad value supplied for REFLON: '^REFLON'", status );
}
if( astUnformat( skyframe, 2, reflat, par + 3 ) == 0 && *status == SAI__OK ) {
msgSetc( "REFLAT", reflat );
errRep( "", "Bad value supplied for REFLAT: '^REFLAT'", status );
}
/* Ensure the reference position in the returned SkyFrame is set to the
supplied position (which defaults to the first telescope base pointing
position). */
if( !moving ){
astSetD( skyframe, "SkyRef(1)", par[ 2 ] );
astSetD( skyframe, "SkyRef(2)", par[ 3 ] );
}
}
/* Get the user defined spatial pixel size in arcsec (the calibration for
the spectral axis is fixed by the first input data file - see
smf_cubebounds.c). First convert the autogrid values form rads to arcsec
and establish them as the dynamic default for "PIXSIZE". */
nval = 0;
if( par[ 4 ] != AST__BAD || par[ 5 ] != AST__BAD ) {
for ( i = 4; i <= 5; i++ ) {
if ( par[ i ] != AST__BAD ) {
defsize[ nval ] = 0.1*NINT( fabs( par[ i ] )*AST__DR2D*36000.0 );
nval++;
}
}
/* set the dynamic default, handling case where both dimensions
have same default. */
if (nval == 1) {
defsize[1] = defsize[0];
} else if (nval == 2 && defsize[0] == defsize[1]) {
nval = 1;
}
parDef1d( "PIXSIZE", nval, defsize, status );
} else {
/* pick a default in case something odd happens and we have
no other values*/
defsize[ 0 ] = fbpixsize;
defsize[ 1 ] = defsize[ 0 ];
nval = 2;
}
if (*status == SAI__OK) {
pixsize[0] = AST__BAD;
pixsize[1] = AST__BAD;
parGet1d( "PIXSIZE", 2, pixsize, &nval, status );
if (*status == PAR__NULL) {
/* Null just defaults to what we had before */
errAnnul( status );
pixsize[0] = defsize[0];
pixsize[1] = defsize[1];
nval = 2;
}
}
/* If OK, duplicate the first value if only one value was supplied. */
if( *status == SAI__OK ) {
if( nval < 2 ) pixsize[ 1 ] = pixsize[ 0 ];
if( defsize[ 0 ] != pixsize[ 0 ] ||
defsize[ 1 ] != pixsize[ 1 ] ) udefs = 0;
/* Check the values are OK. */
if( pixsize[ 0 ] <= 0 || pixsize[ 1 ] <= 0 ) {
msgSetd( "P1", pixsize[ 0 ] );
msgSetd( "P2", pixsize[ 1 ] );
*status = SAI__ERROR;
errRep( FUNC_NAME, "Invalid pixel sizes (^P1,^P2).", status);
}
/* Convert to rads, and set the correct signs. */
if( par[ 4 ] == AST__BAD || par[ 4 ] < 0.0 ) {
par[ 4 ] = -pixsize[ 0 ]*AST__DD2R/3600.0;
} else {
par[ 4 ] = pixsize[ 0 ]*AST__DD2R/3600.0;
}
if( par[ 5 ] == AST__BAD || par[ 5 ] < 0.0 ) {
par[ 5 ] = -pixsize[ 1 ]*AST__DD2R/3600.0;
} else {
par[ 5 ] = pixsize[ 1 ]*AST__DD2R/3600.0;
}
}
/* Convert the autogrid CROTA value from rads to degs and set as the
dynamic default for parameter CROTA (the position angle of the output
Y axis, in degrees). The get the CROTA value and convert to rads. */
if( par[ 6 ] != AST__BAD ) {
autorot = par[ 6 ]*AST__DR2D;
parDef0d( "CROTA", autorot, status );
} else {
parDef0d( "CROTA", map_pa*AST__DR2D, status );
autorot = AST__BAD;
}
parGet0d( "CROTA", par + 6, status );
if( par[ 6 ] != autorot ) udefs = 0;
par[ 6 ] *= AST__DD2R;
/* If any parameter were given explicit values which differ from the
autogrid default values, then we need to re-calculate the optimal CRPIX1/2
values. We also do this if all the points are effectively co-incident. */
if( ( coin || !udefs ) && autogrid && refine_crpix ) {
par[ 0 ] = AST__BAD;
par[ 1 ] = AST__BAD;
kpg1Opgrd( nallpos, allpos, strcmp( usesys, "AZEL" ), par,
&rdiam, status );
}
/* Display the projection parameters being used. */
smf_display_projpars( skyframe, par, status );
/* Write out the reference grid coords to output parameter PIXREF. */
parPut1d( "PIXREF", 2, par, status );
/* If no grid was found, indicate that no spatial projection will be used. */
} else {
msgBlank( status );
msgOutif( MSG__NORM, " ", " The output will be a sparse array "
"containing a list of spectra.", status );
}
/* If we have a pre-defined spatial projection, indicate that the output
array need not be sparse. */
} else {
sparse = 0;
}
/* Return usedefs if requested */
if( usedefs ) {
*usedefs = udefs;
}
/* Set sparse if requested */
if( issparse ) *issparse = sparse;
}
