update ast 8.6.2

1 files changed, 4389 insertions, 0 deletions

diff --git a/ast/winmap.c b/ast/winmap.c
new file mode 100644
index 0000000..5ba97d5
--- /dev/null
+++ b/ast/winmap.c
@@ -0,0 +1,4389 @@
+/*
+*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 );
+}
+
+
+
+