void smf_mapbounds( int fast, Grp *igrp, int size, const char *system,
AstFrameSet *spacerefwcs, int alignsys, int *lbnd_out,
int *ubnd_out, AstFrameSet **outframeset, int *moving,
smfBox ** boxes, fts2Port fts_port, int *status ) {
/* Local Variables */
AstSkyFrame *abskyframe = NULL; /* Output Absolute SkyFrame */
int actval; /* Number of parameter values supplied */
AstMapping *bolo2map = NULL; /* Combined mapping bolo->map
coordinates, WCS->GRID Mapping from
input WCS FrameSet */
smfBox *box = NULL; /* smfBox for current file */
smfData *data = NULL; /* pointer to SCUBA2 data struct */
double dlbnd[ 2 ]; /* Floating point lower bounds for output map */
drcntrl_bits drcntrl_mask = 0;/* Mask to use for DRCONTROL on this instrument */
double dubnd[ 2 ]; /* Floating point upper bounds for output map */
AstMapping *fast_map = NULL; /* Mapping from tracking to absolute map coords */
smfFile *file = NULL; /* SCUBA2 data file information */
int first; /* Is this the first good subscan ? */
AstFitsChan *fitschan = NULL;/* Fits channels to construct WCS header */
AstFrameSet *fs = NULL; /* A general purpose FrameSet pointer */
smfHead *hdr = NULL; /* Pointer to data header this time slice */
int i; /* Loop counter */
dim_t j; /* Loop counter */
AstSkyFrame *junksky = NULL; /* Unused SkyFrame argument */
dim_t k; /* Loop counter */
int lbnd0[ 2 ]; /* Defaults for LBND parameter */
double map_pa=0; /* Map PA in output coord system (rads) */
dim_t maxloop; /* Number of times to go round the time slice loop */
dim_t nbadt = 0; /* Number of bad time slices */
dim_t ngoodt = 0; /* Number of good time slices */
double par[7]; /* Projection parameters */
double shift[ 2 ]; /* Shifts from PIXEL to GRID coords */
AstMapping *oskymap = NULL; /* Mapping celestial->map coordinates,
Sky <> PIXEL mapping in output
FrameSet */
AstSkyFrame *oskyframe = NULL;/* Output SkyFrame */
char *refsys = NULL; /* Sky system from supplied reference FrameSet */
dim_t textreme[4]; /* Time index corresponding to minmax TCS posn */
AstFrame *skyin = NULL; /* Sky Frame in input FrameSet */
double skyref[ 2 ]; /* Values for output SkyFrame SkyRef attribute */
struct timeval tv1; /* Timer */
struct timeval tv2; /* Timer */
AstMapping *tmap; /* Temporary Mapping */
int trim; /* Trim borders of bad pixels from o/p image? */
int ubnd0[ 2 ]; /* Defaults for UBND parameter */
double x_array_corners[4]; /* X-Indices for corner bolos in array */
double x_map[4]; /* Projected X-coordinates of corner bolos */
double y_array_corners[4]; /* Y-Indices for corner pixels in array */
double y_map[4]; /* Projected X-coordinates of corner bolos */
/* Main routine */
if (*status != SAI__OK) return;
/* Start a timer to see how long this takes */
smf_timerinit( &tv1, &tv2, status );
/* Initialize pointer to output FrameSet and moving-source flag */
*outframeset = NULL;
*moving = 0;
/* initialize double precision output bounds and the proj pars */
for( i = 0; i < 7; i++ ) par[ i ] = AST__BAD;
dlbnd[ 0 ] = VAL__MAXD;
dlbnd[ 1 ] = VAL__MAXD;
dubnd[ 0 ] = VAL__MIND;
dubnd[ 1 ] = VAL__MIND;
/* If we have a supplied reference WCS we can use that directly
without having to calculate it from the data. Replace the requested
system with the system from the reference FrameSet (take a copy of the
string since astGetC may re-use its buffer). */
if (spacerefwcs) {
oskyframe = astGetFrame( spacerefwcs, AST__CURRENT );
int nc = 0;
refsys = astAppendString( NULL, &nc, astGetC( oskyframe, "System" ) );
system = refsys;
}
/* Create array of returned smfBox structures and store a pointer
to the next one to be initialised. */
*boxes = astMalloc( sizeof( smfBox ) * size );
box = *boxes;
astBegin;
/* Loop over all files in the Grp */
first = 1;
for( i=1; i<=size; i++, box++ ) {
/* Initialise the spatial bounds of section of the the output cube that is
contributed to by the current ionput file. */
box->lbnd[ 0 ] = VAL__MAXD;
box->lbnd[ 1 ] = VAL__MAXD;
box->ubnd[ 0 ] = VAL__MIND;
box->ubnd[ 1 ] = VAL__MIND;
/* Read data from the ith input file in the group */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data, status );
if (*status != SAI__OK) {
msgSeti( "I", i );
errRep( "smf_mapbounds", "Could not open data file no ^I.", status );
break;
} else {
if( *status == SAI__OK ) {
if( data->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( data->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
} else if( data->hdr->fitshdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No FITS header associated with smfHead.",
status );
break;
}
}
}
/* convenience pointers */
file = data->file;
hdr = data->hdr;
/* report name of the input file */
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti("I", i);
msgSeti("N", size);
msgOutif(MSG__VERB, " ",
"SMF_MAPBOUNDS: Processing ^I/^N ^FILE",
status);
/* Check that there are 3 pixel axes. */
if( data->ndims != 3 ) {
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti( "NDIMS", data->ndims );
*status = SAI__ERROR;
errRep( FUNC_NAME, "^FILE has ^NDIMS pixel axes, should be 3.",
status );
break;
}
/* Check that the data dimensions are 3 (for time ordered data) */
if( *status == SAI__OK ) {
/* If OK Decide which detectors (GRID coord) to use for
checking bounds, depending on the instrument in use. */
switch( hdr->instrument ) {
case INST__SCUBA2:
drcntrl_mask = DRCNTRL__POSITION;
/* 4 corner bolometers of the subarray */
x_array_corners[0] = 1;
x_array_corners[1] = 1;
x_array_corners[2] = (data->dims)[0];
x_array_corners[3] = (data->dims)[0];
y_array_corners[0] = 1;
y_array_corners[1] = (data->dims)[1];
y_array_corners[2] = 1;
y_array_corners[3] = (data->dims)[1];
break;
case INST__AZTEC:
/* Rough guess for extreme bolometers around the edge */
x_array_corners[0] = 22;
x_array_corners[1] = 65;
x_array_corners[2] = 73;
x_array_corners[3] = 98;
y_array_corners[0] = 1; /* Always 1 for AzTEC */
y_array_corners[1] = 1;
y_array_corners[2] = 1;
y_array_corners[3] = 1;
break;
case INST__ACSIS:
smf_find_acsis_corners( data, x_array_corners, y_array_corners,
status);
break;
default:
*status = SAI__ERROR;
errRep(FUNC_NAME, "Don't know how to calculate mapbounds for data created with this instrument", status);
}
}
if( *status == SAI__OK) {
size_t goodidx = SMF__BADSZT;
/* Need to build up a frameset based on good telescope position.
We can not assume that we the first step will be a good TCS position
so we look for one. If we can not find anything we skip to the
next file. */
maxloop = (data->dims)[2];
for (j=0; j<maxloop; j++) {
JCMTState state = (hdr->allState)[j];
if (state.jos_drcontrol >= 0 && state.jos_drcontrol & drcntrl_mask ) {
/* bad TCS - so try again */
} else {
/* Good tcs */
goodidx = j;
break;
}
}
if (goodidx == SMF__BADSZT) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>");
msgOutif( MSG__QUIET, "", "No good telescope positions found in file ^FILE. Ignoring",
status );
smf_close_file( NULL, &data, status );
continue;
}
/* If we are dealing with the first good file, create the output
SkyFrame. */
if( first ) {
first = 0;
/* Create output SkyFrame if it has not come from a reference */
if ( oskyframe == NULL ) {
/* smf_tslice_ast only needs to get called once to set up framesets */
if( hdr->wcs == NULL ) {
smf_tslice_ast( data, goodidx, 1, fts_port, status);
}
/* Retrieve input SkyFrame */
skyin = astGetFrame( hdr->wcs, AST__CURRENT );
smf_calc_skyframe( skyin, system, hdr, alignsys, &oskyframe, skyref,
moving, status );
/* Get the orientation of the map vertical within the output celestial
coordinate system. This is derived form the MAP_PA FITS header, which
gives the orientation of the map vertical within the tracking system. */
map_pa = smf_calc_mappa( hdr, system, skyin, status );
/* Provide a sensible default for the pixel size based on wavelength */
par[4] = smf_calc_telres( hdr->fitshdr, status );
par[4] *= AST__DD2R/3600.0;
par[5] = par[4];
/* Calculate the projection parameters. We do not enable autogrid determination
for SCUBA-2 so we do not need to obtain all the data before calculating
projection parameters. */
smf_get_projpar( oskyframe, skyref, *moving, 0, 0, NULL, 0,
map_pa, par, NULL, NULL, status );
if (skyin) skyin = astAnnul( skyin );
/* If the output skyframe has been supplied, we still need to
determine whether the source is moving or not, and set the
reference position. */
} else {
/* smf_tslice_ast only needs to get called once to set up framesets */
if( hdr->wcs == NULL ) {
smf_tslice_ast( data, goodidx, 1, fts_port, status);
}
/* Retrieve input SkyFrame */
skyin = astGetFrame( hdr->wcs, AST__CURRENT );
smf_calc_skyframe( skyin, system, hdr, alignsys, &junksky, skyref,
moving, status );
/* Store the sky reference position. If the target is moving,
ensure the returned SkyFrame represents offsets from the
reference position rather than absolute coords. */
astSetD( oskyframe, "SkyRef(1)", skyref[ 0 ] );
astSetD( oskyframe, "SkyRef(2)", skyref[ 1 ] );
if( *moving ) astSet( oskyframe, "SkyRefIs=Origin" );
/* Ensure the Epoch attribute in the map is set to the date of
the first data in the map, rather than the date in supplied
reference WCS. */
astSetD( oskyframe, "Epoch", astGetD( junksky, "Epoch" ) );
}
if ( *outframeset == NULL && oskyframe != NULL && (*status == SAI__OK)){
/* Now created a spatial Mapping. Use the supplied reference frameset
if supplied */
if (spacerefwcs) {
oskymap = astGetMapping( spacerefwcs, AST__BASE, AST__CURRENT );
} else {
/* Now populate a FitsChan with FITS-WCS headers describing
the required tan plane projection. The longitude and
latitude axis types are set to either (RA,Dec) or (AZ,EL)
to get the correct handedness. */
fitschan = astFitsChan ( NULL, NULL, " " );
smf_makefitschan( astGetC( oskyframe, "System"), &(par[0]),
&(par[2]), &(par[4]), par[6], fitschan, status );
astClear( fitschan, "Card" );
fs = astRead( fitschan );
/* Extract the output PIXEL->SKY Mapping. */
oskymap = astGetMapping( fs, AST__BASE, AST__CURRENT );
/* Tidy up */
fs = astAnnul( fs );
}
/* Create the output FrameSet */
*outframeset = astFrameSet( astFrame(2, "Domain=GRID"), " " );
/* Now add the SkyFrame to it */
astAddFrame( *outframeset, AST__BASE, oskymap, oskyframe );
/* Now add a POLANAL Frame if required (i.e. if the input time
series are POL-2 Q/U values). */
smf_addpolanal( *outframeset, hdr, status );
/* Invert the oskymap mapping */
astInvert( oskymap );
} /* End WCS FrameSet construction */
}
/* Get a copy of the output SkyFrame and ensure it represents
absolute coords rather than offset coords. */
abskyframe = astCopy( oskyframe );
astClear( abskyframe, "SkyRefIs" );
astClear( abskyframe, "AlignOffset" );
maxloop = (data->dims)[2];
if (fast) {
/* For scan map we scan through looking for largest telescope moves.
For dream/stare we just look at the start and end time slices to
account for sky rotation. */
if (hdr->obsmode != SMF__OBS_SCAN) {
textreme[0] = 0;
textreme[1] = (data->dims)[2] - 1;
maxloop = 2;
} else {
const char *tracksys;
double *ac1list, *ac2list, *bc1list, *bc2list, *p1, *p2, *p3, *p4;
double flbnd[4], fubnd[4];
JCMTState state;
/* If the output and tracking systems are different, get a
Mapping between them. */
tracksys = sc2ast_convert_system( (hdr->allState)[goodidx].tcs_tr_sys,
status );
if( strcmp( system, tracksys ) ) {
AstSkyFrame *tempsf = astCopy( abskyframe );
astSetC( tempsf, "System", tracksys );
AstFrameSet *tempfs = astConvert( tempsf, abskyframe, "" );
tmap = astGetMapping( tempfs, AST__BASE, AST__CURRENT );
fast_map = astSimplify( tmap );
tmap = astAnnul( tmap );
tempsf = astAnnul( tempsf );
tempfs = astAnnul( tempfs );
} else {
fast_map = NULL;
}
/* Copy all ac1/2 positions into two array, and transform them
from tracking to absolute output sky coords. */
ac1list = astMalloc( maxloop*sizeof( *ac1list ) );
ac2list = astMalloc( maxloop*sizeof( *ac2list ) );
if( *status == SAI__OK ) {
p1 = ac1list;
p2 = ac2list;
for( j = 0; j < maxloop; j++ ) {
state = (hdr->allState)[ j ];
*(p1++) = state.tcs_tr_ac1;
*(p2++) = state.tcs_tr_ac2;
}
if( fast_map ) astTran2( fast_map, maxloop, ac1list, ac2list, 1,
ac1list, ac2list );
}
/* If the target is moving, we need to adjust these ac1/2 values
to represent offsets from the base position. */
if( *moving ) {
/* Copy all bc1/2 positions into two arrays. */
bc1list = astMalloc( maxloop*sizeof( *bc1list ) );
bc2list = astMalloc( maxloop*sizeof( *bc2list ) );
if( *status == SAI__OK ) {
p1 = bc1list;
p2 = bc2list;
for( j = 0; j < maxloop; j++ ) {
state = (hdr->allState)[ j ];
*(p1++) = state.tcs_tr_bc1;
*(p2++) = state.tcs_tr_bc2;
}
/* Transform them from tracking to absolute output sky coords. */
if( fast_map ) astTran2( fast_map, maxloop, bc1list, bc2list,
1, bc1list, bc2list );
/* Replace each ac1/2 position with the offsets from the
corresponding base position. */
p1 = bc1list;
p2 = bc2list;
p3 = ac1list;
p4 = ac2list;
for( j = 0; j < maxloop; j++ ) {
smf_offsets( *(p1++), *(p2++), p3++, p4++, status );
}
}
/* We no longer need the base positions. */
bc1list = astFree( bc1list );
bc2list = astFree( bc2list );
}
/* Transform the ac1/2 position from output sky coords to
output pixel coords. */
astTran2( oskymap, maxloop, ac1list, ac2list, 1, ac1list, ac2list );
/* Find the bounding box containing these pixel coords and the
time slices at which the boresight touches each edge of this
box. */
flbnd[ 0 ] = VAL__MAXD;
flbnd[ 1 ] = VAL__MAXD;
fubnd[ 0 ] = VAL__MIND;
fubnd[ 1 ] = VAL__MIND;
for( j = 0; j < 4; j++ ) textreme[ j ] = (dim_t) VAL__BADI;
if( *status == SAI__OK ) {
p1 = ac1list;
p2 = ac2list;
for( j = 0; j < maxloop; j++,p1++,p2++ ) {
if( *p1 != VAL__BADD && *p2 != VAL__BADD ){
if ( *p1 < flbnd[0] ) { flbnd[0] = *p1; textreme[0] = j; }
if ( *p2 < flbnd[1] ) { flbnd[1] = *p2; textreme[1] = j; }
if ( *p1 > fubnd[0] ) { fubnd[0] = *p1; textreme[2] = j; }
if ( *p2 > fubnd[1] ) { fubnd[1] = *p2; textreme[3] = j; }
}
}
}
maxloop = 4;
msgSetd("X1", textreme[0]);
msgSetd("X2", textreme[1]);
msgSetd("X3", textreme[2]);
msgSetd("X4", textreme[3]);
msgOutif( MSG__DEBUG, " ",
"Extrema time slices are ^X1, ^X2, ^X3 and ^X4",
status);
ac1list = astFree( ac1list );
ac2list = astFree( ac2list );
}
}
/* Get the astrometry for all the relevant time slices in this data file */
for( j=0; j<maxloop; j++ ) {
dim_t ts; /* Actual time slice to use */
/* if we are doing the fast loop, we need to read the time slice
index from textreme. Else we just use the index */
if (fast) {
/* get the index but make sure it is good */
ts = textreme[j];
if (ts == (dim_t)VAL__BADI) continue;
} else {
ts = j;
}
/* Calculate the bolo to map-pixel transformation for this tslice */
bolo2map = smf_rebin_totmap( data, ts, abskyframe, oskymap,
*moving, fts_port, status );
if ( *status == SAI__OK ) {
/* skip if we did not get a mapping this time round */
if (!bolo2map) continue;
/* Check corner pixels in the array for their projected extent
on the sky to set the pixel bounds */
astTran2( bolo2map, 4, x_array_corners, y_array_corners, 1,
x_map, y_map );
/* Update min/max for this time slice */
for( k=0; k<4; k++ ) {
if( x_map[k] != AST__BAD && y_map[k] != AST__BAD ) {
if( x_map[k] < dlbnd[0] ) dlbnd[0] = x_map[k];
if( y_map[k] < dlbnd[1] ) dlbnd[1] = y_map[k];
if( x_map[k] > dubnd[0] ) dubnd[0] = x_map[k];
if( y_map[k] > dubnd[1] ) dubnd[1] = y_map[k];
if( x_map[k] < box->lbnd[0] ) box->lbnd[0] = x_map[k];
if( y_map[k] < box->lbnd[1] ) box->lbnd[1] = y_map[k];
if( x_map[k] > box->ubnd[0] ) box->ubnd[0] = x_map[k];
if( y_map[k] > box->ubnd[1] ) box->ubnd[1] = y_map[k];
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Extreme positions are bad.", status );
break;
}
}
}
/* Explicitly annul these mappings each time slice for reduced
memory usage */
if (bolo2map) bolo2map = astAnnul( bolo2map );
if (fs) fs = astAnnul( fs );
/* Break out of loop over time slices if bad status */
if (*status != SAI__OK) goto CLEANUP;
}
/* Annul any remaining Ast objects before moving on to the next file */
if (fs) fs = astAnnul( fs );
if (bolo2map) bolo2map = astAnnul( bolo2map );
}
/* Close the data file */
smf_close_file( NULL, &data, status);
/* Break out of loop over data files if bad status */
if (*status != SAI__OK) goto CLEANUP;
}
/* make sure we got values - should not be possible with good status */
if (dlbnd[0] == VAL__MAXD || dlbnd[1] == VAL__MAXD) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRep( " ", "Unable to find any valid map bounds", status );
}
}
if (nbadt > 0) {
msgOutf( "", " Processed %zu time slices to calculate bounds,"
" of which %zu had bad telescope data and were skipped",
status, (size_t)(ngoodt+nbadt), (size_t)nbadt );
}
/* If spatial reference wcs was supplied, store par values that result in
no change to the pixel origin. */
if( spacerefwcs ){
par[ 0 ] = 0.5;
par[ 1 ] = 0.5;
}
/* Need to re-align with the interim GRID coordinates */
lbnd_out[0] = ceil( dlbnd[0] - par[0] + 0.5 );
ubnd_out[0] = ceil( dubnd[0] - par[0] + 0.5 );
lbnd_out[1] = ceil( dlbnd[1] - par[1] + 0.5 );
ubnd_out[1] = ceil( dubnd[1] - par[1] + 0.5 );
/* Do the same with the individual input file bounding boxes */
box = *boxes;
for (i = 1; i <= size; i++, box++) {
box->lbnd[0] = ceil( box->lbnd[0] - par[0] + 0.5);
box->ubnd[0] = ceil( box->ubnd[0] - par[0] + 0.5);
box->lbnd[1] = ceil( box->lbnd[1] - par[1] + 0.5);
box->ubnd[1] = ceil( box->ubnd[1] - par[1] + 0.5);
}
/* Apply a ShiftMap to the output FrameSet to re-align the GRID
coordinates */
shift[0] = 2.0 - par[0] - lbnd_out[0];
shift[1] = 2.0 - par[1] - lbnd_out[1];
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
/* Set the dynamic defaults for lbnd/ubnd */
lbnd0[ 0 ] = lbnd_out[ 0 ];
lbnd0[ 1 ] = lbnd_out[ 1 ];
parDef1i( "LBND", 2, lbnd0, status );
ubnd0[ 0 ] = ubnd_out[ 0 ];
ubnd0[ 1 ] = ubnd_out[ 1 ];
parDef1i( "UBND", 2, ubnd0, status );
parGet1i( "LBND", 2, lbnd_out, &actval, status );
if( actval == 1 ) lbnd_out[ 1 ] = lbnd_out[ 0 ];
parGet1i( "UBND", 2, ubnd_out, &actval, status );
if( actval == 1 ) ubnd_out[ 1 ] = ubnd_out[ 0 ];
/* Ensure the bounds are the right way round. */
if( lbnd_out[ 0 ] > ubnd_out[ 0 ] ) {
int itmp = lbnd_out[ 0 ];
lbnd_out[ 0 ] = ubnd_out[ 0 ];
ubnd_out[ 0 ] = itmp;
}
if( lbnd_out[ 1 ] > ubnd_out[ 1 ] ) {
int itmp = lbnd_out[ 1 ];
lbnd_out[ 1 ] = ubnd_out[ 1 ];
ubnd_out[ 1 ] = itmp;
}
/* If borders of bad pixels are being trimmed from the output image,
then do not allow the user-specified bounds to extend outside the
default bounding box (since we know that the default bounding box
encloses all available data). */
parGet0l( "TRIM", &trim, status );
if( trim ) {
if( lbnd_out[ 0 ] < lbnd0[ 0 ] ) lbnd_out[ 0 ] = lbnd0[ 0 ];
if( lbnd_out[ 1 ] < lbnd0[ 1 ] ) lbnd_out[ 1 ] = lbnd0[ 1 ];
if( ubnd_out[ 0 ] > ubnd0[ 0 ] ) ubnd_out[ 0 ] = ubnd0[ 0 ];
if( ubnd_out[ 1 ] > ubnd0[ 1 ] ) ubnd_out[ 1 ] = ubnd0[ 1 ];
}
/* Modify the returned FrameSet to take account of the new pixel origin. */
shift[ 0 ] = lbnd0[ 0 ] - lbnd_out[ 0 ];
shift[ 1 ] = lbnd0[ 1 ] - lbnd_out[ 1 ];
if( shift[ 0 ] != 0.0 || shift[ 1 ] != 0.0 ) {
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
}
/* Report the pixel bounds of the cube. */
if( *status == SAI__OK ) {
msgOutif( MSG__NORM, " ", " ", status );
msgSeti( "XL", lbnd_out[ 0 ] );
msgSeti( "YL", lbnd_out[ 1 ] );
msgSeti( "XU", ubnd_out[ 0 ] );
msgSeti( "YU", ubnd_out[ 1 ] );
msgOutif( MSG__NORM, " ", " Output map pixel bounds: ( ^XL:^XU, ^YL:^YU )",
status );
if( ( ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1 ) > MAX_DIM ||
( ubnd_out[ 1 ] - lbnd_out[ 1 ] + 1 ) > MAX_DIM ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": The map is too big. Check your list of input "
"data files does not include widely separated observations.",
status );
}
}
/* If no error has occurred, export the returned FrameSet pointer from the
current AST context so that it will not be annulled when the AST
context is ended. Otherwise, ensure a null pointer is returned. */
if( *status == SAI__OK ) {
astExport( *outframeset );
} else {
*outframeset = astAnnul( *outframeset );
}
msgOutiff( SMF__TIMER_MSG, "",
"Took %.3f s to calculate map bounds",
status, smf_timerupdate( &tv1, &tv2, status ) );
/* Clean Up */
CLEANUP:
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Unable to determine map bounds", status);
}
if (oskymap) oskymap = astAnnul( oskymap );
if (bolo2map) bolo2map = astAnnul( bolo2map );
if (fitschan) fitschan = astAnnul( fitschan );
if( data != NULL )
smf_close_file( NULL, &data, status );
refsys = astFree( refsys );
astEnd;
}
void atlKy2hd( AstKeyMap *keymap, HDSLoc *loc, int *status ) {
/*
* Name:
* atlKy2hd
* Purpose:
* Copies values from an AST KeyMap to a primitive HDS object.
* Language:
* C.
* Invocation:
* void atlKy2hd( AstKeyMap *keymap, HDSLoc *loc, int *status )
* Description:
* This routine copies the contents of an AST KeyMap into a supplied
* HDS structure.
* Arguments:
* keymap
* An AST pointer to the KeyMap.
* loc
* A locator for the HDS object into which the KeyMap contents
* are to be copied. A new component is added to the HDS object for
* each entry in the KeyMap.
* status
* The inherited status.
* Copyright:
* Copyright (C) 2008, 2010, 2012 Science & Technology Facilities 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
* TIMJ: Tim Jenness (JAC, Hawaii)
* {enter_new_authors_here}
* History:
* 29-APR-2008 (DSB):
* Original version.
* 2010-09-23 (TIMJ):
* Fix arrays of strings.
* 2010-09-30 (TIMJ):
* Make sure that we are using the correct status pointer in AST.
* 2010-10-01 (TIMJ):
* Sort the keys when writing to HDS structured.
* 2010-10-04 (TIMJ):
* Support Short ints in keymap
* 14-SEP-2012 (DSB):
* Moved from kaplibs to atl.
* 17-SEP-2012 (DSB):
* Add support for undefined values.
* {enter_further_changes_here}
* Bugs:
* {note_any_bugs_here}
*/
/* Local Varianles: */
AstObject **objArray = NULL;
AstObject *obj = NULL;
HDSLoc *cloc = NULL;
HDSLoc *dloc = NULL;
const char *cval = NULL;
const char *key;
double dval;
float fval;
int i;
int ival;
int j;
int lenc;
int nval;
char *oldsortby;
int *oldstat = NULL;
int size;
int type;
int veclen;
size_t el;
void *pntr = NULL;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Make sure that we are checking AST status */
oldstat = astWatch( status );
/* If set, save the old SortBy value and then ensure alphabetical sorting.
We need to take a copy of the original string since the buffer in which
the string is stored may be re-used by subsequent incocations of astGetC. */
if( astTest( keymap, "SortBy" ) ) {
int nc = 0;
oldsortby = astAppendString( NULL, &nc, astGetC( keymap, "SortBy" ) );
} else {
oldsortby = NULL;
}
astSet( keymap, "SortBy=KeyUp" );
/* Loop round each entry in the KeyMap. */
size = astMapSize( keymap );
for( i = 0; i < size; i++ ) {
if (*status != SAI__OK) break;
/* Get the key. the data type and the vector length for the current
KeyMap entry. */
key = astMapKey( keymap, i );
type = astMapType( keymap, key );
veclen = astMapLength( keymap, key );
/* If the current entry holds one or more nested KeyMaps, then we call
this function recursively to add them into a new HDS component. */
if( type == AST__OBJECTTYPE ) {
/* First deal with scalar entries holding a single KeyMap. */
if( veclen == 1 ) {
datNew( loc, key, "KEYMAP_ENTRY", 0, NULL, status );
datFind( loc, key, &cloc, status );
(void) astMapGet0A( keymap, key, &obj );
if( astIsAKeyMap( obj ) ) {
atlKy2hd( (AstKeyMap *) obj, cloc, status );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "atlKy2hd: Supplied KeyMap contains unusable AST "
"objects (programming error).", status );
}
datAnnul( &cloc, status );
/* Now deal with vector entries holding multiple KeyMaps. */
} else {
datNew( loc, key, "KEYMAP_ENTRY", 1, &veclen, status );
datFind( loc, key, &cloc, status );
objArray = astMalloc( sizeof( AstObject *) * (size_t)veclen );
if( objArray ) {
(void) astMapGet1A( keymap, key, veclen, &nval, objArray );
for( j = 1; j <= veclen; j++ ) {
datCell( cloc, 1, &j, &dloc, status );
if( astIsAKeyMap( objArray[ j - 1 ] ) ) {
atlKy2hd( (AstKeyMap *) objArray[ j - 1 ], dloc, status );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "atlKy2hd: Supplied KeyMap contains unusable AST "
"objects (programming error).", status );
}
datAnnul( &dloc, status );
}
objArray = astFree( objArray );
}
datAnnul( &cloc, status );
}
/* For primitive types... */
} else if( type == AST__INTTYPE ) {
if( veclen == 1 ) {
datNew0I( loc, key, status );
datFind( loc, key, &cloc, status );
(void) astMapGet0I( keymap, key, &ival );
datPut0I( cloc, ival, status );
datAnnul( &cloc, status );
} else {
datNew1I( loc, key, veclen, status );
datFind( loc, key, &cloc, status );
datMapV( cloc, "_INTEGER", "WRITE", &pntr, &el, status );
(void) astMapGet1I( keymap, key, veclen, &nval, (int *) pntr );
datUnmap( cloc, status );
datAnnul( &cloc, status );
}
} else if( type == AST__SINTTYPE ) {
short sval = 0;
if( veclen == 1 ) {
datNew0W( loc, key, status );
datFind( loc, key, &cloc, status );
(void) astMapGet0S( keymap, key, &sval );
datPut0W( cloc, sval, status );
datAnnul( &cloc, status );
} else {
datNew1W( loc, key, veclen, status );
datFind( loc, key, &cloc, status );
datMapV( cloc, "_WORD", "WRITE", &pntr, &el, status );
(void) astMapGet1S( keymap, key, veclen, &nval, (short *) pntr );
datUnmap( cloc, status );
datAnnul( &cloc, status );
}
} else if( type == AST__DOUBLETYPE ) {
if( veclen == 1 ) {
datNew0D( loc, key, status );
datFind( loc, key, &cloc, status );
(void) astMapGet0D( keymap, key, &dval );
datPut0D( cloc, dval, status );
datAnnul( &cloc, status );
} else {
datNew1D( loc, key, veclen, status );
datFind( loc, key, &cloc, status );
datMapV( cloc, "_DOUBLE", "WRITE", &pntr, &el, status );
(void) astMapGet1D( keymap, key, veclen, &nval, (double *) pntr );
datUnmap( cloc, status );
datAnnul( &cloc, status );
}
} else if( type == AST__FLOATTYPE ) {
if( veclen == 1 ) {
datNew0R( loc, key, status );
datFind( loc, key, &cloc, status );
(void) astMapGet0F( keymap, key, &fval );
datPut0R( cloc, fval, status );
datAnnul( &cloc, status );
} else {
datNew1R( loc, key, veclen, status );
datFind( loc, key, &cloc, status );
datMapV( cloc, "_REAL", "WRITE", &pntr, &el, status );
(void) astMapGet1F( keymap, key, veclen, &nval, (float *) pntr );
datUnmap( cloc, status );
datAnnul( &cloc, status );
}
} else if( type == AST__STRINGTYPE ) {
lenc = astMapLenC( keymap, key );
if( veclen == 1 ) {
datNew0C( loc, key, lenc, status );
datFind( loc, key, &cloc, status );
(void) astMapGet0C( keymap, key, &cval );
datPut0C( cloc, cval, status );
datAnnul( &cloc, status );
} else {
datNew1C( loc, key, lenc, veclen, status );
datFind( loc, key, &cloc, status );
datMapV( cloc, "_CHAR", "WRITE", &pntr, &el, status );
(void) atlMapGet1C( keymap, key, veclen*lenc, lenc, &nval,
(char *) pntr, status );
datUnmap( cloc, status );
datAnnul( &cloc, status );
}
/* KeyMap "UNDEF" values are always scalar and have no corresponding HDS
data type. So arbitrarily use an "_INTEGER" primitive with no defined
value to represent a KeyMap UNDEF value. */
} else if( type == AST__UNDEFTYPE ) {
datNew0L( loc, key, status );
/* Unknown or unsupported data types. */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "T", type );
errRep( "", "atlKy2hd: Supplied KeyMap contains entries with "
"unusable data type (^T) (programming error).", status );
}
}
/* If it was originally set, re-instate the old SortBy value in the KeyMap,
then free the memory. Otherwise, clear the SortBy attribute. */
if( oldsortby ) {
astSetC( keymap, "SortBy", oldsortby );
oldsortby = astFree( oldsortby );
} else {
astClear( keymap, "SortBy" );
}
/* Reset AST status */
astWatch( oldstat );
}
static AstTable *ReadNextTable( FILE *fd, const char *fname, int *iline,
int *status ) {
/*
* Name:
* ReadOneTable
* Purpose:
* Reads a single Table from a text file.
* Description:
* This function reads text from the supplied file descriptor until it
* reaches the end of file or encounters an end-of-table marker (a line
* consisting just of two or more minus signs with no leading spaces).
* It creates an AstTable from the text and returns a pointer to it.
* Arguments:
* fd
* The file descriptor.
* fname
* The file name - used for error messages.
* iline
* Pointer to an int holding the number of lines read from the
* file so far. Updated on exit to include the lines read by the
* invocation of this function.
* status
* Pointer to the global status variable.
* Returned Value:
* A pointer to the Table read from the file, or NULL if an error occurs.
*/
/* Local Variables: */
AstTable *result;
AstTable *subtable;
char **cols;
char **words;
char *last_com;
char *line;
char *p;
char *tname;
char key[ 200 ];
const char *cval;
const char *oldname;
const char *newname;
double dval;
int *types;
int blank;
int c;
int com;
int eot;
int first;
int icol;
int irow;
int ival;
int iword;
int line_len;
int max_line_len;
int more;
int nc;
int ncol;
int nrow;
int nword;
int skip;
size_t len;
/* Initialise */
result = NULL;
/* Check the inherited status. */
if( *status != SAI__OK ) return result;
/* Create an empty Table. */
result = astTable( " " );
/* Allocate a buffer for one one line of text. This will be increased in
size as required. */
max_line_len = 80;
line = astMalloc( max_line_len*sizeof( *line ) );
/* Read each line of text from the file. */
eot = 0;
skip = 1;
line_len = 0;
more = 1;
last_com = NULL;
cols = NULL;
first = 1;
irow = 0;
types = NULL;
while( more && *status == SAI__OK ) {
(*iline)++;
line_len = 0;
/* Loop reading characters from the file until a newline or the end of file is
reached. */
while( ( c = fgetc( fd ) ) != EOF && c != '\n' ) {
/* Increment the current line length, and double the size of the line buffer
if it is full. */
if( ++line_len >= max_line_len ) {
max_line_len *= 2;
line = astRealloc( line, max_line_len*sizeof( *line ) );
if( *status != SAI__OK ) break;
}
/* Store the character. Ignore leading white space. */
if( skip ) {
if( ! isspace( c ) ) {
line[ line_len - 1 ] = c;
skip = 0;
} else {
line_len--;
}
} else {
line[ line_len - 1 ] = c;
}
}
/* If the end-of-file was reached indicate that we should leave the main
loop after processing the current line. */
if( c == EOF ) more = 0;
/* Terminate the line. */
line[ line_len ] = 0;
/* Terminate it again to exclude trailing white space. */
line[ astChrLen( line ) ] = 0;
/* Assume the line is a blank non-comment, and store a pointer to the first
character to use. */
blank = 1;
com = 0;
p = line;
/* Skip blank lines. */
if( line[ 0 ] ) {
/* If the line starts with a comment character... */
if( line[ 0 ] == '#' || line[ 0 ] == '!' ) {
com = 1;
/* Get a pointer to the first non-space/tab character after the comment
character. */
p = line + 1;
while( *p == ' ' || *p == '\t' ) p++;
/* Note if it is blank. */
if( *p ) blank = 0;
/* If it is not a comment line, then the line is not blank. */
} else {
blank = 0;
/* See if it is the end-of-table marker - a line containing just two or
more minus signs with no leading spaces. */
eot = ( strspn( line, "-" ) > 1 );
}
}
/* Skip blank lines, whether comment or not. */
if( ! blank ) {
/* First handle comment lines. */
if( com ) {
/* Does it look like a parameter assignment... */
words = astChrSplitRE( p, "^\\s*(\\w+)\\s*=\\s*(.*)$", &nword, NULL );
if( words ) {
/* Add a parameter declaration to the Table. */
astAddParameter( result, words[ 0 ] );
/* Store the parameter value, using an appropriate data type. */
len = strlen( words[ 1 ] );
if( nc = 0, ( 1 == astSscanf( words[ 1 ], "%d%n", &ival, &nc ) )
&& ( nc >= len ) ) {
astMapPut0I( result, words[ 0 ], ival, NULL );
} else if( nc = 0, ( 1 == astSscanf( words[ 1 ], "%lg%n", &dval, &nc ) )
&& ( nc >= len ) ) {
astMapPut0D( result, words[ 0 ], dval, NULL );
} else {
astMapPut0C( result, words[ 0 ], words[ 1 ], NULL );
}
/* Free the words returned by astChrSplitRE. */
for( iword = 0; iword < nword; iword++ ) {
words[ iword ] = astFree( words[ iword ] );
}
words = astFree( words );
/* If it does not look like a parameter assignment... */
} else {
/* Save a copy of it in case it turns out to be the last non-blank comment
line before the first row of data values (in which case it should
contain the column names). */
last_com = astStore( last_com, p, strlen( p ) + 1 );
}
/* If the line is not a comment see if it is an end of table marker. If so
indicate that we should leave the loop. */
} else if( eot ) {
more = 0;
/* If the line is not a comment or an end of table marker ... */
} else {
/* Get the words from the row. */
words = astChrSplit( p, &nword );
/* If this is the first non-blank non-comment line, get the column names from
the previous non-blank comment line. */
if( first ) {
if( last_com ) {
first = 0;
cols = astChrSplit( last_com, &ncol );
/* Create an array to hold the data type for each colum, and initialise
them to "integer". */
types = astMalloc( ncol*sizeof( int ) ) ;
for( iword = 0; iword < nword && astOK; iword++ ) {
if( iword < ncol ) {
types[ iword ] = AST__INTTYPE;
/* The columns are stored initially using interim names which have "T_"
prepended to the names given in the file. */
tname = NULL;
nc = 0;
tname = astAppendString( tname, &nc, "T_" );
tname = astAppendString( tname, &nc, cols[ iword ] );
astFree( cols[ iword ] );
cols[ iword ] = tname;
/* Create the column definition within the returned Table. We store them
initially as strings and then convert to the appropriate column data type
later (once all rows have been read and the the data types are known). */
astAddColumn( result, cols[ iword ], AST__STRINGTYPE,
0, NULL, " " );
}
}
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSetc( "F", fname );
errRep( " ", "No column headers found in file ^F.", status );
}
}
/* Report an error if the line has the wrong number of values. */
if( nword != ncol ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "N", nword );
msgSeti( "I", (*iline) );
msgSeti( "M", ncol );
msgSetc( "F", fname );
errRep( " ", "Wrong number of values (^N) at line ^I in "
"file ^F (should be ^M).", status );
}
/* Otherwise increment the number of rows read. */
} else {
irow++;
/* Store each string value in the table, excluding "null" strings. Also check
the data type of each string an dupdate the column data types if necessary. */
for( iword = 0; iword < nword && *status == SAI__OK; iword++ ) {
if( strcmp( words[ iword ], "null" ) ) {
sprintf( key, "%s(%d)", cols[ iword ], irow );
astMapPut0C( result, key, words[ iword ], NULL );
/* If the column is currently thought to hold integers, check that the
current word looks like an integer. If not, down-grade the column type
to double. */
len = strlen( words[ iword ] );
if( types[ iword ] == AST__INTTYPE ) {
if( nc = 0, ( 1 != astSscanf( words[ iword ], "%d%n",
&ival, &nc ) ) ||
( nc < len ) ) {
types[ iword ] = AST__DOUBLETYPE;
}
}
/* If the column is currently thought to hold doubles, check that the
current word looks like an doubler. If not, down-grade the column type
to string. */
if( types[ iword ] == AST__DOUBLETYPE ) {
if( nc = 0, ( 1 != astSscanf( words[ iword ], "%lg%n",
&dval, &nc ) ) ||
( nc < len ) ) {
types[ iword ] = AST__STRINGTYPE;
}
}
}
}
}
/* Free the words returned by astChrSplit. */
for( iword = 0; iword < nword; iword++ ) {
words[ iword ] = astFree( words[ iword ] );
}
words = astFree( words );
}
}
}
/* The entire file has now been read, and a Table created in which every
column holds strings. We also have flags indicating whether the values
in each column are all integers or doubles. Modify the type of the
column within the Table to match these flags. */
nrow = astGetI( result, "Nrow" );
for( icol = 0; icol < ncol && *status == SAI__OK; icol++ ) {
/* The column will be re-named from "T_<name>" to "<name>". */
oldname = cols[ icol ];
newname = oldname + 2;
/* First convert string columns to integer columns if all the values in
the column look like integers. */
if( types[ icol ] == AST__INTTYPE ) {
/* Create the new column */
astAddColumn( result, newname, AST__INTTYPE, 0, NULL, " " );
/* Copy each cell of the current column, converting from string to integer. */
for( irow = 1; irow <= nrow; irow++ ) {
sprintf( key, "%s(%d)", oldname, irow );
if( astMapGet0I( result, key, &ival ) ) {
sprintf( key, "%s(%d)", newname, irow );
astMapPut0I( result, key, ival, NULL );
}
}
/* Now do double columns in the same way. */
} else if( types[ icol ] == AST__DOUBLETYPE ) {
astAddColumn( result, newname, AST__DOUBLETYPE, 0, NULL, " " );
for( irow = 1; irow <= nrow; irow++ ) {
sprintf( key, "%s(%d)", oldname, irow );
if( astMapGet0D( result, key, &dval ) ) {
sprintf( key, "%s(%d)", newname, irow );
astMapPut0D( result, key, dval, NULL );
}
}
/* Copy string values without change. */
} else {
astAddColumn( result, newname, AST__STRINGTYPE, 0, NULL, " " );
for( irow = 1; irow <= nrow; irow++ ) {
sprintf( key, "%s(%d)", oldname, irow );
if( astMapGet0C( result, key, &cval ) ) {
sprintf( key, "%s(%d)", newname, irow );
astMapPut0C( result, key, cval, NULL );
}
}
}
/* Remove the old column. */
astRemoveColumn( result, oldname );
}
/* Free resources. */
line = astFree( line );
last_com = astFree( last_com );
types = astFree( types );
if( cols ) {
for( icol = 0; icol < ncol; icol++ ) {
cols[ icol ] = astFree( cols[ icol ] );
}
cols = astFree( cols );
}
/* If the table ended with an end-of-table marker, there may be another
Table in the file. Call this function recursively to read it. */
if( eot ) {
subtable = ReadNextTable( fd, fname, iline, status );
/* Store the subtable as a table parameter in the returned table. */
if( subtable ) {
astAddParameter( result, "SubTable" );
astMapPut0A( result, "SubTable", subtable, NULL );
/* The Table clones the pointer, so we must annull our local copy of it. */
subtable = astAnnul( subtable );
}
}
/* Return the Table pointer. */
return result;
}
void kpg1Kygp1( AstKeyMap *keymap, Grp **igrp, const char *prefix,
int *status ){
/*
*+
* Name:
* kpg1Kygp1
* Purpose:
* Creates a GRP group holding keyword/value pairs read from an AST KeyMap.
* Language:
* C.
* Invocation:
* void kpg1Kygp1( AstKeyMap *keymap, Grp **igrp, const char *prefix,
* int *status )
* Description:
* This function is the inverse of kpg1Kymp1. It extracts the values
* from the supplied AST KeyMap and creates a set of "name=value" strings
* which it appends to a supplied group (or creates a new group). If
* the KeyMap contains nested KeyMaps, then the "name" associated with
* each primitive value stored in the returned group is a hierarchical
* list of component names separated by dots.
* Arguments:
* keymap
* A pointer to the KeyMap. Numerical entries which have bad values
* (VAL__BADI for integer entries or VAL__BADD for floating point
* entries) are not copied into the group.
* igrp
* A location at which is stored a pointer to the Grp structure
* to which the name=value strings are to be appended. A new group is
* created and a pointer to it is returned if the supplied Grp
* structure is not valid.
* prefix
* A string to append to the start of each key extracted from the
* supplied KeyMap. If NULL, no prefix is used.
* status
* Pointer to the inherited status value.
* Notes:
* - This function provides a private implementation for the public
* KPG1_KYGRP Fortran routine and kpg1Kygrp C function.
* - Entries will be stored in the group in alphabetical order
* Copyright:
* Copyright (C) 2008,2010 Science & Technology Facilities Council.
* Copyright (C) 2005 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
* TIMJ: Tim Jenness (JAC, Hawaii)
* {enter_new_authors_here}
* History:
* 7-NOV-2005 (DSB):
* Original version.
* 15-JUL-2008 (TIMJ):
* Tweak to GRP C API.
* 2010-07-19 (TIMJ):
* Handle vector keymap entries.
* 2010-08-12 (TIMJ):
* Store entries in group in alphabetical order.
* 13-AUG-2010 (DSB):
* Re-instate the original SortBy value before exiting.
* {enter_further_changes_here}
* Bugs:
* {note_any_bugs_here}
*-
*/
/* Local Variables: */
AstObject *obj; /* Pointer to nested AST Object */
char *oldsortby; /* The old value of the KeyMap's SortBy attribute */
char *text; /* Sum of concatenated strings */
const char *key; /* Key string for current entry in KeyMap */
const char *value; /* Value of current entry in KeyMap */
double dval; /* Double value */
int *old_status; /* Pointer to original status variable */
int bad; /* Is the numerical entry value bad? */
int i; /* Index into supplied KeyMap */
int ival; /* Integer value */
int n; /* Number of entries in the KeyMap */
int nc; /* Length of "text" excluding trailing null */
int type; /* Data type of current entry in KeyMap */
int valid; /* Is the supplied GRP structure valid? */
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Make AST use the Fortran status variable. */
old_status = astWatch( status );
/* Create a new GRP group if required. */
valid = grpValid( *igrp, status );
if( !valid ) *igrp = grpNew( "Created by kpg1_Kygp1", status );
/* If set, save the old SortBy value and then ensure alphabetical sorting.
We need to take a copy of the original string since the buffer in which
the string is stored may be re-used by subsequent incocations of astGetC. */
if( astTest( keymap, "SortBy" ) ) {
nc = 0;
oldsortby = astAppendString( NULL, &nc, astGetC( keymap, "SortBy" ) );
} else {
oldsortby = NULL;
}
astSet( keymap, "SortBy=KeyUp" );
/* Get the number of entries in the KeyMap. */
n = astMapSize( keymap );
/* Loop round all the entries in the KeyMap.*/
for( i = 0; i < n; i++ ) {
/* Get the name and type of the current KeyMap entry. */
key = astMapKey( keymap, i );
type = astMapType( keymap, key );
/* If the entry is an AST Object, get a pointer to it.*/
if( type == AST__OBJECTTYPE && astMapGet0A( keymap, key, &obj ) ) {
/* If it is a nested KeyMap, update the prefix and call this function
recursively. We ignore other forms of AST Objects. */
if( astIsAKeyMap( obj ) ) {
nc = 0;
text = astAppendString( NULL, &nc, prefix );
text = astAppendString( text, &nc, key );
text = astAppendString( text, &nc, "." );
kpg1Kygp1( (AstKeyMap *) obj, igrp, text, status );
text = astFree( text );
}
/* If it is a primitive, format it and add it to the group. */
} else {
/* If it is a numerical type, see if it has a bad value. */
bad = 0;
if( type == AST__INTTYPE && astMapGet0I( keymap, key, &ival ) ){
if( ival == VAL__BADI ) bad = 1;
} else if( type == AST__DOUBLETYPE && astMapGet0D( keymap, key, &dval ) ){
if( dval == VAL__BADD ) bad = 1;
}
/* If it not bad, get its formatted value. We also make sure that astMapGet0C returns
true because we intend to skip undefined values. */
if( !bad && astMapGet0C( keymap, key, &value ) ) {
size_t length;
/* Write the key and equals sign to a buffer */
nc = 0;
text = astAppendString( NULL, &nc, prefix );
text = astAppendString( text, &nc, key );
text = astAppendString( text, &nc, "=" );
length = astMapLength( keymap, key );
if( length > 1 ) {
/* Vector so we need to use (a,b,c) syntax */
char thiselem[GRP__SZNAM+1];
size_t l;
text = astAppendString( text, &nc, "(");
for ( l = 0; l < length; l++) {
if( astMapGetElemC( keymap, key, sizeof(thiselem), l, thiselem ) ) {
text = astAppendString( text, &nc, thiselem );
}
/* always deal with the comma. Even if value was undef we need to put in the comma */
if( l < (length - 1) ) {
text = astAppendString( text, &nc, "," );
}
}
text = astAppendString( text, &nc, ")");
} else {
/* Scalar */
text = astAppendString( text, &nc, value );
}
/* Put it in the group. */
grpPut1( *igrp, text, 0, status );
text = astFree( text );
}
}
}
/* If it was originally set, re-instate the old SortBy value in the KeyMap,
then free the memory. Otherwise, clear the SortBy attribute. */
if( oldsortby ) {
astSetC( keymap, "SortBy", oldsortby );
oldsortby = astFree( oldsortby );
} else {
astClear( keymap, "SortBy" );
}
/* Make AST use its original status variable. */
astWatch( old_status );
}
void smurf_jsatileinfo( int *status ) {
/* Local Variables */
AstCmpRegion *overlap;
AstFitsChan *fc;
AstFrameSet *fs;
AstObject *obj;
AstRegion *region;
AstRegion *target;
HDSLoc *cloc = NULL;
HDSLoc *xloc = NULL;
char *jcmt_tiles;
char *tilendf = NULL;
char text[ 200 ];
double dec[ 8 ];
double dist;
double dlbnd[ 2 ];
double dubnd[ 2 ];
double gx[ 8 ];
double gy[ 8 ];
double maxdist;
double norm_radec[2];
double point1[ 2 ];
double point2[ 2 ];
double ra[ 8 ];
double ra0;
double dec0;
int *ipntr;
int axes[ 2 ];
int create;
int dirlen;
int el;
int exists;
int flag;
int i;
int indf1;
int indf2;
int indf3;
int itile;
int iv;
int jtile;
int lbnd[ 2 ];
int local_origin;
int nc;
int place;
int tlbnd[ 2 ];
int tubnd[ 2 ];
int ubnd[ 2 ];
smf_jsaproj_t proj;
int xt;
int yt;
smfJSATiling skytiling;
void *pntr;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Start a new AST context. */
astBegin;
/* Get the instrument to use abnd get the parameters describing the
layout of its JSA tiles. */
smf_jsainstrument( "INSTRUMENT", NULL, SMF__INST_NONE, &skytiling,
status );
/* Return the maximum tile index. */
parPut0i( "MAXTILE", skytiling.ntiles - 1, status );
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Decide what sort of projection to use. */
parChoic( "PROJ", "HPX", "HPX,HPX12,XPHN,XPHS", 1, text, sizeof(text),
status );
proj = smf_jsaproj_fromstr( text, 1, status );
/* If required, create an all-sky NDF in which each pixel covers the area
of a single tile, and holds the integer tile index. The NDF has an
initial size of 1x1 pixels, but is expanded later to the required size. */
lbnd[ 0 ] = ubnd[ 0 ] = lbnd[ 1 ] = ubnd[ 1 ] = 1;
ndfCreat( "ALLSKY", "_INTEGER", 2, lbnd, ubnd, &indf3, status );
/* If a null (!) value was supplied for parameter ALLSKY, annull the
error and pass on. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, create a FrameSet describing the whole sky in which each
pixel corresponds to a single tile. */
} else {
smf_jsatile( -1, &skytiling, 0, proj, NULL, &fs, NULL, lbnd, ubnd,
status );
/* Change the bounds of the output NDF. */
ndfSbnd( 2, lbnd, ubnd, indf3, status );
/* Store the FrameSet in the NDF. */
ndfPtwcs( fs, indf3, status );
/* Map the data array. */
ndfMap( indf3, "Data", "_INTEGER", "WRITE/BAD", (void **) &ipntr, &el,
status );
/* Create all-sky map using XPH projection. */
if( *status == SAI__OK ) {
/* Loop round every tile index. */
for( jtile = 0; jtile < skytiling.ntiles; jtile++ ) {
/* Get the zero-based (x,y) indices of the tile within an HPX projection.
This flips the bottom left half-facet up to the top right. */
smf_jsatilei2xy( jtile, &skytiling, &xt, &yt, NULL, status );
/* Convert these HPX indices to the corresponding indices within the
required projection. Note, the lower left facet is split by the above
call to smf_jsatilei2xy tile (i.e. (xt,yt) indices are *not* in the
"raw" mode). For instance, (0,0) is not a valid tile. */
smf_jsatilexyconv( &skytiling, proj, xt, yt, 0, &xt, &yt, status );
/* Get the vector index of the corresponding element of the all-sky NDF. */
if( proj == SMF__JSA_HPX || proj == SMF__JSA_HPX12 ) {
iv = xt + 5*skytiling.ntpf*yt;
} else {
iv = xt + 4*skytiling.ntpf*yt;
}
/* Report an error if this element has already been assigned a tile
index. Otherwise, store the tile index. */
if( ipntr[ iv ] == VAL__BADI ) {
ipntr[ iv ] = jtile;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "%s projection assigns multiple tiles to "
"pixel (%d,%d).", status, text, xt, yt );
break;
}
}
}
/* Store NDF title. */
sprintf( text, "JSA tile indices for %s data", skytiling.name );
ndfCput( text, indf3, "TITLE", status );
/* Store the instrument as a component in the SMURF extension. */
ndfXnew( indf3, "SMURF", "INSTRUMENT", 0, 0, &xloc, status );
ndfXpt0c( skytiling.name, indf3, "SMURF", "INSTRUMENT", status );
datAnnul( &xloc, status );
/* Close the NDF. */
ndfAnnul( &indf3, status );
}
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Get the zero-based index of the required tile. If a null value is
supplied, annull the error and skip to the end. */
parGdr0i( "ITILE", 0, 0, skytiling.ntiles - 1, 0, &itile, status );
if( *status == PAR__NULL ) {
errAnnul( status );
goto L999;
}
/* See if the pixel origin is to be at the centre of the tile. */
parGet0l( "LOCAL", &local_origin, status );
/* Display the tile number. */
msgBlank( status );
msgSeti( "ITILE", itile );
msgSeti( "MAXTILE", skytiling.ntiles - 1);
msgOut( " ", " Tile ^ITILE (from 0 to ^MAXTILE):", status );
/* Get the FITS header, FrameSet and Region defining the tile, and the tile
bounds in pixel indices. */
smf_jsatile( itile, &skytiling, local_origin, proj, &fc, &fs, ®ion,
lbnd, ubnd, status );
/* Write the FITS headers out to a file, annulling the error if the
header is not required. */
if( *status == SAI__OK ) {
atlDumpFits( "HEADER", fc, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* If required, write the Region out to a text file. */
if( *status == SAI__OK ) {
atlCreat( "REGION", (AstObject *) region, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Store the lower and upper pixel bounds of the tile. */
parPut1i( "LBND", 2, lbnd, status );
parPut1i( "UBND", 2, ubnd, status );
/* Display pixel bounds on the screen. */
msgSeti( "XL", lbnd[ 0 ] );
msgSeti( "XU", ubnd[ 0 ] );
msgSeti( "YL", lbnd[ 1 ] );
msgSeti( "YU", ubnd[ 1 ] );
msgOut( " ", " Pixel bounds: (^XL:^XU,^YL:^YU)", status );
/* Get the RA,Dec at the tile centre. */
if( astTest( fs, "SkyRef" ) ) {
ra0 = astGetD( fs, "SkyRef(1)" );
dec0 = astGetD( fs, "SkyRef(2)" );
/* Format the central RA and Dec. and display. Call astNorm on the
coordinates provided that the frame set has the correct number of
axes (which it should as it comes from smf_jsatile). */
norm_radec[0] = ra0;
norm_radec[1] = dec0;
if (astGetI(fs, "Naxes") == 2) astNorm(fs, norm_radec);
msgSetc( "RACEN", astFormat( fs, 1, norm_radec[ 0 ] ));
msgSetc( "DECCEN", astFormat( fs, 2, norm_radec[ 1 ] ));
msgOut( " ", " Centre (ICRS): RA=^RACEN DEC=^DECCEN", status );
/* Transform a collection of points on the edge of the region (corners and
side mid-points) from GRID coords to RA,Dec. */
point1[ 0 ] = 0.5;
point1[ 1 ] = 0.5;
point2[ 0 ] = ubnd[ 0 ] - lbnd[ 0 ] + 1;
point2[ 1 ] = ubnd[ 1 ] - lbnd[ 1 ] + 1;
gx[ 0 ] = point1[ 0 ]; /* Bottom left */
gy[ 0 ] = point1[ 1 ];
gx[ 1 ] = point1[ 0 ]; /* Centre left */
gy[ 1 ] = gy[ 0 ];
gx[ 2 ] = point1[ 0 ]; /* Top left */
gy[ 2 ] = point2[ 1 ];
gx[ 3 ] = gx[ 0 ]; /* Top centre */
gy[ 3 ] = point2[ 1 ];
gx[ 4 ] = point2[ 0 ]; /* Top right */
gy[ 4 ] = point2[ 1 ];
gx[ 5 ] = point2[ 0 ]; /* Centre right */
gy[ 5 ] = gy[ 0 ];
gx[ 6 ] = point2[ 0 ]; /* Bottom right */
gy[ 6 ] = point1[ 1 ];
gx[ 7 ] = gx[ 0 ]; /* Bottom centre */
gy[ 7 ] = point1[ 1 ];
astTran2( fs, 8, gx, gy, 1, ra, dec );
/* Find the arc-distance from the centre to the furthest point from the
centre. */
point1[ 0 ] = ra0;
point1[ 1 ] = dec0;
maxdist = -1.0;
for( i = 1; i < 8; i++ ) {
if( ra[ i ] != AST__BAD && dec[ i ] != AST__BAD ) {
point2[ 0 ] = ra[ i ];
point2[ 1 ] = dec[ i ];
dist = astDistance( fs, point1, point2 );
if( dist > maxdist ) maxdist = dist;
}
}
/* Convert from radius to diameter. */
maxdist *= 2.0;
/* Format this size as a dec value (i.e. arc-distance) and display it. */
if( maxdist > 0.0 ) {
msgSetc( "SIZE", astFormat( fs, 2, maxdist ) );
msgOut( " ", " Size: ^SIZE", status );
} else {
maxdist = AST__BAD;
msgOut( " ", " Size: <unknown>", status );
}
/* If a discontinuity passes through the tile, the centre and size may be
unknown. */
} else {
ra0 = AST__BAD;
dec0 = AST__BAD;
maxdist = AST__BAD;
msgOut( " ", " Centre (ICRS): RA=<unknown> DEC=<unknown>", status );
msgOut( " ", " Size: <unknown>", status );
}
/* Write the tile centre ra and dec in radians to the output parameters. */
parPut0d( "RACEN", norm_radec[ 0 ], status );
parPut0d( "DECCEN", norm_radec[ 1 ], status );
/* Write the size to the output parameter as radians. */
parPut0d( "SIZE", maxdist, status );
/* Get the translation of the environment variable JSA_TILE_DIR. */
jcmt_tiles = getenv( "JSA_TILE_DIR" );
/* Initialise the path to the tile's NDF to hold the root directory.
Use the current working directory if JSA_TILE_DIR is undefined. */
if( jcmt_tiles ) {
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
} else {
nc = 512;
jcmt_tiles = astMalloc( nc );
while( !getcwd( jcmt_tiles, nc ) ) {
nc *= 2;
jcmt_tiles = astRealloc( jcmt_tiles, nc );
}
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
jcmt_tiles = astFree( jcmt_tiles );
}
/* Complete the path to the tile's NDF. */
tilendf = astAppendString( tilendf, &nc, "/" );
tilendf = astAppendString( tilendf, &nc, skytiling.subdir );
dirlen = nc;
sprintf( text, "/tile_%d.sdf", itile );
tilendf = astAppendString( tilendf, &nc, text );
/* Write it to the output parameter. */
parPut0c( "TILENDF", tilendf, status );
/* See if the NDF exists, and store the flag in the output parameter. */
exists = access( tilendf, F_OK ) ? 0 : 1;
parPut0l( "EXISTS", exists, status );
/* If the NDF does not exist, create it if required. */
parGet0l( "CREATE", &create, status );
if( !exists && create && *status == SAI__OK ) {
/* Write the NDF info to the screen. */
msgSetc( "NDF", tilendf );
msgOutif( MSG__NORM, " ", " NDF: ^NDF (created)", status );
/* Temporarily terminate the NDF path at the end of the subdirectory. */
tilendf[ dirlen ] = 0;
/* Create the required directory (does nothing if the directory
already exists). It is given read/write/search permissions for owner
and group, and read/search permissions for others. */
(void) mkdir( tilendf, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
/* Replace the character temporarily overwritten above. */
tilendf[ dirlen ] = '/';
/* Now create the tile's NDF. */
ndfPlace( NULL, tilendf, &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf1, status );
/* Fill its data array with zeros. */
ndfMap( indf1, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
/* Store the WCS FrameSet. */
ndfPtwcs( fs, indf1, status );
/* If the instrument jsatiles.have variance, fill the variance array with zeros. */
if( skytiling.var ) {
ndfMap( indf1, "Variance", skytiling.type, "WRITE/ZERO", &pntr,
&el, status );
}
/* Create a SMURF extension. */
ndfXnew( indf1, SMURF__EXTNAME, SMURF__EXTTYPE, 0, NULL, &xloc, status );
/* Store the tile number and instrument name in the extension. */
datNew0I( xloc, "TILE", status );
datFind( xloc, "TILE", &cloc, status );
datPut0I( cloc, itile, status );
datAnnul( &cloc, status );
datNew0C( xloc, "INSTRUMENT", strlen( skytiling.name ), status );
datFind( xloc, "INSTRUMENT", &cloc, status );
datPut0C( cloc, skytiling.name, status );
datAnnul( &cloc, status );
/* Create a weights NDF within the SMURF extension, and fill its data
array with zeros. */
ndfPlace( xloc, "WEIGHTS", &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf2, status );
ndfMap( indf2, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
ndfPtwcs( fs, indf2, status );
ndfAnnul( &indf2, status );
/* Annul the extension locator and the main NDF identifier. */
datAnnul( &xloc, status );
ndfAnnul( &indf1, status );
/* Write the NDF info to the screen. */
} else {
msgSetc( "NDF", tilendf );
msgSetc( "E", exists ? "exists" : "does not exist" );
msgOut( " ", " NDF: ^NDF (^E)", status );
}
/* Initialise TBND and TLBND to indicate no overlap. */
tlbnd[ 0 ] = 1;
tlbnd[ 1 ] = 1;
tubnd[ 0 ] = 0;
tubnd[ 1 ] = 0;
/* Attempt to to get an AST Region (assumed to be in some 2D sky coordinate
system) using parameter "TARGET". */
if( *status == SAI__OK ) {
kpg1Gtobj( "TARGET", "Region",
(void (*)( void )) F77_EXTERNAL_NAME(ast_isaregion),
&obj, status );
/* Annul the error if none was obtained. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, use the supplied object. */
} else {
target = (AstRegion *) obj;
/* If the target Region is 3-dimensional, remove the third axis, which
is assumed to be a spectral axis. */
if( astGetI( target, "Naxes" ) == 3 ) {
axes[ 0 ] = 1;
axes[ 1 ] = 2;
target = astPickAxes( target, 2, axes, NULL );
}
/* See if there is any overlap between the target and the tile. */
overlap = NULL;
flag = astOverlap( region, target );
if( flag == 0 ) {
msgOut( "", " Cannot convert between the coordinate system of the "
"supplied target and the tile.", status );
} else if( flag == 1 || flag == 6 ) {
msgOut( "", " There is no overlap between the target and the tile.",
status );
} else if( flag == 2 ) {
msgOut( "", " The tile is contained within the target.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( flag == 3 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 4 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 5 ) {
msgOut( "", " The target and tile are identical.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( *status == SAI__OK ) {
*status = SAI__OK;
errRepf( "", "Unexpected value %d returned by astOverlap "
"(programming error).", status, flag );
}
/* If a region containing the intersection of the tile and target was
created above, map it into the grid coordinate system of the tile. */
if( overlap ) {
overlap = astMapRegion( overlap, astGetMapping( fs, AST__CURRENT,
AST__BASE ),
astGetFrame( fs, AST__BASE ) );
/* Get its GRID bounds. */
astGetRegionBounds( overlap, dlbnd, dubnd );
/* Convert to integer. */
tlbnd[ 0 ] = ceil( dlbnd[ 0 ] - 0.5 );
tlbnd[ 1 ] = ceil( dlbnd[ 1 ] - 0.5 );
tubnd[ 0 ] = ceil( dubnd[ 0 ] - 0.5 );
tubnd[ 1 ] = ceil( dubnd[ 1 ] - 0.5 );
/* Convert to PIXEL indices within the tile. */
tlbnd[ 0 ] += lbnd[ 0 ] - 1;
tlbnd[ 1 ] += lbnd[ 1 ] - 1;
tubnd[ 0 ] += lbnd[ 0 ] - 1;
tubnd[ 1 ] += lbnd[ 1 ] - 1;
msgOutf( "", " The target overlaps section (%d:%d,%d:%d).",
status, tlbnd[ 0 ], tubnd[ 0 ], tlbnd[ 1 ], tubnd[ 1 ] );
}
}
}
/* Store the pixel index bounds of the tiles overlap with the target. */
parPut1i( "TLBND", 2, tlbnd, status );
parPut1i( "TUBND", 2, tubnd, status );
/* Arrive here if an error occurs. */
L999:;
/* Free resources. */
tilendf = astFree( tilendf );
/* End the AST context. */
astEnd;
/* Issue a status indication.*/
msgBlank( status );
if( *status == SAI__OK ) {
msgOutif( MSG__VERB, "", "JSATILEINFO succeeded.", status);
} else {
msgOutif( MSG__VERB, "", "JSATILEINFO failed.", status);
}
}
/*
* Process an NDF history element and construct a KeyMay.
*
* This is intended as a handler routine for use with ndfHout,
* it reads the supplied text and sets the global historyConfig
* variable.
*/
void HistoryKeyMap(int n, char* const text[], int* status) {
char patt_group[] = "Group:";
char patt_cont[] = " ";
char patt_name[] = "CONFIG";
char* buff = NULL;
int nc = 0;
char line[NDF__SZHIS + 1];
char* p;
char* q;
int i;
int groupstarting = 0;
int groupcontinuing = 0;
Grp* grp;
size_t grpsize;
int grpadded, grpflag;
/* Check the inherited status */
if (*status != SAI__OK) return;
/* Loop over history text lines, copying each into line for editing
and setting p to point at the start of line. */
for (i = 0; i < n; i ++) {
one_strlcpy(line, text[i], NDF__SZHIS + 1, status);
p = line;
/* If a group is in progess, check that it continues, and if so
add the line to the buffer, otherwise end the group. Since we
only extract one group, we can leave processing buff to the end. */
if (groupcontinuing) {
if (! strncmp(patt_cont, p, strlen(patt_cont))) {
p += strlen(patt_cont);
while (*p == ' ') p++;
while (p[strlen(p) - 1] == ' ') p[strlen(p) - 1] = '\0';
buff = astAppendString(buff, &nc, p);
continue;
}
else {
groupcontinuing = 0;
}
}
/* If we didn't already detect a group to be starting, see whether
one is starting now. */
if (! groupstarting) {
if (strncmp(patt_group, p, strlen(patt_group))) {
continue;
}
else {
groupstarting = 1;
p += strlen(patt_group);
}
}
while (*p == ' ') p ++;
if (! *p) continue;
/* Group is starting, so check whether the group name is the one
for which we are looking, and if so, start collecting the
text in buff. */
if (! strncmp(patt_name, p, strlen(patt_name))) {
p += strlen(patt_name);
while (*p == ' ') p ++;
if (*p == '=') {
p++;
if (*p == '"') p++;
while (*p == ' ') p++;
while (p[strlen(p) - 1] == ' ') p[strlen(p) - 1] = '\0';
buff = astAppendString(astFree(buff), &nc, p);
groupcontinuing = 1;
}
}
groupstarting = 0;
}
/* Convert buff to a KeyMap and set the global variable historyConfig. */
if (buff && *buff) {
if (buff[strlen(buff) - 1] == '"') buff[strlen(buff) - 1] = '\0';
grp = grpNew("CONFIG", status);
p = buff;
while (*p) {
q = p;
i = 0;
groupcontinuing = 0;
for (q = p; *q; q ++) {
if (*q == '(' || *q == '[' || (*q == '\'' && i == 0)) i ++;
else if (*q == ')' || *q == ']' || (*q == '\'' && i > 0)) i --;
else if (*q == ',' && i == 0) {
*q = '\0';
groupcontinuing = 1;
break;
}
}
grpGrpex(p, GRP__NOID, grp, &grpsize, &grpadded, &grpflag, status);
if (!groupcontinuing) break;
p = q + 1;
}
kpg1Kymap(grp, &historyConfig, status);
grpDelet(&grp, status);
buff = astFree(buff);
}
}
static void DisplayKeyMap( AstKeyMap *km, int sort, const char *prefix,
AstKeyMap *refkm, int *status ){
/*
* Name:
* DisplayKeyMap
* Purpose:
* Display the contents of a keymap.
* Synopsis:
* void DisplayKeyMap( AstKeyMap *km, int sort, const char *prefix,
* int *status )
* Arguments:
* km
* Pointer to the KeyMaps containing the values to display.
* sort
* If non-zero, sort the values alphabetically by their keys.
* prefix
* A string to prepend to eack key.
* refkm
* Reference key map (e.g. values from the supplied configuration
* rather than the NDF history), or null if not required.
* status
* Inherited status pointer.
* Description:
* This function displays the contents of a supplied KeyMap as
* a series of "key = value" strings, one per line. It calls itself
* recursively if a nested KeyMap is found, adding a suitable
* prefix to the nested keys. If a reference key map is supplied then
* the output shows how the main key map differs from it.
*/
/* Local Variables: */
AstObject *avalue;
AstObject *refavalue;
char cbuffer[ 255 ];
char newpref[ 255 ];
const char *cvalue;
const char *refcvalue;
const char *key;
int ikey;
int ival;
int nc;
int nkey;
int nval;
/* Check the inherited status */
if( *status != SAI__OK ) return;
if (refkm) astClear(refkm, "KeyError");
/* Sort the supplied KeyMap is required. */
if( sort ) astSetC( km, "SortBy", "KeyUp" );
/* Loop round all keys in the supplied KeyMap. */
nkey = astMapSize( km );
for( ikey = 0; ikey < nkey; ikey++ ) {
key = astMapKey( km, ikey );
/* If the current entry is a nest KeyMap, get a pointer to it and call
this function recurisvely to display it, modifying the prefix to add
to each key so that it includes the key associated with the nest keymap. */
if( astMapType( km, key ) == AST__OBJECTTYPE ) {
astMapGet0A( km, key, &avalue );
if (refkm) {
if (! astMapGet0A(refkm, key, &refavalue)) {
refavalue = (AstObject*) astKeyMap("");
}
}
else {
refavalue = NULL;
}
sprintf( newpref, "%s%s.", prefix, key );
DisplayKeyMap( (AstKeyMap *) avalue, sort, newpref,
(AstKeyMap *) refavalue, status );
avalue = astAnnul( avalue );
if (refavalue) refavalue = astAnnul(refavalue);
/* If the current entry is not a nested keymap, we display it now. */
} else {
/* Get the vector length of the entry. */
nval = astMapLength( km, key );
/* If it is a scalar, just get its value as a character string using
the automatic type conversion provided by the KeyMap class, and
display it, putting the supplied prefix at the start of the key. */
if( nval <= 1 ) {
cvalue = "<undef>";
astMapGet0C( km, key, &cvalue );
if (refkm) {
refcvalue = "<undef>";
if (astMapGet0C(refkm, key, &refcvalue)
&& ! strcmp(cvalue, refcvalue)) {
msgOutf("", "- %s%s = %s", status, prefix, key, cvalue);
}
else {
msgOutf("", "+ %s%s = %s", status, prefix, key, cvalue);
}
}
else {
msgOutf( "", "%s%s = %s", status, prefix, key, cvalue );
}
/* If it is a vector, we construct a string containing a comma-separated
list of elements, enclosed in parentheses. */
} else {
nc = 0;
cvalue = astAppendString( NULL, &nc, "(" );
for( ival = 0; ival < nval; ival++ ) {
if( astMapGetElemC( km, key, sizeof( cbuffer) - 1, ival,
cbuffer ) ) {
cvalue = astAppendString( (char *) cvalue, &nc, cbuffer );
}
if( ival < nval - 1 ) cvalue = astAppendString( (char *) cvalue,
&nc, "," );
}
cvalue = astAppendString( (char *) cvalue, &nc, ")" );
/* Do the same for the reference KeyMap. */
if (refkm && (nval = astMapLength(refkm, key))) {
nc = 0;
refcvalue = astAppendString(NULL, &nc, "(");
for (ival = 0; ival < nval; ival++) {
if (ival) {
refcvalue = astAppendString((char*) refcvalue, &nc, "," );
}
if (astMapGetElemC(refkm, key, sizeof(cbuffer) - 1, ival,
cbuffer)) {
refcvalue = astAppendString((char*) refcvalue, &nc,
cbuffer);
}
}
refcvalue = astAppendString((char*) refcvalue, &nc, ")");
}
else {
refcvalue = NULL;
}
/* Display the total string, with the current key prefix, and free the memory
used to store it. */
if (refkm) {
if (refcvalue && ! strcmp(cvalue, refcvalue)) {
msgOutf("", "- %s%s = %s", status, prefix, key, cvalue);
}
else {
msgOutf("", "+ %s%s = %s", status, prefix, key, cvalue);
}
}
else {
msgOutf( "", "%s%s = %s", status, prefix, key, cvalue );
}
cvalue = astFree( (void *) cvalue );
if (refcvalue) refcvalue = astFree((void*) refcvalue);
}
}
}
}