diff options
author | William Joye <wjoye@cfa.harvard.edu> | 2018-01-09 19:26:44 (GMT) |
---|---|---|
committer | William Joye <wjoye@cfa.harvard.edu> | 2018-01-09 19:26:44 (GMT) |
commit | 1332d38f2805d986ea130e43218c0d2e870b4dc1 (patch) | |
tree | aa72853cb8d0d8fcd53a6f5eddf196a374226706 /ast/winmap.c | |
parent | 5e545ec8058cc5238dc870468b34b5d4617f307f (diff) | |
download | blt-1332d38f2805d986ea130e43218c0d2e870b4dc1.zip blt-1332d38f2805d986ea130e43218c0d2e870b4dc1.tar.gz blt-1332d38f2805d986ea130e43218c0d2e870b4dc1.tar.bz2 |
update ast 8.6.2
Diffstat (limited to 'ast/winmap.c')
-rw-r--r-- | ast/winmap.c | 4389 |
1 files changed, 0 insertions, 4389 deletions
diff --git a/ast/winmap.c b/ast/winmap.c deleted file mode 100644 index 5ba97d5..0000000 --- a/ast/winmap.c +++ /dev/null @@ -1,4389 +0,0 @@ -/* -*class++ -* Name: -* WinMap - -* Purpose: -* Map one window on to another by scaling and shifting each axis. - -* Constructor Function: -c astWinMap -f AST_WINMAP - -* Description: -* A Winmap is a linear Mapping which transforms a rectangular -* window in one coordinate system into a similar window in another -* coordinate system by scaling and shifting each axis (the window -* edges being parallel to the coordinate axes). -* -* A WinMap is specified by giving the coordinates of two opposite -* corners (A and B) of the window in both the input and output -* coordinate systems. - -* Inheritance: -* The WinMap class inherits from the Mapping class. - -* Attributes: -* The WinMap class does not define any new attributes beyond those -* which are applicable to all Mappings. - -* Functions: -c The WinMap class does not define any new functions beyond those -f The WinMap class does not define any new routines beyond those -* which are applicable to all Mappings. - -* Copyright: -* Copyright (C) 1997-2006 Council for the Central Laboratory of the -* Research Councils - -* Licence: -* This program is free software: you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public -* License as published by the Free Software Foundation, either -* version 3 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 Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General -* License along with this program. If not, see -* <http://www.gnu.org/licenses/>. - -* Authors: -* DSB: David Berry (Starlink) -* RFWS: R.F. Warren-Smith (Starlink) - -* History: -* 23-OCT-1996 (DSB): -* Original version. -* 4-MAR-1997 (RFWS): -* Tidied public prologues. -* 11-MAR-1997 (DSB): -* Added MapMerge method and associated bits. -* 30-JUN-1997 (DSB): -* Bug fixed which caused the MapMerge method to generate a -* segmentation violation. -* 24-MAR-1998 (RFWS): -* Improved output format from Dump. -* 9-APR-1998 (DSB): -* MapMerge modified to allow merging of WinMaps with ZoomMaps and -* and UnitMaps in parallel. -* 4-SEP-1998 (DSB): -* Improved MapMerge so that WinMaps can change places with a wider -* range of PermMaps, allowing them to approach closer to a Mapping -* with which they can merge. -* 22-FEB-1999 (DSB): -* Corrected logic of MapMerge method to avoid infinite looping. -* 5-MAY-1999 (DSB): -* More corrections to MapMerge: Cleared up errors in the use of the -* supplied invert flags, and corrected logic for deciding which -* neighbouring Mapping to swap with. -* 16-JUL-1999 (DSB): -* Fixed memory leaks in WinMat and MapMerge. -* 8-JAN-2003 (DSB): -* Changed private InitVtab method to protected astInitWinMapVtab -* method. -* 8-SEP-2003 (DSB): -* Allow WinMaps to swap with WcsMaps if possible. -* 10-NOV-2003 (DSB): -* Modified functions which swap a WinMap with another Mapping -* (e.g. WinPerm, etc), to simplify the returned Mappings. -* 23-APR-2004 (DSB): -* Changes to simplification algorithm. -* 1-SEP-2004 (DSB): -* Ensure do1 and do2 are initialised before use in MapMerge. -* 7-SEP-2005 (DSB): -* Take account of the Invert flag when using the soom factor from -* a ZoomMap. -* 14-FEB-2006 (DSB): -* Override astGetObjSize. -* 15-MAR-2006 (DSB): -* Override astEqual. -* 23-AUG-2006 (DSB): -* Correct initialisation of "result" in the Equal function. -* 19-JAN-2007 (DSB): -* Fix memory leak. -* 3-MAY-2013 (DSB): -* Improve simplification by adding check for inverse pairs of -* WinMaps in function WinWin. -* 23-APR-2015 (DSB): -* Improve MapMerge. If a WinMap can merge with its next-but-one -* neighbour, then swap the WinMap with its neighbour, so that -* it is then next its next-but-one neighbour, and then merge the -* two Mappings into a single Mapping. Previously, only the swap -* was performed - not the merger. And the swap was only performed -* if the intervening neighbour could not itself merge. This could -* result in an infinite simplification loop, which was detected by -* CmpMap and and aborted, resulting in no useful simplification. -*class-- -*/ - -/* Module Macros. */ -/* ============== */ -/* Set the name of the class we are implementing. This indicates to - the header files that define class interfaces that they should make - "protected" symbols available. */ -#define astCLASS WinMap - -/* Include files. */ -/* ============== */ -/* Interface definitions. */ -/* ---------------------- */ - -#include "globals.h" /* Thread-safe global data access */ -#include "error.h" /* Error reporting facilities */ -#include "memory.h" /* Memory management facilities */ -#include "object.h" /* Base Object class */ -#include "pointset.h" /* Sets of points/coordinates */ -#include "matrixmap.h" /* Linear mappings */ -#include "unitmap.h" /* Unit mappings */ -#include "zoommap.h" /* Zoom mappings */ -#include "permmap.h" /* Axis permutations */ -#include "cmpmap.h" /* Compound mappings */ -#include "wcsmap.h" /* Celestial projections */ -#include "mapping.h" /* Coordinate mappings (parent class) */ -#include "channel.h" /* I/O channels */ -#include "winmap.h" /* Interface definition for this class */ - -/* Error code definitions. */ -/* ----------------------- */ -#include "ast_err.h" /* AST error codes */ - -/* C header files. */ -/* --------------- */ -#include <float.h> -#include <math.h> -#include <stdarg.h> -#include <stddef.h> -#include <stdio.h> -#include <string.h> - -/* Module Variables. */ -/* ================= */ - -/* Address of this static variable is used as a unique identifier for - member of this class. */ -static int class_check; - -/* Pointers to parent class methods which are extended by this class. */ -static int (* parent_getobjsize)( AstObject *, int * ); -static AstPointSet *(* parent_transform)( AstMapping *, AstPointSet *, int, AstPointSet *, int * ); -static const char *(* parent_getattrib)( AstObject *, const char *, int * ); -static int (* parent_testattrib)( AstObject *, const char *, int * ); -static void (* parent_clearattrib)( AstObject *, const char *, int * ); -static void (* parent_setattrib)( AstObject *, const char *, int * ); - - -#ifdef THREAD_SAFE -/* Define how to initialise thread-specific globals. */ -#define GLOBAL_inits \ - globals->Class_Init = 0; - -/* Create the function that initialises global data for this module. */ -astMAKE_INITGLOBALS(WinMap) - -/* Define macros for accessing each item of thread specific global data. */ -#define class_init astGLOBAL(WinMap,Class_Init) -#define class_vtab astGLOBAL(WinMap,Class_Vtab) - - -#include <pthread.h> - - -#else - - -/* Define the class virtual function table and its initialisation flag - as static variables. */ -static AstWinMapVtab class_vtab; /* Virtual function table */ -static int class_init = 0; /* Virtual function table initialised? */ - -#endif - -/* External Interface Function Prototypes. */ -/* ======================================= */ -/* The following functions have public prototypes only (i.e. no - protected prototypes), so we must provide local prototypes for use - within this module. */ -AstWinMap *astWinMapId_( int, const double [], const double [], - const double [], const double [], const char *, ... ); - -/* Prototypes for Private Member Functions. */ -/* ======================================== */ - -static AstPointSet *Transform( AstMapping *, AstPointSet *, int, AstPointSet *, int * ); -static AstWinMap *WinUnit( AstWinMap *, AstUnitMap *, int, int, int * ); -static AstWinMap *WinWin( AstMapping *, AstMapping *, int, int, int, int * ); -static AstWinMap *WinZoom( AstWinMap *, AstZoomMap *, int, int, int, int, int * ); -static int GetObjSize( AstObject *, int * ); -static const char *GetAttrib( AstObject *, const char *, int * ); -static double Rate( AstMapping *, double *, int, int, int * ); -static int CanSwap( AstMapping *, AstMapping *, int, int, int *, int * ); -static int Equal( AstObject *, AstObject *, int * ); -static int GetIsLinear( AstMapping *, int * ); -static int MapMerge( AstMapping *, int, int, int *, AstMapping ***, int **, int * ); -static int TestAttrib( AstObject *, const char *, int * ); -static int WinTerms( AstWinMap *, double **, double **, int * ); -static void ClearAttrib( AstObject *, const char *, int * ); -static void Copy( const AstObject *, AstObject *, int * ); -static void Delete( AstObject *, int * ); -static void Dump( AstObject *, AstChannel *, int * ); -static void PermGet( AstPermMap *, int **, int **, double **, int * ); -static void SetAttrib( AstObject *, const char *, int * ); -static void WinMat( AstMapping **, int *, int, int * ); -static void WinPerm( AstMapping **, int *, int, int * ); -static void WinWcs( AstMapping **, int *, int, int * ); -static int *MapSplit( AstMapping *, int, const int *, AstMapping **, int * ); - -/* Member functions. */ -/* ================= */ -static int CanSwap( AstMapping *map1, AstMapping *map2, int inv1, int inv2, - int *simpler, int *status ){ -/* -* Name: -* CanSwap - -* Purpose: -* Determine if two Mappings could be swapped. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* int CanSwap( AstMapping *map1, AstMapping *map2, int inv1, int inv2, -* int *simpler, int *status ) - -* Class Membership: -* WinMap member function - -* Description: -* This function returns a flag indicating if the pair of supplied -* Mappings could be replaced by an equivalent pair of Mappings from the -* same classes as the supplied pair, but in reversed order. Each pair -* of Mappings is considered to be compunded in series. The supplied -* Mapings are not changed in any way. - -* Parameters: -* map1 -* The Mapping to be applied first. -* map2 -* The Mapping to be applied second. -* inv1 -* The invert flag to use with map1. A value of zero causes the forward -* mapping to be used, and a non-zero value causes the inverse -* mapping to be used. -* inv2 -* The invert flag to use with map2. -* simpler -* Addresss of a location at which to return a flag indicating if -* the swapped Mappings would be intrinsically simpler than the -* original Mappings. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* 1 if the Mappings could be swapped, 0 otherwise. - -* Notes: -* - One of the supplied pair of Mappings must be a WinMap. -* - A value of 0 is returned if the two Mappings could be merged into -* a single Mapping. -* - A value of 0 is returned if an error has already occurred, or if -* this function should fail for any reason. -*/ - -/* Local Variables: */ - AstMapping *nowin; /* Pointer to non-WinMap Mapping */ - AstWinMap *win; /* Pointer to the WinMap */ - const char *class1; /* Pointer to map1 class string */ - const char *class2; /* Pointer to map2 class string */ - const char *nowin_class; /* Pointer to non-WinMap class string */ - double *consts; /* Pointer to constants array */ - int *inperm; /* Pointer to input axis permutation array */ - int *outperm; /* Pointer to output axis permutation array */ - int axlat; /* Latitude axis in WcsMap */ - int axlon; /* Longitude axis in WcsMap */ - int i; /* Loop count */ - int invert[ 2 ]; /* Original invert flags */ - int nin; /* No. of input coordinates for the PermMap */ - int nout; /* No. of output coordinates for the PermMap */ - int ret; /* Returned flag */ - -/* Check the global error status. */ - if ( !astOK ) return 0; - -/* Initialise */ - ret = 0; - *simpler = 0; - -/* Temporarily set the Invert attributes of both Mappings to the supplied - values. */ - invert[ 0 ] = astGetInvert( map1 ); - astSetInvert( map1, inv1 ); - - invert[ 1 ] = astGetInvert( map2 ); - astSetInvert( map2, inv2 ); - -/* Get the classes of the two mappings. */ - class1 = astGetClass( map1 ); - class2 = astGetClass( map2 ); - if( astOK ){ - -/* Get a pointer to the non-WinMap Mapping. */ - if( !strcmp( class1, "WinMap" ) ){ - nowin = map2; - nowin_class = class2; - win = (AstWinMap *) map1; - } else { - nowin = map1; - nowin_class = class1; - win = (AstWinMap *) map2; - } - -/* If it is a MatrixMap, the Mappings can be swapped. */ - if( !strcmp( nowin_class, "MatrixMap" ) ){ - ret = 1; - -/* If it is a WcsMap, the Mappings can be swapped if the WinMap is - equivalent to a unit transformation on the celestial axes of the - WcsMap. */ - } else if( !strcmp( nowin_class, "WcsMap" ) ){ - -/* Get the indices of the celestial coordinates inthe WcsMap. */ - axlat = astGetWcsAxis( (AstWcsMap *) nowin, 1 ); - axlon = astGetWcsAxis( (AstWcsMap *) nowin, 0 ); - -/* Check the shift and scale for these axes. */ - ret = ( win->a[ axlon ] == 0.0 && win->b[ axlon ] == 1.0 && - win->a[ axlat ] == 0.0 && win->b[ axlat ] == 1.0 ); - -/* If it is a PermMap, the Mappings can be swapped so long as all links - between input and output axes in the PermMap are bi-directional. This - does not preclude the existence of unconnected axes, which do not - have links (bi-directional or otherwise). */ - } else if( !strcmp( nowin_class, "PermMap" ) ){ - -/* Get the number of input and output coordinates. */ - nin = astGetNin( nowin ); - nout = astGetNout( nowin ); - -/* We need to know the axis permutation arrays and constants array for - the PermMap. */ - PermGet( (AstPermMap *) nowin, &outperm, &inperm, &consts, status ); - if( astOK ) { - -/* Indicate we can swap with the PermMap. */ - ret = 1; - -/* Check each output axis. If any links between axes are found which are - not bi-directional, indicate that we cannot swap with the PermMap. */ - for( i = 0; i < nout; i++ ){ - if( outperm[ i ] >= 0 && outperm[ i ] < nin ) { - if( inperm[ outperm[ i ] ] != i ) { - ret = 0; - break; - } - } - } - -/* Check each input axis. If any links between axes are found which are - not bi-directional, indicate that we cannot swap with the PermMap. */ - for( i = 0; i < nin; i++ ){ - if( inperm[ i ] >= 0 && inperm[ i ] < nout ) { - if( outperm[ inperm[ i ] ] != i ) { - ret = 0; - break; - } - } - } - -/* If we can swap with the PermMap, the swapped Mappings may be - intrinsically simpler than the original mappings. */ - if( ret ) { - -/* If the PermMap precedes the WinMap, this will be the case if the PermMap - has more outputs than inputs. If the WinMap precedes the PermMap, this - will be the case if the PermMap has more inputs than outputs. */ - *simpler = ( nowin == map1 ) ? nout > nin : nin > nout; - } - -/* Free the axis permutation and constants arrays. */ - outperm = (int *) astFree( (void *) outperm ); - inperm = (int *) astFree( (void *) inperm ); - consts = (double *) astFree( (void *) consts ); - } - } - } - -/* Re-instate the original settings of the Invert attributes for the - supplied MatrixMaps. */ - astSetInvert( map1, invert[ 0 ] ); - astSetInvert( map2, invert[ 1 ] ); - -/* Return the answer. */ - return astOK ? ret : 0; -} - -static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) { -/* -* Name: -* ClearAttrib - -* Purpose: -* Clear an attribute value for a WinMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* void ClearAttrib( AstObject *this, const char *attrib, int *status ) - -* Class Membership: -* WinMap member function (over-rides the astClearAttrib protected -* method inherited from the Mapping class). - -* Description: -* This function clears the value of a specified attribute for a -* WinMap, so that the default value will subsequently be used. - -* Parameters: -* this -* Pointer to the WinMap. -* attrib -* Pointer to a null-terminated string specifying the attribute -* name. This should be in lower case with no surrounding white -* space. -* status -* Pointer to the inherited status variable. -*/ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* At the moment the WinMap class has no attributes, so pass it on to the - parent method for further interpretation. */ - (*parent_clearattrib)( this_object, attrib, status ); - -} - -static int Equal( AstObject *this_object, AstObject *that_object, int *status ) { -/* -* Name: -* Equal - -* Purpose: -* Test if two WinMaps are equivalent. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* int Equal( AstObject *this, AstObject *that, int *status ) - -* Class Membership: -* WinMap member function (over-rides the astEqual protected -* method inherited from the astMapping class). - -* Description: -* This function returns a boolean result (0 or 1) to indicate whether -* two WinMaps are equivalent. - -* Parameters: -* this -* Pointer to the first Object (a WinMap). -* that -* Pointer to the second Object. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* One if the WinMaps are equivalent, zero otherwise. - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstWinMap *that; - AstWinMap *this; - double *a_that; - double *a_this; - double *b_that; - double *b_this; - int i; - int nin; - int result; - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain pointers to the two WinMap structures. */ - this = (AstWinMap *) this_object; - that = (AstWinMap *) that_object; - -/* Check the second object is a WinMap. We know the first is a - WinMap since we have arrived at this implementation of the virtual - function. */ - if( astIsAWinMap( that ) ) { - -/* Get the number of inputs and outputs and check they are the same for both. */ - nin = astGetNin( this ); - if( astGetNin( that ) == nin ) { - -/* Assume the WinMaps are equivalent. */ - result = 1; - -/* Compare the shift and scale terms from both WinMaps ignoring the - setting of the Invert flag for the moment. */ - for( i = 0; i < nin; i++ ) { - if( !astEQUAL( this->a[ i ], that->a[ i ] ) || - !astEQUAL( this->b[ i ], that->b[ i ] ) ) { - result = 0; - break; - } - } - -/* If the scale and shifts are equal, check the Invert flags are equal. */ - if( result ) { - result= ( astGetInvert( this ) == astGetInvert( that ) ); - -/* If the scale and shifts differ, there is still a chance that the - WinMaps may be equivalent if their Invert flags differ. */ - } else if( astGetInvert( this ) != astGetInvert( that ) ) { - -/* Create copies of the scale and shift terms from the two WinMaps, taking - into account the setting of the Invert attribute. Finding the inverted - terms involves arithmetic which introduces rounding errors, so this - test is not as reliable as the above direct comparison of terms. */ - astWinTerms( this, &a_this, &b_this ); - astWinTerms( that, &a_that, &b_that ); - result = 1; - - for( i = 0; i < nin; i++ ) { - if( !astEQUAL( a_this[ i ], a_that[ i ] ) || - !astEQUAL( b_this[ i ], b_that[ i ] ) ) { - result = 0; - break; - } - } - -/* Free resources */ - a_this = astFree( a_this ); - a_that = astFree( a_that ); - b_this = astFree( b_this ); - b_that = astFree( b_that ); - } - } - } - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = 0; - -/* Return the result, */ - return result; -} - -static int GetIsLinear( AstMapping *this_mapping, int *status ){ -/* -* Name: -* GetIsLinear - -* Purpose: -* Return the value of the IsLinear attribute for a WinMap. - -* Type: -* Private function. - -* Synopsis: -* #include "mapping.h" -* void GetIsLinear( AstMapping *this, int *status ) - -* Class Membership: -* WinMap member function (over-rides the protected astGetIsLinear -* method inherited from the Mapping class). - -* Description: -* This function returns the value of the IsLinear attribute for a -* Frame, which is always one. - -* Parameters: -* this -* Pointer to the WinMap. -* status -* Pointer to the inherited status variable. -*/ - return 1; -} - -static int GetObjSize( AstObject *this_object, int *status ) { -/* -* Name: -* GetObjSize - -* Purpose: -* Return the in-memory size of an Object. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* int GetObjSize( AstObject *this, int *status ) - -* Class Membership: -* WinMap member function (over-rides the astGetObjSize protected -* method inherited from the parent class). - -* Description: -* This function returns the in-memory size of the supplied WinMap, -* in bytes. - -* Parameters: -* this -* Pointer to the WinMap. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The Object size, in bytes. - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstWinMap *this; /* Pointer to WinMap structure */ - int result; /* Result value to return */ - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointers to the WinMap structure. */ - this = (AstWinMap *) this_object; - -/* Invoke the GetObjSize method inherited from the parent class, and then - add on any components of the class structure defined by thsi class - which are stored in dynamically allocated memory. */ - result = (*parent_getobjsize)( this_object, status ); - result += astTSizeOf( this->a ); - result += astTSizeOf( this->b ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = 0; - -/* Return the result, */ - return result; -} - -static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) { -/* -* Name: -* GetAttrib - -* Purpose: -* Get the value of a specified attribute for a WinMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* const char *GetAttrib( AstObject *this, const char *attrib, int *status ) - -* Class Membership: -* WinMap member function (over-rides the protected astGetAttrib -* method inherited from the Mapping class). - -* Description: -* This function returns a pointer to the value of a specified -* attribute for a WinMap, formatted as a character string. - -* Parameters: -* this -* Pointer to the WinMap. -* attrib -* Pointer to a null-terminated string containing the name of -* the attribute whose value is required. This name should be in -* lower case, with all white space removed. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* - Pointer to a null-terminated string containing the attribute -* value. - -* Notes: -* - The returned string pointer may point at memory allocated -* within the WinMap, or at static memory. The contents of the -* string may be over-written or the pointer may become invalid -* following a further invocation of the same function or any -* modification of the WinMap. A copy of the string should -* therefore be made if necessary. -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Constants: */ -#define BUFF_LEN 50 /* Max. characters in result buffer */ - -/* Local Variables: */ - const char *result; /* Pointer value to return */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* At the moment the WinMap class has no attributes, so pass it on to the - parent method for further interpretation. */ - result = (*parent_getattrib)( this_object, attrib, status ); - -/* Return the result. */ - return result; - -/* Undefine macros local to this function. */ -#undef BUFF_LEN -} - -void astInitWinMapVtab_( AstWinMapVtab *vtab, const char *name, int *status ) { -/* -*+ -* Name: -* astInitWinMapVtab - -* Purpose: -* Initialise a virtual function table for a WinMap. - -* Type: -* Protected function. - -* Synopsis: -* #include "winmap.h" -* void astInitWinMapVtab( AstWinMapVtab *vtab, const char *name ) - -* Class Membership: -* WinMap vtab initialiser. - -* Description: -* This function initialises the component of a virtual function -* table which is used by the WinMap class. - -* Parameters: -* vtab -* Pointer to the virtual function table. The components used by -* all ancestral classes will be initialised if they have not already -* been initialised. -* name -* Pointer to a constant null-terminated character string which contains -* the name of the class to which the virtual function table belongs (it -* is this pointer value that will subsequently be returned by the Object -* astClass function). -*- -*/ - -/* Local Variables: */ - astDECLARE_GLOBALS /* Pointer to thread-specific global data */ - AstObjectVtab *object; /* Pointer to Object component of Vtab */ - AstMappingVtab *mapping; /* Pointer to Mapping component of Vtab */ - -/* Check the local error status. */ - if ( !astOK ) return; - -/* Get a pointer to the thread specific global data structure. */ - astGET_GLOBALS(NULL); - -/* Initialize the component of the virtual function table used by the - parent class. */ - astInitMappingVtab( (AstMappingVtab *) vtab, name ); - -/* Store a unique "magic" value in the virtual function table. This - will be used (by astIsAWinMap) to determine if an object belongs - to this class. We can conveniently use the address of the (static) - class_check variable to generate this unique value. */ - vtab->id.check = &class_check; - vtab->id.parent = &(((AstMappingVtab *) vtab)->id); - -/* Initialise member function pointers. */ -/* ------------------------------------ */ -/* Store pointers to the member functions (implemented here) that provide - virtual methods for this class. */ - vtab->WinTerms = WinTerms; - -/* Save the inherited pointers to methods that will be extended, and - replace them with pointers to the new member functions. */ - object = (AstObjectVtab *) vtab; - mapping = (AstMappingVtab *) vtab; - parent_getobjsize = object->GetObjSize; - object->GetObjSize = GetObjSize; - - parent_clearattrib = object->ClearAttrib; - object->ClearAttrib = ClearAttrib; - parent_getattrib = object->GetAttrib; - object->GetAttrib = GetAttrib; - parent_setattrib = object->SetAttrib; - object->SetAttrib = SetAttrib; - parent_testattrib = object->TestAttrib; - object->TestAttrib = TestAttrib; - - parent_transform = mapping->Transform; - mapping->Transform = Transform; - -/* Store replacement pointers for methods which will be over-ridden by - new member functions implemented here. */ - object->Equal = Equal; - mapping->MapMerge = MapMerge; - mapping->MapSplit = MapSplit; - mapping->Rate = Rate; - mapping->GetIsLinear = GetIsLinear; - -/* Declare the class dump, copy and delete functions.*/ - astSetDump( vtab, Dump, "WinMap", "Map one window on to another" ); - astSetCopy( (AstObjectVtab *) vtab, Copy ); - astSetDelete( (AstObjectVtab *) vtab, Delete ); - -/* If we have just initialised the vtab for the current class, indicate - that the vtab is now initialised, and store a pointer to the class - identifier in the base "object" level of the vtab. */ - if( vtab == &class_vtab ) { - class_init = 1; - astSetVtabClassIdentifier( vtab, &(vtab->id) ); - } -} - -static int MapMerge( AstMapping *this, int where, int series, int *nmap, - AstMapping ***map_list, int **invert_list, int *status ) { -/* -* Name: -* MapMerge - -* Purpose: -* Simplify a sequence of Mappings containing a WinMap. - -* Type: -* Private function. - -* Synopsis: -* #include "mapping.h" -* int MapMerge( AstMapping *this, int where, int series, int *nmap, -* AstMapping ***map_list, int **invert_list, int *status ) - -* Class Membership: -* WinMap method (over-rides the protected astMapMerge method -* inherited from the Mapping class). - -* Description: -* This function attempts to simplify a sequence of Mappings by -* merging a nominated WinMap in the sequence with its neighbours, -* so as to shorten the sequence if possible. -* -* In many cases, simplification will not be possible and the -* function will return -1 to indicate this, without further -* action. -* -* In most cases of interest, however, this function will either -* attempt to replace the nominated WinMap with a Mapping which it -* considers simpler, or to merge it with the Mappings which -* immediately precede it or follow it in the sequence (both will -* normally be considered). This is sufficient to ensure the -* eventual simplification of most Mapping sequences by repeated -* application of this function. -* -* In some cases, the function may attempt more elaborate -* simplification, involving any number of other Mappings in the -* sequence. It is not restricted in the type or scope of -* simplification it may perform, but will normally only attempt -* elaborate simplification in cases where a more straightforward -* approach is not adequate. - -* Parameters: -* this -* Pointer to the nominated WinMap which is to be merged with -* its neighbours. This should be a cloned copy of the WinMap -* pointer contained in the array element "(*map_list)[where]" -* (see below). This pointer will not be annulled, and the -* WinMap it identifies will not be modified by this function. -* where -* Index in the "*map_list" array (below) at which the pointer -* to the nominated WinMap resides. -* series -* A non-zero value indicates that the sequence of Mappings to -* be simplified will be applied in series (i.e. one after the -* other), whereas a zero value indicates that they will be -* applied in parallel (i.e. on successive sub-sets of the -* input/output coordinates). -* nmap -* Address of an int which counts the number of Mappings in the -* sequence. On entry this should be set to the initial number -* of Mappings. On exit it will be updated to record the number -* of Mappings remaining after simplification. -* map_list -* Address of a pointer to a dynamically allocated array of -* Mapping pointers (produced, for example, by the astMapList -* method) which identifies the sequence of Mappings. On entry, -* the initial sequence of Mappings to be simplified should be -* supplied. -* -* On exit, the contents of this array will be modified to -* reflect any simplification carried out. Any form of -* simplification may be performed. This may involve any of: (a) -* removing Mappings by annulling any of the pointers supplied, -* (b) replacing them with pointers to new Mappings, (c) -* inserting additional Mappings and (d) changing their order. -* -* The intention is to reduce the number of Mappings in the -* sequence, if possible, and any reduction will be reflected in -* the value of "*nmap" returned. However, simplifications which -* do not reduce the length of the sequence (but improve its -* execution time, for example) may also be performed, and the -* sequence might conceivably increase in length (but normally -* only in order to split up a Mapping into pieces that can be -* more easily merged with their neighbours on subsequent -* invocations of this function). -* -* If Mappings are removed from the sequence, any gaps that -* remain will be closed up, by moving subsequent Mapping -* pointers along in the array, so that vacated elements occur -* at the end. If the sequence increases in length, the array -* will be extended (and its pointer updated) if necessary to -* accommodate any new elements. -* -* Note that any (or all) of the Mapping pointers supplied in -* this array may be annulled by this function, but the Mappings -* to which they refer are not modified in any way (although -* they may, of course, be deleted if the annulled pointer is -* the final one). -* invert_list -* Address of a pointer to a dynamically allocated array which, -* on entry, should contain values to be assigned to the Invert -* attributes of the Mappings identified in the "*map_list" -* array before they are applied (this array might have been -* produced, for example, by the astMapList method). These -* values will be used by this function instead of the actual -* Invert attributes of the Mappings supplied, which are -* ignored. -* -* On exit, the contents of this array will be updated to -* correspond with the possibly modified contents of the -* "*map_list" array. If the Mapping sequence increases in -* length, the "*invert_list" array will be extended (and its -* pointer updated) if necessary to accommodate any new -* elements. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* If simplification was possible, the function returns the index -* in the "map_list" array of the first element which was -* modified. Otherwise, it returns -1 (and makes no changes to the -* arrays supplied). - -* Notes: -* - A value of -1 will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstCmpMap *cm; /* Pointer to neighbouring CmpMap */ - AstMapping **maplt; /* New mappings list pointer */ - AstMapping *map2; /* Pointer to replacement Mapping */ - AstMapping *mc[2]; /* Copies of supplied Mappings to swap */ - AstMapping *nc[2]; /* Copies of neighbouring Mappings to merge */ - AstMapping *smc0; /* Simplified Mapping */ - AstMapping *smc1; /* Simplified Mapping */ - AstMapping *simp1; /* Simplified Mapping */ - AstMapping *simp2; /* Simplified Mapping */ - AstMatrixMap *mtr; /* Pointer to replacement MatrixMap */ - AstWinMap *newwm2; /* Second component WinMap */ - AstWinMap *newwm; /* Pointer to replacement WinMap */ - AstWinMap *oldwm; /* Pointer to supplied WinMap */ - const char *class1; /* Pointer to first Mapping class string */ - const char *class2; /* Pointer to second Mapping class string */ - const char *nclass; /* Pointer to neighbouring Mapping class */ - double *a; /* Pointer to zero terms */ - double *b; /* Pointer to scale terms */ - int *invlt; /* New invert flags list pointer */ - int cmlow; /* Is lower neighbour a CmpMap? */ - int diag; /* Is WinMap equivalent to a diagonal matrix? */ - int do1; /* Would a backward swap make a simplification? */ - int do2; /* Would a forward swap make a simplification? */ - int i1; /* Index of first WinMap to merge */ - int i2; /* Index of last WinMap to merge */ - int i; /* Loop counter */ - int ic[2]; /* Copies of supplied invert flags to swap */ - int inc[4]; /* Copies of supplied invert flags to merge */ - int invert; /* Should the inverted Mapping be used? */ - int nin2; /* No. of inputs for second component WinMap */ - int nin; /* Number of coordinates for WinMap */ - int nmapt; /* No. of Mappings in list */ - int nstep1; /* No. of Mappings backwards to next mergable Mapping */ - int nstep2; /* No. of Mappings forward to next mergable Mapping */ - int old_winv; /* original Invert value for supplied WinMap */ - int result; /* Result value to return */ - int ser; /* Are Mappings applied in series? */ - int simpler; /* Is the resulting Mapping simpler than original? */ - int swap; /* Is there an advantage in swapping mappings? */ - int swaphi; /* Can WinMap be swapped with higher neighbour? */ - int swaplo; /* Can WinMap be swapped with lower neighbour? */ - -/* Initialise. */ - result = -1; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Initialise variables to avoid "used of uninitialised variable" - messages from dumb compilers. */ - i1 = 0; - i2 = 0; - -/* Get the number of axes for the WinMap. */ - nin = astGetNin( ( *map_list )[ where ] ); - -/* Get a pointer to the WinMap. */ - oldwm = (AstWinMap *) this; - -/* First of all, see if the WinMap can be replaced by a simpler Mapping, - without reference to the neighbouring Mappings in the list. */ -/* ======================================================================*/ -/* If the shift terms in the WinMap are all zero, the WinMap can be - replaced by a diagonal MatrixMap (which is faster to compute). Check the - shift terms. */ - diag = 1; - newwm = (AstWinMap *) ( *map_list )[ where ]; - for( i = 0; i < nin; i++ ){ - if( !astEQUAL( ( newwm->a )[ i ], 0.0 ) ){ - diag = 0; - break; - } - } - -/* If all the shift terms are zero... */ - if( diag ){ - -/* Temporarily set the Invert attribute of the WinMap to the supplied - value. */ - old_winv = astGetInvert( newwm ); - astSetInvert( newwm, ( *invert_list )[ where ] ); - -/* Get a copy of the scale terms from the WinMap. */ - astWinTerms( newwm, NULL, &b ); - -/* Create a diagonal MatrixMap holding the scale terms. */ - mtr = astMatrixMap( nin, nin, 1, b, "", status ); - -/* Restore the Invert attribute of the supplied WinMap. */ - astSetInvert( newwm, old_winv ); - -/* Free the memory used to hold the scale terms. */ - b = (double *) astFree( (void *) b ); - -/* Annul the WinMap pointer in the list and replace it with the MatrixMap - pointer, and indicate that the forward transformation of the returned - MatrixMap should be used. */ - (void) astAnnul( ( *map_list )[ where ] ); - ( *map_list )[ where ] = (AstMapping *) mtr; - ( *invert_list )[ where ] = 0; - -/* Return the index of the first modified element. */ - result = where; - -/* If the WinMap itself could not be simplified, see if it can be merged - with the Mappings on either side of it in the list. */ - } else { - -/* Store the classes of the neighbouring Mappings in the list. */ - class1 = ( where > 0 ) ? astGetClass( ( *map_list )[ where - 1 ] ) : NULL; - class2 = ( where < *nmap - 1 ) ? astGetClass( ( *map_list )[ where + 1 ] ) : NULL; - -/* In series. */ -/* ========== */ - if ( series ) { - -/* We first look to see if the WinMap can be merged with one of its - neighbours, resulting in a reduction of one in the number of Mappings - in the list. WinMaps can only merge directly with another WinMap, a - ZoomMap, or a UnitMap. */ - if( class1 && ( !strcmp( class1, "WinMap" ) || - !strcmp( class1, "ZoomMap" ) || - !strcmp( class1, "UnitMap" ) ) ){ - nclass = class1; - i1 = where - 1; - i2 = where; - - } else if( class2 && ( !strcmp( class2, "WinMap" ) || - !strcmp( class2, "ZoomMap" ) || - !strcmp( class2, "UnitMap" ) ) ){ - nclass = class2; - i1 = where; - i2 = where + 1; - - } else { - nclass = NULL; - } - -/* If the WinMap can merge with one of its neighbours, create the merged - Mapping. */ - if( nclass ){ - - if( !strcmp( nclass, "WinMap" ) ){ - newwm = WinWin( ( *map_list )[ i1 ], ( *map_list )[ i2 ], - ( *invert_list )[ i1 ], ( *invert_list )[ i2 ], - 1, status ); - invert = 0; - - } else if( !strcmp( nclass, "ZoomMap" ) ){ - if( i1 == where ){ - newwm = WinZoom( (AstWinMap *)( *map_list )[ i1 ], - (AstZoomMap *)( *map_list )[ i2 ], - ( *invert_list )[ i1 ], ( *invert_list )[ i2 ], 1, 1, status ); - } else { - newwm = WinZoom( (AstWinMap *)( *map_list )[ i2 ], - (AstZoomMap *)( *map_list )[ i1 ], - ( *invert_list )[ i2 ], ( *invert_list )[ i1 ], 0, 1, status ); - } - invert = 0; - - } else { - newwm = astClone( ( *map_list )[ where ] ); - invert = ( *invert_list )[ where ]; - } - -/* If succesfull... */ - if( astOK ){ - -/* Annul the first of the two Mappings, and replace it with the merged - WinMap. Also set the invert flag. */ - (void) astAnnul( ( *map_list )[ i1 ] ); - ( *map_list )[ i1 ] = (AstMapping *) newwm; - ( *invert_list )[ i1 ] = invert; - -/* Annul the second of the two Mappings, and shuffle down the rest of the - list to fill the gap. */ - (void) astAnnul( ( *map_list )[ i2 ] ); - for ( i = i2 + 1; i < *nmap; i++ ) { - ( *map_list )[ i - 1 ] = ( *map_list )[ i ]; - ( *invert_list )[ i - 1 ] = ( *invert_list )[ i ]; - } - -/* Clear the vacated element at the end. */ - ( *map_list )[ *nmap - 1 ] = NULL; - ( *invert_list )[ *nmap - 1 ] = 0; - -/* Decrement the Mapping count and return the index of the first - modified element. */ - ( *nmap )--; - result = i1; - - } - -/* If one of the neighbours is a (parallel) CmpMap, we convert the WinMap - into an equivalent parallel CmpMap, and then merge this parallel - CmpMap with the neighbouring parallel CmpMap to create a parallel CmpMap - containing two series CmpMaps. */ - } else if( ( class1 && !strcmp( "CmpMap", class1 ) ) || - ( class2 && !strcmp( "CmpMap", class2 ) ) ) { - -/* Identify the WinMap and the CmpMap. */ - if( class1 && !strcmp( "CmpMap", class1 ) ) { - i1 = where - 1; - i2 = where; - cm = (AstCmpMap *) ( *map_list )[ where - 1 ]; - cmlow = 1; - - } else { - i1 = where; - i2 = where + 1; - cm = (AstCmpMap *) ( *map_list )[ where + 1 ]; - cmlow = 0; - - } - -/* Temporarily set the required Invert attributes in the two Mappings. */ - inc[ 0 ] = astGetInvert( ( *map_list )[ i1 ] ); - astSetInvert( ( *map_list )[ i1 ], ( *invert_list )[ i1 ] ); - - inc[ 1 ] = astGetInvert( ( *map_list )[ i2 ] ); - astSetInvert( ( *map_list )[ i2 ], ( *invert_list )[ i2 ] ); - -/* Now get pointers to the scale and zero terms of the nominated WinMap - (these describe the forward transformation, taking into account the - setting of the Invert flag). */ - (void) astWinTerms( oldwm , &a, &b ); - -/* Get pointers to the two components of the parallel CmpMap. */ - astDecompose( cm, mc, mc + 1, &ser, ic, ic + 1 ); - -/* Check component Mappings are combined in parallel. */ - map2 = NULL; - if( astOK && !ser ) { - -/* Temporarily set the required Invert attributes in the two component - Mappings to the indicated values. */ - inc[ 2 ] = astGetInvert( mc[ 0 ] ); - astSetInvert( mc[ 0 ], ic[ 0 ] ); - - inc[ 3 ] = astGetInvert( mc[ 1 ] ); - astSetInvert( mc[ 1 ], ic[ 1 ] ); - -/* Create the first of two corresponding WinMaps, initially with undefined - corners. These could be combined into a parallel CmpMap which would be - equivalent to the nominated WinMap. The number of inputs for each WinMap - is equal to either the number of outputs or inputs of the corresponding - component of the CmpMap, depending on whether the CmpMap is upper or lower - neighbour. */ - nin = cmlow ? astGetNout( mc[ 0 ] ):astGetNin( mc[ 0 ] ); - newwm = astWinMap( nin, NULL, NULL, NULL, NULL, "", status ); - if( astOK ) { - -/* Store the first "nin" scale and zero terms from the nominated WinMap - in the new WinMap. */ - for( i = 0; i < nin; i++ ) { - (newwm->a)[ i ] = a[ i ]; - (newwm->b)[ i ] = b[ i ]; - } - } - -/* Now create the second WinMap in the same way, which transforms the - remaining outputs of the CmpMap. */ - nin2 = cmlow ? astGetNout( mc[ 1 ] ):astGetNin( mc[ 1 ] ); - newwm2 = astWinMap( nin2, NULL, NULL, NULL, NULL, "", status ); - if( astOK ) { - -/* Store the remaining scale and zero terms from the nominated WinMap - in the new WinMap. */ - for( i = 0; i < nin2; i++ ) { - (newwm2->a)[ i ] = a[ i + nin ]; - (newwm2->b)[ i ] = b[ i + nin ]; - } - } - -/* Combine the two corresponding lower component Mappings into a series - CmpMap, and likewise combine the two corresponding upper component - Mappings into a series CmpMap. */ - if( cmlow ) { - nc[ 0 ] = (AstMapping *) astCmpMap( mc[ 0 ], newwm, 1, "", status ); - nc[ 1 ] = (AstMapping *) astCmpMap( mc[ 1 ], newwm2, 1, "", status ); - } else { - nc[ 0 ] = (AstMapping *) astCmpMap( newwm, mc[ 0 ], 1, "", status ); - nc[ 1 ] = (AstMapping *) astCmpMap( newwm2, mc[ 1 ], 1, "", status ); - } - newwm = astAnnul( newwm ); - newwm2 = astAnnul( newwm2 ); - -/* Attempt to simplify each of the two new series CmpMaps. If neither of - them simplify then there is no point in doing the current merger. In fact - it would be dangerous to do so since we may end up in an infinite loop - where the resulting parallel CmpMap gets converted back into the - existing series CmpMap by the CmpMap MapMerge method, and then back - again by this method, etc. */ - simp1 = astSimplify( nc[ 0 ] ); - simp2 = astSimplify( nc[ 1 ] ); - -/* Test if either could be simplified by checking if its pointer value - has changed. */ - simpler = ( simp1 != nc[ 0 ] ) || ( simp2 != nc[ 1 ] ); - -/* If either CmpMap was simplified, then combine the two series CmpMap into - a single parallel CmpMap. */ - if( simpler ) { - map2 = (AstMapping *) astCmpMap( simp1, simp2, 0, "", status ); - } - -/* Re-instate the original Invert attributes in the two component Mappings. */ - astSetInvert( mc[ 0 ], inc[ 2 ] ); - astSetInvert( mc[ 1 ], inc[ 3 ] ); - -/* Free resources. */ - simp1 = astAnnul( simp1 ); - simp2 = astAnnul( simp2 ); - nc[ 0 ] = astAnnul( nc[ 0 ] ); - nc[ 1 ] = astAnnul( nc[ 1 ] ); - - } - -/* Free resources. */ - mc[ 0 ] = astAnnul( mc[ 0 ] ); - mc[ 1 ] = astAnnul( mc[ 1 ] ); - a = astFree( a ); - b = astFree( b ); - -/* Re-instate the original Invert attributes. */ - astSetInvert( ( *map_list )[ i1 ], inc[ 0 ] ); - astSetInvert( ( *map_list )[ i2 ], inc[ 1 ] ); - -/* If the above produced a new Mapping, annul the supplied pointers for - the two merged Mappings, store the pointer for the new merged Mapping, - and shuffle the remaining Mappings down to fill the space left. Nullify - the end slot which is no longer used, reduce the number of Mappings in - the list by 1, and return the index of the first modified Mapping. */ - if( map2 ) { - (void) astAnnul( ( *map_list )[ i1 ] ); - (void) astAnnul( ( *map_list )[ i2 ] ); - ( *map_list )[ i1 ] = map2; - ( *invert_list )[ i1 ] = 0; - for( i = i2 + 1; i < *nmap; i++ ){ - ( *map_list )[ i - 1 ] = ( *map_list )[ i ]; - ( *invert_list )[ i - 1 ] = ( *invert_list )[ i ]; - } - ( *map_list )[ *nmap - 1 ] = NULL; - (*nmap)--; - result = i1; - } - -/* If the WinMap could not merge directly with either of its neighbours, - we consider whether it would be worthwhile to swap the WinMap with - either of its neighbours. This can only be done for certain classes - of Mapping (MatrixMap & some PermMaps & WcsMaps), and will usually require both - Mappings to be modified (unless they are commutative). The advantage of - swapping the order of the Mappings is that it may result in the WinMap - being adjacent to a Mapping with which it can merge directly on the next - invocation of this function, thus reducing the number of Mappings - in the list. */ - } else { - -/* Set a flag if we could swap the WinMap with its higher neighbour. "do2" - is returned if swapping the Mappings would simplify either of the - Mappings. */ - if( where + 1 < *nmap ){ - swaphi = CanSwap( ( *map_list )[ where ], - ( *map_list )[ where + 1 ], - ( *invert_list )[ where ], - ( *invert_list )[ where + 1 ], &do2, status ); - } else { - swaphi = 0; - do2 = 0; - } - -/* If so, step through each of the Mappings which follow the WinMap, - looking for a Mapping with which the WinMap could merge directly. Stop - when such a Mapping is found, or if a Mapping is found with which the - WinMap could definitely not swap. Note the number of Mappings which - separate the WinMap from the Mapping with which it could merge (if - any). */ - nstep2 = -1; - if( swaphi ){ - for( i2 = where + 1; i2 < *nmap; i2++ ){ - -/* See if we can merge with this Mapping. If so, note the number of steps - between the two Mappings and leave the loop. */ - nclass = astGetClass( ( *map_list )[ i2 ] ); - if( !strcmp( nclass, "WinMap" ) || - !strcmp( nclass, "ZoomMap" ) || - !strcmp( nclass, "UnitMap" ) ) { - nstep2 = i2 - where - 1; - break; - } - -/* If there is no chance that we can swap with this Mapping, leave the loop - with -1 for the number of steps to indicate that no merging is possible. - WinMaps can swap with MatrixMaps and some PermMaps. */ - if( strcmp( nclass, "MatrixMap" ) && - strcmp( nclass, "WcsMap" ) && - strcmp( nclass, "PermMap" ) ) { - break; - } - - } - - } - -/* Do the same working forward from the WinMap towards the start of the map - list. */ - if( where > 0 ){ - swaplo = CanSwap( ( *map_list )[ where - 1 ], - ( *map_list )[ where ], - ( *invert_list )[ where - 1 ], - ( *invert_list )[ where ], &do1, status ); - } else { - swaplo = 0; - do1 = 0; - } - - nstep1 = -1; - if( swaplo ){ - for( i1 = where - 1; i1 >= 0; i1-- ){ - - nclass = astGetClass( ( *map_list )[ i1 ] ); - if( !strcmp( nclass, "WinMap" ) || - !strcmp( nclass, "ZoomMap" ) || - !strcmp( nclass, "UnitMap" ) ) { - nstep1 = where - 1 - i1; - break; - } - - if( strcmp( nclass, "MatrixMap" ) && - strcmp( nclass, "WcsMap" ) && - strcmp( nclass, "PermMap" ) ) { - break; - } - - } - - } - -/* Choose which neighbour to swap with so that the WinMap moves towards the - nearest Mapping with which it can merge. */ - if( do1 || ( - nstep1 != -1 && ( nstep2 == -1 || nstep2 > nstep1 ) ) ){ - nclass = class1; - i1 = where - 1; - i2 = where; - } else if( do2 || nstep2 != -1 ){ - nclass = class2; - i1 = where; - i2 = where + 1; - } else { - nclass = NULL; - } - -/* If there is a target Mapping in the list with which the WinMap could - merge, replace the supplied Mappings with swapped Mappings to bring a - WinMap closer to the target Mapping. */ - if( nclass ){ - -/* Swap the Mappings. */ - if( !strcmp( nclass, "MatrixMap" ) ){ - WinMat( (*map_list) + i1, (*invert_list) + i1, where - i1, status ); - - } else if( !strcmp( nclass, "PermMap" ) ){ - WinPerm( (*map_list) + i1, (*invert_list) + i1, where - i1, status ); - - } else if( !strcmp( nclass, "WcsMap" ) ){ - WinWcs( (*map_list) + i1, (*invert_list) + i1, where - i1, status ); - } - -/* And then merge them if possible. */ - if( where == i1 && where + 1 < *nmap ) { /* Merging upwards */ - map2 = astClone( (*map_list)[ where + 1 ] ); - nmapt = *nmap - where - 1; - maplt = *map_list + where + 1; - invlt = *invert_list + where + 1; - - (void) astMapMerge( map2, 0, series, &nmapt, &maplt, &invlt ); - map2 = astAnnul( map2 ); - *nmap = where + 1 + nmapt; - - } else if( where - 2 >= 0 ) { /* Merging downwards */ - map2 = astClone( (*map_list)[ where - 2 ] ); - nmapt = *nmap - where + 2; - maplt = *map_list + where - 2 ; - invlt = *invert_list + where - 2; - - (void) astMapMerge( map2, 0, series, &nmapt, &maplt, &invlt ); - map2 = astAnnul( map2 ); - *nmap = where - 2 + nmapt; - } - - result = i1; - -/* If there is no Mapping available for merging, it may still be - advantageous to swap with a neighbour because the swapped Mapping may - be simpler than the original Mappings. For instance, a PermMap may - strip axes of the WinMap leaving only a UnitMap. Also, the two neighbours - may be able to merge. */ - } else if( swaphi || swaplo ) { - -/* Try swapping with each possible neighbour in turn. */ - for( i = 0; i < 2; i++ ) { - -/* Set up the class and pointers for the mappings to be swapped, first - the lower neighbour, then the upper neighbour. */ - if( i == 0 && swaplo ){ - nclass = class1; - i1 = where - 1; - i2 = where; - - } else if( i == 1 && swaphi ){ - nclass = class2; - i1 = where; - i2 = where + 1; - - } else { - nclass = NULL; - } - -/* If we have a Mapping to swap with... */ - if( nclass ) { - -/* Take copies of the Mapping and Invert flag arrays so we do not change - the supplied values. */ - mc[ 0 ] = (AstMapping *) astCopy( ( (*map_list) + i1 )[0] ); - mc[ 1 ] = (AstMapping *) astCopy( ( (*map_list) + i1 )[1] ); - ic[ 0 ] = ( (*invert_list) + i1 )[0]; - ic[ 1 ] = ( (*invert_list) + i1 )[1]; - -/* Swap these Mappings. */ - if( !strcmp( nclass, "MatrixMap" ) ){ - WinMat( mc, ic, where - i1, status ); - } else if( !strcmp( nclass, "PermMap" ) ){ - WinPerm( mc, ic, where - i1, status ); - } else if( !strcmp( nclass, "WcsMap" ) ){ - WinWcs( mc, ic, where - i1, status ); - } - -/* See if the two neighbouring Mappings can merge now that the nominated - Mapping is no longer in between them. First get a list of Mapping - pointers containing the two Mappings to be merged, and associated - invert flags. */ - if( i == 0 && where != *nmap - 1 ) { - nc[ 0 ] = astClone( mc[ 1 ] ); - nc[ 1 ] = astClone( (*map_list)[ where + 1 ] ); - inc[ 0 ] = ic[ 1 ]; - inc[ 1 ] = (*invert_list)[ where + 1 ]; - - } else if( i == 1 && where > 0 ) { - nc[ 0 ] = astClone( (*map_list)[ where - 1 ] ); - nc[ 1 ] = astClone( mc[ 0 ] ); - inc[ 0 ] = (*invert_list)[ where - 1 ]; - inc[ 1 ] = ic[ 0 ]; - - } else { - nc[ 0 ] = NULL; - nc[ 1 ] = NULL; - } - -/* If both neighbours are available, use astMapMerge to see if it is - possible to merge the two Mappings. */ - swap = 0; - if( nc[ 0 ] && nc[ 1 ] ) { - nmapt = 2; - maplt = nc; - invlt = inc; - map2 = astClone( nc[ 0 ] ); - swap = astMapMerge( map2, 0, series, &nmapt, &maplt, &invlt ); - map2 = astAnnul( map2 ); - if( swap == -1 ) { - map2 = astClone( nc[ 1 ] ); - swap = astMapMerge( map2, 1, series, &nmapt, &maplt, &invlt ); - map2 = astAnnul( map2 ); - } - swap = ( nmapt < 2 ) ? 1 : 0; - } - -/* Free resources. */ - if( nc[ 0 ] ) nc[ 0 ] = astAnnul( nc[ 0 ] ); - if( nc[ 1 ] ) nc[ 1 ] = astAnnul( nc[ 1 ] ); - -/* If the neighbours could not merge, see if either swapped Mapping can - be simplified. */ - if( !swap ) { - smc0 = astSimplify( mc[0] ); - if( smc0 != mc[0] ) { - swap = 1; - } else { - smc1 = astSimplify( mc[1] ); - swap = ( smc1 != mc[1] ); - smc1 = astAnnul( smc1 ); - } - smc0 = astAnnul( smc0 ); - } - -/* If there is some point in swapping the Mappings, swap them in the - supplied lists. Otherwise annul the swapped Mappings. */ - if( swap ) { - (*map_list)[ i1 ] = astAnnul( (*map_list)[ i1 ] ); - (*map_list)[ i2 ] = astAnnul( (*map_list)[ i2 ] ); - (*map_list)[ i1 ] = mc[ 0 ]; - (*map_list)[ i2 ] = mc[ 1 ]; - (*invert_list)[ i1 ] = ic[ 0 ]; - (*invert_list)[ i2 ] = ic[ 1 ]; - result = i1; - break; - - } else { - mc[ 0 ] = astAnnul( mc[ 0 ] ); - mc[ 1 ] = astAnnul( mc[ 1 ] ); - } - } - } - } - } - -/* In parallel. */ -/* ============ */ -/* WinMaps are combined in parallel with neighbouring WinMaps, ZoomMaps and - UnitMaps. */ - } else { - -/* We first look to see if the WinMap can be merged with one of its - neighbours, resulting in a reduction of one in the number of Mappings - in the list. WinMaps can only merge directly with another WinMap, a - ZoomMap, or a UnitMap. */ - if( class1 && ( !strcmp( class1, "WinMap" ) || - !strcmp( class1, "ZoomMap" ) || - !strcmp( class1, "UnitMap" ) ) ){ - nclass = class1; - i1 = where - 1; - i2 = where; - - } else if( class2 && ( !strcmp( class2, "WinMap" ) || - !strcmp( class2, "ZoomMap" ) || - !strcmp( class2, "UnitMap" ) ) ){ - nclass = class2; - i1 = where; - i2 = where + 1; - - } else { - nclass = NULL; - } - -/* If the WinMap can merge with one of its neighbours, create the merged - Mapping. */ - if( nclass ){ - - if( !strcmp( nclass, "WinMap" ) ){ - newwm = WinWin( ( *map_list )[ i1 ], ( *map_list )[ i2 ], - ( *invert_list )[ i1 ], ( *invert_list )[ i2 ], - 0, status ); - invert = 0; - - } else if( !strcmp( nclass, "ZoomMap" ) ){ - if( i1 == where ){ - newwm = WinZoom( (AstWinMap *)( *map_list )[ i1 ], - (AstZoomMap *)( *map_list )[ i2 ], - ( *invert_list )[ i1 ], ( *invert_list )[ i2 ], 1, 0, status ); - } else { - newwm = WinZoom( (AstWinMap *)( *map_list )[ i2 ], - (AstZoomMap *)( *map_list )[ i1 ], - ( *invert_list )[ i2 ], ( *invert_list )[ i1 ], 0, 0, status ); - } - invert = 0; - - } else { - if( i1 == where ){ - newwm = WinUnit( (AstWinMap *)( *map_list )[ i1 ], - (AstUnitMap *)( *map_list )[ i2 ], - ( *invert_list )[ i1 ], 1, status ); - } else { - newwm = WinUnit( (AstWinMap *)( *map_list )[ i2 ], - (AstUnitMap *)( *map_list )[ i1 ], - ( *invert_list )[ i2 ], 0, status ); - } - invert = 0; - - } - -/* If succesfull... */ - if( astOK ){ - -/* Annul the first of the two Mappings, and replace it with the merged - WinMap. Also set the invert flag. */ - (void) astAnnul( ( *map_list )[ i1 ] ); - ( *map_list )[ i1 ] = (AstMapping *) newwm; - ( *invert_list )[ i1 ] = invert; - -/* Annul the second of the two Mappings, and shuffle down the rest of the - list to fill the gap. */ - (void) astAnnul( ( *map_list )[ i2 ] ); - for ( i = i2 + 1; i < *nmap; i++ ) { - ( *map_list )[ i - 1 ] = ( *map_list )[ i ]; - ( *invert_list )[ i - 1 ] = ( *invert_list )[ i ]; - } - -/* Clear the vacated element at the end. */ - ( *map_list )[ *nmap - 1 ] = NULL; - ( *invert_list )[ *nmap - 1 ] = 0; - -/* Decrement the Mapping count and return the index of the first - modified element. */ - ( *nmap )--; - result = i1; - - } - } - } - } - -/* Return the result. */ - return result; -} - -static int *MapSplit( AstMapping *this_map, int nin, const int *in, AstMapping **map, int *status ){ -/* -* Name: -* MapSplit - -* Purpose: -* Create a Mapping representing a subset of the inputs of an existing -* WinMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* int *MapSplit( AstMapping *this, int nin, const int *in, AstMapping **map, int *status ) - -* Class Membership: -* WinMap method (over-rides the protected astMapSplit method -* inherited from the Mapping class). - -* Description: -* This function creates a new Mapping by picking specified inputs from -* an existing WinMap. This is only possible if the specified inputs -* correspond to some subset of the WinMap outputs. That is, there -* must exist a subset of the WinMap outputs for which each output -* depends only on the selected WinMap inputs, and not on any of the -* inputs which have not been selected. If this condition is not met -* by the supplied WinMap, then a NULL Mapping is returned. - -* Parameters: -* this -* Pointer to the WinMap to be split (the WinMap is not actually -* modified by this function). -* nin -* The number of inputs to pick from "this". -* in -* Pointer to an array of indices (zero based) for the inputs which -* are to be picked. This array should have "nin" elements. If "Nin" -* is the number of inputs of the supplied WinMap, then each element -* should have a value in the range zero to Nin-1. -* map -* Address of a location at which to return a pointer to the new -* Mapping. This Mapping will have "nin" inputs (the number of -* outputs may be different to "nin"). A NULL pointer will be -* returned if the supplied WinMap has no subset of outputs which -* depend only on the selected inputs. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A pointer to a dynamically allocated array of ints. The number of -* elements in this array will equal the number of outputs for the -* returned Mapping. Each element will hold the index of the -* corresponding output in the supplied WinMap. The array should be -* freed using astFree when no longer needed. A NULL pointer will -* be returned if no output Mapping can be created. - -* Notes: -* - If this function is invoked with the global error status set, -* or if it should fail for any reason, then NULL values will be -* returned as the function value and for the "map" pointer. -*/ - -/* Local Variables: */ - AstWinMap *newwm; /* Pointer to returned WinMap */ - AstWinMap *this; /* Pointer to WinMap structure */ - double *a; /* Pointer to zero terms */ - double *b; /* Pointer to scale terms */ - int *result; /* Pointer to returned array */ - int i; /* Loop count */ - int iin; /* Mapping input index */ - int mnin; /* No. of Mapping inputs */ - int ok; /* Are input indices OK? */ - -/* Initialise */ - result = NULL; - *map = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Get a pointer to the WinMap structure. */ - this = (AstWinMap *) this_map; - -/* Allocate memory for the returned array and create a WinMap with the - required number of axes and undefined corners. */ - result = astMalloc( sizeof( int )*(size_t) nin ); - newwm = astWinMap( nin, NULL, NULL, NULL, NULL, "", status ); - *map = (AstMapping *) newwm; - -/* Now get pointers to the scale and zero terms of the supplied WinMap - (these describe the forward transformation, taking into account the - setting of the Invert flag). */ - (void) astWinTerms( this , &a, &b ); - -/* Check pointers can be used safely. */ - if( astOK ) { - -/* Store the required scale and zero terms from the supplied WinMap - in the new WinMap. At the same time check that each axis is valid. */ - mnin = astGetNin( this ); - ok = 1; - for( i = 0; i < nin; i++ ) { - iin = in[ i ]; - if( iin >= 0 && iin < mnin ) { - (newwm->a)[ i ] = a[ iin ]; - (newwm->b)[ i ] = b[ iin ]; - result[ i ] = iin; - } else { - ok = 0; - break; - } - } - -/* If the "in" array contained any invalid values, free the returned - resources. */ - if( !ok ) { - result = astFree( result ); - *map = astAnnul( *map ); - } - } - -/* Free resources. */ - a = astFree( a ); - b = astFree( b ); - -/* Free returned resources if an error has occurred. */ - if( !astOK ) { - result = astFree( result ); - *map = astAnnul( *map ); - } - -/* Return the list of output indices. */ - return result; -} - -static void PermGet( AstPermMap *map, int **outperm, int **inperm, - double **consts, int *status ){ -/* -* Name: -* PermGet - -* Purpose: -* Get the axis permutation and constants array for a PermMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* void PermGet( AstPermMap *map, int **outperm, int **inperm, -* double **const, int *status ) - -* Class Membership: -* WinMap member function - -* Description: -* This function returns axis permutation and constants arrays which can -* be used to create a PermMap which is equivalent to the supplied PermMap. - -* Parameters: -* map -* The PermMap. -* outperm -* An address at which to return a popinter to an array of ints -* holding the output axis permutation array. The array should be -* released using astFree when no longer needed. -* inperm -* An address at which to return a popinter to an array of ints -* holding the input axis permutation array. The array should be -* released using astFree when no longer needed. -* consts -* An address at which to return a popinter to an array of doubles -* holding the constants array. The array should be released using -* astFree when no longer needed. -* status -* Pointer to the inherited status variable. - -* Notes: -* - NULL pointers are returned if an error has already occurred, or if -* this function should fail for any reason. -*/ - -/* Local Variables: */ - AstPointSet *pset1; /* PointSet holding input positions for PermMap */ - AstPointSet *pset2; /* PointSet holding output positions for PermMap */ - double **ptr1; /* Pointer to pset1 data */ - double **ptr2; /* Pointer to pset2 data */ - double *cnst; /* Pointer to constants array */ - double cn; /* Potential new constant value */ - double ip; /* Potential output axis index */ - double op; /* Potential input axis index */ - int *inprm; /* Pointer to input axis permutation array */ - int *outprm; /* Pointer to output axis permutation array */ - int i; /* Axis count */ - int nc; /* Number of constants stored so far */ - int nin; /* No. of input coordinates for the PermMap */ - int nout; /* No. of output coordinates for the PermMap */ - -/* Initialise. */ - if( outperm ) *outperm = NULL; - if( inperm ) *inperm = NULL; - if( consts ) *consts = NULL; - -/* Check the global error status and the supplied pointers. */ - if ( !astOK || !outperm || !inperm || !consts ) return; - -/* Initialise variables to avoid "used of uninitialised variable" - messages from dumb compilers. */ - nc = 0; - -/* Get the number of input and output axes for the supplied PermMap. */ - nin = astGetNin( map ); - nout = astGetNout( map ); - -/* Allocate the memory for the returned arrays. */ - outprm = (int *) astMalloc( sizeof( int )* (size_t) nout ); - inprm = (int *) astMalloc( sizeof( int )* (size_t) nin ); - cnst = (double *) astMalloc( sizeof( double )* (size_t) ( nout + nin ) ); - -/* Returned the pointers to these arrays.*/ - *outperm = outprm; - *inperm = inprm; - *consts = cnst; - -/* Create two PointSets, each holding two points, which can be used for - input and output positions with the PermMap. */ - pset1 = astPointSet( 2, nin, "", status ); - pset2 = astPointSet( 2, nout, "", status ); - -/* Set up the two input positions to be [0,1,2...] and [-1,-1,-1,...]. The - first position is used to enumerate the axes, and the second is used to - check for constant axis values. */ - ptr1 = astGetPoints( pset1 ); - if( astOK ){ - for( i = 0; i < nin; i++ ){ - ptr1[ i ][ 0 ] = ( double ) i; - ptr1[ i ][ 1 ] = -1.0; - } - } - -/* Use the PermMap to transform these positions in the forward direction. */ - (void) astTransform( map, pset1, 1, pset2 ); - -/* Look at the mapped positions to determine the output axis permutation - array. */ - ptr2 = astGetPoints( pset2 ); - if( astOK ){ - -/* No constant axis valeus found yet. */ - nc = 0; - -/* Do each output axis. */ - for( i = 0; i < nout; i++ ){ - -/* If the output axis value is copied from an input axis value, the index - of the appropriate input axis will be in the mapped first position. */ - op = ptr2[ i ][ 0 ]; - -/* If the output axis value is assigned a constant value, the result of - mapping the two different input axis values will be the same. */ - cn = ptr2[ i ][ 1 ]; - if( op == cn ) { - -/* We have found another constant. Store it in the constants array, and - store the index of the constant in the output axis permutation array. */ - cnst[ nc ] = cn; - outprm[ i ] = -( nc + 1 ); - nc++; - -/* If the output axis values are different, then the output axis value - must be copied from the input axis value. */ - } else { - outprm[ i ] = (int) ( op + 0.5 ); - } - } - } - -/* Now do the same thing to determine the input permutation array. */ - if( astOK ){ - for( i = 0; i < nout; i++ ){ - ptr2[ i ][ 0 ] = ( double ) i; - ptr2[ i ][ 1 ] = -1.0; - } - } - - (void) astTransform( map, pset2, 0, pset1 ); - - if( astOK ){ - - for( i = 0; i < nin; i++ ){ - - ip = ptr1[ i ][ 0 ]; - cn = ptr1[ i ][ 1 ]; - if( ip == cn ) { - - cnst[ nc ] = cn; - inprm[ i ] = -( nc + 1 ); - nc++; - - } else { - inprm[ i ] = (int) ( ip + 0.5 ); - } - } - } - -/* Annul the PointSets. */ - pset1 = astAnnul( pset1 ); - pset2 = astAnnul( pset2 ); - -/* If an error has occurred, attempt to free the returned arrays. */ - if( !astOK ) { - *outperm = (int *) astFree( (void *) *outperm ); - *inperm = (int *) astFree( (void *) *inperm ); - *consts = (double *) astFree( (void *) *consts ); - } - -/* Return. */ - return; -} - -static double Rate( AstMapping *this, double *at, int ax1, int ax2, int *status ){ -/* -* Name: -* Rate - -* Purpose: -* Calculate the rate of change of a Mapping output. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* result = Rate( AstMapping *this, double *at, int ax1, int ax2, int *status ) - -* Class Membership: -* WinMap member function (overrides the astRate method inherited -* from the Mapping class ). - -* Description: -* This function returns the rate of change of a specified output of -* the supplied Mapping with respect to a specified input, at a -* specified input position. - -* Parameters: -* this -* Pointer to the Mapping to be applied. -* at -* The address of an array holding the axis values at the position -* at which the rate of change is to be evaluated. The number of -* elements in this array should equal the number of inputs to the -* Mapping. -* ax1 -* The index of the Mapping output for which the rate of change is to -* be found (output numbering starts at 0 for the first output). -* ax2 -* The index of the Mapping input which is to be varied in order to -* find the rate of change (input numbering starts at 0 for the first -* input). -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The rate of change of Mapping output "ax1" with respect to input -* "ax2", evaluated at "at", or AST__BAD if the value cannot be -* calculated. - -*/ - -/* Local Variables: */ - AstWinMap *map; - double result; - -/* Check inherited status */ - if( !astOK ) return AST__BAD; - -/* Get a pointer to the WinMap structure. */ - map = (AstWinMap *) this; - -/* If the input and output axes are not equal the result is zero. */ - if( ax1 != ax2 ) { - result = 0.0; - -/* Otherwise, return the scale factor for the axis, taking the reciprocal - if the WinMap has been inverted. */ - } else { - result = ( map->b )[ ax1 ]; - if( astGetInvert( map ) ) { - if( result != 0.0 && result != AST__BAD ) { - result = 1.0/result; - } else { - result = AST__BAD; - } - } - } - -/* Return the result. */ - return result; -} - -static void SetAttrib( AstObject *this_object, const char *setting, int *status ) { -/* -* Name: -* SetAttrib - -* Purpose: -* Set an attribute value for a WinMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* void SetAttrib( AstObject *this, const char *setting ) - -* Class Membership: -* WinMap member function (over-rides the astSetAttrib protected -* method inherited from the Mapping class). - -* Description: -* This function assigns an attribute value for a WinMap, the -* attribute and its value being specified by means of a string of -* the form: -* -* "attribute= value " -* -* Here, "attribute" specifies the attribute name and should be in -* lower case with no white space present. The value to the right -* of the "=" should be a suitable textual representation of the -* value to be assigned and this will be interpreted according to -* the attribute's data type. White space surrounding the value is -* only significant for string attributes. - -* Parameters: -* this -* Pointer to the WinMap. -* setting -* Pointer to a null-terminated string specifying the new attribute -* value. -*/ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* The WinMap class currently has no attributes, so pass it on to the parent - method for further interpretation. */ - (*parent_setattrib)( this_object, setting, status ); - -} - -static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) { -/* -* Name: -* TestAttrib - -* Purpose: -* Test if a specified attribute value is set for a WinMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* int TestAttrib( AstObject *this, const char *attrib, int *status ) - -* Class Membership: -* WinMap member function (over-rides the astTestAttrib protected -* method inherited from the Mapping class). - -* Description: -* This function returns a boolean result (0 or 1) to indicate whether -* a value has been set for one of a WinMap's attributes. - -* Parameters: -* this -* Pointer to the WinMap. -* attrib -* Pointer to a null-terminated string specifying the attribute -* name. This should be in lower case with no surrounding white -* space. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* One if a value has been set, otherwise zero. - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - int result; /* Result value to return */ - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* The WinMap class currently has no attributes, so pass it on to the parent - method for further interpretation. */ - result = (*parent_testattrib)( this_object, attrib, status ); - -/* Return the result, */ - return result; -} - -static AstPointSet *Transform( AstMapping *this, AstPointSet *in, - int forward, AstPointSet *out, int *status ) { -/* -* Name: -* Transform - -* Purpose: -* Apply a WinMap to transform a set of points. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* AstPointSet *Transform( AstMapping *this, AstPointSet *in, -* int forward, AstPointSet *out, int *status ) - -* Class Membership: -* WinMap member function (over-rides the astTransform protected -* method inherited from the Mapping class). - -* Description: -* This function takes a WinMap and a set of points encapsulated in a -* PointSet and transforms the points so as to map them into the -* required window. - -* Parameters: -* this -* Pointer to the WinMap. -* in -* Pointer to the PointSet holding the input coordinate data. -* forward -* A non-zero value indicates that the forward coordinate transformation -* should be applied, while a zero value requests the inverse -* transformation. -* out -* Pointer to a PointSet which will hold the transformed (output) -* coordinate values. A NULL value may also be given, in which case a -* new PointSet will be created by this function. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to the output (possibly new) PointSet. - -* Notes: -* - A null pointer will be returned if this function is invoked with the -* global error status set, or if it should fail for any reason. -* - The number of coordinate values per point in the input PointSet must -* match the number of coordinates for the WinMap being applied. -* - If an output PointSet is supplied, it must have space for sufficient -* number of points and coordinate values per point to accommodate the -* result. Any excess space will be ignored. -*/ - -/* Local Variables: */ - AstPointSet *result; /* Pointer to output PointSet */ - AstWinMap *map; /* Pointer to WinMap to be applied */ - const char *class; /* Object class */ - double **ptr_in; /* Pointer to input coordinate data */ - double **ptr_out; /* Pointer to output coordinate data */ - double *axin; /* Pointer to next input axis value */ - double *axout; /* Pointer to next output axis value */ - double *a; /* Pointer to next constant term */ - double *b; /* Pointer to next multiplicative term */ - double aa; /* Constant term */ - double bb; /* Multiplicative term */ - int coord; /* Loop counter for coordinates */ - int def; /* Is mapping defined? */ - int ncoord; /* Number of coordinates per point */ - int npoint; /* Number of points */ - int point; /* Loop counter for points */ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Initialise variables to avoid "used of uninitialised variable" - messages from dumb compilers. */ - aa = 0.0; - bb = 0.0; - -/* Obtain a pointer to the WinMap. */ - map = (AstWinMap *) this; - -/* Apply the parent mapping using the stored pointer to the Transform member - function inherited from the parent Mapping class. This function validates - all arguments and generates an output PointSet if necessary, but does not - actually transform any coordinate values. */ - result = (*parent_transform)( this, in, forward, out, status ); - -/* We will now extend the parent astTransform method by performing the - calculations needed to generate the output coordinate values. */ - -/* Determine the numbers of points and coordinates per point from the input - PointSet and obtain pointers for accessing the input and output coordinate - values. */ - ncoord = astGetNcoord( in ); - npoint = astGetNpoint( in ); - ptr_in = astGetPoints( in ); - ptr_out = astGetPoints( result ); - -/* Determine whether to apply the forward or inverse mapping, according to the - direction specified and whether the mapping has been inverted. */ - if ( astGetInvert( map ) ) forward = !forward; - -/* Report an error if the WinMap does not contain any scales or shifts. */ - if( !(map->a && map->b) && astOK ){ - class = astGetClass( this ); - astError( AST__BADWM, "astTransform(%s): The supplied %s does not " - "contain any window information.", status, class, class ); - } - -/* Perform coordinate arithmetic. */ -/* ------------------------------ */ - if( astOK ){ - -/* Store pointers to the shift and scale for the next axis. */ - a = map->a; - b = map->b; - -/* Apply the mapping to each axis. */ - for( coord = 0; coord < ncoord; coord++ ){ - -/* If either the scale or shift is bad indicate that the mapping is - not defined on this axis. */ - if( *a == AST__BAD || *b == AST__BAD ){ - def = 0; - -/* Otherwise, get the scale and offset factors for this axis, taking account of - whether the mapping is inverted or not. If the mapping is undefined, set - the "def" flag to indicate this. */ - } else { - aa = *a; - bb = *b; - - if( forward ){ - def = 1; - - } else if( bb != 0.0 ){ - bb = 1.0/bb; - aa = -aa*bb; - def = 1; - - } else { - def = 0; - } - - } - -/* Store pointers to the first inpout and output values on this axis. */ - axin = ptr_in[ coord ]; - axout = ptr_out[ coord ]; - -/* If the mapping is defined, apply it to the supplied points. */ - if( def ){ - - for( point = 0; point < npoint; point++ ){ - if( *axin != AST__BAD ){ - *(axout++) = aa + bb*(*axin); - } else { - *(axout++) = AST__BAD; - } - axin++; - } - -/* If the mapping is not defined, store bad values on this axis in the - returned points. */ - } else { - for( point = 0; point < npoint; point++ ) *(axout++) = AST__BAD; - } - -/* Point to the scale and shift for the next axis. */ - a++; - b++; - } - - } - -/* Return a pointer to the output PointSet. */ - return result; -} - -static void WinMat( AstMapping **maps, int *inverts, int iwm, int *status ){ -/* -* Name: -* WinMat - -* Purpose: -* Swap a WinMap and a MatrixMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* void WinMat( AstMapping **maps, int *inverts, int iwm, int *status ) - -* Class Membership: -* WinMap member function - -* Description: -* A list of two Mappings is supplied containing a WinMap and a -* MatrixMap. These Mappings are annulled, and replaced with -* another pair of Mappings consisting of a WinMap and a MatrixMap -* in the opposite order. These Mappings are chosen so that their -* combined effect is the same as the original pair of Mappings. -* The scale factors in the returned WinMap are always unity (i.e. -* the differences in scaling get absorbed into the returned -* MatrixMap). - -* Parameters: -* maps -* A pointer to an array of two Mapping pointers. -* inverts -* A pointer to an array of two invert flags. -* iwm -* The index within "maps" of the WinMap. -* status -* Pointer to the inherited status variable. - -*/ - -/* Local Variables: */ - AstMatrixMap *m1; /* Pointer to Diagonal scale factor MatrixMap */ - AstMatrixMap *m2; /* Pointer to returned MatrixMap */ - AstMatrixMap *sm2; /* Pointer to simplified returned MatrixMap */ - AstMatrixMap *mm; /* Pointer to the supplied MatrixMap */ - AstPointSet *pset1; /* Shift terms from supplied WinMap */ - AstPointSet *pset2; /* Shift terms for returned WinMap */ - AstWinMap *w1; /* Pointer to the returned WinMap */ - AstWinMap *sw1; /* Pointer to the simplified returned WinMap */ - AstWinMap *wm; /* Pointer to the supplied WinMap */ - double **ptr1; /* Pointer to pset1 data */ - double **ptr2; /* Pointer to pset2 data */ - double *a; /* Array of shift terms from supplied WinMap */ - double *aa; /* Pointer to next shift term */ - double *b; /* Array of scale terms from supplied WinMap */ - double *bb; /* Pointer to next scale term */ - int i; /* Axis count */ - int nin; /* No. of axes in supplied WinMap */ - int nout; /* No. of axes in returned WinMap */ - int old_minv; /* Invert value for the supplied MatrixMap */ - int old_winv; /* Invert value for the supplied WinMap */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Store pointers to the supplied WinMap and the MatrixMap. */ - wm = (AstWinMap *) maps[ iwm ]; - mm = (AstMatrixMap *) maps[ 1 - iwm ]; - -/* Temporarily set the Invert attribute of the supplied Mappings to the - supplied values. */ - old_winv = astGetInvert( wm ); - astSetInvert( wm, inverts[ iwm ] ); - - old_minv = astGetInvert( mm ); - astSetInvert( mm, inverts[ 1 - iwm ] ); - -/* Get copies of the shift and scale terms used by the WinMap. This - also returns the number of axes in the WinMap. */ - nin = astWinTerms( wm, &a, &b ); - -/* Create a diagonal MatrixMap holding the scale factors from the - supplied WinMap. */ - m1 = astMatrixMap( nin, nin, 1, b, "", status ); - -/* Create a PointSet holding a single position given by the shift terms - in the supplied WinMap. */ - pset1 = astPointSet( 1, nin, "", status ); - ptr1 = astGetPoints( pset1 ); - if( astOK ){ - aa = a; - for( i = 0; i < nin; i++ ) ptr1[ i ][ 0 ] = *(aa++); - } - -/* First deal with cases when the WinMap is applied first, followed by - the MatrixMap. */ - if( iwm == 0 ){ - -/* Multiply the diagonal matrix holding the WinMap scale factors by the - supplied matrix. The resulting MatrixMap is the one to return in the - map list. */ - m2 = astMtrMult( m1, mm ); - -/* Transform the position given by the shift terms from the supplied - WinMap using the supplied MatrixMap to get the shift terms for - the returned WinMap. */ - pset2 = astTransform( mm, pset1, 1, NULL ); - -/* Now deal with cases when the MatrixMap is applied first, followed by - the WinMap. */ - } else { - -/* Multiply the supplied MatrixMap by the diagonal matrix holding scale - factors from the supplied WinMap. The resulting MatrixMap is the one to - return in the map list. */ - m2 = astMtrMult( mm, m1 ); - -/* Transform the position given by the shift terms from the supplied - WinMap using the inverse of the returned MatrixMap to get the shift - terms for the returned WinMap. */ - pset2 = astTransform( m2, pset1, 0, NULL ); - - } - -/* Re-instate the original value of the Invert attributes of the supplied - Mappings. */ - astSetInvert( wm, old_winv ); - astSetInvert( mm, old_minv ); - -/* Get pointers to the shift terms for the returned WinMap. */ - ptr2 = astGetPoints( pset2 ); - -/* Create the returned WinMap, initially with undefined corners. The number of - axes in the WinMap must equal the number of shift terms. */ - nout = astGetNcoord( pset2 ); - w1 = astWinMap( nout, NULL, NULL, NULL, NULL, "", status ); - -/* If succesful, store the scale and shift terms in the WinMap. The scale - terms are always unity. */ - if( astOK ){ - bb = w1->b; - aa = w1->a; - for( i = 0; i < nout; i++ ) { - *(bb++) = 1.0; - *(aa++) = ptr2[ i ][ 0 ]; - } - -/* Replace the supplied Mappings and invert flags with the ones found - above. Remember that the order of the Mappings is now swapped */ - (void) astAnnul( maps[ 0 ] ); - (void) astAnnul( maps[ 1 ] ); - - sw1 = astSimplify( w1 ); - w1 = astAnnul( w1 ); - - maps[ 1 - iwm ] = (AstMapping *) sw1; - inverts[ 1 - iwm ] = astGetInvert( sw1 ); - - sm2 = astSimplify( m2 ); - m2 = astAnnul( m2 ); - - maps[ iwm ] = (AstMapping *) sm2; - inverts[ iwm ] = astGetInvert( sm2 ); - - } - -/* Annul the MatrixMap and PointSet holding the scale and shift terms from the - supplied WinMap. */ - m1 = astAnnul( m1 ); - pset1 = astAnnul( pset1 ); - pset2 = astAnnul( pset2 ); - -/* Free the copies of the scale and shift terms from the supplied WinMap. */ - b = (double *) astFree( (void *) b ); - a = (double *) astFree( (void *) a ); - -/* Return. */ - return; -} - -static void WinWcs( AstMapping **maps, int *inverts, int iwm, int *status ){ -/* -* Name: -* WinWcs - -* Purpose: -* Swap a WinMap and a WcsMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* void WinWcs( AstMapping **maps, int *inverts, int iwm, int *status ) - -* Class Membership: -* WinMap member function - -* Description: -* A list of two Mappings is supplied containing a WinMap and a -* WcsMap. These Mappings are swapped. - -* Parameters: -* maps -* A pointer to an array of two Mapping pointers. -* inverts -* A pointer to an array of two invert flags. -* iwm -* The index within "maps" of the WinMap. -* status -* Pointer to the inherited status variable. - -*/ - -/* Local Variables: */ - AstMapping *m1; /* Pointer to a Mapping */ - int inv; /* Invert value */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Simply swap the values (the CanSwap function will have checked that - the WcsMap and WinMap can simply be swapped). */ - m1 = maps[ 0 ]; - maps[ 0 ] = maps[ 1 ]; - maps[ 1 ] = m1; - - inv = inverts[ 0 ]; - inverts[ 0 ] = inverts[ 1 ]; - inverts[ 1 ] = inv; - -/* Return. */ - return; -} - -static void WinPerm( AstMapping **maps, int *inverts, int iwm, int *status ){ -/* -* Name: -* WinPerm - -* Purpose: -* Swap a WinMap and a PermMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* void WinPerm( AstMapping **maps, int *inverts, int iwm, int *status ) - -* Class Membership: -* WinMap member function - -* Description: -* A list of two Mappings is supplied containing a WinMap and a -* PermMap. These Mappings are annulled, and replaced with -* another pair of Mappings consisting of a WinMap and a PermMap -* in the opposite order. These Mappings are chosen so that their -* combined effect is the same as the original pair of Mappings. - -* Parameters: -* maps -* A pointer to an array of two Mapping pointers. -* inverts -* A pointer to an array of two invert flags. -* iwm -* The index within "maps" of the WinMap. -* status -* Pointer to the inherited status variable. - -* Notes: -* - All links between input and output axes in the PermMap must -* be bi-directional, but there can be unconnected axes, and there -* need not be the same number of input and output axes. - -*/ - -/* Local Variables: */ - AstPermMap *pm; /* Pointer to the supplied PermMap */ - AstPermMap *p1; /* Pointer to the returned PermMap */ - AstPermMap *sp1; /* Pointer to the simplified returned PermMap */ - AstWinMap *w1; /* Pointer to the returned WinMap */ - AstWinMap *sw1; /* Pointer to the simplified returned PermMap */ - AstWinMap *wm; /* Pointer to the supplied WinMap */ - double *a; /* Array of shift terms from supplied WinMap */ - double *aa; /* Pointer to next shift term */ - double *b; /* Array of scale terms from supplied WinMap */ - double *bb; /* Pointer to next scale term */ - double *consts; /* Pointer to constants array */ - double c; /* A constant value */ - int *inperm; /* Pointer to input axis permutation array */ - int *outperm; /* Pointer to output axis permutation array */ - int i; /* Axis count */ - int j; /* Axis index */ - int nin; /* No. of axes in supplied WinMap */ - int npin; /* No. of input axes in supplied PermMap */ - int npout; /* No. of output axes in supplied PermMap */ - int old_pinv; /* Invert value for the supplied PermMap */ - int old_winv; /* Invert value for the supplied WinMap */ - - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Initialise variables to avoid "used of uninitialised variable" - messages from dumb compilers. */ - p1 = NULL; - w1 = NULL; - -/* Store pointers to the supplied WinMap and the PermMap. */ - wm = (AstWinMap *) maps[ iwm ]; - pm = (AstPermMap *) maps[ 1 - iwm ]; - -/* Temporarily set the Invert attribute of the supplied Mappings to the - supplied values. */ - old_winv = astGetInvert( wm ); - astSetInvert( wm, inverts[ iwm ] ); - - old_pinv = astGetInvert( pm ); - astSetInvert( pm, inverts[ 1 - iwm ] ); - -/* Get copies of the shift and scale terms used by the WinMap. This - also returns the number of axes in the WinMap. */ - nin = astWinTerms( wm, &a, &b ); - -/* Get the axis permutation and constants arrays representing the - PermMap. Note, no constants are used more than once in the returned - arrays (i.e. duplicate constants are returned in "consts" if more than - one axis uses a given constant). */ - PermGet( pm, &outperm, &inperm, &consts, status ); - - if( astOK ) { - -/* Get the number of input and output axes in the PermMap. */ - npin = astGetNin( pm ); - npout = astGetNout( pm ); - -/* First consider cases where the WinMap is applied first, followed by the - PermMap. */ - if( iwm == 0 ) { - -/* Create the new WinMap, initially with undefined corners. Its number - of axes will equal the number of output axes of the PermMap. */ - w1 = astWinMap( npout, NULL, NULL, NULL, NULL, "", status ); - -/* Get pointers to the scale and shift terms for the new WinMap. */ - bb = w1->b; - aa = w1->a; - -/* Thinking of the forward CmpMap first, consider each of the output axes of - the PermMap. */ - for( i = 0; i < npout; i++ ){ - -/* If the value for this output axis is derived from an input axis, copy the - scale and shift terms from the corresponding input axis to the new - WinMap. */ - j = outperm[ i ]; - if( j >= 0 && j < nin ) { - aa[ i ] = a[ j ]; - bb[ i ] = b[ j ]; - -/* If this output axis is assigned a constant value, use zero and one for - the shift and scale in order to preserve the constant value produced - by the PermMap. */ - } else { - aa[ i ] = 0.0; - bb[ i ] = 1.0; - } - - } - -/* Now consider the inverse CmpMap. Any constants produced by the inverse - PermMap would previously have been scaled by the inverse WinMap. Since - there will be no inverse WinMap to perform this scaling in the returned - Mappings, we need to change the constant values to be the values after - the scaling which would have been applied by the WinMap. Consider each - of the input axes of the PermMap.*/ - for( i = 0; i < npin; i++ ){ - -/* Skip axes which are not assigned a constant value. */ - if( inperm[ i ] < 0 ) { - -/* Scale the constant term associated with this input axis using the - inverse WinMap unless it is AST__BAD. */ - c = consts[ -inperm[ i ] - 1 ]; - if( c != AST__BAD ) { - - if( a[ i ] != AST__BAD && b[ i ] != AST__BAD && - b[ i ] != 0.0 ) { - consts[ -inperm[ i ] - 1 ] = ( c - a[ i ] )/b[ i ]; - } else { - consts[ -inperm[ i ] - 1 ] = AST__BAD; - } - - } - - } - - } - -/* Now consider cases where the PermMap is applied first, followed by the - WinMap. */ - } else { - -/* Create the new WinMap, initially with undefined corners. Its number - of axes will equal the number of input axes of the PermMap. */ - w1 = astWinMap( npin, NULL, NULL, NULL, NULL, "", status ); - -/* Get pointers to the scale and shift terms for the new WinMap. */ - bb = w1->b; - aa = w1->a; - -/* Thinking first about the inverse WinMap, consider each of the input axes - of the PermMap. */ - for( i = 0; i < npin; i++ ){ - -/* If the value for this input axis is derived from an output axis, copy the - scale and shift terms from the corresponding output axis to the new - WinMap. */ - j = inperm[ i ]; - if( j >= 0 && j < nin ) { - aa[ i ] = a[ j ]; - bb[ i ] = b[ j ]; - -/* If this input axis is assigned a constant value, use zero and one for - the shift and scale in order to preserve the constant value produced - by the PermMap. */ - } else { - aa[ i ] = 0.0; - bb[ i ] = 1.0; - } - - } - -/* Now consider the forward WinMap. Any constants produced by the forward - PermMap would previously have been scaled by the forward WinMap. Since - there will be no forward WinMap to perform this scaling in the returned - Mappings, we need to change the constant values to be the values after - the scaling which would have been applied by the WinMap. Consider each - of the output axes of the PermMap.*/ - for( i = 0; i < npout; i++ ){ - -/* Skip axes which are not assigned a constant value. */ - if( outperm[ i ] < 0 ) { - -/* Scale the constant term associated with this input axis using the - forward WinMap unless it is AST__BAD. */ - c = consts[ -outperm[ i ] - 1 ]; - if( c != AST__BAD ) { - - if( a[ i ] != AST__BAD && b[ i ] != AST__BAD ) { - consts[ -outperm[ i ] - 1 ] = a[ i ] + c*b[ i ]; - } else { - consts[ -outperm[ i ] - 1 ] = AST__BAD; - } - - } - - } - - } - - } - -/* Create a new PermMap (since the constants may have changed). */ - p1 = astPermMap( npin, inperm, npout, outperm, consts, "", status ); - -/* Free the axis permutation and constants arrays. */ - outperm = (int *) astFree( (void *) outperm ); - inperm = (int *) astFree( (void *) inperm ); - consts = (double *) astFree( (void *) consts ); - } - -/* Re-instate the original value of the Invert attributes of the supplied - Mappings. */ - astSetInvert( wm, old_winv ); - astSetInvert( pm, old_pinv ); - -/* Replace the supplied Mappings with the ones created above, swapping the - order. */ - if( astOK ){ - (void) astAnnul( wm ); - (void) astAnnul( pm ); - - sp1 = astSimplify( p1 ); - p1 = astAnnul( p1 ); - - sw1 = astSimplify( w1 ); - w1 = astAnnul( w1 ); - - maps[ iwm ] = (AstMapping *) sp1; - inverts[ iwm ] = 0; - - maps[ 1 - iwm ] = (AstMapping *) sw1; - inverts[ 1 - iwm ] = astGetInvert( sw1 ); - } - -/* Free the copies of the scale and shift terms from the supplied WinMap. */ - b = (double *) astFree( (void *) b ); - a = (double *) astFree( (void *) a ); - -/* Return. */ - return; -} - -static int WinTerms( AstWinMap *this, double **shift, double **scale, int *status ){ -/* -*+ -* Name: -* astWinTerms - -* Purpose: -* Obtain the scale and shift terms used by a WinMap. - -* Type: -* Protected virtual function. - -* Synopsis: -* #include "winmap.h" -* int astWinTerms( AstWinMap *this, double **shift, double **scale ) - -* Class Membership: -* WinMap mewthod. - -* Description: -* This function returns copies of the scale and shift terms used by a -* WinMap when transforming points. Each axis of the WinMap has a scale -* term B, and a shift term A, and the transformation of a point is done -* by applying these to each input axis value X in turn, to get the -* output axis value B.X + A. The returned terms take into account the -* current setting of the Invert attribute of the WinMap. - -* Parameters: -* this -* Pointer to the WinMap. -* shift -* The address of a location at which to return a pointer to the -* start of a dynamically allocated array holding the shift terms -* for each axis. -* scale -* The address of a location at which to return a pointer to the -* start of a dynamically allocated array holding the scale terms -* for each axis. - -* Returned Value: -* The number of axes in the WinMap. This is the same as the number of -* elements in the returned arrays. - -* Notes: -* - The returned arrays should be released using astFree when no -* longer needed. -* - NULL pointers can be supplied for "scale" or "shift" if the -* corresponding arrays are not required. -* - A value of zero will be returned, together with NULL pointers -* for "scale" and "shift" if this function is invoked with the -* global error status set, or if it should fail for any reason. -*- -*/ - -/* Local Variables: */ - double *a; /* Pointer to a copy of the shift term array */ - double *aa; /* Pointer to the next shift term */ - double *b; /* Pointer to a copy of the scale term array */ - double *bb; /* Pointer to the next scale term */ - int i; /* Axis count */ - int result; /* The returned number of axes */ - size_t absize; /* Size of shift and scale arrays */ - -/* Initialise. */ - result = 0; - if( scale ) *scale = NULL; - if( shift ) *shift = NULL; - -/* Check the global status. */ - if ( !astOK ) return result; - -/* Get the number of axes in the WinMap. */ - result = astGetNin( this ); - -/* Create copies of the scale and shift terms from the WinMap. */ - absize = sizeof( double )*(size_t) result; - b = (double *) astStore( NULL, (void *) this->b, absize ); - a = (double *) astStore( NULL, (void *) this->a, absize ); - -/* Check the pointers can be used. */ - if( astOK ){ - -/* If the WinMap is inverted, replace the scale and shift terms - by the corresponding values for the inverted mapping. */ - if( astGetInvert( this ) ){ - bb = b; - aa = a; - - for( i = 0; i < result; i++ ){ - if( *aa != AST__BAD && *bb != 0.0 && *bb != AST__BAD ){ - *bb = 1.0/(*bb); - *aa *= -(*bb); - } else { - *bb = AST__BAD; - *aa = AST__BAD; - } - - aa++; - bb++; - - } - } - -/* Store the required pointers, and free arrays which are not required. */ - if( scale ){ - *scale = b; - } else { - b = (double *) astFree( (void *) b ); - } - - if( shift ){ - *shift = a; - } else { - a = (double *) astFree( (void *) a ); - } - - } - -/* If an error has occurred, free the arrays and return zero. */ - if( !astOK ){ - if( scale ) *scale = (double *) astFree( (void *) *scale ); - if( shift ) *shift = (double *) astFree( (void *) *shift ); - result = 0; - } - -/* Return the answer. */ - return result; - -} - -static AstWinMap *WinUnit( AstWinMap *wm, AstUnitMap *um, int winv, - int win1, int *status ){ -/* -* Name: -* WinUnit - -* Purpose: -* Create a WinMap by merging a WinMap and a UnitMap in parallel. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* AstWinMap *WinUnit( AstWinMap *wm, AstUnitMap *um, int winv, int win1, int *status ) - -* Class Membership: -* WinMap member function - -* Description: -* This function creates a new WinMap which performs a mapping -* equivalent to applying the two supplied Mappings in parallel in -* the directions specified by the "invert" flag (the Invert -* attribute of the supplied WinMap is ignored). - -* Parameters: -* wm -* A pointer to the WinMap. -* um -* A pointer to the UnitMap. -* winv -* The invert flag to use with wm. A value of zero causes the forward -* mapping to be used, and a non-zero value causes the inverse -* mapping to be used. -* win1 -* Indicates the order in which the Mappings should be applied. -* -* If win1 is non-zero: -* "wm" applies to the lower axis indices and "um" to the upper -* axis indices. -* -* If win1 is zero: -* "um" applies to the lower axis indices and "wm" to the upper -* axis indices. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to the new WinMap. - -* Notes: -* - The forward direction of the returned WinMap is equivalent to the -* combined effect of the two supplied Mappings, operating in the -* directions specified by "winv". -* - A null pointer will be returned if this function is invoked with the -* global error status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstWinMap *result; /* Pointer to output WinMap */ - double *a; /* Pointer to shift term array */ - double *aa; /* Pointer to next shift term */ - double *ar; /* Pointer to next shift term in result */ - double *b; /* Pointer to scale term array */ - double *bb; /* Pointer to next scale term */ - double *br; /* Pointer to next scale term in result */ - int i; /* Axis index */ - int ninw; /* No. of axes in the WinMap */ - int ninu; /* No. of axes in the UnitMap */ - int old_winv; /* Original setting of WinMap Invert attribute */ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Initialise the returned pointer. */ - result = NULL; - -/* Temporarily set the Invert attribute of the WinMap to the supplied - value. */ - old_winv = astGetInvert( wm ); - astSetInvert( wm, winv ); - -/* Create copies of the scale and shift terms from the WinMap, and store the - number of axes in it. */ - ninw = astWinTerms( wm, &a, &b ); - -/* Get the number of axes in the UnitMap. */ - ninu = astGetNin( um ); - -/* Create the merged WinMap with unspecified corners. */ - result = astWinMap( ninw + ninu, NULL, NULL, NULL, NULL, "", status ); - -/* Check the pointers can be used. */ - if( astOK ){ - -/* If the WinMap applies to the lower axis indices... */ - if( win1 ){ - -/* Use the scale and shift terms from the WinMap for the lower axes of - the new WinMap. */ - aa = a; - bb = b; - ar = result->a; - br = result->b; - - for( i = 0; i < ninw; i++ ){ - *(ar++) = *(aa++); - *(br++) = *(bb++); - } - -/* Use the scale factor to 1.0 and the shift term to zero for the upper axes - of the new WinMap. */ - for( i = 0; i < ninu; i++ ){ - *(ar++) = 0.0; - *(br++) = 1.0; - } - -/* If the WinMap applies to the upper axis indices... */ - } else { - -/* Use the scale factor to 1.0 and the shift term to zero for the lower axes - of the new WinMap. */ - ar = result->a; - br = result->b; - - for( i = 0; i < ninu; i++ ){ - *(ar++) = 0.0; - *(br++) = 1.0; - } - -/* Use the scale and shift terms from the WinMap for the upper axes of - the new WinMap. */ - aa = a; - bb = b; - - for( i = 0; i < ninw; i++ ){ - *(ar++) = *(aa++); - *(br++) = *(bb++); - } - } - } - -/* Free the copies of the scale and shift terms from the supplied WinMap. */ - b = (double *) astFree( (void *) b ); - a = (double *) astFree( (void *) a ); - -/* Re-instate the original setting of the Invert attribute for the - supplied WinMap. */ - astSetInvert( wm, old_winv ); - -/* If an error has occurred, annull the returned WinMap. */ - if( !astOK ) result = astAnnul( result ); - -/* Return a pointer to the output WinMap. */ - return result; -} - -static AstWinMap *WinWin( AstMapping *map1, AstMapping *map2, int inv1, - int inv2, int series, int *status ){ -/* -* Name: -* WinWin - -* Purpose: -* Create a merged WinMap from two supplied WinMaps. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* AstWinMap *WinWin( AstMapping *map1, AstMapping *map2, int inv1, -* int inv2, int series, int *status ) - -* Class Membership: -* WinMap member function - -* Description: -* This function creates a new WinMap which performs a mapping -* equivalent to applying the two supplied WinMaps either in series -* or parallel in the directions specified by the "invert" flags -* (the Invert attributes of the supplied WinMaps are ignored). - -* Parameters: -* map1 -* A pointer to the WinMap to apply first (if in series), or to the -* lower axis indices (if in parallel) -* map2 -* A pointer to the WinMap to apply second (if in series), or to the -* upper axis indices (if in parallel) -* inv1 -* The invert flag to use with map1. A value of zero causes the forward -* mapping to be used, and a non-zero value causes the inverse -* mapping to be used. -* inv2 -* The invert flag to use with map2. -* series -* If non-zero, then the supplied WinMaps are combined in series. -* Otherwise, they are combined in parallel. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to the new WinMap. - -* Notes: -* - The forward direction of the returned WinMap is equivalent to the -* combined effect of the two supplied WinMap, operating in the -* directions specified by "inv1" and "inv2". -* - A null pointer will be returned if this function is invoked with the -* global error status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstWinMap *result; /* Pointer to output WinMap */ - AstWinMap *wm1; /* Pointer to the first supplied WinMap */ - AstWinMap *wm2; /* Pointer to the second supplied WinMap */ - double *a[ 2 ]; /* Pointers to shift term arrays */ - double *a0; /* Pointer to next shift term from WinMap 1 */ - double *a1; /* Pointer to next shift term from WinMap 2 */ - double *ar; /* Pointer to next shift term in result */ - double *b[ 2 ]; /* Pointers to scale term arrays */ - double *b0; /* Pointer to next scale term from WinMap 1 */ - double *b1; /* Pointer to next scale term from WinMap 2 */ - double *br; /* Pointer to next scale term in result */ - double amean; /* Geometric mean of the offset terms */ - int cancel; /* Do the two WinMaps cancel out? */ - int i; /* Axis index */ - int invert[ 2 ]; /* Array of invert flags */ - int nin[ 2 ]; /* No. of axes in the two WinMaps */ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Initialise the returned pointer. */ - result = NULL; - -/* Store pointers to the WinMaps. */ - wm1 = (AstWinMap *) map1; - wm2 = (AstWinMap *) map2; - -/* Temporarily set their Invert attributes to the supplied values. */ - invert[ 0 ] = astGetInvert( wm1 ); - astSetInvert( wm1, inv1 ); - - invert[ 1 ] = astGetInvert( wm2 ); - astSetInvert( wm2, inv2 ); - -/* Create copies of the scale and shift terms from the two WinMaps, - and store the number of axes in each WinMap. The scale and shift terms - returned take into account the setting of the Invert attribute. */ - nin[ 0 ] = astWinTerms( wm1, a, b ); - nin[ 1 ] = astWinTerms( wm2, a + 1, b + 1 ); - -/* Check the pointers can be used. */ - if( astOK ){ - -/* Series */ -/* ====== */ - if( series ){ - -/* Check for equal and opposite WinMaps. Do this explicitly using the - supplied Mappings rather than the values returned by astWinTerms to - avoid the affects of rounding errors in the inversions performed by - astWinTerms. */ - if( ( inv1 == 0 ) != ( inv2 == 0 ) ) { - cancel = 1; - for( i = 0; i < nin[ 0 ]; i++ ){ - if( !astEQUAL( (wm1->a)[ i ], (wm2->a)[ i ] ) || - !astEQUAL( (wm1->b)[ i ], (wm2->b)[ i ] ) ) { - cancel = 0; - break; - } - } - } else { - cancel = 0; - } - -/* If they cancel, just put unit values into the WinMap. */ - if( cancel ) { - a0 = a[ 0 ]; - b0 = b[ 0 ]; - for( i = 0; i < nin[ 0 ]; i++ ){ - *(a0++) = 0.0; - *(b0++) = 1.0; - } - -/* Otherwise, merge the scale and shift terms for the two WinMaps, overwriting - the terms for the first WinMap. To be merged in series, both WinMaps must - have the same number of axes, so it matters not whether we use nin[ 0 ] - or nin[ 1 ] to specify the number of axes. Include rounding checks for values - close to a unit mapping. */ - } else { - a0 = a[ 0 ]; - b0 = b[ 0 ]; - a1 = a[ 1 ]; - b1 = b[ 1 ]; - for( i = 0; i < nin[ 0 ]; i++ ){ - - if( *a0 != AST__BAD && *b0 != AST__BAD && - *a1 != AST__BAD && *b1 != AST__BAD ){ - - amean = sqrt(fabs((*a0)*(*a1))); - - *a0 *= (*b1); - *a0 += (*a1); - *b0 *= (*b1); - - if( fabs( *a0 ) < amean*1E-15 ) *a0 = 0.0; - if( fabs( *b0 - 1.0 ) < 1E-15 ) *b0 = 1.0; - - } else { - *a0 = AST__BAD; - *b0 = AST__BAD; - *a1 = AST__BAD; - *b1 = AST__BAD; - } - -/* Move on to the next axis. */ - a0++; - b0++; - a1++; - b1++; - } - } - -/* Create the merged WinMap with unspecified corners. */ - result = astWinMap( nin[ 0 ], NULL, NULL, NULL, NULL, "", status ); - -/* Store the merged scale and shift terms in the new WinMap. The forward - transformation of this WinMap then corresponds to the combination of the - two supplied WinMaps, taking into account their invert flags. */ - a0 = a[ 0 ]; - b0 = b[ 0 ]; - ar = result->a; - br = result->b; - for( i = 0; i < nin[ 0 ]; i++ ){ - *(ar++) = *(a0++); - *(br++) = *(b0++); - } - -/* Parallel */ -/* ======== */ - } else { - -/* Create the merged WinMap with unspecified corners. */ - result = astWinMap( nin[ 0 ] + nin[ 1 ], NULL, NULL, NULL, NULL, "", status ); - -/* Copy the scale and shift terms into the new WinMap. */ - a0 = a[ 0 ]; - b0 = b[ 0 ]; - a1 = a[ 1 ]; - b1 = b[ 1 ]; - ar = result->a; - br = result->b; - - for( i = 0; i < nin[ 0 ]; i++ ){ - *(ar++) = *(a0++); - *(br++) = *(b0++); - } - - for( i = 0; i < nin[ 1 ]; i++ ){ - *(ar++) = *(a1++); - *(br++) = *(b1++); - } - } - } - -/* Re-instate the original settings of the Invert attributes for the - supplied WinMaps. */ - astSetInvert( wm1, invert[ 0 ] ); - astSetInvert( wm2, invert[ 1 ] ); - -/* Free the memory. */ - a[ 0 ] = (double *) astFree( (void *) a[ 0 ] ); - b[ 0 ] = (double *) astFree( (void *) b[ 0 ] ); - a[ 1 ] = (double *) astFree( (void *) a[ 1 ] ); - b[ 1 ] = (double *) astFree( (void *) b[ 1 ] ); - -/* If an error has occurred, annull the returned WinMap. */ - if( !astOK ) result = astAnnul( result ); - -/* Return a pointer to the output WinMap. */ - return result; -} - -static AstWinMap *WinZoom( AstWinMap *wm, AstZoomMap *zm, int winv, - int zinv, int win1, int series, int *status ){ -/* -* Name: -* WinZoom - -* Purpose: -* Create a WinMap by merging a WinMap and a ZoomMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* AstWinMap *WinZoom( AstWinMap *wm, AstZoomMap *zm, int winv, -* int zinv, int win1, int series, int *status ) - -* Class Membership: -* WinMap member function - -* Description: -* This function creates a new WinMap which performs a mapping -* equivalent to applying the two supplied Mappings in series or -* parallel in the directions specified by the "invert" flags (the -* Invert attributes of the supplied WinMaps are ignored). - -* Parameters: -* wm -* A pointer to the WinMap. -* zm -* A pointer to the ZoomMap. -* winv -* The invert flag to use with wm. A value of zero causes the forward -* mapping to be used, and a non-zero value causes the inverse -* mapping to be used. -* zinv -* The invert flag to use with zm. -* win1 -* Indicates the order in which the Mappings should be applied. -* -* If win1 is non-zero: -* If in series: -* "wm" is applied first followed by "zm". -* If in parallel: -* "wm" applies to the lower axis indices and "zm" to the upper -* axis indices. -* -* If win1 is zero: -* If in series: -* "zm" is applied first followed by "wm". -* If in parallel: -* "zm" applies to the lower axis indices and "wm" to the upper -* axis indices. -* series -* Should be supplied non-zero if the Mappings are to be combined in -* series. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to the new WinMap. - -* Notes: -* - The forward direction of the returned WinMap is equivalent to the -* combined effect of the two supplied Mappings, operating in the -* directions specified by "zinv" and "winv". -* - A null pointer will be returned if this function is invoked with the -* global error status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstWinMap *result; /* Pointer to output WinMap */ - double *a; /* Pointer to shift term array */ - double *aa; /* Pointer to next shift term */ - double *ar; /* Pointer to next shift term in result */ - double *b; /* Pointer to scale term array */ - double *bb; /* Pointer to next scale term */ - double *br; /* Pointer to next scale term in result */ - double zfac; /* Zoom factor */ - int i; /* Axis index */ - int ninw; /* No. of axes in the WinMap */ - int ninz; /* No. of axes in the ZoomMap */ - int old_winv; /* Original setting of WinMap Invert attribute */ - int old_zinv; /* Original setting of ZoomMap Invert attribute */ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Initialise the returned pointer. */ - result = NULL; - -/* Temporarily set the Invert attributes of both Mappings to the supplied - values. */ - old_winv = astGetInvert( wm ); - astSetInvert( wm, winv ); - - old_zinv = astGetInvert( zm ); - astSetInvert( zm, zinv ); - -/* Get the zoom factor implemented by the ZoomMap. Invert it if necessary - since astGetZoom does not take account of the Invert setting. */ - zfac = astGetZoom( zm ); - if( zinv ) zfac = 1.0 / zfac; - -/* Create copies of the scale and shift terms from the WinMap, and store the - number of axes in it. */ - ninw = astWinTerms( wm, &a, &b ); - -/* Check the pointers can be used. */ - if( astOK ){ - -/* First do series mode... */ - if( series ) { - -/* Modify the WinMap scale and shift terms by the zoom factor. How this is - done depends on which way round the Mappings are applied. */ - bb = b; - aa = a; - - for( i = 0; i < ninw; i++ ){ - - if( *aa != AST__BAD && *bb != AST__BAD && zfac != AST__BAD ){ - *bb *= zfac; - if( win1 ) *aa *= zfac; - } else { - *bb = AST__BAD; - *aa = AST__BAD; - } - - aa++; - bb++; - } - -/* Create the merged WinMap with unspecified corners. */ - result = astWinMap( ninw, NULL, NULL, NULL, NULL, "", status ); - -/* Store the merged scale and shift terms in the new WinMap. The forward - transformation of this WinMap then corresponds to the combination of the - two supplied Mappings, taking into account their invert flags. */ - aa = a; - bb = b; - ar = result->a; - br = result->b; - for( i = 0; i < ninw; i++ ){ - *(ar++) = *(aa++); - *(br++) = *(bb++); - } - -/* Now do parallel mode... */ - } else { - -/* Get the number of axes in the ZoomMap. */ - ninz = astGetNin( zm ); - -/* Create the merged WinMap with unspecified corners. */ - result = astWinMap( ninw + ninz, NULL, NULL, NULL, NULL, "", status ); - -/* If the WinMap applies to the lower axis indices... */ - if( win1 ) { - -/* Use the scale and shift terms from the WinMap for the lower axes of - the new WinMap. */ - aa = a; - bb = b; - ar = result->a; - br = result->b; - - for( i = 0; i < ninw; i++ ){ - *(ar++) = *(aa++); - *(br++) = *(bb++); - } - -/* Use the scale factor (with zero shift) from the ZoomMap for the upper axes - of the new WinMap. */ - for( i = 0; i < ninz; i++ ){ - *(ar++) = 0.0; - *(br++) = zfac; - } - -/* If the WinMap applies to the upper axis indices... */ - } else { - -/* Use the scale factor (with zero shift) from the ZoomMap for the lower axes - of the new WinMap. */ - ar = result->a; - br = result->b; - - for( i = 0; i < ninz; i++ ){ - *(ar++) = 0.0; - *(br++) = zfac; - } - -/* Use the scale and shift terms from the WinMap for the upper axes of - the new WinMap. */ - aa = a; - bb = b; - - for( i = 0; i < ninw; i++ ){ - *(ar++) = *(aa++); - *(br++) = *(bb++); - } - } - } - } - -/* Free the copies of the scale and shift terms from the supplied WinMap. */ - b = (double *) astFree( (void *) b ); - a = (double *) astFree( (void *) a ); - -/* Re-instate the original settings of the Invert attribute for the - supplied Mappings. */ - astSetInvert( wm, old_winv ); - astSetInvert( zm, old_zinv ); - -/* If an error has occurred, annull the returned WinMap. */ - if( !astOK ) result = astAnnul( result ); - -/* Return a pointer to the output WinMap. */ - return result; -} - -/* Functions which access class attributes. */ -/* ---------------------------------------- */ -/* Implement member functions to access the attributes associated with - this class using the macros defined for this purpose in the - "object.h" file. For a description of each attribute, see the class - interface (in the associated .h file). */ - -/* Copy constructor. */ -/* ----------------- */ -static void Copy( const AstObject *objin, AstObject *objout, int *status ) { -/* -* Name: -* Copy - -* Purpose: -* Copy constructor for WinMap objects. - -* Type: -* Private function. - -* Synopsis: -* void Copy( const AstObject *objin, AstObject *objout, int *status ) - -* Description: -* This function implements the copy constructor for WinMap objects. - -* Parameters: -* objin -* Pointer to the WinMap to be copied. -* objout -* Pointer to the WinMap being constructed. -* status -* Pointer to the inherited status variable. - -*/ - -/* Local Variables: */ - AstWinMap *out; /* Pointer to output WinMap */ - AstWinMap *in; /* Pointer to input WinMap */ - int ncoord; /* No. of axes for the mapping */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the input and output WinMaps. */ - in= (AstWinMap *) objin; - out = (AstWinMap *) objout; - -/* Get the number of coordinates mapped by the WinMap. */ - ncoord = astGetNin( in ); - -/* Allocate memory holding copies of the scales and shifts window defining the - mapping. */ - out->a = (double *) astStore( NULL, (void *) in->a, - sizeof(double)*(size_t)ncoord ); - out->b = (double *) astStore( NULL, (void *) in->b, - sizeof(double)*(size_t)ncoord ); - -/* If an error occurred, free any allocated memory. */ - if ( !astOK ) { - out->a = (double *) astFree( (void *) out->a ); - out->b = (double *) astFree( (void *) out->b ); - } - -} - -/* Destructor. */ -/* ----------- */ -static void Delete( AstObject *obj, int *status ) { -/* -* Name: -* Delete - -* Purpose: -* Destructor for WinMap objects. - -* Type: -* Private function. - -* Synopsis: -* void Delete( AstObject *obj, int *status ) - -* Description: -* This function implements the destructor for WinMap objects. - -* Parameters: -* obj -* Pointer to the WinMap to be deleted. -* status -* Pointer to the inherited status variable. - -* Notes: -* - This destructor does nothing and exists only to maintain a -* one-to-one correspondence between destructors and copy -* constructors. -*/ - -/* Local Variables: */ - AstWinMap *this; /* Pointer to WinMap */ - -/* Obtain a pointer to the WinMap structure. */ - this = (AstWinMap *) obj; - -/* Free the memory holding the scales and shifts. */ - this->a = (double *) astFree( (void *) this->a ); - this->b = (double *) astFree( (void *) this->b ); - -} - -/* Dump function. */ -/* -------------- */ -static void Dump( AstObject *this_object, AstChannel *channel, int *status ) { -/* -* Name: -* Dump - -* Purpose: -* Dump function for WinMap objects. - -* Type: -* Private function. - -* Synopsis: -* void Dump( AstObject *this, AstChannel *channel, int *status ) - -* Description: -* This function implements the Dump function which writes out data -* for the WinMap class to an output Channel. - -* Parameters: -* this -* Pointer to the WinMap whose data are being written. -* channel -* Pointer to the Channel to which the data are being written. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Constants: */ -#define COMMENT_LEN 50 /* Maximum length of a comment string */ -#define KEY_LEN 50 /* Maximum length of a keyword */ - -/* Local Variables: */ - AstWinMap *this; /* Pointer to the WinMap structure */ - char buff[ KEY_LEN + 1 ]; /* Buffer for keyword string */ - char comment[ COMMENT_LEN + 1 ]; /* Buffer for comment string */ - int axis; /* Axis index */ - int ncoord; /* No. of axes for mapping */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the WinMap structure. */ - this = (AstWinMap *) this_object; - -/* Get the number of coordinates to be mapped. */ - ncoord = astGetNin( this ); - -/* Write out values representing the instance variables for the - WinMap class. Accompany these with appropriate comment strings, - possibly depending on the values being written.*/ - -/* The scales and shifts. */ - for( axis = 0; axis < ncoord; axis++ ){ - (void) sprintf( buff, "Sft%d", axis + 1 ); - (void) sprintf( comment, "Shift for axis %d", axis + 1 ); - astWriteDouble( channel, buff, (this->a)[ axis ] != 0.0, 0, - (this->a)[ axis ], comment ); - (void) sprintf( buff, "Scl%d", axis + 1 ); - (void) sprintf( comment, "Scale factor for axis %d", axis + 1 ); - astWriteDouble( channel, buff, (this->b)[ axis ] != 1.0, 0, - (this->b)[ axis ], comment ); - } - -/* Undefine macros local to this function. */ -#undef COMMENT_LEN -#undef KEY_LEN -} - -/* Standard class functions. */ -/* ========================= */ -/* Implement the astIsAWinMap and astCheckWinMap functions using the macros - defined for this purpose in the "object.h" header file. */ -astMAKE_ISA(WinMap,Mapping) -astMAKE_CHECK(WinMap) - -AstWinMap *astWinMap_( int ncoord, const double c1_in[], const double c2_in[], - const double c1_out[], const double c2_out[], - const char *options, int *status, ...) { -/* -*++ -* Name: -c astWinMap -f AST_WINMAP - -* Purpose: -* Create a WinMap. - -* Type: -* Public function. - -* Synopsis: -c #include "winmap.h" -c AstWinMap *astWinMap( int ncoord, -c const double ina[], const double inb[], -c const double outa[], const double outb[], -c const char *options, ... ) -f RESULT = AST_WINMAP( NCOORD, INA, INB, OUTA, OUTB, OPTIONS, STATUS ) - -* Class Membership: -* WinMap constructor. - -* Description: -* This function creates a new WinMap and optionally initialises its -* attributes. -* -* A Winmap is a linear Mapping which transforms a rectangular -* window in one coordinate system into a similar window in another -* coordinate system by scaling and shifting each axis (the window -* edges being parallel to the coordinate axes). -* -* A WinMap is specified by giving the coordinates of two opposite -* corners (A and B) of the window in both the input and output -* coordinate systems. - -* Parameters: -c ncoord -f NCOORD = INTEGER (Given) -* The number of coordinate values for each point to be -* transformed (i.e. the number of dimensions of the space in -* which the points will reside). The same number is applicable -* to both input and output points. -c ina -f INA( NCOORD ) = DOUBLE PRECISION (Given) -c An array containing the "ncoord" -f An array containing the -* coordinates of corner A of the window in the input coordinate -* system. -c inb -f INB( NCOORD ) = DOUBLE PRECISION (Given) -c An array containing the "ncoord" -f An array containing the -* coordinates of corner B of the window in the input coordinate -* system. -c outa -f OUTA( NCOORD ) = DOUBLE PRECISION (Given) -c An array containing the "ncoord" -f An array containing the -* coordinates of corner A of the window in the output coordinate -* system. -c outb -f OUTB( NCOORD ) = DOUBLE PRECISION (Given) -c An array containing the "ncoord" -f An array containing the -* coordinates of corner B of the window in the output coordinate -* system. -c options -f OPTIONS = CHARACTER * ( * ) (Given) -c Pointer to a null-terminated string containing an optional -c comma-separated list of attribute assignments to be used for -c initialising the new WinMap. The syntax used is identical to -c that for the astSet function and may include "printf" format -c specifiers identified by "%" symbols in the normal way. -f A character string containing an optional comma-separated -f list of attribute assignments to be used for initialising the -f new WinMap. The syntax used is identical to that for the -f AST_SET routine. -c ... -c If the "options" string contains "%" format specifiers, then -c an optional list of additional arguments may follow it in -c order to supply values to be substituted for these -c specifiers. The rules for supplying these are identical to -c those for the astSet function (and for the C "printf" -c function). -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Returned Value: -c astWinMap() -f AST_WINMAP = INTEGER -* A pointer to the new WinMap. - -* Notes: -* - A null Object pointer (AST__NULL) will be returned if this -c function is invoked with the AST error status set, or if it -f function is invoked with STATUS set to an error value, or if it -* should fail for any reason. - -* Status Handling: -* The protected interface to this function includes an extra -* parameter at the end of the parameter list descirbed above. This -* parameter is a pointer to the integer inherited status -* variable: "int *status". - -*-- -*/ - -/* Local Variables: */ - astDECLARE_GLOBALS /* Pointer to thread-specific global data */ - AstWinMap *new; /* Pointer to new WinMap */ - va_list args; /* Variable argument list */ - -/* Get a pointer to the thread specific global data structure. */ - astGET_GLOBALS(NULL); - -/* Check the global status. */ - if ( !astOK ) return NULL; - -/* Initialise the WinMap, allocating memory and initialising the - virtual function table as well if necessary. */ - new = astInitWinMap( NULL, sizeof( AstWinMap ), !class_init, &class_vtab, - "WinMap", ncoord, c1_in, c2_in, c1_out, c2_out ); - -/* If successful, note that the virtual function table has been - initialised. */ - if ( astOK ) { - class_init = 1; - -/* Obtain the variable argument list and pass it along with the options string - to the astVSet method to initialise the new WinMap's attributes. */ - va_start( args, status ); - astVSet( new, options, NULL, args ); - va_end( args ); - -/* If an error occurred, clean up by deleting the new object. */ - if ( !astOK ) new = astDelete( new ); - } - -/* Return a pointer to the new WinMap. */ - return new; -} - -AstWinMap *astWinMapId_( int ncoord, const double c1_in[], const double c2_in[], - const double c1_out[], const double c2_out[], - const char *options, ... ) { -/* -* Name: -* astWinMapId_ - -* Purpose: -* Create a WinMap. - -* Type: -* Private function. - -* Synopsis: -* #include "winmap.h" -* AstWinMap *astWinMapId_( int ncoord, const double c1_in[], -* const double c2_in[], const double c1_out[], -* const double c2_out[], -* const char *options, ... ) - -* Class Membership: -* WinMap constructor. - -* Description: -* This function implements the external (public) interface to the -* astWinMap constructor function. It returns an ID value (instead -* of a true C pointer) to external users, and must be provided -* because astWinMap_ has a variable argument list which cannot be -* encapsulated in a macro (where this conversion would otherwise -* occur). -* -* The variable argument list also prevents this function from -* invoking astWinMap_ directly, so it must be a re-implementation -* of it in all respects, except for the final conversion of the -* result to an ID value. - -* Parameters: -* As for astWinMap_. - -* Returned Value: -* The ID value associated with the new WinMap. -*/ - -/* Local Variables: */ - astDECLARE_GLOBALS /* Pointer to thread-specific global data */ - AstWinMap *new; /* Pointer to new WinMap */ - va_list args; /* Variable argument list */ - int *status; /* Pointer to inherited status value */ - -/* Get a pointer to the inherited status value. */ - status = astGetStatusPtr; - -/* Get a pointer to the thread specific global data structure. */ - astGET_GLOBALS(NULL); - -/* Check the global status. */ - if ( !astOK ) return NULL; - -/* Initialise the WinMap, allocating memory and initialising the - virtual function table as well if necessary. */ - new = astInitWinMap( NULL, sizeof( AstWinMap ), !class_init, &class_vtab, - "WinMap", ncoord, c1_in, c2_in, c1_out, c2_out ); - -/* If successful, note that the virtual function table has been - initialised. */ - if ( astOK ) { - class_init = 1; - -/* Obtain the variable argument list and pass it along with the options string - to the astVSet method to initialise the new WinMap's attributes. */ - va_start( args, options ); - astVSet( new, options, NULL, args ); - va_end( args ); - -/* If an error occurred, clean up by deleting the new object. */ - if ( !astOK ) new = astDelete( new ); - } - -/* Return an ID value for the new WinMap. */ - return astMakeId( new ); -} - -AstWinMap *astInitWinMap_( void *mem, size_t size, int init, - AstWinMapVtab *vtab, const char *name, - int ncoord, const double *c1_in, - const double *c2_in, const double *c1_out, - const double *c2_out, int *status ) { -/* -*+ -* Name: -* astInitWinMap - -* Purpose: -* Initialise a WinMap. - -* Type: -* Protected function. - -* Synopsis: -* #include "winmap.h" -* AstWinMap *astInitWinMap( void *mem, size_t size, int init, -* AstWinMapVtab *vtab, const char *name, -* int ncoord, const double *c1_in, -* const double *c2_in, -* const double *c1_out, const double *c2_out ) - -* Class Membership: -* WinMap initialiser. - -* Description: -* This function is provided for use by class implementations to initialise -* a new WinMap object. It allocates memory (if necessary) to accommodate -* the WinMap plus any additional data associated with the derived class. -* It then initialises a WinMap structure at the start of this memory. If -* the "init" flag is set, it also initialises the contents of a virtual -* function table for a WinMap at the start of the memory passed via the -* "vtab" parameter. - -* Parameters: -* mem -* A pointer to the memory in which the WinMap is to be initialised. -* This must be of sufficient size to accommodate the WinMap data -* (sizeof(WinMap)) plus any data used by the derived class. If a value -* of NULL is given, this function will allocate the memory itself using -* the "size" parameter to determine its size. -* size -* The amount of memory used by the WinMap (plus derived class data). -* This will be used to allocate memory if a value of NULL is given for -* the "mem" parameter. This value is also stored in the WinMap -* structure, so a valid value must be supplied even if not required for -* allocating memory. -* init -* A logical flag indicating if the WinMap's virtual function table is -* to be initialised. If this value is non-zero, the virtual function -* table will be initialised by this function. -* vtab -* Pointer to the start of the virtual function table to be associated -* with the new WinMap. -* name -* Pointer to a constant null-terminated character string which contains -* the name of the class to which the new object belongs (it is this -* pointer value that will subsequently be returned by the astGetClass -* method). -* ncoord -* The number of coordinate values per point. -* c1_in -* The input coordinates of corner C1 of the window. -* c2_in -* The input coordinates of corner C2 of the window. -* c1_out -* The output coordinates of corner C1 of the window. -* c2_out -* The output coordinates of corner C2 of the window. - -* Returned Value: -* A pointer to the new WinMap. - -* Notes: -* - A null pointer will be returned if this function is invoked with the -* global error status set, or if it should fail for any reason. -*- -*/ - -/* Local Variables: */ - AstWinMap *new; /* Pointer to new WinMap */ - double denom; /* Denominotor */ - int axis; /* Axis index */ - -/* Check the global status. */ - if ( !astOK ) return NULL; - -/* If necessary, initialise the virtual function table. */ - if ( init ) astInitWinMapVtab( vtab, name ); - -/* Initialise. */ - new = NULL; - -/* Initialise a Mapping structure (the parent class) as the first component - within the WinMap structure, allocating memory if necessary. Specify that - the Mapping should be defined in both the forward and inverse directions. */ - new = (AstWinMap *) astInitMapping( mem, size, 0, - (AstMappingVtab *) vtab, name, - ncoord, ncoord, 1, 1 ); - - if ( astOK ) { - -/* Initialise the WinMap data. */ -/* ---------------------------- */ -/* Allocate memory to hold the shift and scale for each axis. */ - new->a = (double *) astMalloc( sizeof(double)*(size_t)ncoord ); - new->b = (double *) astMalloc( sizeof(double)*(size_t)ncoord ); - -/* Check the pointers can be used */ - if( astOK ){ - -/* Calculater and store the shift and scale for each axis. */ - for( axis = 0; axis < ncoord; axis++ ){ - -/* If any of the corners have not been provided, store bad values. */ - if( !c1_in || !c1_out || !c2_in || !c2_out ) { - (new->b)[ axis ] = AST__BAD; - (new->a)[ axis ] = AST__BAD; - -/* Otherwise, check the corners are good (not AST__BAD or NaN)... */ - } else if( astISGOOD(c2_in[ axis ]) && astISGOOD(c1_in[ axis ]) && - astISGOOD(c2_out[ axis ]) && astISGOOD(c1_out[ axis ]) ){ - - denom = c2_in[ axis ] - c1_in[ axis ]; - if( denom != 0.0 ){ - (new->b)[ axis ] = ( c2_out[ axis ] - c1_out[ axis ] )/denom; - (new->a)[ axis ] = c1_out[ axis ] - (new->b)[ axis ]*c1_in[ axis ]; - } else { - (new->b)[ axis ] = AST__BAD; - (new->a)[ axis ] = AST__BAD; - } - - } else { - (new->b)[ axis ] = AST__BAD; - (new->a)[ axis ] = AST__BAD; - } - - } - - } - -/* If an error occurred, clean up by deleting the new WinMap. */ - if ( !astOK ) new = astDelete( new ); - } - -/* Return a pointer to the new WinMap. */ - return new; -} - -AstWinMap *astLoadWinMap_( void *mem, size_t size, - AstWinMapVtab *vtab, const char *name, - AstChannel *channel, int *status ) { -/* -*+ -* Name: -* astLoadWinMap - -* Purpose: -* Load a WinMap. - -* Type: -* Protected function. - -* Synopsis: -* #include "winmap.h" -* AstWinMap *astLoadWinMap( void *mem, size_t size, -* AstWinMapVtab *vtab, const char *name, -* AstChannel *channel ) - -* Class Membership: -* WinMap loader. - -* Description: -* This function is provided to load a new WinMap using data read -* from a Channel. It first loads the data used by the parent class -* (which allocates memory if necessary) and then initialises a -* WinMap structure in this memory, using data read from the input -* Channel. -* -* If the "init" flag is set, it also initialises the contents of a -* virtual function table for a WinMap at the start of the memory -* passed via the "vtab" parameter. - - -* Parameters: -* mem -* A pointer to the memory into which the WinMap is to be -* loaded. This must be of sufficient size to accommodate the -* WinMap data (sizeof(WinMap)) plus any data used by derived -* classes. If a value of NULL is given, this function will -* allocate the memory itself using the "size" parameter to -* determine its size. -* size -* The amount of memory used by the WinMap (plus derived class -* data). This will be used to allocate memory if a value of -* NULL is given for the "mem" parameter. This value is also -* stored in the WinMap structure, so a valid value must be -* supplied even if not required for allocating memory. -* -* If the "vtab" parameter is NULL, the "size" value is ignored -* and sizeof(AstWinMap) is used instead. -* vtab -* Pointer to the start of the virtual function table to be -* associated with the new WinMap. If this is NULL, a pointer -* to the (static) virtual function table for the WinMap class -* is used instead. -* name -* Pointer to a constant null-terminated character string which -* contains the name of the class to which the new object -* belongs (it is this pointer value that will subsequently be -* returned by the astGetClass method). -* -* If the "vtab" parameter is NULL, the "name" value is ignored -* and a pointer to the string "WinMap" is used instead. - -* Returned Value: -* A pointer to the new WinMap. - -* Notes: -* - A null pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Local Constants. */ - astDECLARE_GLOBALS /* Pointer to thread-specific global data */ -#define KEY_LEN 50 /* Maximum length of a keyword */ - -/* Local Variables: */ - AstWinMap *new; /* Pointer to the new WinMap */ - char buff[ KEY_LEN + 1 ]; /* Buffer for keyword string */ - int axis; /* Axis index */ - int ncoord; /* The number of coordinate axes */ - -/* Get a pointer to the thread specific global data structure. */ - astGET_GLOBALS(channel); - -/* Initialise. */ - new = NULL; - -/* Check the global error status. */ - if ( !astOK ) return new; - -/* If a NULL virtual function table has been supplied, then this is - the first loader to be invoked for this WinMap. In this case the - WinMap belongs to this class, so supply appropriate values to be - passed to the parent class loader (and its parent, etc.). */ - if ( !vtab ) { - size = sizeof( AstWinMap ); - vtab = &class_vtab; - name = "WinMap"; - -/* If required, initialise the virtual function table for this class. */ - if ( !class_init ) { - astInitWinMapVtab( vtab, name ); - class_init = 1; - } - } - -/* Invoke the parent class loader to load data for all the ancestral - classes of the current one, returning a pointer to the resulting - partly-built WinMap. */ - new = astLoadMapping( mem, size, (AstMappingVtab *) vtab, name, - channel ); - - if ( astOK ) { - -/* Get the number of axis for the mapping. */ - ncoord = astGetNin( (AstMapping *) new ); - -/* Allocate memory to hold the scales and shifts. */ - new->a = (double *) astMalloc( sizeof(double)*(size_t)ncoord ); - new->b = (double *) astMalloc( sizeof(double)*(size_t)ncoord ); - -/* Read input data. */ -/* ================ */ -/* Request the input Channel to read all the input data appropriate to - this class into the internal "values list". */ - astReadClassData( channel, "WinMap" ); - -/* Now read each individual data item from this list and use it to - initialise the appropriate instance variable(s) for this class. */ - -/* The scales and shifts. */ - for( axis = 0; axis < ncoord; axis++ ){ - (void) sprintf( buff, "sft%d", axis + 1 ); - (new->a)[ axis ] = astReadDouble( channel, buff, 0.0 ); - (void) sprintf( buff, "scl%d", axis + 1 ); - (new->b)[ axis ] = astReadDouble( channel, buff, 1.0 ); - } - } - -/* If an error occurred, clean up by deleting the new WinMap. */ - if ( !astOK ) new = astDelete( new ); - -/* Return the new WinMap pointer. */ - return new; - -/* Undefine macros local to this function. */ -#undef KEY_LEN -} - -/* Virtual function interfaces. */ -/* ============================ */ -/* These provide the external interface to the virtual functions defined by - this class. Each simply checks the global error status and then locates and - executes the appropriate member function, using the function pointer stored - in the object's virtual function table (this pointer is located using the - astMEMBER macro defined in "object.h"). - - Note that the member function may not be the one defined here, as it may - have been over-ridden by a derived class. However, it should still have the - same interface. */ - -int astWinTerms_( AstWinMap *this, double **scale, double **shift, int *status ){ - if( !astOK ) return 0; - return (**astMEMBER(this,WinMap,WinTerms))( this, scale, shift, status ); -} - - - - |