/*
*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) 2004 Central Laboratory of the Research Councils

*  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.
*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 "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. */
/* ================= */
/* 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? */

/* Pointers to parent class methods which are extended by this class. */
static AstPointSet *(* parent_transform)( AstMapping *, AstPointSet *, int, AstPointSet * );
static const char *(* parent_getattrib)( AstObject *, const char * );
static int (* parent_testattrib)( AstObject *, const char * );
static void (* parent_clearattrib)( AstObject *, const char * );
static void (* parent_setattrib)( AstObject *, const char * );

/* 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 * );
static AstWinMap *WinUnit( AstWinMap *, AstUnitMap *, int, int );
static AstWinMap *WinWin( AstMapping *, AstMapping *, int, int, int );
static AstWinMap *WinZoom( AstWinMap *, AstZoomMap *, int, int, int, int );
static const char *GetAttrib( AstObject *, const char * );
static int CanSwap( AstMapping *, AstMapping *, int, int, int * );
static int MapMerge( AstMapping *, int, int, int *, AstMapping ***, int ** );
static int TestAttrib( AstObject *, const char * );
static int WinTerms( AstWinMap *, double **, double ** );
static void ClearAttrib( AstObject *, const char * );
static void Copy( const AstObject *, AstObject * );
static void Delete( AstObject * );
static void Dump( AstObject *, AstChannel * );
static void PermGet( AstPermMap *, int **, int **, double ** );
static void SetAttrib( AstObject *, const char * );
static void WinMat( AstMapping **, int *, int );
static void WinPerm( AstMapping **, int *, int );
static void WinWcs( AstMapping **, int *, int );

/* Function Macros */
/* =============== */
/* Macros which return the maximum and minimum of two values. */
#define MAX(aa,bb) ((aa)>(bb)?(aa):(bb))
#define MIN(aa,bb) ((aa)<(bb)?(aa):(bb))

/* Macro to check for equality of floating point values. We cannot
compare bad values directory because of the danger of floating point
exceptions, so bad values are dealt with explicitly. */
#define EQUAL(aa,bb) (((aa)==AST__BAD)?(((bb)==AST__BAD)?1:0):(((bb)==AST__BAD)?0:(fabs((aa)-(bb))<=1.0E5*MAX((fabs(aa)+fabs(bb))*DBL_EPSILON,DBL_MIN))))

/* Member functions. */
/* ================= */
static int CanSwap( AstMapping *map1, AstMapping *map2, int inv1, int inv2,
                    int *simpler ){
/*
*  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 )

*  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.

*  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 );
         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 preceeds the WinMap, this will be the case if the PermMap
   has more outputs than inputs. If the WinMap preceeds 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 ) {
/*
*  Name:
*     ClearAttrib

*  Purpose:
*     Clear an attribute value for a WinMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "winmap.h"
*     void ClearAttrib( AstObject *this, const char *attrib )

*  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.
*/

/* Local Variables: */
   AstWinMap *this;             /* Pointer to the WinMap structure */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the WinMap structure. */
   this = (AstWinMap *) this_object;

/* 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 );

}

static const char *GetAttrib( AstObject *this_object, const char *attrib ) {
/*
*  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 )

*  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.

*  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: */
   AstWinMap *this;             /* Pointer to the WinMap structure */
   const char *result;           /* Pointer value to return */

/* Initialise. */
   result = NULL;

/* Check the global error status. */   
   if ( !astOK ) return result;

/* Obtain a pointer to the WinMap structure. */
   this = (AstWinMap *) this_object;

/* 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 );

/* Return the result. */
   return result;

/* Undefine macros local to this function. */
#undef BUFF_LEN
}

void astInitWinMapVtab_(  AstWinMapVtab *vtab, const char *name ) {
/*
*+
*  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: */
   AstObjectVtab *object;        /* Pointer to Object component of Vtab */
   AstMappingVtab *mapping;      /* Pointer to Mapping component of Vtab */

/* Check the local error status. */
   if ( !astOK ) return;

/* 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_init variable to generate this unique value. */
   vtab->check = &class_init;

/* 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_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. */
   mapping->MapMerge = MapMerge;

/* 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 );

}

static int MapMerge( AstMapping *this, int where, int series, int *nmap,
                     AstMapping ***map_list, int **invert_list ) {
/*
*  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 )

*  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.

*  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 neighbour;        /* Index of Mapping with which to swap */
   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;
   neighbour = 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( !EQUAL( ( 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, "" );

/* 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 );
               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 );
               } else {
                  newwm = WinZoom( (AstWinMap *)( *map_list )[ i2 ], 
                                   (AstZoomMap *)( *map_list )[ i1 ],
                           ( *invert_list )[ i2 ], ( *invert_list )[ i1 ], 0, 1 );
               }
               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, "" );
               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, "" );
               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, "" );
                  nc[ 1 ] = (AstMapping *) astCmpMap( mc[ 1 ], newwm2, 1, "" );
               } else {
                  nc[ 0 ] = (AstMapping *) astCmpMap( newwm, mc[ 0 ], 1, "" );
                  nc[ 1 ] = (AstMapping *) astCmpMap( newwm2, mc[ 1 ], 1, "" );
               }
               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, "" );
               }

/* 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 ) {
               astAnnul( ( *map_list )[ i1 ] );
               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 );
            } 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 );
            } 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;
               neighbour = i1;
            } else if( do2 || nstep2 != -1 ){
               nclass = class2;
               i1 = where;
               i2 = where + 1;
               neighbour = i2;
            } 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 ){

/* It is possible that the neighbouring Mapping with which we are about to 
   swap could also merge with the target Mapping. When the neighbouring
   Mapping is reconsidered it may well swap the pair back to put itself nearer 
   the target Mapping. We need to be careful not to end up in an infinite loop 
   in which the pair of neighbouring Mappings are constantly swapped backwards 
   and forwards as each attempts to put itself closer to the target Mapping.
   To prevent this, we only swap the pair of Mappings if the neighbouring
   Mapping could not itself merge with the target Mapping. Check to see
   if this is the case by attempting to merge the neighbouring Mapping with
   the target Mapping. */
               map2 = astClone( (*map_list)[ neighbour ] );
               nmapt = *nmap - neighbour;
               maplt = *map_list + neighbour;
               invlt = *invert_list + neighbour;
               result = astMapMerge( map2, 0, series, &nmapt, &maplt, &invlt );
               map2 = astAnnul( map2 );

/* If the above call produced a change in the  Mapping list, return the
   remaining number of mappings.. */
               if( result != -1 ){
                  *nmap = nmapt + neighbour;

/* Otherwise, if there was no change in the mapping list... */
               } else {

                  if( !strcmp( nclass, "MatrixMap" ) ){
                     WinMat( (*map_list) + i1, (*invert_list) + i1, where - i1 );

                  } else if( !strcmp( nclass, "PermMap" ) ){
                     WinPerm( (*map_list) + i1, (*invert_list) + i1, where - i1 );

                  } else if( !strcmp( nclass, "WcsMap" ) ){
                     WinWcs( (*map_list) + i1, (*invert_list) + i1, where - i1 );
                  }

/* Store the index of the first modified Mapping. */
                  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 );
                     } else if( !strcmp( nclass, "PermMap" ) ){
                        WinPerm( mc, ic, where - i1 );
                     } else if( !strcmp( nclass, "WcsMap" ) ){
                        WinWcs( mc, ic, where - i1 );
                     }

/* 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 );
               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 );
               } else {
                  newwm = WinZoom( (AstWinMap *)( *map_list )[ i2 ], 
                                   (AstZoomMap *)( *map_list )[ i1 ],
                           ( *invert_list )[ i2 ], ( *invert_list )[ i1 ], 0, 0 );
               }
               invert = 0;

            } else {
               if( i1 == where ){
                  newwm = WinUnit( (AstWinMap *)( *map_list )[ i1 ], 
                                   (AstUnitMap *)( *map_list )[ i2 ],
                                   ( *invert_list )[ i1 ], 1 );
               } else {
                  newwm = WinUnit( (AstWinMap *)( *map_list )[ i2 ], 
                                   (AstUnitMap *)( *map_list )[ i1 ],
                                   ( *invert_list )[ i2 ], 0 );
               }
               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 void PermGet( AstPermMap *map, int **outperm, int **inperm, 
                     double **consts ){
/*
*  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 )

*  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.

*  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, "" );
   pset2 = astPointSet( 2, nout, "" );

/* 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 void SetAttrib( AstObject *this_object, const char *setting ) {
/*
*  Name:
*     astSetAttrib

*  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.
*/

/* Local Variables: */
   AstWinMap *this;             /* Pointer to the WinMap structure */
   int len;                      /* Length of setting string */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the WinMap structure. */
   this = (AstWinMap *) this_object;

/* Obtain the length of the setting string. */
   len = (int) strlen( setting );

/* The WinMap class currently has no attributes, so pass it on to the parent
   method for further interpretation. */
   (*parent_setattrib)( this_object, setting );

}

static int TestAttrib( AstObject *this_object, const char *attrib ) {
/*
*  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 )

*  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.

*  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: */
   AstWinMap *this;             /* Pointer to the WinMap structure */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Obtain a pointer to the WinMap structure. */
   this = (AstWinMap *) this_object;

/* The WinMap class currently has no attributes, so pass it on to the parent
   method for further interpretation. */
   result = (*parent_testattrib)( this_object, attrib );

/* Return the result, */
   return result;
}

static AstPointSet *Transform( AstMapping *this, AstPointSet *in,
                               int forward, AstPointSet *out ) {
/*
*  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 )

*  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.

*  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 );

/* 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.", 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  ){
/*
*  Name:
*     WinMat

*  Purpose:
*     Swap a WinMap and a MatrixMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "winmap.h"
*     void WinMat( AstMapping **maps, int *inverts, int iwm )

*  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.

*/

/* 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, "" );

/* Create a PointSet holding a single position given by the shift terms
   in the supplied WinMap. */
   pset1 = astPointSet( 1, nin, "" );
   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, "" );

/* 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  ){
/*
*  Name:
*     WinWcs

*  Purpose:
*     Swap a WinMap and a WcsMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "winmap.h"
*     void WinWcs( AstMapping **maps, int *inverts, int iwm )

*  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.

*/

/* 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  ){
/*
*  Name:
*     WinPerm

*  Purpose:
*     Swap a WinMap and a PermMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "winmap.h"
*     void WinPerm( AstMapping **maps, int *inverts, int iwm )

*  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.

*  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 );

   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, "" );

/* 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, "" );

/* 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, "" );

/* 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 ){
/*
*+
*  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 ){
/*
*  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 )

*  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.

*  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 );
   
/* Check the pointers can be used. */
   if( astOK ){

/* 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, "" );

/* 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 ){
/*
*  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 )

*  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.

*  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 */
   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 ){

/* 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. */
         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 ){
   
               *a0 *= (*b1);
               *a0 += (*a1);
               *b0 *= (*b1);
   
            } 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, "" );

/* 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, "" );

/* 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 ){
/*
*  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 )

*  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.

*  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. */
   zfac = astGetZoom( zm );

/* 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, "" );

/* 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, "" );

/* 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 ) {
/*
*  Name:
*     Copy

*  Purpose:
*     Copy constructor for WinMap objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Copy( const AstObject *objin, AstObject *objout )

*  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.

*/

/* 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 ) {
/*
*  Name:
*     Delete

*  Purpose:
*     Destructor for WinMap objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Delete( AstObject *obj )

*  Description:
*     This function implements the destructor for WinMap objects.

*  Parameters:
*     obj
*        Pointer to the WinMap to be deleted.

*  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 ) {
/*
*  Name:
*     Dump

*  Purpose:
*     Dump function for WinMap objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Dump( AstObject *this, AstChannel *channel )

*  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.
*/

/* 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,check,&class_init)
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, ... ) {
/*
*++
*  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.
*--
*/

/* Local Variables: */
   AstWinMap *new;              /* Pointer to new WinMap */
   va_list args;                /* Variable argument list */

/* 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, 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: */
   AstWinMap *new;              /* Pointer to new WinMap */
   va_list args;                /* Variable argument list */

/* 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, 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 ) {
/*
*+
*  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 ) {
/*
*+
*  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. */
#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 */

/* 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 ){
   if( !astOK ) return 0;
   return (**astMEMBER(this,WinMap,WinTerms))( this, scale, shift );
}