static PyObject*
pyndf_gtwcs(NDF *self)
{
AstFrameSet *wcs = NULL;
char *string;
PyObject *pywcs;
PyObject *result = NULL;
int status = SAI__OK;
#if HAVE_AST
errBegin(&status);
astBegin;
ndfGtwcs(self->_ndfid, &wcs, &status );
if( wcs ) {
string = astToString( wcs );
wcs = astAnnul( wcs );
pywcs = PyAst_FromString( string );
string = astFree( string );
if( pywcs ) result = Py_BuildValue("O",pywcs);
Py_XDECREF(pywcs);
}
astEnd;
if (raiseNDFException(&status)) return NULL;
#else
PyErr_SetString( PyExc_NotImplementedError,
"starlink.Ast must be available for WCS to be retrieved from an NDF");
#endif
return result;
};
static void smf1_jsadicer( int indfo, int *olbnd, int *oubnd,
AstMapping *tile_map, AstFrame *tile_frm,
AstMapping *p2pmap, void *ipd, void *ipv,
unsigned char *ipq, int *status ){
/*
* Name:
* smf1_jsadicer
* Purpose:
* Copy one tile from the input NDF into a specified output NDF.
* Language:
* Starlink ANSI C
* Type of Module:
* C function
* Invocation:
* void smf1_jsadicer( int indfo, int *olbnd, int *oubnd,
* AstMapping *tile_map, AstFrame *tile_frm,
* AstMapping *p2pmap, void *ipd, void *ipv,
* unsigned char *ipq, int *status )
* Arguments:
* indfo = int (Given)
* An identifier for the NDF in which the copied data is to be
* stored. It's original pixel bounds are used as the bounds of the
* ipd, ipv and ipq arrays.
* olbnd = int * (Given)
* The new lower pixel bounds required for the output NDF. The bounds
* of the supplied NDF are changed to match these values.
* oubnd = int * (Given)
* The new upper pixel bounds required for the output NDF. The bounds
* of the supplied NDF are changed to match these values.
* tile_map = AstMapping * (Given)
* The mapping from pixel coords in the output NDF to WCS coords.
* tile_frm = AstMapping * (Given)
* The WCS Frame for the output NDF.
* p2pmap = AstMapping * (Given)
* The mapping from pixel coords in the input NDF to pixel coords in
* the output NDF.
* ipd = void * (Given)
* Pointer to the start of the input data array. If this is NULL,
* the existing contents of the NDF are used as input.
* ipv = void * (Given)
* Pointer to the start of the input variance array. Should be NULL
* if no variances are available.
* ipq = unsigned char * (Given)
* Pointer to the start of the input quality array. Should be NULL
* if no quality is available.
* status = int * (Given)
* Pointer to the inherited status variable.
*/
/* Local Variables: */
AstFrame *use_frm = NULL;
AstFrameSet *owcs;
AstMapping *use_map = NULL;
AstMapping *use_p2pmap = NULL;
AstShiftMap *sm;
char type[ NDF__SZTYP + 1 ];
double shifts[ 3 ];
int axes[ 2 ];
int axout[ NDF__MXDIM ];
int free_arrays;
int isreal;
int lbnd_tile[ 3 ];
int ndim;
int nel;
int nin;
int there;
int ubnd_tile[ 3 ];
unsigned char *ipq_out = NULL;
void *ipd_out = NULL;
void *ipv_out = NULL;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context. */
astBegin;
/* Get the NDF data type - _REAL or _DOUBLE. */
ndfType( indfo, "Data", type, sizeof(type), status );
isreal = !strcmp( type, "_REAL" );
/* Get the existing bounds of the NDF. */
ndfBound( indfo, 3, lbnd_tile, ubnd_tile, &ndim, status );
/* If no data array has been supplied, take a copy of the original Data,
Quality and Variance arrays and use these as the input arrays. */
if( !ipd ) {
free_arrays = 1;
ndfMap( indfo, "Data", type, "Read", &ipd_out, &nel, status );
ipd = astStore( NULL, ipd_out,
nel*(isreal?sizeof(float):sizeof(double)) );
ndfUnmap( indfo, "Data", status );
ndfState( indfo, "Variance", &there, status );
if( there ) {
ndfMap( indfo, "Variance", type, "Read", &ipv_out, &nel, status );
ipv = astStore( NULL, ipv_out,
nel*(isreal?sizeof(float):sizeof(double)) );
ndfUnmap( indfo, "Variance", status );
} else {
ipv = NULL;
}
ndfState( indfo, "Quality", &there, status );
if( there ) {
ndfMap( indfo, "Quality", "_UBYTE", "Read", (void **) &ipq_out,
&nel, status );
ipq = astStore( NULL, ipq_out, nel*sizeof(*ipq) );
ndfUnmap( indfo, "Quality", status );
} else {
ipq = NULL;
}
} else {
free_arrays = 0;
}
/* Set the bounds of the NDF to the required values. */
ndfSbnd( ndim, olbnd, oubnd, indfo, status );
/* Erase the existing WCS FrameSet and then get the default WCS FrameSet. */
ndfReset( indfo, "WCS", status );
ndfGtwcs( indfo, &owcs, status );
/* If the supplied mapping and Frame have two many axes, strip some off.
The orering of pixel axes in the output JSA tile is hardwired by SMURF
as (ra,dec,spec). */
nin = astGetI( tile_map, "Nin" );
if( nin == 3 && ndim == 2 ) {
axes[ 0 ] = 1;
axes[ 1 ] = 2;
astMapSplit( tile_map, 2, axes, axout, &use_map );
if( use_map ) {
use_frm = astPickAxes( tile_frm, 2, axout, NULL );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "smf1_jsadicer: cannot split mapping (programming "
"error).", status );
}
astMapSplit( p2pmap, 2, axes, axout, &use_p2pmap );
if( !use_p2pmap && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "smf1_jsadicer: cannot split mapping (programming "
"error).", status );
}
} else if( nin == ndim ) {
use_p2pmap = astClone( p2pmap );
use_map = astClone( tile_map );
use_frm = astClone( tile_frm );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "smf1_jsadicer: unexpected combination of nin (%d) and "
"ndim (%d) (programming error).", status, nin, ndim );
}
/* Add the tile WCS Frame into the output NDF's WCS FrameSet, using "tilemap"
to connect it to the PIXEL Frame (NDF ensure Frame 2 is the PIXEL
Frame). */
astAddFrame( owcs, 2, use_map, use_frm );
/* The astResample function is odd in that it assumes that pixel coords
are defined such that the centre of pixel "I" has integral pixel
coord "I" (rather than "I-0.5" as is usual in Starlink). So we need to
use a half-pixel ShiftMap at start and end of the p2pmap Mapping to
account for this. */
shifts[ 0 ] = -0.5;
shifts[ 1 ] = -0.5;
shifts[ 2 ] = -0.5;
sm = astShiftMap( ndim, shifts, " " );
use_p2pmap = (AstMapping *) astCmpMap( sm, use_p2pmap, 1, " " );
astInvert( sm );
use_p2pmap = (AstMapping *) astCmpMap( use_p2pmap, sm, 1, " " );
/* Store this modified WCS FrameSet in the output NDF. */
ndfPtwcs( owcs, indfo, status );
/* Map the required arrays of the output NDF. */
ndfMap( indfo, "Data", type, "Write", &ipd_out, &nel, status );
if( ipv ) ndfMap( indfo, "Variance", type, "Write", &ipv_out, &nel,
status );
if( ipq ) ndfMap( indfo, "Quality", "_UBYTE", "Write",
(void **) &ipq_out, &nel, status );
/* Copy the input data values to the output, using nearest neighbour
interpolation (the mapping should always map input pixel centres onto
output pixel centres). We can set the "tol" argument non-zero (e.g. 0.1)
without introducing any error because the the p2pmap mapping will be
piecewise linear. This gives a factor of about 5 decrease in the time
spent within astResample. */
if( !strcmp( type, "_REAL" ) ) {
(void) astResampleF( use_p2pmap, ndim, lbnd_tile, ubnd_tile, (float *) ipd,
(float *) ipv, AST__NEAREST, NULL, NULL,
AST__USEBAD, 0.1, 1000, VAL__BADR, ndim,
olbnd, oubnd, olbnd, oubnd,
(float *) ipd_out, (float *) ipv_out );
} else {
(void) astResampleD( use_p2pmap, ndim, lbnd_tile, ubnd_tile, (double *) ipd,
(double *) ipv, AST__NEAREST, NULL, NULL,
AST__USEBAD, 0.1, 1000, VAL__BADD, ndim,
olbnd, oubnd, olbnd, oubnd,
(double *) ipd_out, (double *) ipv_out );
}
if( ipq ) {
(void) astResampleUB( use_p2pmap, ndim, lbnd_tile, ubnd_tile, ipq, NULL,
AST__NEAREST, NULL, NULL, 0, 0.1, 1000, 0,
ndim, olbnd, oubnd, olbnd, oubnd, ipq_out,
NULL );
}
/* Unmap everything the output NDF. */
ndfUnmap( indfo, "*", status );
/* Free the input arrays if they were allocated in this function. */
if( free_arrays ) {
ipd = astFree( ipd );
ipv = astFree( ipv );
ipq = astFree( ipq );
}
/* End the AST context. */
astEnd;
}
void smf_add_spectral_axis( int indf, AstFitsChan *fc, int *status ){
/* Local Variables */
AstFrame *cfrm; /* Pointer to the current WCS Frame in the NDF */
AstFrameSet *wcs; /* Pointer to the WCS FrameSet for the NDF */
AstSpecFrame *specfrm; /* Pointer to the new SpecFrame */
AstWinMap *specmap; /* Pointer to Mapping from GRID to wavelength */
char attrib[ 10 ]; /* Buffer for attribute name */
double bandwid; /* Bandwidth, in metres */
double grid_hi; /* GRID coord at upper edge of spectral pixel */
double grid_lo; /* GRID coord at lower edge of spectral pixel */
double ref_lat; /* Celestial latitude at reference point */
double ref_lon; /* Celestial longitude at reference point */
double spec_hi; /* Wavelength at upper edge of spectral pixel */
double spec_lo; /* Wavelength at lower edge of spectral pixel */
double wavelen; /* Central wavelength, in metres */
int lbnd[ NDF__MXDIM ]; /* Original lower pixel bounds of the NDF */
int ndim; /* Original number of pixel axis in the the NDF */
int ubnd[ NDF__MXDIM ]; /* Original lower pixel bounds of the NDF */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST Object context so that we do not need to annul explicitly
the AST Objects created in this function. */
astBegin;
/* Get the pixel bounds of the NDF. */
ndfBound( indf, NDF__MXDIM, lbnd, ubnd, &ndim, status );
/* Get the required FITS header. Return without further action if either
is not present in the supplied FitsChan, or if the NDF is not
2-dimensional. */
if( astGetFitsF( fc, "WAVELEN", &wavelen ) &&
astGetFitsF( fc, "BANDWID", &bandwid ) && ndim == 2 ) {
/* Get the current WCS FrameSet from the supplied NDF, and get a pointer
to its current Frame. */
ndfGtwcs( indf, &wcs, status );
cfrm = astGetFrame( wcs, AST__CURRENT );
/* Return without action if this is not a SkyFrame. */
if( astIsASkyFrame( cfrm ) ) {
/* Construct a topocentric wavelength SpecFrame to describe the new spectral
WCS axis. */
specfrm = astSpecFrame( "System=wavelen,StdOfRest=topo,Unit=m" );
/* We set the RefRA and RefDec attributes for the SpecFrame to the FK5
J2000 equivalent of the SkyRef attribute in the current Frame. */
sprintf( attrib, "SkyRef(%d)", astGetI( cfrm, "LonAxis" ) );
ref_lon = astGetD( cfrm, attrib );
sprintf( attrib, "SkyRef(%d)", astGetI( cfrm, "LatAxis" ) );
ref_lat = astGetD( cfrm, attrib );
astSetRefPos( specfrm, cfrm, ref_lon, ref_lat );
/* Inherit other relevant Frame attributes from the SkyFrame. */
#define OVERLAY(attr) \
if( astTest( cfrm, attr ) ) { \
astSetC( specfrm, attr, astGetC( cfrm, attr ) ); \
}
OVERLAY( "Dut1" );
OVERLAY( "Epoch" );
OVERLAY( "ObsAlt" );
OVERLAY( "ObsLat" );
OVERLAY( "ObsLon" );
#undef OVERLAY
/* Create a WinMap that gives wavelength as a function of spectral GRID
position. Assume the pixel centre maps onto WAVELEN and the pixel
width is BANDWID. */
grid_lo= 0.5;
grid_hi = 1.5;
spec_lo = wavelen - 0.5*bandwid;
spec_hi = spec_lo + bandwid;
specmap = astWinMap( 1, &grid_lo, &grid_hi, &spec_lo, &spec_hi, " " );
/* Modify the WCS FrameSet so that the base and current Frames are
3-dimensional. The current Frame is expanded by adding in the
SpecFrame, and the base Frame is expanded by adding in a 3rd GRID
axis. Other Frames are left unchanged. The SpecFrame and the new GRID
axis are connected using the WinMap created above. */
atlAddWcsAxis( wcs, (AstMapping *) specmap, (AstFrame *) specfrm,
NULL, NULL, status );
/* Change the NDF bounds to include a 3rd axis with pixel bounds "1:1". */
lbnd[ 2 ] = 1;
ubnd[ 2 ] = 1;
ndfSbnd( 3, lbnd, ubnd, indf, status );
/* Store the modified WCS FrameSet in the NDF. */
ndfPtwcs( wcs, indf, status );
}
}
/* End the AST Object context. This will annull annull the AST Objects
created in this function. */
astEnd;
}
void smf_getrefwcs( const char *param, Grp *igrp, AstFrameSet **specwcs,
AstFrameSet **spacewcs, int *isjsa, int *status ){
/* Local Variables */
AstFrame *frm = NULL;
AstFrameSet *refwcs = NULL; /* The WCS FrameSet from the reference NDF */
AstRegion *circle;
char text[ 255 ]; /* Parameter value */
int *tiles;
int i;
int jsatiles;
int lbnd[2]; /* Lower pixel index bounds of mid tile */
int ntile;
int perm[ 2 ];
int refndf; /* NDF identifier for the refence NDF */
int ubnd[2]; /* Upper pixel index bounds of mid tile */
size_t code;
smfData *data = NULL; /* Structure describing 1st input file */
smfJSATiling skytiling;
smf_inst_t inst = SMF__INST_NONE;
smf_jsaproj_t proj; /* Specific JSA projection to use */
smf_subinst_t subinst;
/* Initialise the returned values. */
*specwcs = NULL;
*spacewcs = NULL;
*isjsa = 0;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context. */
astBegin;
/* If the JSAILES parameter is TRUE, then we use the JSA all-sky pixel
grid regardless of the setting of REF. */
parGet0l( "JSATILES", &jsatiles, status );
if( jsatiles ) {
strcpy( text, "JSA" );
*isjsa = 1;
/* Otherwise, first get the parameter value as a string. Use subpar to avoid problem
caused by interpretion of the text within the parameter system. */
} else {
subParFindpar( param, &code, status );
subParGetname( code, text, sizeof(text), status );
}
/* If no value was supplied, annul the error and do nothing more. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* If it is "JSA", or one of the JSA projection codes, we return WCS that
describes one of the the JSA all-sky pixel grids. */
} else if( *status == SAI__OK ) {
proj = smf_jsaproj_fromstr( text, 0, status );
if( astChrMatch( text, "JSA" ) || proj != SMF__JSA_NULL ) {
*isjsa = 1;
/* Report an error if the instrument cannot be determined. */
if( !igrp ) {
*status = SAI__ERROR;
errRep( "", "smf_getrefwcs: Cannot use the JSA all-sky pixel "
"grid since no input group has been supplied (possibly "
"programming error).", status );
} else {
/* Open the first input file. */
smf_open_file( NULL, igrp, 1, "READ", SMF__NOCREATE_DATA, &data,
status );
if( *status == SAI__OK ) {
/* Get the instrument. */
if( data->hdr->instrument == INST__SCUBA2 ) {
subinst = smf_calc_subinst( data->hdr, status );
if( subinst == SMF__SUBINST_850 ) {
inst = SMF__INST_SCUBA_2_850;
} else {
inst = SMF__INST_SCUBA_2_450;
}
} else if( data->hdr->instrument == INST__ACSIS ) {
inst = SMF__INST_ACSIS;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
if( data->file ) {
smf_smfFile_msg( data->file, "FILE", 1, "one or more of "
"the input data files" );
} else {
msgSetc( "FILE", "one or more of the input data files" );
}
errRep( "", "No tiles are yet defined for the instrument that "
"created ^FILE.", status );
}
/* Get the parameters that define the layout of sky tiles for the
instrument. */
smf_jsatiling( inst, &skytiling, status );
/* For "JSA" - choose the best projection. */
if( astChrMatch( text, "JSA" ) ) {
/* Use the FITS headers in the first raw data file to create an AST Circle
describing the approximate area of the observation within the tracking
system. */
circle = smf_mapregion_approx( igrp, status );
/* Convert the circle to ICRS (as used by the JSA all-sky grid). */
astSetC( circle, "System", "ICRS" );
/* Get a list of the tiles that touch this circle. */
tiles = smf_jsatiles_region( circle, &skytiling,
&ntile, status );
/* Choose the best projection (i.e. the projection that puts the circle
furthest away from any singularities). */
proj = smf_jsaproj( ntile, tiles, &skytiling, status);
/* Free resources. */
tiles = astFree( tiles );
circle = astAnnul( circle );
/* If a good projection was specified, use it. Otherwise report an error. */
} else if( proj == SMF__JSA_NULL && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "Bad value '%s' supplied for parameter %s.",
status, text, param );
}
/* Report the projection type. */
msgOutf( " ", "The %s will be created on the JSA %s "
"pixel grid.", status,
(data->hdr->instrument==INST__ACSIS)?"cube":"map",
smf_jsaproj_tostr( proj ) );
/* All tiles within the same JSA projection use the same WCS, so we get
the WCS FrameSet for an arbitrary central tile, and use it for the
full map. The exception is that tiles within the HPX facet that is
split between bottom-left and top-right, use a different WCS (they
have different reference points). But our choice of projection should
mean that the map never falls in that facet. The base Frame will be
GRID coords within the tile, and the current Frame will be ICRS
(RA,Dec). */
smf_jsatile( ((skytiling.ntpf * skytiling.ntpf - 1) * 2) / 3,
&skytiling, 0, proj, NULL, spacewcs, NULL, lbnd,
ubnd, status );
/* Change the base Frame to be PIXEL. */
for( i = 1; i <= astGetI( *spacewcs, "NFrame" ); i++ ) {
frm = astGetFrame( *spacewcs, i );
if( astChrMatch( astGetC( frm, "Domain" ), "PIXEL" ) ) {
astSetI( *spacewcs, "Base", i );
}
frm = astAnnul( frm );
}
}
/* Close the current input data file. */
smf_close_file( NULL, &data, status);
}
/* Otherwise get the parameter value as an NDF. */
} else {
ndfAssoc( param, "READ", &refndf, status );
/* Get the WCS FrameSet from the reference NDF. */
ndfGtwcs( refndf, &refwcs, status );
/* Attempt to extract a new FrameSet from this WCS FrameSet, in which the
current Frame is a SkyFrame, and the base Frame is a 2D PIXEL Frame.
Since the NDF library sets the GRID Frame to be the Base Frame, we need
to make the PIXEL Frame the base Frame first. The NDF library ensures
that the pixel Frame is Frame 2. */
astSetI( refwcs, "Base", 2 );
*spacewcs = atlFrameSetSplit( refwcs, "SKY", NULL, NULL, status );
if( !(*spacewcs) ) {
if( *status == SAI__OK ) {
ndfMsg( "N", refndf );
*status = SAI__ERROR;
errRep( "", "The supplied reference NDF (^N) either has no "
"celestial WCS axes, or the celestial axes cannot "
"be separated from the non-celestial axes.", status );
}
/* The rest of makemap assumes that the sky frame axes are in the default
order (lon,lat). If this is not the case, permute them. */
} else if( astGetI( *spacewcs, "IsLatAxis(1)" ) ) {
perm[ 0 ] = 2;
perm[ 1 ] = 1;
astPermAxes( *spacewcs, perm );
}
/* Now look for the spectral WCS (described by a DSBSpecFrame). */
smf_getspectralwcs( refwcs, 1, specwcs, status );
/* We no longer need the NDF so annul it. */
ndfAnnul( &refndf, status );
}
}
/* If no error has occurred, export any returned FrameSet pointers 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 ) {
if( *spacewcs ) astExport( *spacewcs );
if( *specwcs ) astExport( *specwcs );
} else {
if( *spacewcs ) *spacewcs = astAnnul( *spacewcs );
if( *specwcs ) *specwcs = astAnnul( *specwcs );
}
/* End the AST context. This will annul all AST objects created within the
context (except for those that have been exported from the context). */
astEnd;
}
