upgrade AST

1 files changed, 5127 insertions, 0 deletions

diff --git a/ast/cmpregion.c b/ast/cmpregion.c
new file mode 100644
index 0000000..c3b5b07
--- /dev/null
+++ b/ast/cmpregion.c
@@ -0,0 +1,5127 @@
+/*
+*class++
+*  Name:
+*     CmpRegion
+
+*  Purpose:
+*     A combination of two regions within a single Frame
+
+*  Constructor Function:
+c     astCmpRegion
+f     AST_CMPREGION
+
+*  Description:
+*     A CmpRegion is a Region which allows two component
+*     Regions (of any class) to be combined to form a more complex
+*     Region. This combination may be performed a boolean AND, OR
+*     or XOR (exclusive OR) operator. If the AND operator is
+*     used, then a position is inside the CmpRegion only if it is
+*     inside both of its two component Regions. If the OR operator is
+*     used, then a position is inside the CmpRegion if it is inside
+*     either (or both) of its two component Regions. If the XOR operator
+*     is used, then a position is inside the CmpRegion if it is inside
+*     one but not both of its two component Regions. Other operators can
+*     be formed by negating one or both component Regions before using
+*     them to construct a new CmpRegion.
+*
+*     The two component Region need not refer to the same coordinate
+*     Frame, but it must be possible for the
+c     astConvert
+f     AST_CONVERT
+*     function to determine a Mapping between them (an error will be
+*     reported otherwise when the CmpRegion is created). For instance,
+*     a CmpRegion may combine a Region defined within an ICRS SkyFrame
+*     with a Region defined within a Galactic SkyFrame. This is
+*     acceptable because the SkyFrame class knows how to convert between
+*     these two systems, and consequently the
+c     astConvert
+f     AST_CONVERT
+*     function will also be able to convert between them. In such cases,
+*     the second component Region will be mapped into the coordinate Frame
+*     of the first component Region, and the Frame represented by the
+*     CmpRegion as a whole will be the Frame of the first component Region.
+*
+*     Since a CmpRegion is itself a Region, it can be used as a
+*     component in forming further CmpRegions. Regions of arbitrary
+*     complexity may be built from simple individual Regions in this
+*     way.
+
+*  Inheritance:
+*     The CmpRegion class inherits from the Region class.
+
+*  Attributes:
+*     The CmpRegion class does not define any new attributes beyond those
+*     which are applicable to all Regions.
+
+*  Functions:
+c     The CmpRegion class does not define any new functions beyond those
+f     The CmpRegion class does not define any new routines beyond those
+*     which are applicable to all Regions.
+
+*  Copyright:
+*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
+*     Research Councils
+*     Copyright (C) 2009 Science & Technology Facilities Council.
+*     All Rights Reserved.
+
+*  Licence:
+*     This program is free software: you can redistribute it and/or
+*     modify it under the terms of the GNU Lesser General Public
+*     License as published by the Free Software Foundation, either
+*     version 3 of the License, or (at your option) any later
+*     version.
+*
+*     This program is distributed in the hope that it will be useful,
+*     but WITHOUT ANY WARRANTY; without even the implied warranty of
+*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*     GNU Lesser General Public License for more details.
+*
+*     You should have received a copy of the GNU Lesser General
+*     License along with this program.  If not, see
+*     <http://www.gnu.org/licenses/>.
+
+*  Authors:
+*     DSB: David S. Berry (Starlink)
+
+*  History:
+*     7-OCT-2004 (DSB):
+*        Original version.
+*     28-MAY-2007 (DSB):
+*        - Corrected RegBaseMesh.
+*        - In RegBaseBox, if the CmpRegion is bounded find the box by
+*        finding the extreme position sin a mesh covering the boundary.
+*     20-JAN-2009 (DSB):
+*        Over-ride astRegBasePick.
+*     19-MAR-2009 (DSB):
+*        Over-ride the astDecompose method.
+*     8-SEP-2009 (DSB):
+*        Fix logic in RegTrace.
+*     9-SEP-2009 (DSB):
+*        - Added astCmpRegionList
+*        - Added support for XOR
+*        - Override astGetObjSize.
+*     27-APR-2012 (DSB):
+*        - Cache the bounded property.
+*        - Speed up plotting of CmpRegions by using the cached negation
+*        of a Region instead of setting the Regions's Negated flag (which
+*        causes the Region's cache to be cleared).
+*     30-APR-2012 (DSB):
+*        Use geodesic distance to measure distances around the two component
+*        Regions when tracing the border. Previously, a distance normalised
+*        from zero to one was used for both component Regions, but this gives
+*        greater priority to Regions higher in the CmpRegion nesting order,
+*        resulting in a high chance that lower Regions will not be seen.
+*     7-JUN-2012 (DSB):
+*        Override astRegSplit method.
+*     21-NOV-2012 (DSB):
+*        Map the regions returned by RegSplit into the current Frame of the
+*        CmpRegion.
+*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 CmpRegion
+
+/* Include files. */
+/* ============== */
+/* Interface definitions. */
+/* ---------------------- */
+
+#include "globals.h"             /* Thread-safe global data access */
+#include "error.h"               /* Error reporting facilities */
+#include "memory.h"              /* Memory allocation facilities */
+#include "object.h"              /* Base Object class */
+#include "pointset.h"            /* Sets of points/coordinates */
+#include "region.h"              /* Regions (parent class) */
+#include "channel.h"             /* I/O channels */
+#include "nullregion.h"          /* Boundless Regions */
+#include "cmpregion.h"           /* Interface definition for this class */
+#include "unitmap.h"             /* Unit Mapings */
+
+/* Error code definitions. */
+/* ----------------------- */
+#include "ast_err.h"             /* AST error codes */
+
+/* C header files. */
+/* --------------- */
+#include <stdarg.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+#include <limits.h>
+
+/* Module Variables. */
+/* ================= */
+
+/* Address of this static variable is used as a unique identifier for
+   member of this class. */
+static int class_check;
+
+/* Pointers to parent class methods which are extended by this class. */
+static AstPointSet *(* parent_transform)( AstMapping *, AstPointSet *, int, AstPointSet *, int * );
+static AstRegion *(* parent_getdefunc)( AstRegion *, int * );
+static void (* parent_setregfs)( AstRegion *, AstFrame *, int * );
+static AstMapping *(* parent_simplify)( AstMapping *, int * );
+static int (* parent_equal)( AstObject *, AstObject *, int * );
+static void (* parent_setclosed)( AstRegion *, int, int * );
+static void (* parent_setmeshsize)( AstRegion *, int, int * );
+static void (* parent_clearclosed)( AstRegion *, int * );
+static void (* parent_clearmeshsize)( AstRegion *, int * );
+static double (*parent_getfillfactor)( AstRegion *, int * );
+static void (*parent_regsetattrib)( AstRegion *, const char *, char **, int * );
+static void (*parent_regclearattrib)( AstRegion *, const char *, char **, int * );
+static void (* parent_resetcache)( AstRegion *, int * );
+static int (* parent_getobjsize)( AstObject *, int * );
+
+#if defined(THREAD_SAFE)
+static int (* parent_managelock)( AstObject *, int, int, AstObject **, int * );
+#endif
+
+
+#ifdef THREAD_SAFE
+/* Define how to initialise thread-specific globals. */
+#define GLOBAL_inits \
+   globals->Class_Init = 0;
+
+/* Create the function that initialises global data for this module. */
+astMAKE_INITGLOBALS(CmpRegion)
+
+/* Define macros for accessing each item of thread specific global data. */
+#define class_init astGLOBAL(CmpRegion,Class_Init)
+#define class_vtab astGLOBAL(CmpRegion,Class_Vtab)
+
+
+#include <pthread.h>
+
+
+#else
+
+
+/* Define the class virtual function table and its initialisation flag
+   as static variables. */
+static AstCmpRegionVtab class_vtab;   /* Virtual function table */
+static int class_init = 0;       /* Virtual function table initialised? */
+
+#endif
+
+/* External Interface Function Prototypes. */
+/* ======================================= */
+/* The following functions have public prototypes only (i.e. no
+   protected prototypes), so we must provide local prototypes for use
+   within this module. */
+AstCmpRegion *astCmpRegionId_( void *, void *, int, const char *, ... );
+
+/* Prototypes for Private Member Functions. */
+/* ======================================== */
+static AstMapping *Simplify( AstMapping *, int * );
+static AstPointSet *RegBaseMesh( AstRegion *, int * );
+static AstPointSet *Transform( AstMapping *, AstPointSet *, int, AstPointSet *, int * );
+static AstRegion *GetDefUnc( AstRegion *, int * );
+static AstRegion *MatchRegion( AstRegion *, int, AstRegion *, const char *, int * );
+static AstRegion *RegBasePick( AstRegion *this, int, const int *, int * );
+static AstRegion **RegSplit( AstRegion *, int *, int * );
+static double GetFillFactor( AstRegion *, int * );
+static int CmpRegionList( AstCmpRegion *, int *, AstRegion ***, int * );
+static int Equal( AstObject *, AstObject *, int * );
+static int GetBounded( AstRegion *, int * );
+static int GetObjSize( AstObject *, int * );
+static int RegPins( AstRegion *, AstPointSet *, AstRegion *, int **, int * );
+static int RegTrace( AstRegion *, int, double *, double **, int * );
+static void ClearClosed( AstRegion *, int * );
+static void ClearMeshSize( AstRegion *, int * );
+static void Copy( const AstObject *, AstObject *, int * );
+static void Decompose( AstMapping *, AstMapping **, AstMapping **, int *, int *, int *, int * );
+static void Delete( AstObject *, int * );
+static void Dump( AstObject *, AstChannel *, int * );
+static void GetRegions( AstCmpRegion *, AstRegion **, AstRegion **, int *, int *, int *, int * );
+static void RegBaseBox( AstRegion *, double *, double *, int * );
+static void RegBaseBox2( AstRegion *, double *, double *, int * );
+static void RegClearAttrib( AstRegion *, const char *, char **, int * );
+static void RegSetAttrib( AstRegion *, const char *, char **, int * );
+static void ResetCache( AstRegion *this, int * );
+static void SetBreakInfo( AstCmpRegion *, int, int * );
+static void SetClosed( AstRegion *, int, int * );
+static void SetMeshSize( AstRegion *, int, int * );
+static void SetRegFS( AstRegion *, AstFrame *, int * );
+static void XORCheck( AstCmpRegion *, int * );
+
+#if defined(THREAD_SAFE)
+static int ManageLock( AstObject *, int, int, AstObject **, int * );
+#endif
+
+
+/* Member functions. */
+/* ================= */
+int CmpRegionList( AstCmpRegion *this, int *nreg, AstRegion ***reg_list,
+                   int *status ) {
+/*
+*+
+*  Name:
+*     astCmpRegionList
+
+*  Purpose:
+*     Decompose a CmpRegion into a sequence of simpler Regions.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     int astCmpRegionList( AstCmpRegion *this, int *nreg,
+*                           AstRegion ***reg_list, int *status )
+
+*  Class Membership:
+*     CmpRegion method.
+
+*  Description:
+*     This function decomposes a CmpRegion into a sequence of simpler
+*     Regions which may be applied in sequence to achieve the same
+*     effect.
+
+*  Parameters:
+*     this
+*        Pointer to the CmpRegion to be decomposed (the CmpRegion is not
+*        actually modified by this function).
+*     nreg
+*        The address of an int which holds a count of the number of
+*        individual Regions in the decomposition. On entry, this
+*        should count the number of Regions already in the
+*        "*reg_list" array (below). On exit, it is updated to include
+*        any new Regions appended by this function.
+*     reg_list
+*        Address of a pointer to an array of Region pointers. On
+*        entry, this array pointer should either be NULL (if no
+*        Regions have yet been obtained) or should point at a
+*        dynamically allocated array containing Region pointers
+*        ("*nreg" in number) which have been obtained from a previous
+*        invocation of this function.
+*
+*        On exit, the dynamic array will be enlarged to contain any
+*        new Region pointers that result from the decomposition
+*        requested. These pointers will be appended to any previously
+*        present, and the array pointer will be updated as necessary
+*        to refer to the enlarged array (any space released by the
+*        original array will be freed automatically).
+*
+*        The new Region pointers returned will identify a sequence of
+*        Region which, when applied in order, will represent an area
+*        equivalent to that of the original Region.
+*
+*        All the Region pointers returned by this function should be
+*        annulled by the caller, using astAnnul, when no longer
+*        required. The dynamic array holding these pointers should
+*        also be freed, using astFree.
+
+*  Returned Value:
+*     An integer identifying the boolean operation that should be used to
+*     combine the Regions returned in "reg_list". This will be AST__AND
+*     or AST__OR.
+
+*-
+*/
+
+/* Local Variables: */
+   AstCmpRegion *cmpreg;
+   int add;
+   int result;
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__AND;
+
+/* Check if this CmpRegion has an equivalent XOR representation. Is so,
+   store details of the XOR representation in the CmpRegion. */
+   XORCheck( this, status );
+
+/* The CmpRegion class only has full support for AND and OR operators.
+   However, it can also represent XOR operators, but it does this by
+   an equivalent set of AND and OR operators. When an XOR CmpRegion is
+   created, the original supplied argument regions are stored in
+   "this->xor1" and "this->xor2", and the component Regions placed in the
+   new CmpRegion are actually CmpRegions that implement the equivalent
+   of an XOR operation, using AND and OR operators. We want to hide this
+   to the outside world, so if the supplied CmpRegion represents an XOR
+   operation, add the XOR regions to the returned list, and return an
+   XOR operator. */
+   if( this->xor1 ) {
+      *reg_list = astGrow( *reg_list, *nreg + 2, sizeof( AstRegion * ) );
+      if( astOK ) {
+         ( *reg_list )[ (*nreg)++ ] = astClone( this->xor1 );
+         ( *reg_list )[ (*nreg)++ ] = astClone( this->xor2 );
+      }
+      result = AST__XOR;
+
+/* For AND and OR operators, we deal with the component Regions directly. */
+   } else {
+
+/* If the first component of the supplied CmpRegion is itself a CmpRegion
+   that uses the same boolean operator as "this", call this function
+   recursively to add its component Regions to the returned list. */
+      add = 1;
+      if( astIsACmpRegion( this->region1 ) ) {
+         cmpreg = (AstCmpRegion *) this->region1;
+         if( cmpreg->oper == this->oper ) {
+            (void) CmpRegionList( cmpreg, nreg, reg_list, status );
+            add = 0;
+         }
+      }
+
+/* Otherwise, add the component Region directly into the returned list of
+   Regions. */
+      if( add ) {
+         *reg_list = astGrow( *reg_list, *nreg + 1, sizeof( AstRegion * ) );
+         if( astOK ) {
+            ( *reg_list )[ *nreg ] = astClone( this->region1 );
+            ( *nreg )++;
+         }
+      }
+
+/* Do the same for the second component region */
+      add = 1;
+      if( astIsACmpRegion( this->region2 ) ) {
+         cmpreg = (AstCmpRegion *) this->region2;
+         if( cmpreg->oper == this->oper ) {
+            (void) CmpRegionList( cmpreg, nreg, reg_list, status );
+            add = 0;
+         }
+      }
+
+      if( add ) {
+         *reg_list = astGrow( *reg_list, *nreg + 1, sizeof( AstRegion * ) );
+         if( astOK ) {
+            ( *reg_list )[ *nreg ] = astClone( this->region2 );
+            ( *nreg )++;
+         }
+      }
+
+      result = this->oper;
+   }
+
+/* Return the boolean operator used to combine the regions in the
+   returned array. */
+   return result;
+}
+
+static void Decompose( AstMapping *this_mapping, AstMapping **map1,
+                       AstMapping **map2, int *series, int *invert1,
+                       int *invert2, int *status ) {
+/*
+*
+*  Name:
+*     Decompose
+
+*  Purpose:
+*     Decompose a CmpRegion into two component Regions.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void Decompose( AstMapping *this, AstMapping **map1,
+*                     AstMapping **map2, int *series,
+*                     int *invert1, int *invert2, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the protected astDecompose
+*     method inherited from the Mapping class).
+
+*  Description:
+*     This function returns pointers to two Mappings which, when applied
+*     either in series or parallel, are equivalent to the supplied Mapping.
+*
+*     Since the Frame class inherits from the Mapping class, Frames can
+*     be considered as special types of Mappings and so this method can
+*     be used to decompose either CmpMaps, CmpFrames, CmpRegions or Prisms.
+
+*  Parameters:
+*     this
+*        Pointer to the Mapping.
+*     map1
+*        Address of a location to receive a pointer to first component
+*        Mapping.
+*     map2
+*        Address of a location to receive a pointer to second component
+*        Mapping.
+*     series
+*        Address of a location to receive a value indicating if the
+*        component Mappings are applied in series or parallel. A non-zero
+*        value means that the supplied Mapping is equivalent to applying map1
+*        followed by map2 in series. A zero value means that the supplied
+*        Mapping is equivalent to applying map1 to the lower numbered axes
+*        and map2 to the higher numbered axes, in parallel.
+*     invert1
+*        The value of the Invert attribute to be used with map1.
+*     invert2
+*        The value of the Invert attribute to be used with map2.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - Any changes made to the component rames using the returned
+*     pointers will be reflected in the supplied CmpFrame.
+
+*-
+*/
+
+
+/* Local Variables: */
+   AstCmpRegion *this;              /* Pointer to CmpRegion structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the CmpMap structure. */
+   this = (AstCmpRegion *) this_mapping;
+
+/* The components Frames of a CmpRegion are considered to be series
+   Mappings. */
+   if( series ) *series = 1;
+
+/* The Frames are returned in their original order whether or not the
+   CmpRegion has been inverted. */
+   if( map1 ) *map1 = astClone( this->region1 );
+   if( map2 ) *map2 = astClone( this->region2 );
+
+/* The invert flags dont mean anything for a Region, but we return them
+   anyway. If the CmpRegion has been inverted, return inverted Invert flags. */
+   if( astGetInvert( this ) ) {
+      if( invert1 ) *invert1 = astGetInvert( this->region1 ) ? 0 : 1;
+      if( invert2 ) *invert2 = astGetInvert( this->region2 ) ? 0 : 1;
+
+/* If the CmpRegion has not been inverted, return the current Invert flags. */
+   } else {
+      if( invert1 ) *invert1 = astGetInvert( this->region1 );
+      if( invert2 ) *invert2 = astGetInvert( this->region2 );
+   }
+}
+
+static int Equal( AstObject *this_object, AstObject *that_object, int *status ) {
+/*
+*  Name:
+*     Equal
+
+*  Purpose:
+*     Test if two Objects are equivalent.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     int Equal( AstObject *this_object, AstObject *that_object, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astEqual protected
+*     method inherited from the Region class).
+
+*  Description:
+*     This function returns a boolean result (0 or 1) to indicate whether
+*     two CmpRegions are equivalent.
+
+*  Parameters:
+*     this
+*        Pointer to the first CmpRegion.
+*     that
+*        Pointer to the second CmpRegion.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     One if the CmpRegions are equivalent, zero otherwise.
+
+*  Notes:
+*     - The CmpRegions are equivalent if their component Regions are
+*     equivalent and if they have the same boolean operation, negation
+*     and closed flags.
+*     - 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: */
+   AstCmpRegion *that;
+   AstCmpRegion *this;
+   int result;
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Invoke the Equal method inherited from the parent Region class. This checks
+   that the Objects are both of the same class, and have the same Negated
+   and Closed flags (amongst other things). */
+   if( (*parent_equal)( this_object, that_object, status ) ) {
+
+/* Obtain pointers to the two CmpRegion structures. */
+      this = (AstCmpRegion *) this_object;
+      that = (AstCmpRegion *) that_object;
+
+/* Test their first component Regions for equality. */
+      if( astEqual( this->region1, that->region1 ) ) {
+
+/* Test their second component Regions for equality. */
+         if( astEqual( this->region2, that->region2 ) ) {
+
+/* Test their boolean operator for equality. */
+            if( this->oper == that->oper ) result = 1;
+         }
+      }
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result, */
+   return result;
+}
+
+/*
+*  Name:
+*     MAKE_SET
+
+*  Purpose:
+*     Define a function to set an attribute value for a CmpRegion.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     MAKE_SET(attribute,lattribute,type)
+
+*  Class Membership:
+*     Defined by the CmpRegion class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static void Set<Attribute>( AstRegion *this, <Type> value )
+*
+*     that sets the value of a specified Region attribute in the parent
+*     Region structure and also in the component Regions.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*     lattribute
+*        Name of the attribute, all in lower case.
+*     type
+*        The C type of the attribute.
+*/
+
+/* Define the macro. */
+#define MAKE_SET(attribute,lattribute,type) \
+static void Set##attribute( AstRegion *this_region, type value, int *status ) { \
+\
+/* Local Variables: */ \
+   AstCmpRegion *this;         /* Pointer to the CmpRegion structure */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Use the parent method to set the value in the parent Region structure. */ \
+   (*parent_set##lattribute)( this_region, value, status ); \
+\
+/* Also set the value in the two component Regions. */ \
+   this = (AstCmpRegion *) this_region; \
+   astSet##attribute( this->region1, value ); \
+   astSet##attribute( this->region2, value ); \
+}
+
+/* Use the above macro to create accessors for the MeshSize and Closed attributes. */
+MAKE_SET(MeshSize,meshsize,int)
+MAKE_SET(Closed,closed,int)
+
+/* Undefine the macro. */
+#undef MAKE_SET
+
+/*
+*  Name:
+*     MAKE_CLEAR
+
+*  Purpose:
+*     Define a function to clear an attribute value for a CmpRegion.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     MAKE_CLEAR(attribute,lattribute)
+
+*  Class Membership:
+*     Defined by the CmpRegion class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static void Clear<Attribute>( AstRegion *this )
+*
+*     that sets the value of a specified Region attribute in the parent
+*     Region structure and also in the component Regions.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*     lattribute
+*        Name of the attribute, all in lower case.
+*/
+
+/* Define the macro. */
+#define MAKE_CLEAR(attribute,lattribute) \
+static void Clear##attribute( AstRegion *this_region, int *status ) { \
+\
+/* Local Variables: */ \
+   AstCmpRegion *this;         /* Pointer to the CmpRegion structure */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Use the parent method to clear the value in the parent Region structure. */ \
+   (*parent_clear##lattribute)( this_region, status ); \
+\
+/* Also clear the value in the two component Regions. */ \
+   this = (AstCmpRegion *) this_region; \
+   astClear##attribute( this->region1 ); \
+   astClear##attribute( this->region2 ); \
+}
+
+/* Use the above macro to create accessors for the MeshSize and Closed attributes. */
+MAKE_CLEAR(MeshSize,meshsize)
+MAKE_CLEAR(Closed,closed)
+
+/* Undefine the macro. */
+#undef MAKE_CLEAR
+
+static int GetBounded( AstRegion *this_region, int *status ) {
+/*
+*  Name:
+*     GetBounded
+
+*  Purpose:
+*     Is the Region bounded?
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     int GetBounded( AstRegion *this, int *status )
+
+*  Class Membership:
+*     CmpRegion method (over-rides the astGetBounded method inherited from
+*     the Region class).
+
+*  Description:
+*     This function returns a flag indicating if the Region is bounded.
+*     The implementation provided by the base Region class is suitable
+*     for Region sub-classes representing the inside of a single closed
+*     curve (e.g. Circle, Ellipse, Box, etc). Other sub-classes (such as
+*     CmpRegion, PointList, etc ) may need to provide their own
+*     implementations.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Non-zero if the Region is bounded. Zero otherwise.
+
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;        /* Pointer to CmpRegion structure */
+   AstRegion *reg1;           /* Pointer to first component Region */
+   AstRegion *reg2;           /* Pointer to second component Region */
+   int neg1;                  /* Negated flag to use with first component */
+   int neg2;                  /* Negated flag to use with second component */
+   int oper;                  /* Combination operator */
+   int overlap;               /* Nature of overlap between components */
+   int reg1b;                 /* Is the first component Region bounded?*/
+   int reg2b;                 /* Is the second component Region bounded?*/
+   int result;                /* Returned result */
+
+/* Initialise */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* Only calculated a new value if there is no cached value in the Region. */
+   if( this->bounded == -INT_MAX ) {
+
+/* Get the component Regions, how they should be combined, and the
+   Negated values which should be used with them. The returned values
+   take account of whether the supplied CmpRegion has itself been Negated
+   or not. The returned Regions represent regions within the base Frame
+   of the FrameSet encapsulated by the parent Region structure. */
+      GetRegions( this, &reg1, &reg2, &oper, &neg1, &neg2, status );
+
+/* If the first component Region does not have the required value for
+   its "Negated" attribute, use the negation of "reg1" in place of "reg1"
+   itself. */
+      if( neg1 != astGetNegated( reg1 ) ) {
+         AstRegion *tmp = astGetNegation( reg1 );
+         (void) astAnnul( reg1 );
+         reg1 = tmp;
+      }
+
+/* If the second component Region does not have the required value for
+   its "Negated" attribute, use the negation of "reg2" in place of "reg2"
+   itself. */
+      if( neg2 != astGetNegated( reg2 ) ) {
+         AstRegion *tmp = astGetNegation( reg2 );
+         (void) astAnnul( reg2 );
+         reg2 = tmp;
+      }
+
+/* See if either of the component Regions is bounded. */
+      reg1b = astGetBounded( reg1 );
+      reg2b = astGetBounded( reg2 );
+
+/* If the regions are ANDed... */
+      if( oper == AST__AND ) {
+
+/* If either one of the two components are bounded, then the AND region is
+   bounded. */
+         if( reg1b || reg2b ) {
+            result = 1;
+
+/* If neither of the two components is bounded, then the AND region is
+   unbounded if there is partial or no overlap between them and is bounded
+   otherwise. */
+         } else {
+            overlap = astOverlap( reg1, reg2 );
+            if( overlap == 1 || overlap == 4 || overlap == 6 ) {
+               result = 0;
+            } else {
+               result = 1;
+            }
+         }
+
+/* If the regions are ORed... */
+      } else {
+
+/* If either one of the two components is unbounded, then the OR region is
+   unbounded. */
+         if( !reg1b || !reg2b ) {
+            result = 0;
+
+/* If both of the two components are bounded, then the OR region is also
+   bounded. */
+         } else {
+            result = 1;
+         }
+      }
+
+/* Free resources. */
+      reg1 = astAnnul( reg1 );
+      reg2 = astAnnul( reg2 );
+
+/* Cache the value in the CmpRegion. */
+      this->bounded = astOK ? result : -INT_MAX;
+   }
+
+/* Return zero if an error occurred. Otherwise, return the cached value. */
+   if( astOK ) {
+      result = ( this->bounded == -INT_MAX ) ? 0 : this->bounded;
+   } else {
+      result = 0;
+   }
+
+/* Return the required pointer. */
+   return result;
+}
+
+static double GetFillFactor( AstRegion *this_region, int *status ) {
+/*
+*  Name:
+*     GetFillFactor
+
+*  Purpose:
+*     Obtain the value of the FillFactor attribute for a CmpRegion.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     double GetFillFactor( AstRegion *this, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astGetFillFactor method inherited
+*     from the Region class).
+
+*  Description:
+*     This function returns the value of the FillFactor attribute for a
+*     CmpRegion.  A suitable default value is returned if no value has
+*     previously been set.
+
+*  Parameters:
+*     this
+*        Pointer to the CmpRegion.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The FillFactor value to use.
+
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;
+   double result;
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Obtain a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* See if a FillFactor value has been set. If so, use the parent
+   astGetFillFactor  method to obtain it. */
+   if ( astTestFillFactor( this ) ) {
+      result = (*parent_getfillfactor)( this_region, status );
+
+/* Otherwise, we will generate a default value equal to the FillFactor values
+   of the first component Region. */
+   } else {
+      result = astGetFillFactor( this->region1 );
+   }
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+static int GetObjSize( AstObject *this_object, int *status ) {
+/*
+*  Name:
+*     GetObjSize
+
+*  Purpose:
+*     Return the in-memory size of an Object.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     int GetObjSize( AstObject *this, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astGetObjSize protected
+*     method inherited from the parent class).
+
+*  Description:
+*     This function returns the in-memory size of the supplied CmpRegion,
+*     in bytes.
+
+*  Parameters:
+*     this
+*        Pointer to the CmpRegion.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The Object size, in bytes.
+
+*  Notes:
+*     - A value of zero will be returned if this function is invoked
+*     with the global status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;        /* Pointer to CmpRegion structure */
+   int result;                /* Result value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointers to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_object;
+
+/* Invoke the GetObjSize method inherited from the parent class, and then
+   add on any components of the class structure defined by this class
+   which are stored in dynamically allocated memory. */
+   result = (*parent_getobjsize)( this_object, status );
+
+   result += astGetObjSize( this->region1 );
+   result += astGetObjSize( this->region2 );
+   if( this->xor1 ) result += astGetObjSize( this->xor1 );
+   if( this->xor2 ) result += astGetObjSize( this->xor2 );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result, */
+   return result;
+}
+
+static void GetRegions( AstCmpRegion *this, AstRegion **reg1, AstRegion **reg2,
+                        int *oper, int *neg1, int *neg2, int *status ) {
+/*
+*
+*  Name:
+*     GetRegions
+
+*  Purpose:
+*     Get the component Regions of a CmpRegion.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void GetRegions( AstCmpRegion *this, AstRegion **reg1, AstRegion **reg2,
+*                      int *oper, int *neg1, int *neg2, int *status )
+
+*  Class Membership:
+*     CmpRegion member function
+
+*  Description:
+*     This function returns pointers to two Regions which, when applied
+*     using the returned boolean operator, are equivalent to the supplied
+*     Region. If the CmpRegion has been negated, then the returned operator
+*     and "negated" flags will be set such that they represent the
+*     negated CmpRegion.
+*
+*     The current Frames in both the returned component Regions will be
+*     equivalent to the base Frame in the FrameSet encapsulated by the
+*     parent Region structure.
+
+*  Parameters:
+*     this
+*        Pointer to the CmpRegion.
+*     reg1
+*        Address of a location to receive a pointer to first component
+*        Region. The current Frame in this region will be equivalent to
+*        the base Frame in the FrameSet
+*     reg2
+*        Address of a location to receive a pointer to second component
+*        Region.
+*     oper
+*        Address of a location to receive a value indicating how the
+*        component Regions are combined together. This will be one of
+*        AST__AND or AST__OR
+*     neg1
+*        The value of the Negated attribute to be used with reg1.
+*     neg2
+*        The value of the Negated attribute to be used with reg2.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - Any changes made to the component Regions using the returned
+*     pointers will be reflected in the supplied CmpRegion.
+
+*-
+*/
+
+/* Initialise */
+   if( reg1 ) *reg1 = NULL;
+   if( reg2 ) *reg2 = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Return the component Region pointers. */
+   if( reg1 ) *reg1 = astClone( this->region1 );
+   if( reg2 ) *reg2 = astClone( this->region2 );
+
+/* Initialise the other returned items. Note, the CmpRegion initialiser
+   stored a deep copy of the supplied component Regions, and so we do not
+   need to worry about attributes of the components having been changed
+   after the creation of the CmpRegion. This is different to the CmpMap
+   class which merely clones its supplied component pointers and so has
+   to save copies of the original Invert settings within the CmpMap
+   structure. */
+   if( oper ) *oper = this->oper;
+   if( neg1 ) *neg1 = astGetNegated( this->region1 );
+   if( neg2 ) *neg2 = astGetNegated( this->region2 );
+
+/* If the CmpRegion has been inverted, we modify the boolean operator and
+   negation flags so that they reflect the inverted CmpRegion. */
+   if( astGetNegated( this ) ) {
+
+/* If the component Regions are combined using AND, then the negated
+   CmpRegion combines its negated components using  OR. */
+      if( this->oper == AST__AND ){
+         if( oper ) *oper = AST__OR;
+         if( neg1 ) *neg1 = *neg1 ? 0 : 1;
+         if( neg2 ) *neg2 = *neg2 ? 0 : 1;
+
+/* If the component Regions are combined using OR, then the negated CmpRegion
+   combines its negated components using  AND. */
+      } else if( this->oper == AST__OR ){
+         if( oper ) *oper = AST__AND;
+         if( neg1 ) *neg1 = *neg1 ? 0 : 1;
+         if( neg2 ) *neg2 = *neg2 ? 0 : 1;
+
+      } else if( astOK ) {
+         astError( AST__INTER, "GetRegions(%s): The %s refers to an unknown "
+                   "boolean operator with identifier %d (internal AST "
+                   "programming error).", status, astGetClass( this ),
+                   astGetClass( this ), this->oper );
+      }
+   }
+}
+
+static AstRegion *GetDefUnc( AstRegion *this_region, int *status ) {
+/*
+*  Name:
+*     GetDefUnc
+
+*  Purpose:
+*     Obtain a pointer to the default uncertainty Region for a given Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     AstRegion *GetDefUnc( AstRegion *this )
+
+*  Class Membership:
+*     CmpRegion method (over-rides the astGetDefUnc method inherited from
+*     the Region class).
+
+*     This function returns a pointer to a Region which represents the
+*     default uncertainty associated with a position on the boundary of the
+*     given  Region. The returned Region refers to the base Frame within the
+*     FrameSet encapsulated by the supplied Region.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     A pointer to the Region. This should be annulled (using astAnnul)
+*     when no longer needed.
+
+*  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: */
+   AstCmpRegion *this;        /* Pointer to CmpRegion structure */
+   AstRegion *result;         /* Returned pointer */
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* If the first component region has non-default uncertainty, use it as
+   the default uncertainty for the CmpRegion. Note, the current Frame of
+   an uncertainty Region is assumed to be the same as the base Frame in the
+   CmpRegion. */
+   if( astTestUnc( this->region1 ) ) {
+      result = astGetUncFrm( this->region1, AST__CURRENT );
+
+/* Otherwise, if the second component region has non-default uncertainty,
+   use it as the default uncertainty for the CmpRegion. */
+   } else if( astTestUnc( this->region2 ) ) {
+      result = astGetUncFrm( this->region2, AST__CURRENT );
+
+/* Otherwise, use the parent method to determine the default uncertainty. */
+   } else {
+      result = (* parent_getdefunc)( this_region, status );
+   }
+
+/* Return NULL if an error occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the required pointer. */
+   return result;
+}
+
+void astInitCmpRegionVtab_(  AstCmpRegionVtab *vtab, const char *name, int *status ) {
+/*
+*+
+*  Name:
+*     astInitCmpRegionVtab
+
+*  Purpose:
+*     Initialise a virtual function table for a CmpRegion.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void astInitCmpRegionVtab( AstCmpRegionVtab *vtab, const char *name )
+
+*  Class Membership:
+*     CmpRegion vtab initialiser.
+
+*  Description:
+*     This function initialises the component of a virtual function
+*     table which is used by the CmpRegion class.
+
+*  Parameters:
+*     vtab
+*        Pointer to the virtual function table. The components used by
+*        all ancestral classes will be initialised if they have not already
+*        been initialised.
+*     name
+*        Pointer to a constant null-terminated character string which contains
+*        the name of the class to which the virtual function table belongs (it
+*        is this pointer value that will subsequently be returned by the Object
+*        astClass function).
+*-
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   AstMappingVtab *mapping;      /* Pointer to Mapping component of Vtab */
+   AstObjectVtab *object;        /* Pointer to Object component of Vtab */
+   AstRegionVtab *region;        /* Pointer to Region component of Vtab */
+
+/* Check the local error status. */
+   if ( !astOK ) return;
+
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* Initialize the component of the virtual function table used by the
+   parent class. */
+   astInitRegionVtab( (AstRegionVtab *) vtab, name );
+
+/* Store a unique "magic" value in the virtual function table. This
+   will be used (by astIsACmpRegion) to determine if an object belongs to
+   this class.  We can conveniently use the address of the (static)
+   class_check variable to generate this unique value. */
+   vtab->id.check = &class_check;
+   vtab->id.parent = &(((AstRegionVtab *) vtab)->id);
+
+/* Initialise member function pointers. */
+/* ------------------------------------ */
+/* Store pointers to the member functions (implemented here) that
+   provide virtual methods for this class. */
+
+   vtab->CmpRegionList = CmpRegionList;
+
+/* 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;
+   region = (AstRegionVtab *) vtab;
+
+   parent_transform = mapping->Transform;
+   mapping->Transform = Transform;
+
+   parent_simplify = mapping->Simplify;
+   mapping->Simplify = Simplify;
+
+   parent_getdefunc = region->GetDefUnc;
+   region->GetDefUnc = GetDefUnc;
+
+   parent_setregfs = region->SetRegFS;
+   region->SetRegFS = SetRegFS;
+
+   parent_resetcache = region->ResetCache;
+   region->ResetCache = ResetCache;
+
+   parent_equal = object->Equal;
+   object->Equal = Equal;
+
+   parent_getobjsize = object->GetObjSize;
+   object->GetObjSize = GetObjSize;
+
+#if defined(THREAD_SAFE)
+   parent_managelock = object->ManageLock;
+   object->ManageLock = ManageLock;
+#endif
+
+   parent_clearclosed = region->ClearClosed;
+   region->ClearClosed = ClearClosed;
+
+   parent_clearmeshsize = region->ClearMeshSize;
+   region->ClearMeshSize = ClearMeshSize;
+
+   parent_setclosed = region->SetClosed;
+   region->SetClosed = SetClosed;
+
+   parent_setmeshsize = region->SetMeshSize;
+   region->SetMeshSize = SetMeshSize;
+
+   parent_getfillfactor = region->GetFillFactor;
+   region->GetFillFactor = GetFillFactor;
+
+   parent_regsetattrib = region->RegSetAttrib;
+   region->RegSetAttrib = RegSetAttrib;
+
+   parent_regclearattrib = region->RegClearAttrib;
+   region->RegClearAttrib = RegClearAttrib;
+
+/* Store replacement pointers for methods which will be over-ridden by
+   new member functions implemented here. */
+   mapping->Decompose = Decompose;
+   region->RegBaseBox = RegBaseBox;
+   region->RegBaseBox2 = RegBaseBox2;
+   region->RegBaseMesh = RegBaseMesh;
+   region->RegSplit = RegSplit;
+   region->RegPins = RegPins;
+   region->RegTrace = RegTrace;
+   region->GetBounded = GetBounded;
+   region->RegBasePick = RegBasePick;
+
+/* Declare the copy constructor, destructor and class dump function. */
+   astSetCopy( vtab, Copy );
+   astSetDelete( vtab, Delete );
+   astSetDump( vtab, Dump, "CmpRegion", "Combination of two Regions" );
+
+/* If we have just initialised the vtab for the current class, indicate
+   that the vtab is now initialised, and store a pointer to the class
+   identifier in the base "object" level of the vtab. */
+   if( vtab == &class_vtab ) {
+      class_init = 1;
+      astSetVtabClassIdentifier( vtab, &(vtab->id) );
+   }
+}
+
+#if defined(THREAD_SAFE)
+static int ManageLock( AstObject *this_object, int mode, int extra,
+                       AstObject **fail, int *status ) {
+/*
+*  Name:
+*     ManageLock
+
+*  Purpose:
+*     Manage the thread lock on an Object.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "object.h"
+*     AstObject *ManageLock( AstObject *this, int mode, int extra,
+*                            AstObject **fail, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astManageLock protected
+*     method inherited from the parent class).
+
+*  Description:
+*     This function manages the thread lock on the supplied Object. The
+*     lock can be locked, unlocked or checked by this function as
+*     deteremined by parameter "mode". See astLock for details of the way
+*     these locks are used.
+
+*  Parameters:
+*     this
+*        Pointer to the Object.
+*     mode
+*        An integer flag indicating what the function should do:
+*
+*        AST__LOCK: Lock the Object for exclusive use by the calling
+*        thread. The "extra" value indicates what should be done if the
+*        Object is already locked (wait or report an error - see astLock).
+*
+*        AST__UNLOCK: Unlock the Object for use by other threads.
+*
+*        AST__CHECKLOCK: Check that the object is locked for use by the
+*        calling thread (report an error if not).
+*     extra
+*        Extra mode-specific information.
+*     fail
+*        If a non-zero function value is returned, a pointer to the
+*        Object that caused the failure is returned at "*fail". This may
+*        be "this" or it may be an Object contained within "this". Note,
+*        the Object's reference count is not incremented, and so the
+*        returned pointer should not be annulled. A NULL pointer is
+*        returned if this function returns a value of zero.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*    A local status value:
+*        0 - Success
+*        1 - Could not lock or unlock the object because it was already
+*            locked by another thread.
+*        2 - Failed to lock a POSIX mutex
+*        3 - Failed to unlock a POSIX mutex
+*        4 - Bad "mode" value supplied.
+
+*  Notes:
+*     - This function attempts to execute even if an error has already
+*     occurred.
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;       /* Pointer to CmpRegion structure */
+   int result;               /* Returned status value */
+
+/* Initialise */
+   result = 0;
+
+/* Check the supplied pointer is not NULL. */
+   if( !this_object ) return result;
+
+/* Obtain a pointers to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_object;
+
+/* Invoke the ManageLock method inherited from the parent class. */
+   if( !result ) result = (*parent_managelock)( this_object, mode, extra,
+                                                fail, status );
+
+/* Invoke the astManageLock method on any Objects contained within
+   the supplied Object. */
+   if( !result ) result = astManageLock( this->region1, mode, extra, fail );
+   if( !result ) result = astManageLock( this->region2, mode, extra, fail );
+
+   return result;
+
+}
+#endif
+
+static AstRegion *MatchRegion( AstRegion *this, int ifrm, AstRegion *that,
+                               const char *method, int *status ) {
+/*
+*  Name:
+*     MatchRegion
+
+*  Purpose:
+*     Map a Region into the Frame of another Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     AstRegion *MatchRegion( AstRegion *this, int ifrm, AstRegion *that,
+*                             const char *method, int *status )
+
+*  Class Membership:
+*     CmpRegion method.
+
+*  Description:
+*     This function returns a pointer to a new Region which is a copy of
+*     "that" mapped into either the base or current Frame of "this".
+
+*  Parameters:
+*     this
+*        Pointer to a Region defining the Frame of the returned Region.
+*     ifrm
+*        The index of a Frame within the FrameSet encapsulated by "this".
+*        The returned Region will refer to the requested Frame. It should
+*        be either AST__CURRENT or AST__BASE.
+*     that
+*        Pointer to a Region defining the shape and extent of the
+*        returned Region.
+*     method
+*        Pointer to a string holding the calling method.This is only used
+*        in error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer to a new Region. This should be annulled (using astAnnul)
+*     when no longer needed.
+
+*  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: */
+   AstFrame *frm;             /* Current Frame from "fs" */
+   AstFrameSet *fs;           /* FrameSet connecting that to this */
+   AstMapping *map;           /* Base->Current Mapping from "fs" */
+   AstRegion *result;         /* Returned pointer */
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. Also return NULL if no Regions were
+   supplied. */
+   if ( !astOK || !this || !that ) return result;
+
+/* Temporarily invert "this" if we are matching its base Frame (since the
+   astConvert method matches current Frames). */
+   if( ifrm == AST__BASE ) astInvert( this );
+
+/* Find a FrameSet connecting the current Frames of the two Regions */
+   fs = astConvert( that, this, "" );
+
+/* Re-instate the original Frame indices in "this" if required. */
+   if( ifrm == AST__BASE ) astInvert( this );
+
+/* Check a conversion path was found. */
+   if( fs ) {
+
+/* Get the Frame and Mapping form the FrameSet. */
+      frm = astGetFrame( fs, AST__CURRENT );
+      map = astGetMapping( fs, AST__BASE, AST__CURRENT );
+
+/* Re-map the Region. */
+      result = astMapRegion( that, map, frm );
+
+/* Free resources. */
+      frm = astAnnul( frm );
+      map = astAnnul( map );
+      fs = astAnnul( fs );
+
+/* Report an error if there is no conversion between the two Frames. */
+   } else {
+      astError( AST__INTER, "%s(%s): MatchRegion cannot convert between "
+                "the two supplied coordinate Frames (internal AST "
+                "programming error).", status, method, astGetClass( this ) );
+   }
+
+/* Annul the returned pointer if an error has occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+static void RegBaseBox( AstRegion *this_region, double *lbnd, double *ubnd, int *status ){
+/*
+*  Name:
+*     RegBaseBox
+
+*  Purpose:
+*     Returns the bounding box of an un-negated Region in the base Frame of
+*     the encapsulated FrameSet.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void RegBaseBox( AstRegion *this, double *lbnd, double *ubnd, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astRegBaseBox protected
+*     method inherited from the Region class).
+
+*  Description:
+*     This function returns the upper and lower axis bounds of a Region in
+*     the base Frame of the encapsulated FrameSet, assuming the Region
+*     has not been negated. That is, the value of the Negated attribute
+*     is ignored.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     lbnd
+*        Pointer to an array in which to return the lower axis bounds
+*        covered by the Region in the base Frame of the encapsulated
+*        FrameSet. It should have at least as many elements as there are
+*        axes in the base Frame.
+*     ubnd
+*        Pointer to an array in which to return the upper axis bounds
+*        covered by the Region in the base Frame of the encapsulated
+*        FrameSet. It should have at least as many elements as there are
+*        axes in the base Frame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;          /* Pointer to CmpRegion structure */
+   AstPointSet *ps;             /* Mesh pointset */
+   AstRegion *reg1;             /* Pointer to first component Region */
+   AstRegion *reg2;             /* Pointer to second component Region */
+   double **ptr;                /* Pointer to mesh data */
+   double *clbnd1;              /* Point to 1st comp lower bounds array */
+   double *clbnd2;              /* Point to 2nd comp lower bounds array */
+   double *cubnd1;              /* Point to 1st comp upper bounds array */
+   double *cubnd2;              /* Point to 2nd comp upper bounds array */
+   double *p;                   /* Pointer to next coordinate value */
+   double lb;                   /* Lower limit */
+   double ub;                   /* Upper limit */
+   int i;                       /* Axis index */
+   int icoord;                  /* Coordinate index */
+   int inc1;                    /* First component interval is included? */
+   int inc2;                    /* Second component interval is included? */
+   int ipoint;                  /* Point index */
+   int nax;                     /* Number of axes in Frame */
+   int ncoord;                  /* Number of coords */
+   int neg1;                    /* First component negated? */
+   int neg2;                    /* Second component negated? */
+   int npoint;                  /* Number of points */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Get a pointer to the CmpRegion structure */
+   this = (AstCmpRegion *) this_region;
+
+/* If the CmpRegion is bounded, we find the bounding box using a mesh of
+   points spread evenly over the boundary of the CmpRegion. */
+   if( astGetBounded( this ) ) {
+      ps = astRegBaseMesh( this_region );
+      ptr = astGetPoints( ps );
+      ncoord = astGetNcoord( ps );
+      npoint = astGetNpoint( ps );
+
+      if( astOK ) {
+         for( icoord = 0; icoord < ncoord; icoord++ ) {
+            lbnd[ icoord ] = DBL_MAX;
+            ubnd[ icoord ] = -DBL_MAX;
+            p = ptr[ icoord ];
+            for( ipoint = 0; ipoint < npoint; ipoint++, p++ ) {
+               if( *p != AST__BAD ) {
+                  if( *p < lbnd[ icoord ] )  lbnd[ icoord ] = *p;
+                  if( *p > ubnd[ icoord ] )  ubnd[ icoord ] = *p;
+               }
+            }
+         }
+      }
+      ps = astAnnul( ps );
+
+/* If the CmpRegion is not bounded we look at each axis individually. */
+   } else {
+
+/* Get pointers to the component Regions. */
+      reg1 = this->region1;
+      reg2 = this->region2;
+
+/* Get their negated flags */
+      neg1 = astGetNegated( reg1 );
+      neg2 = astGetNegated( reg2 );
+
+/* The base Frame of the parent Region structure is the current Frame of
+   the component Regions. Get the no. of axes in this Frame. */
+      nax = astGetNaxes( reg1 );
+
+/* Get the bounding boxes of the component Regions in this Frame. */
+      clbnd1 = astMalloc( sizeof( double )*(size_t) nax );
+      cubnd1 = astMalloc( sizeof( double )*(size_t) nax );
+      clbnd2 = astMalloc( sizeof( double )*(size_t) nax );
+      cubnd2 = astMalloc( sizeof( double )*(size_t) nax );
+      if( astOK ) {
+         astGetRegionBounds( reg1, clbnd1, cubnd1 );
+         astGetRegionBounds( reg2, clbnd2, cubnd2 );
+
+/* Loop round every axis. */
+         for( i = 0; i < nax; i++ ) {
+
+/* If the first component Region has been negated, the lower and upper
+   bounds from the first component are the bounds of an *excluded* axis
+   interval, not an included interval. If either of the bounds are
+   infinite, we can swap it to an included interval. If both bounds are
+   finite, we cannot convert to an included interval. In this case, we
+   assume that the gap will be filled at some point on another axis, if
+   there is more than 1 axis, and convert it to an unbouded included
+   interval. */
+            inc1 = 1;
+            if( neg1 ) {
+               lb = clbnd1[ i ];
+               ub = cubnd1[ i ];
+               if( lb == -DBL_MAX ) clbnd1[ i ] = ub;
+               if( ub == DBL_MAX ) cubnd1[ i ] = lb;
+               if( lb != -DBL_MAX && ub != DBL_MAX ) {
+                  if( nax == 1 ) {
+                     inc1 = 0;
+                  } else {
+                     clbnd1[ i ] = -DBL_MAX;
+                     cubnd1[ i ] = DBL_MAX;
+                  }
+               }
+            }
+
+/* Likewise attempt to convert an excluded interval into an included
+   interval for the second component Region. */
+            inc2 = 1;
+            if( neg2 ) {
+               lb = clbnd2[ i ];
+               ub = cubnd2[ i ];
+               if( lb == -DBL_MAX ) clbnd2[ i ] = ub;
+               if( ub == DBL_MAX ) cubnd2[ i ] = lb;
+               if( lb != -DBL_MAX && ub != DBL_MAX ) {
+                  if( nax == 1 ) {
+                     inc2 = 0;
+                  } else {
+                     clbnd2[ i ] = -DBL_MAX;
+                     cubnd2[ i ] = DBL_MAX;
+                  }
+               }
+            }
+
+/* If the component Regions are combined using AND, find the overlap of
+   the axis intervals. This depends on whether the intervals are included
+   or excluded. */
+            if( this->oper == AST__AND ) {
+
+               if( inc1 ) {
+                  if( inc2 ) {
+                     lbnd[ i ] = astMAX( clbnd1[ i ], clbnd2[ i ] );
+                     ubnd[ i ] = astMIN( cubnd1[ i ], cubnd2[ i ] );
+                  } else {
+                     lbnd[ i ] = clbnd1[ i ] < clbnd2[ i ] ? clbnd1[ i ] : cubnd2[ i ];
+                     ubnd[ i ] = cubnd1[ i ] > cubnd2[ i ] ? cubnd1[ i ] : clbnd2[ i ];
+                  }
+               } else {
+                  if( inc2 ) {
+                     lbnd[ i ] = clbnd2[ i ] < clbnd1[ i ] ? clbnd2[ i ] : cubnd1[ i ];
+                     ubnd[ i ] = cubnd2[ i ] > cubnd1[ i ] ? cubnd2[ i ] : clbnd1[ i ];
+                  } else {
+                     lbnd[ i ] = clbnd1[ i ] < clbnd2[ i ] ? clbnd1[ i ] : cubnd2[ i ];
+                     ubnd[ i ] = cubnd1[ i ] > cubnd2[ i ] ? cubnd1[ i ] : clbnd2[ i ];
+                  }
+               }
+
+/* If the component Regions are not combined using AND, find the union of
+   the axis intervals. */
+            } else {
+               if( inc1 && inc2 ) {
+                  lbnd[ i ] = astMIN( clbnd1[ i ], clbnd2[ i ] );
+                  ubnd[ i ] = astMAX( cubnd1[ i ], cubnd2[ i ] );
+               } else {
+                  lbnd[ i ] = -DBL_MAX;
+                  ubnd[ i ] = DBL_MAX;
+               }
+            }
+         }
+      }
+
+/* Free resources. */
+      clbnd1 = astFree( clbnd1 );
+      cubnd1 = astFree( cubnd1 );
+      clbnd2 = astFree( clbnd2 );
+      cubnd2 = astFree( cubnd2 );
+   }
+}
+
+static void RegBaseBox2( AstRegion *this_region, double *lbnd, double *ubnd, int *status ){
+/*
+*  Name:
+*     RegBaseBox2
+
+*  Purpose:
+*     Returns the bounding box of an un-negated Region in the base Frame of
+*     the encapsulated FrameSet.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void RegBaseBox2( AstRegion *this, double *lbnd, double *ubnd, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astRegBaseBox2 protected
+*     method inherited from the Region class).
+
+*  Description:
+*     This function is similar to astRegBaseBox in that it returns the
+*     upper and lower axis bounds of a Region in the base Frame of the
+*     encapsulated FrameSet. But, in addition to assuming that the
+*     supplied Region has not been negated, it also assumes that any
+*     component Regions contained within the supplied Region have not been
+*     negated.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     lbnd
+*        Pointer to an array in which to return the lower axis bounds
+*        covered by the Region in the base Frame of the encapsulated
+*        FrameSet. It should have at least as many elements as there are
+*        axes in the base Frame.
+*     ubnd
+*        Pointer to an array in which to return the upper axis bounds
+*        covered by the Region in the base Frame of the encapsulated
+*        FrameSet. It should have at least as many elements as there are
+*        axes in the base Frame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;          /* Pointer to CmpRegion structure */
+   AstRegion *reg1;             /* Pointer to first component Region */
+   AstRegion *reg2;             /* Pointer to second component Region */
+   double *clbnd1;              /* Point to 1st comp lower bounds array */
+   double *clbnd2;              /* Point to 2nd comp lower bounds array */
+   double *cubnd1;              /* Point to 1st comp upper bounds array */
+   double *cubnd2;              /* Point to 2nd comp upper bounds array */
+   int i;                       /* Axis index */
+   int nax;                     /* Number of axes in Frame */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Get a pointer to the CmpRegion structure */
+   this = (AstCmpRegion *) this_region;
+
+/* Get pointers to the component Regions. */
+   reg1 = this->region1;
+   reg2 = this->region2;
+
+/* The base Frame of the parent Region structure is the current Frame of
+   the component Regions. Get the no. of axes in this Frame. */
+   nax = astGetNaxes( reg1 );
+
+/* Get the bounding boxes of the component Regions in this Frame. */
+   clbnd1 = astMalloc( sizeof( double )*(size_t) nax );
+   cubnd1 = astMalloc( sizeof( double )*(size_t) nax );
+   clbnd2 = astMalloc( sizeof( double )*(size_t) nax );
+   cubnd2 = astMalloc( sizeof( double )*(size_t) nax );
+   if( astOK ) {
+      astGetRegionBounds2( reg1, clbnd1, cubnd1 );
+      astGetRegionBounds2( reg2, clbnd2, cubnd2 );
+
+/* How we combine the two bounding boxes depends on the boolean operator
+   associated with this CmpRegion.  For AND find the overlap of the two
+   bounding boxes. For other operators find the union. */
+      if( this->oper == AST__AND ) {
+         for( i = 0; i < nax; i++ ) {
+            lbnd[ i ]= astMAX( clbnd1[ i ], clbnd2[ i ] );
+            ubnd[ i ]= astMIN( cubnd1[ i ], cubnd2[ i ] );
+         }
+
+      } else {
+         for( i = 0; i < nax; i++ ) {
+            lbnd[ i ]= astMIN( clbnd1[ i ], clbnd2[ i ] );
+            ubnd[ i ]= astMAX( cubnd1[ i ], cubnd2[ i ] );
+         }
+      }
+   }
+
+/* Free resources. */
+   clbnd1 = astFree( clbnd1 );
+   cubnd1 = astFree( cubnd1 );
+   clbnd2 = astFree( clbnd2 );
+   cubnd2 = astFree( cubnd2 );
+
+}
+
+static AstPointSet *RegBaseMesh( AstRegion *this_region, int *status ){
+/*
+*  Name:
+*     RegBaseMesh
+
+*  Purpose:
+*     Return a PointSet containing a mesh of points on the boundary of a
+*     Region in its base Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     AstPointSet *astRegBaseMesh( AstRegion *this, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astRegBaseMesh protected
+*     method inherited from the Region class).
+
+*  Description:
+*     This function returns a PointSet containing a mesh of points on the
+*     boundary of the Region. The points refer to the base Frame of
+*     the encapsulated FrameSet.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to the PointSet. Annul the pointer using astAnnul when it
+*     is no longer needed.
+
+*  Notes:
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+
+*/
+
+
+/* Local Variables: */
+   AstCmpRegion *this;            /* The CmpRegion structure */
+   AstPointSet *mesh1;            /* PointSet holding mesh for 1st component */
+   AstPointSet *mesh1b;           /* Mesh for 1st component mapped by 2nd comp. */
+   AstPointSet *mesh2;            /* PointSet holding mesh for 2nd component */
+   AstPointSet *mesh2b;           /* Mesh for 2nd component mapped by 1st comp. */
+   AstPointSet *result;           /* Returned pointer */
+   AstRegion *reg1;               /* Pointer to first component Region */
+   AstRegion *reg2;               /* Pointer to second component Region */
+   double **ptr1;                 /* Pointer to array of mesh1b axis value pointers */
+   double **ptr2;                 /* Pointer to array of mesh2b axis value pointers */
+   double **ptr;                  /* Pointer to array of total axis value pointers */
+   double *lbnd;                  /* Pointer to array of bounding box lower bounds */
+   double *ubnd;                  /* Pointer to array of bounding box upper bounds */
+   double v;                      /* Axis value */
+   int hasMesh1;                  /* Does 1st component Region have a mesh? */
+   int hasMesh2;                  /* Does 2nd component Region have a mesh? */
+   int ic;                        /* Axis index */
+   int ip;                        /* Input point index */
+   int jp;                        /* Output point index */
+   int nc;                        /* No. of axis values per point */
+   int np1;                       /* No. of points in mesh1b */
+   int np2;                       /* No. of points in mesh2b */
+   int np;                        /* No. of points in returned PointSet */
+   int ok;                        /* Were all axis values good at this point? */
+
+/* Initialise */
+   result= NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* If the Region structure contains a pointer to a PointSet holding
+   a previously created mesh, return it. */
+   if( this_region->basemesh ) {
+      result = astClone( this_region->basemesh );
+
+/* Otherwise, create a new mesh. */
+   } else {
+
+/* Get pointers to the component regions. */
+      reg1 = this->region1;
+      reg2 = this->region2;
+
+/* A mesh can only be produced for a Region if it is bounded when either
+   negated or un-negated. See if meshes can be produced for the component
+   Regions. */
+      hasMesh1 = astGetBounded( reg1 );
+      if( !hasMesh1 ){
+         astNegate( reg1 );
+         hasMesh1 = astGetBounded( reg1 );
+         astNegate( reg1 );
+      }
+
+      hasMesh2 = astGetBounded( reg2 );
+      if( !hasMesh2 ){
+         astNegate( reg2 );
+         hasMesh2 = astGetBounded( reg2 );
+         astNegate( reg2 );
+      }
+
+/* If neither Region has a mesh we cannot produce a mesh. */
+      if( !hasMesh1 && !hasMesh2 && astOK ) {
+         astError( AST__INTER, "astRegBaseMesh(%s): No mesh can be "
+                   "produced for the %s bacause neither of its component "
+                   "Regions has a mesh (internal AST programming error).", status,
+                   astGetClass( this ), astGetClass( this ) );
+
+/* If only one Region has a mesh, we can produce a mesh so long as the
+    boolean operator is not OR. */
+      } else if( ( !hasMesh1 || !hasMesh2 ) && this->oper == AST__OR && astOK ) {
+         astError( AST__INTER, "astRegBaseMesh(%s): No mesh can be produced "
+                   "for the %s bacause one its component Regions has no "
+                   "mesh and the union of the Regions is required (internal "
+                   "AST programming error).", status, astGetClass( this ), astGetClass( this ) );
+      }
+
+/* Allocate memory to hold a bounding box in the base Frame of the CmpRegion. */
+      nc = astGetNin( this_region->frameset );
+      lbnd = astMalloc( sizeof( double )*(size_t) nc );
+      ubnd = astMalloc( sizeof( double )*(size_t) nc );
+
+/* Get current Frame meshes covering the two component Regions (the current
+   Frame of the component Regions is the same as the base Frame of the parent
+   Region). We now know that at least one Region has a mesh. If the other
+   one does not have a mesh we may be able to create a mesh by taking the
+   intersection of the Region with the bounding box of the bounded Region. */
+      if( hasMesh1 ) {
+         mesh1 = astRegMesh( reg1 );
+         if( hasMesh2 ) {
+            mesh2 = astRegMesh( reg2 );
+         } else {
+            astGetRegionBounds( reg1, lbnd, ubnd );
+            mesh2 = astBndMesh( reg2, lbnd, ubnd );
+         }
+
+      } else {
+         mesh2 = astRegMesh( reg2 );
+         astGetRegionBounds( reg2, lbnd, ubnd );
+         mesh1 = astBndMesh( reg1, lbnd, ubnd );
+      }
+
+/* If the CmpRegion represents the intersection of the two component Regions
+   (AND operator), the total mesh is the sum of the component mesh points
+   which are inside the other component region. If the CmpRegion represents
+   the union of the two component Regions (OR operator), the total mesh is
+   the sum of the component mesh points which are outside the other component
+   region. So temporarily negate the component Regions if they are
+   combined using OR. */
+      if( this->oper == AST__OR ) {
+         astNegate( reg1 );
+         astNegate( reg2 );
+      }
+
+/* Transform the mesh for the first component using the second component
+   as a Mapping. Mesh points outside (or inside if "oper" is OR) the bounds
+   of the second component will be set bad. */
+      mesh1b = astTransform( reg2, mesh1, 1, NULL );
+
+/* Transform the mesh for the second component using the first component
+   as a Mapping. Mesh points outside (or inside if "oper" is OR) the bounds
+   of the first component will be set bad. */
+      mesh2b = astTransform( reg1, mesh2, 1, NULL );
+
+/* If required, negate them again to bring them back to their original state.*/
+      if( this->oper == AST__OR ) {
+         astNegate( reg1 );
+         astNegate( reg2 );
+      }
+
+/* The required mesh contains all the good points form both mesh1b and
+   mesh2b (i.e. all boundary points which are inside -or inside if "oper"
+   is OR- the other component Region). Create a PointSet assuming that all
+   points are good. First allocate an array to hold pointers to the arrays
+   holding coordinate values for each axis. */
+      nc = astGetNcoord( mesh1b );
+      np1 = astGetNpoint( mesh1b );
+      np2 = astGetNpoint( mesh2b );
+      np = np1 + np2;
+      result = astPointSet( np, nc, "", status );
+      ptr = astGetPoints( result );
+
+/* Get points to the axis values of the mapped meshes. */
+      ptr1 = astGetPoints( mesh1b );
+      ptr2 = astGetPoints( mesh2b );
+
+/* Check pointers can be used safely. */
+      if( astOK ) {
+
+/* Initialise the index of the next point in the total mesh. */
+         jp = 0;
+
+/* Loop round all the points in the transformed mesh for the first
+   component. */
+         for( ip = 0; ip < np1; ip++ ) {
+
+/* Assume this point has good axis values */
+            ok = 1;
+
+/* Copy the axis values into the total mesh. Break if a bad axis value is
+   found. */
+            for( ic = 0; ic < nc; ic++ ) {
+               v = ptr1[ ic ][ ip ];
+               if( v != AST__BAD ) {
+                  ptr[ ic ][ jp ] = v;
+               } else {
+                  ok = 0;
+                  break;
+               }
+            }
+
+/* If no bad axis values were found, increment the index of the next
+   point in the total mesh. */
+            if( ok ) jp++;
+         }
+
+/* Now similarly copy the good values from the second transformed mesh onto
+   the end of the total mesh array. */
+         for( ip = 0; ip < np2; ip++ ) {
+            ok = 1;
+            for( ic = 0; ic < nc; ic++ ) {
+               v = ptr2[ ic ][ ip ];
+               if( v != AST__BAD ) {
+                  ptr[ ic ][ jp ] = v;
+               } else {
+                  ok = 0;
+                  break;
+               }
+            }
+            if( ok ) jp++;
+         }
+
+/* If the total mesh contains no good points, we will create a PointSet
+   holding a single bad position. */
+         if( jp == 0 ) {
+            np = 1;
+            for( ic = 0; ic < nc; ic++ ) ptr[ ic ][ 0 ] = AST__BAD;
+         } else {
+            np = jp;
+         }
+
+/* Adjust the size of the returned PointSet to exclude the extra space
+   caused by any axis values being bad in the transformed meshes. */
+         astSetNpoint( result, np );
+
+      }
+
+/* Free resources. */
+      mesh1 = astAnnul( mesh1 );
+      mesh2 = astAnnul( mesh2 );
+      mesh1b = astAnnul( mesh1b );
+      mesh2b = astAnnul( mesh2b );
+      lbnd = astFree( lbnd );
+      ubnd = astFree( ubnd );
+
+/* Save the returned pointer in the Region structure so that it does not
+   need to be created again next time this function is called. */
+      if( astOK && result ) this_region->basemesh = astClone( result );
+   }
+
+/* Annul the result if an error has occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return a pointer to the output PointSet. */
+   return result;
+}
+
+static AstRegion *RegBasePick( AstRegion *this_region, int naxes,
+                               const int *axes, int *status ){
+/*
+*  Name:
+*     RegBasePick
+
+*  Purpose:
+*     Return a Region formed by picking selected base Frame axes from the
+*     supplied Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     AstRegion *RegBasePick( AstRegion *this, int naxes, const int *axes,
+*                             int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astRegBasePick protected
+*     method inherited from the Region class).
+
+*  Description:
+*     This function attempts to return a Region that is spanned by selected
+*     axes from the base Frame of the encapsulated FrameSet of the supplied
+*     Region. This may or may not be possible, depending on the class of
+*     Region. If it is not possible a NULL pointer is returned.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     naxes
+*        The number of base Frame axes to select.
+*     axes
+*        An array holding the zero-based indices of the base Frame axes
+*        that are to be selected.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to the Region, or NULL if no region can be formed.
+
+*  Notes:
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;     /* Pointer to CmpRegion structure */
+   AstFrame *frm1;         /* Axes picked from the 1st encapsulated Region */
+   AstFrame *frm2;         /* Axes picked from the 2nd encapsulated Region */
+   AstRegion *result;      /* Returned Region */
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the CmpRegion information. */
+   this = (AstCmpRegion *) this_region;
+
+/* Both encapsulated regions refer to the same Frame (the base Frame of
+   the parent Region), so attempt to pick the requested axs from them.
+   If the resulting Frames are not Regions, we cannot pick the requested
+   axes so return the NULL Frame pointer initialised above. */
+   frm1 = astPickAxes( this->region1, naxes, axes, NULL );
+   if( astIsARegion( frm1 ) ) {
+      frm2 = astPickAxes( this->region2, naxes, axes, NULL );
+      if( astIsARegion( frm2 ) ) {
+
+/* Create the new CmpRegion. */
+         result = (AstRegion *) astCmpRegion( (AstRegion *) frm1,
+                                              (AstRegion *) frm2,
+                                              this->oper, "", status );
+      }
+
+/* Free resources */
+      frm2 = astAnnul( frm2 );
+   }
+   frm1 = astAnnul( frm1 );
+
+/* Return a NULL pointer if an error has occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+static int RegPins( AstRegion *this_region, AstPointSet *pset, AstRegion *unc,
+                    int **mask, int *status ){
+/*
+*  Name:
+*     RegPins
+
+*  Purpose:
+*     Check if a set of points fall on the boundary of a given CmpRegion.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     int RegPins( AstRegion *this, AstPointSet *pset, AstRegion *unc,
+*                  int **mask, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astRegPins protected
+*     method inherited from the Region class).
+
+*  Description:
+*     This function returns a flag indicating if the supplied set of
+*     points all fall on the boundary of the given CmpRegion.
+*
+*     Some tolerance is allowed, as specified by the uncertainty Region
+*     stored in the supplied CmpRegion "this", and the supplied uncertainty
+*     Region "unc" which describes the uncertainty of the supplied points.
+
+*  Parameters:
+*     this
+*        Pointer to the CmpRegion.
+*     pset
+*        Pointer to the PointSet. The points are assumed to refer to the
+*        base Frame of the FrameSet encapsulated by "this".
+*     unc
+*        Pointer to a Region representing the uncertainties in the points
+*        given by "pset". The Region is assumed to represent the base Frame
+*        of the FrameSet encapsulated by "this". Zero uncertainity is assumed
+*        if NULL is supplied.
+*     mask
+*        Pointer to location at which to return a pointer to a newly
+*        allocated dynamic array of ints. The number of elements in this
+*        array is equal to the value of the Npoint attribute of "pset".
+*        Each element in the returned array is set to 1 if the
+*        corresponding position in "pset" is on the boundary of the Region
+*        and is set to zero otherwise. A NULL value may be supplied
+*        in which case no array is created. If created, the array should
+*        be freed using astFree when no longer needed.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Non-zero if the points all fall on the boundary of the given
+*     Region, to within the tolerance specified. Zero otherwise.
+
+*/
+
+/* Local variables: */
+   AstCmpRegion *this;          /* Pointer to the CmpRegion structure. */
+   AstPointSet *pset1;          /* Points masked by 1st component Region */
+   AstPointSet *pset2;          /* Points masked by 2nd component Region */
+   AstPointSet *psetb1;         /* Points in base Frame of 1st component Region */
+   AstPointSet *psetb2;         /* Points in base Frame of 2nd component Region */
+   AstRegion *reg1;             /* Pointer to first component Region */
+   AstRegion *reg2;             /* Pointer to second component Region */
+   AstRegion *unc1;             /* Base Frame uncertainty in 1st component Region */
+   AstRegion *unc2;             /* Base Frame uncertainty in 2nd component Region */
+   double **ptr1;               /* Pointer to axis values in "pset1" */
+   double **ptr2;               /* Pointer to axis values in "pset2" */
+   double *p1;                  /* Pointer to next axis zero value for pset1 */
+   double *p2;                  /* Pointer to next axis zero value for pset2 */
+   int *mask1;                  /* Mask for first component boundary */
+   int *mask2;                  /* Mask for second component boundary */
+   int ip;                      /* Point index */
+   int np;                      /* Number of points */
+   int result;                  /* Returned flag */
+
+/* Initialise */
+   result = 0;
+   if( mask ) *mask = NULL;
+
+/* Check the inherited status. */
+   if( !astOK ) return result;
+
+/* Get a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* Get pointers to the two component Regions. */
+   reg1 = this->region1;
+   reg2 = this->region2;
+
+/* Get a mask which indicates if each supplied point is on or off the
+   boundary of the first component Region. astRegPins expects its "pset"
+   argument to contain positions in the base Frame of the Region, so
+   we must first transform the supplied points into the base Frame of
+   "reg1". We must also map the uncertainty into the base Frame of the
+   component Region. */
+   psetb1 = astRegTransform( reg1, pset, 0, NULL, NULL );
+   unc1 = MatchRegion( reg1, AST__BASE, unc, "astRegPins", status );
+   astRegPins( reg1, psetb1, unc1, &mask1 );
+
+/* Likewise, get a mask which indicates if each supplied point is on or off
+   the boundary of the second component Region. */
+   psetb2 = astRegTransform( reg2, pset, 0, NULL, NULL );
+   unc2 = MatchRegion( reg2, AST__BASE, unc, "astRegPins", status );
+   astRegPins( reg2, psetb2, unc2, &mask2 );
+
+/* The criteria for a point to be on the boundary of the CmpRegion depend
+   on the boolean operator being used. If component regions A and B are
+   ANDed together, then a point is on the boundary of the CmpRegion if
+   either 1) it is on the boundary of A and inside B, or 2) it is on the
+   boundary of B and inside A. If the component regions are ORed together,
+   then a point is on the boundary of the CmpRegion if either 1) it is on
+   the boundary of A and outside B, or 2) it is on the boundary of B and
+   outside A. Either we need to transform the supplied PointSet using each
+   component Region as a Mapping. But if using OR we temporarily negate
+   the Regions. */
+   if( this->oper == AST__OR ) {
+      astNegate( reg1 );
+      astNegate( reg2 );
+   }
+   pset1 = astTransform( reg1, pset, 1, NULL );
+   pset2 = astTransform( reg2, pset, 1, NULL );
+   if( this->oper == AST__OR ) {
+      astNegate( reg1 );
+      astNegate( reg2 );
+   }
+
+/* Get pointers to the axis values in these PointSets */
+   ptr1 = astGetPoints( pset1 );
+   ptr2 = astGetPoints( pset2 );
+
+/* If required, create an output mask array */
+   np = astGetNpoint( pset );
+   if( mask ) *mask = astMalloc( sizeof(int)*(size_t) np );
+
+/* Check pointers can be used safely. */
+   if( astOK ) {
+
+/* We can use the values for the first axis to indicate if a point is
+   inside or outside a Region. So store pointers to the first axis arrays. */
+      p1 = ptr1[ 0 ];
+      p2 = ptr2[ 0 ];
+
+/* Assume all points are on the boundary of the CmpRegion. */
+      result = 1;
+
+/* If we are creating an output mask, we must check every point. Otherwise
+   we can stop checking when we find the first point which is not on the
+   boundary of the CmpRegion. */
+      if( mask ) {
+
+         for( ip = 0; ip < np; ip++ ) {
+            if( ( mask1[ ip ] && p2[ ip ] != AST__BAD ) ||
+                ( mask2[ ip ] && p1[ ip ] != AST__BAD ) ){
+               (*mask)[ ip ] = 1;
+            } else {
+               (*mask)[ ip ] = 0;
+               result = 0;
+            }
+         }
+
+      } else {
+
+         for( ip = 0; ip < np; ip++ ) {
+            if( ( !mask1[ ip ] || p2[ ip ] == AST__BAD ) &&
+                ( !mask2[ ip ] || p1[ ip ] == AST__BAD ) ){
+               result = 0;
+               break;
+            }
+         }
+      }
+   }
+
+/* Free resources */
+   mask1 = astFree( mask1 );
+   mask2 = astFree( mask2 );
+   pset1 = astAnnul( pset1 );
+   pset2 = astAnnul( pset2 );
+   psetb1 = astAnnul( psetb1 );
+   psetb2 = astAnnul( psetb2 );
+   if( unc1 ) unc1 = astAnnul( unc1 );
+   if( unc2 ) unc2 = astAnnul( unc2 );
+
+/* If an error has occurred, return zero. */
+   if( !astOK ) {
+      result = 0;
+      if( mask ) *mask = astAnnul( *mask );
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static void RegSetAttrib( AstRegion *this_region, const char *setting,
+                          char **base_setting, int *status ) {
+/*
+*  Name:
+*     RegSetAttrib
+
+*  Purpose:
+*     Set an attribute value for a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void RegSetAttrib( AstRegion *this, const char *setting,
+*                        char **base_setting, int *status )
+
+*  Class Membership:
+*     CmpRegion method (over-rides the astRegSetAttrib method inherited from
+*     the Region class).
+
+*  Description:
+*     This function assigns an attribute value to both the base and
+*     current Frame in the FrameSet encapsulated within a Region, without
+*     remapping either Frame.
+*
+*     No error is reported if the attribute is not recognised by the base
+*     Frame.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     setting
+*        Pointer to a null terminated attribute setting string. NOTE, IT
+*        SHOULD BE ENTIRELY LOWER CASE. The supplied string will be
+*        interpreted using the public interpretation implemented by
+*        astSetAttrib. This can be different to the interpretation of the
+*        protected accessor functions. For instance, the public
+*        interpretation of an unqualified floating point value for the
+*        Epoch attribute is to interpet the value as a gregorian year,
+*        but the protected interpretation is to interpret the value as an
+*        MJD.
+*     base_setting
+*        Address of a location at which to return a pointer to the null
+*        terminated attribute setting string which was applied to the
+*        base Frame of the encapsulated FrameSet. This may differ from
+*        the supplied setting if the supplied setting contains an axis
+*        index and the current->base Mapping in the FrameSet produces an
+*        axis permutation. The returned pointer should be freed using
+*        astFree when no longer needed. A NULL pointer may be supplied in
+*        which case no pointer is returned.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;
+   char *bset;
+   int rep;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Get a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* Use the RegSetAttrib method inherited from the parent class to apply the
+   setting to the current and base Frames in the FrameSet encapsulated by the
+   parent Region structure. */
+   (*parent_regsetattrib)( this_region, setting, &bset, status );
+
+/* Now apply the base Frame setting to the component Regions (the current
+   Frame within the component Regions is equivalent to the base Frame in the
+   parent Region structure). Annul any "attribute unknown" error that results
+   from attempting to do this. */
+   if( astOK ) {
+      rep = astReporting( 0 );
+      astRegSetAttrib( this->region1, bset, NULL );
+      astRegSetAttrib( this->region2, bset, NULL );
+      if( astStatus == AST__BADAT ) astClearStatus;
+      astReporting( rep );
+   }
+
+/* If required, return the base Frame setting string, otherwise free it. */
+   if( base_setting ) {
+      *base_setting = bset;
+   } else {
+      bset = astFree( bset );
+   }
+}
+
+static AstRegion **RegSplit( AstRegion *this_region, int *nlist, int *status ){
+/*
+*+
+*  Name:
+*     RegSplit
+
+*  Purpose:
+*     Split a Region into a list of disjoint component Regions.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion **astRegSplit( AstRegion *this, int *nlist )
+
+*  Class Membership:
+*     CmpRegion member function (overrides the astRegSplit method
+*     inherited from the parent Region class).
+
+*  Description:
+*     This function splits the supplied Region into a set of disjoint
+*     component Regions. If the Region cannot be split, then the returned
+*     array contains only one pointer - a clone of the supplied Region
+*     pointer.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     nlist
+*        Pointer to an int in which to return the number of elements in
+*        the returned array.
+
+*  Returned Value:
+*     Pointer to dynamically alloctaed memory holding an array of Region
+*     pointers. The length of this array is given by the value returned
+*     in "*nlist". The pointers in the returned array should be annulled
+*     using astAnnul when no longer needed, and the memory used to hold
+*     the array should be freed using astFree.
+
+*  Notes:
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*-
+*/
+
+/* Local Variables; */
+   AstCmpRegion *new;
+   AstCmpRegion *this;
+   AstFrame *frm;
+   AstFrameSet *fs;
+   AstMapping *map;
+   AstRegion **cmplist;
+   AstRegion **result;
+   AstRegion *cmpreg;
+   AstRegion *new_reg;
+   int icomp;
+   int ifirst;
+   int ilist;
+   int iw;
+   int jcomp;
+   int ncomp;
+   int nn;
+   int unbounded;
+
+/* Initialise. */
+   result = NULL;
+   *nlist = 0;
+
+/* Check the local error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* Indicate we have not yet found any unbounded component regions. */
+   unbounded = 0;
+
+/* Can only split non-inverted CmpRegions that combine their components
+   using the OR operator. */
+   if( this->oper == AST__OR && !astGetNegated( this->region1 ) &&
+                                !astGetNegated( this->region2 ) ) {
+
+/* Process each of the two component Regions in turn. */
+      for( icomp = 0; icomp < 2 && !unbounded; icomp++ ) {
+         cmpreg = icomp ? this->region2 : this->region1;
+
+/* Create a set of disjoint Regions that are equivalent to the current
+   component Region, and loop round them. */
+         cmplist = astRegSplit( cmpreg, &ncomp );
+         for( jcomp = 0; jcomp < ncomp; jcomp++ ) {
+
+/* If any of the components are unbounds, we cannot split the supplied
+   Region. */
+            unbounded = unbounded || !astGetBounded( cmplist[ jcomp ] );
+            if( ! unbounded ) {
+
+/* Initialise the index within the returned list of the first Region that
+   overlaps the current disjoint component Region. */
+               ifirst = -1;
+
+/* Loop round all the Regions currently in the returned list. */
+               for( ilist = 0; ilist < *nlist; ilist++ ) {
+                  if( result[ ilist ] ) {
+
+/* See if the current disjoint component overlaps the current entry in
+   the returned list. */
+                     if( astOverlap( cmplist[ jcomp ], result[ ilist ] ) > 1 ) {
+
+/* If this is the first overlap found for the current disjoint component,
+   form a CmpRegion that combines the two overlapping Regions, and use it
+   to replace the current entry in the returned list. */
+                        if( ifirst == -1 ) {
+                           new = astCmpRegion( cmplist[ jcomp ], result[ ilist ],
+                                               AST__OR, " ", status );
+                           (void) astAnnul( result[ ilist ] );
+                           result[ ilist ] = (AstRegion *) new;
+
+/* Note the index within the returned list of the first Region that overlaps
+   the current disjoint component Region. */
+                           ifirst = ilist;
+
+/* If this is the second or later overlap, add the overlapping returned Region
+   into the CmpRegion that it is stored at index "ifirsT" in the returned
+   list. */
+                        } else {
+                           new = astCmpRegion( result[ ilist ], result[ ifirst ],
+                                               AST__OR, " ", status );
+                           result[ ilist ] = astAnnul( result[ ilist ] );
+                           (void) astAnnul( result[ ifirst ] );
+                           result[ ifirst ] = (AstRegion *) new;
+                        }
+                     }
+                  }
+               }
+
+/* If the current disjoint component does not overlap any of the Regions
+   already in the returned list, append the current disjoint component to
+   the end of the returned list. */
+               if( ifirst == -1 ) {
+                  ilist = (*nlist)++;
+                  result = astGrow( result, *nlist, sizeof( *result ) );
+                  if( astOK ) result[ ilist ] = astClone( cmplist[ jcomp ] );
+               }
+            }
+
+/* Annul the pointer to the disjoint component Region. */
+            cmplist[ jcomp ] = astAnnul( cmplist[ jcomp ] );
+         }
+
+/* Free the mnemory holding the list of disjoint components. */
+         cmplist = astFree( cmplist );
+      }
+   }
+
+/* If any unbounded components were found, ensure the returned list is
+   empty. */
+   if( unbounded && result ) {
+      for( ilist = 0; ilist < *nlist; ilist++ ) {
+         if( result[ ilist ] ) result[ ilist ] = astAnnul( result[ ilist ] );
+      }
+      result = astFree( result );
+      *nlist = 0;
+
+/* Otherwise, shuffle later entries down to fill any NULL slots in the returned
+   list. */
+   } else if( result ){
+      nn = *nlist;
+      iw = 0;
+      for( ilist = 0; ilist < nn; ilist++ ) {
+         if( result[ ilist ] ) result[ iw++ ] = result[ ilist ];
+      }
+      *nlist = iw;
+   }
+
+/* If this CmpRegion cannot be split, the returned list just holds a
+   clone of the Region pointer. */
+   if( !result ) {
+      result = astMalloc( sizeof( *result ) );
+      if( astOK ) {
+         result[ 0 ] = astClone( this );
+         *nlist = 1;
+      }
+   }
+
+/* Remap any returned Regions so that they are defined within the same
+   coordinate system as the supplied Region. */
+   if( result && *nlist > 0 )  {
+      fs = this_region->frameset;
+      map = astGetMapping( fs, AST__BASE, AST__CURRENT );
+      frm = astGetFrame( fs, AST__CURRENT );
+      for( ilist = 0; ilist < *nlist; ilist++ ) {
+         new_reg = astMapRegion( result[ ilist ], map, frm );
+         (void) astAnnul( result[ ilist ] );
+         result[ ilist ] = new_reg;
+      }
+      map = astAnnul( map );
+      frm = astAnnul( frm );
+   }
+
+/* Free all returned pointers if an error has occurred. */
+   if( !astOK && result ) {
+      for( ilist = 0; ilist < *nlist; ilist++ ) {
+         result[ ilist ] = astAnnul( result[ ilist ] );
+      }
+      result = astFree( result );
+      *nlist = 0;
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static int RegTrace( AstRegion *this_region, int n, double *dist, double **ptr,
+                     int *status ){
+/*
+*+
+*  Name:
+*     RegTrace
+
+*  Purpose:
+*     Return requested positions on the boundary of a 2D Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     int astRegTrace( AstRegion *this, int n, double *dist, double **ptr );
+
+*  Class Membership:
+*     CmpRegion member function (overrides the astRegTrace method
+*     inherited from the parent Region class).
+
+*  Description:
+*     This function returns positions on the boundary of the supplied
+*     Region, if possible. The required positions are indicated by a
+*     supplied list of scalar parameter values in the range zero to one.
+*     Zero corresponds to some arbitrary starting point on the boundary,
+*     and one corresponds to the end (which for a closed region will be
+*     the same place as the start).
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     n
+*        The number of positions to return. If this is zero, the function
+*        returns without action (but the returned function value still
+*        indicates if the method is supported or not).
+*     dist
+*        Pointer to an array of "n" scalar parameter values in the range
+*        0 to 1.0.
+*     ptr
+*        A pointer to an array of pointers. The number of elements in
+*        this array should equal tthe number of axes in the Frame spanned
+*        by the Region. Each element of the array should be a pointer to
+*        an array of "n" doubles, in which to return the "n" values for
+*        the corresponding axis. The contents of the arrays are unchanged
+*        if the supplied Region belongs to a class that does not
+*        implement this method.
+
+*  Returned Value:
+*     Non-zero if the astRegTrace method is implemented by the class
+*     of Region supplied, and zero if not.
+
+*  Notes:
+*    - The current algorithm results in the boundary of the CmpRegion
+*    being dis-contiguous - supplied distance values from zero up to some
+*    mid-value correspond to positions on the first component Region, and
+*    higher distance (up to 1.0) correspond to points on the second
+*    component Region.
+
+*-
+*/
+
+/* Local Variables; */
+   AstCmpRegion *this;
+   AstFrame *frm;
+   AstMapping *map;
+   AstPointSet *bpset;
+   AstPointSet *cpset;
+   AstRegion *ureg1;
+   AstRegion *ureg2;
+   double **bptr;
+   int i;
+   int j;
+   int ncur;
+   int result;
+   double *rval;
+   double *off;
+   double *r1d;
+   double *r2d;
+   double *r1ptr[ 2 ];
+   double *r2ptr[ 2 ];
+   double **r1ptrb;
+   double **r2ptrb;
+   double dbreak;
+   double dtot;
+   double x;
+   double x0;
+   int r1n;
+   int r2n;
+   AstPointSet *r1pset;
+   AstPointSet *r2pset;
+   AstPointSet *r1psetb;
+   AstPointSet *r2psetb;
+
+/* Initialise */
+   result = 0;
+
+/* Check inherited status. */
+   if( ! astOK ) return result;
+
+/* Get a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* Get a pointer to the base Frame in the encapsulated FrameSet. */
+   frm = astGetFrame( this_region->frameset, AST__BASE );
+
+/* Check it is 2-dimensional. */
+   result = 1;
+   if( astGetNaxes( frm ) != 2 ) result = 0;
+
+/* Check the component Regions can be traced. */
+   if( !astRegTrace( this->region1, 0, NULL, NULL ) ||
+       !astRegTrace( this->region1, 0, NULL, NULL ) ) result = 0;
+
+/* Check we have some points to find. */
+   if( result && n > 0 ) {
+
+/* We first determine the required positions in the base Frame of the
+   Region, and then transform them into the current Frame. Get the
+   base->current Mapping, and the number of current Frame axes. */
+      map = astGetMapping( this_region->frameset, AST__BASE, AST__CURRENT );
+
+/* If it's a UnitMap we do not need to do the transformation, so put the
+   base Frame positions directly into the supplied arrays. */
+      if( astIsAUnitMap( map ) ) {
+         bpset = NULL;
+         bptr = ptr;
+         ncur = 2;
+
+/* Otherwise, create a PointSet to hold the base Frame positions. */
+      } else {
+         bpset = astPointSet( n, 2, " ", status );
+         bptr = astGetPoints( bpset );
+         ncur = astGetNout( map );
+      }
+
+      r1d = astMalloc( sizeof( double )*n );
+      r2d = astMalloc( sizeof( double )*n );
+
+/* Ensure information about the breaks in the boundary of each component
+   region is available within the CmpRegion structure. These breaks are
+   the points at which the two boundaries cross. */
+      SetBreakInfo( this, 0, status );
+      SetBreakInfo( this, 1, status );
+
+/* Get the constants needed to convert the supplied distances (normalised
+   so that the border of the entire CmpRegion has a length of 1.0), into
+   geodesic distances around the border of each component Region. */
+      dtot = this->d0[ 0 ] + this->d0[ 1 ];
+      dbreak = this->d0[ 0 ]/dtot;
+
+/* Initialise here to avoid compiler warnings. */
+      r1n = 0;
+      r2n = 0;
+
+/* Check the pointers can be used safely. */
+      if( astOK ) {
+
+/* Loop round all supplied distances, determining if they represent a
+   position on the first or second component Region. */
+         for( i = 0; i < n; i++ ) {
+
+/* If the current distance represents a point in the second component
+   Region... */
+            if( dist[ i ] > dbreak ) {
+
+/* Find the correspond distance around the used sections of the second
+   component region (normalised so that the entire border of the
+   component region has a length of "this->d0[1]"). */
+               x0 = ( dist[ i ] - dbreak )*dtot;
+               x = x0;
+
+/* Convert this into the correspond distance around the entire border of
+   the second component region (normalised so that the entire border of the
+   component region has unit length). */
+               rval = this->rvals[ 1 ];
+               off = this->offs[ 1 ];
+
+               for( j = 0; j < this->nbreak[ 1 ]; j++,rval++,off++ ) {
+                  if( *rval >= x0 ) break;
+                  x += *off;
+               }
+
+/* Store this as the next distance to move around the second component
+   Region, normalising it to the range 0 to 1 as required by astRegTrace. */
+               r2d[ r2n++ ] = x/this->dtot[ 1 ];
+
+/* Now we do the same if the current distance corresponds to a position
+   in the first component Region. */
+            } else {
+
+               x0 = dist[ i ]*dtot;
+               x = x0;
+
+               rval = this->rvals[ 0 ];
+               off = this->offs[ 0 ];
+
+               for( j = 0; j < this->nbreak[ 0 ]; j++,rval++,off++ ) {
+                  if( *rval >= x0 ) break;
+                  x += *off;
+               }
+
+               r1d[ r1n++ ] = x/this->dtot[ 0 ];
+
+            }
+
+         }
+      }
+
+/* Allocate memory to hold the axis values at the corresponding positions
+   in the first component Region. */
+      r1ptr[ 0 ] = astMalloc( sizeof( double )*r1n );
+      r1ptr[ 1 ] = astMalloc( sizeof( double )*r1n );
+
+/* Allocate memory to hold the axis values at the corresponding positions
+   in the second component Region. */
+      r2ptr[ 0 ] = astMalloc( sizeof( double )*r2n );
+      r2ptr[ 1 ] = astMalloc( sizeof( double )*r2n );
+
+/* Check the pointers can be used safely. */
+      if( astOK ) {
+
+/* Find the axis values at each of the required positions that fall in
+   the first component Region. Negate it first if needed to ensure the
+   Region is bounded (not guaranteed, but likely). */
+         if( astGetBounded( this->region1 ) ) {
+            (void) astRegTrace( this->region1, r1n, r1d, r1ptr );
+         } else {
+            AstRegion *negation = astGetNegation( this->region1 );
+            (void) astRegTrace( negation, r1n, r1d, r1ptr );
+            negation = astAnnul( negation );
+         }
+
+/* Do the same for the second component Region. */
+         if( astGetBounded( this->region2 ) ) {
+            (void) astRegTrace( this->region2, r2n, r2d, r2ptr );
+         } else {
+            AstRegion *negation = astGetNegation( this->region2 );
+            (void) astRegTrace( negation, r2n, r2d, r2ptr );
+            negation = astAnnul( negation );
+         }
+
+/* The arrays of positions returned by the above calls to astRegTrace may
+   include points that should not be there (e.g. points on the boundary
+   of one component region that should have been blanked due to being inside
+   the second component region - if the regions are ORed together). This
+   is a consequence of the relatively low value of the "NP" local constant
+   in function SetBreakInfo. So we now refine the positions to exclude
+   any such unwanted positions.
+
+   If the two component Regions are ANDed together, we want to remove the
+   positions from the boundary of the required component Region that fall
+   outside the other region. We can do this by simply using the other Region
+   as a Mapping. If the two component Regions are ORed together, we want to
+   remove the position that fall within (rather than outside) the other
+   Region. To do this we need to negate the other region  first. */
+         if( this->oper == AST__OR ) {
+            ureg1 = astGetNegation( this->region1 );
+            ureg2 = astGetNegation( this->region2 );
+         } else {
+            ureg1 = astClone( this->region1 );
+            ureg2 = astClone( this->region2 );
+         }
+
+/* Now transform the points on the boundary of the first Region in order
+   to set invalid those positions which are not on the boundary of the
+   supplied CmpRegion. */
+         if( r1n > 0 ) {
+            r1pset = astPointSet( r1n, 2, " ", status );
+            astSetPoints( r1pset, r1ptr );
+            r1psetb = astTransform( ureg2, r1pset, 1, NULL );
+            r1ptrb = astGetPoints( r1psetb );
+         } else {
+            r1pset = NULL;
+            r1psetb = NULL;
+            r1ptrb = NULL;
+         }
+
+/* Now transform the points on the boundary of the second Region in order
+   to set invalid those positions which are not on the boundary of the
+   supplied CmpRegion. */
+         if( r2n > 0 ) {
+            r2pset = astPointSet( r2n, 2, " ", status );
+            astSetPoints( r2pset, r2ptr );
+            r2psetb = astTransform( ureg1, r2pset, 1, NULL );
+            r2ptrb = astGetPoints( r2psetb );
+         } else {
+            r2pset = NULL;
+            r2psetb = NULL;
+            r2ptrb = NULL;
+         }
+
+/* Free the begation pointers. */
+         ureg1 = astAnnul( ureg1 );
+         ureg2 = astAnnul( ureg2 );
+
+/* Check pointer can be used safely. */
+         if( astOK ) {
+
+/* Copy the boundary positions from each component Region into a single
+   PointSet. These positions are in the base Frame of the CmpRegion. */
+            r1n = 0;
+            r2n = 0;
+            for( i = 0; i < n; i++ ) {
+               if( dist[ i ] > dbreak ) {
+                  bptr[ 0 ][ i ] = r2ptrb[ 0 ][ r2n ];
+                  bptr[ 1 ][ i ] = r2ptrb[ 1 ][ r2n++ ];
+               } else {
+                  bptr[ 0 ][ i ] = r1ptrb[ 0 ][ r1n ];
+                  bptr[ 1 ][ i ] = r1ptrb[ 1 ][ r1n++ ];
+               }
+            }
+
+         }
+
+/* Free resources. */
+         if( r1pset ) r1pset = astAnnul( r1pset );
+         if( r2pset ) r2pset = astAnnul( r2pset );
+         if( r1psetb ) r1psetb = astAnnul( r1psetb );
+         if( r2psetb ) r2psetb = astAnnul( r2psetb );
+
+      }
+
+/* If required, transform the base frame positions into the current
+   Frame of the CmpRegion, storing them in the supplied array. Then
+   free resources. */
+      if( bpset ) {
+         cpset = astPointSet( n, ncur, " ", status );
+         astSetPoints( cpset, ptr );
+
+         (void) astTransform( map, bpset, 1, cpset );
+
+         cpset = astAnnul( cpset );
+         bpset = astAnnul( bpset );
+      }
+
+/* Free remaining resources. */
+      map = astAnnul( map );
+   }
+   frm = astAnnul( frm );
+
+/* Return the result. */
+   return result;
+}
+
+static void RegClearAttrib( AstRegion *this_region, const char *attrib,
+                            char **base_attrib, int *status ) {
+/*
+*  Name:
+*     RegClearAttrib
+
+*  Purpose:
+*     Clear an attribute value for a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void RegClearAttrib( AstRegion *this, const char *attrib,
+*                          char **base_attrib, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astRegClearAttrib method
+*     inherited from the Region class).
+
+*  Description:
+*     This function clears the value of a named attribute in both the base
+*     and current Frame in the FrameSet encapsulated within a Region, without
+*     remapping either Frame.
+*
+*     No error is reported if the attribute is not recognised by the base
+*     Frame.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     attrib
+*        Pointer to a null terminated string holding the attribute name.
+*        NOTE, IT SHOULD BE ENTIRELY LOWER CASE.
+*     base_attrib
+*        Address of a location at which to return a pointer to the null
+*        terminated string holding the attribute name which was cleared in
+*        the base Frame of the encapsulated FrameSet. This may differ from
+*        the supplied attribute if the supplied attribute contains an axis
+*        index and the current->base Mapping in the FrameSet produces an
+*        axis permutation. The returned pointer should be freed using
+*        astFree when no longer needed. A NULL pointer may be supplied in
+*        which case no pointer is returned.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;
+   char *batt;
+   int rep;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Get a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_region;
+
+/* Use the RegClearAttrib method inherited from the parent class to clear the
+   attribute in the current and base Frames in the FrameSet encapsulated by
+   the parent Region structure. */
+   (*parent_regclearattrib)( this_region, attrib, &batt, status );
+
+/* Now clear the base Frame attribute to the component Regions (the current
+   Frame within the component Regions is equivalent to the base Frame in the
+   parent Region structure). Annul any "attribute unknown" error that results
+   from attempting to do this. */
+   if( astOK ) {
+      rep = astReporting( 0 );
+      astRegClearAttrib( this->region1, batt, NULL );
+      astRegClearAttrib( this->region2, batt, NULL );
+      if( astStatus == AST__BADAT ) astClearStatus;
+      astReporting( rep );
+   }
+
+/* If required, return the base Frame attribute name, otherwise free it. */
+   if( base_attrib ) {
+      *base_attrib = batt;
+   } else {
+      batt = astFree( batt );
+   }
+}
+
+static void ResetCache( AstRegion *this_region, int *status ){
+/*
+*  Name:
+*     ResetCache
+
+*  Purpose:
+*     Clear cached information within the supplied Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void ResetCache( AstRegion *this, int *status )
+
+*  Class Membership:
+*     Region member function (overrides the astResetCache method
+*     inherited from the parent Region class).
+
+*  Description:
+*     This function clears cached information from the supplied Region
+*     structure.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables *: */
+   AstCmpRegion *this;
+   int i;
+
+/* Check a Region was supplied. */
+   if( this_region ) {
+
+/* Get a pointer to the CmpRegion structure. */
+      this = (AstCmpRegion *) this_region;
+
+/* Clear information cached in the CmpRegion structure. */
+      for( i = 0; i < 2; i++ ) {
+         this->rvals[ i ] = astFree(  this->rvals[ i ] );
+         this->offs[ i ] = astFree(  this->offs[ i ] );
+         this->nbreak[ i ] = 0;
+         this->d0[ i ] = AST__BAD;
+         this->dtot[ i ] = AST__BAD;
+      }
+
+      this->bounded = -INT_MAX;
+
+/* Clear information cached in the component regions. */
+      if( this->region1 ) astResetCache( this->region1 );
+      if( this->region2 ) astResetCache( this->region2 );
+
+/* Clear information cached in the parent Region structure. */
+      (*parent_resetcache)( this_region, status );
+   }
+}
+
+static void SetBreakInfo( AstCmpRegion *this, int comp, int *status ){
+/*
+*  Name:
+*     SetBreakInfo
+
+*  Purpose:
+*     Ensure that a CmpRegion has information about the breaks in the
+*     boundaries of one of the two component Regions.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void SetBreakInfo( AstCmpRegion *this, int comp, int *status )
+
+*  Class Membership:
+*     CmpRegion method.
+
+*  Description:
+*     This function returns without action if the supplied CmpRegion
+*     already contains break information for the specified component Region.
+*     Otherwise, it creates the required information and stores it in the
+*     CmpRegion.
+*
+*     Each component Region in the CmpRegion has a boundary. But in
+*     general only part of the boundary of a component Region will also
+*     be included in the CmpRegion boundary. Thus the component Region
+*     boundary can be broken up into sections; sections that form part
+*     of the CmpRegion boundary, and sections that do not. This function
+*     stores information about the breaks between these sections.
+*
+*     The complete boundary of a component Region is parameterised by a
+*     geodesic distance that goes from 0.0 to the value found by this
+*     function and stored in this->dtot (the total geodesic distance
+*     around the border). This function find the ranges of this parameter
+*     that correspond to the sections of the boundary that are also on the
+*     CmpRegion boundary, and thus finds the total length that the component
+*     boundary contributes to the CmpRegion boundary. This length is stored
+*     in "this->d0" (a two element array, one for each component Region).
+*
+*     It also find two arrays "this->rvals" and "this->offs" that allow a
+*     distance value in the range 0.0 to "this->d0" (i.e. a distance
+*     measured by skipping over the parts of the component boundary that
+*     are not on the CmpRegion boundary), to be converted into the
+*     corresponding distance value in the range 0.0 to "this->dtot" (i.e. a
+*     distance measured round the complete component boundary, including the
+*     parts not on the CmpRegion boundary).
+
+*  Parameters:
+*     this
+*        Pointer to a CmpRegion.
+*     comp
+*        Zero or one, indicating which component Region is to be checked.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* The number of points to be spread evenly over the entire boundary of the
+   component Region. */
+#define NP 101
+
+/* Local Variables: */
+   AstFrame *frm;
+   AstPointSet *pset1;
+   AstPointSet *pset2;
+   AstRegion *other;
+   AstRegion *reg;
+   AstRegion *uother;
+   double **ptr2;
+   double **ptr1;
+   double *d;
+   double *offs;
+   double *p0;
+   double *p1;
+   double *p;
+   double *q;
+   double *rvals;
+   double delta;
+   double dist;
+   double pnt1[ 2 ];
+   double pnt2[ 2 ];
+   double rbad;
+   double rval;
+   double totdist;
+   int i;
+   int j;
+   int nn;
+   int prevgood;
+
+/* Check inherited status */
+   if( !astOK ) return;
+
+/* If the information describing breaks in the component boundary has not
+   yet been set up, do so now. */
+   if( this->d0[ comp ] == AST__BAD ) {
+
+/* Get a pointer to the component Region for which break information is
+   required. */
+      reg = comp ? this->region2 : this->region1;
+
+/* Check the component class implements the astRegTrace method. */
+      if( astRegTrace( reg, 0, NULL, NULL ) ) {
+
+/* Create a pointSet to hold axis values at evenly spaced positions along
+   the entire boundary of the selected component region. */
+         pset1 = astPointSet( NP, 2, " ", status );
+         ptr1 = astGetPoints( pset1 );
+
+/* Allocate memory to hold an array of corresponding scalar distances around
+   the boundary. */
+         d = astMalloc( NP*sizeof( double ) );
+
+/* Check pointers can be used safely. */
+         if( astOK ) {
+
+/* Get the distance increment between points (at this point the distances
+   are normalised so that the entire boundary has unit length, as
+   required by astRegTrace). */
+            delta = 1.0/( NP - 1 );
+
+/* Set up the array of evenly spaced distances around the boundary of the
+   component region. */
+            for( i = 0; i < NP; i++ ) d[ i ] = i*delta;
+
+/* Get the corresponding Frame positions. If the Region is unbounded
+   (e.g. a negated circle, etc), then negate it first in the hope that
+   this may produced a bounded Region. */
+            if( astGetBounded( reg ) ) {
+               (void) astRegTrace( reg, NP, d, ptr1 );
+            } else {
+               AstRegion *negation = astGetNegation( reg );
+               (void) astRegTrace( negation, NP, d, ptr1 );
+               negation = astAnnul( negation );
+            }
+
+/* Get a pointer to the other component Region. */
+            other = comp ? this->region1 : this->region2;
+
+/* If the two component Regions are ANDed together, we want to remove the
+   positions from the boundary of the required component Region that fall
+   outside the other region. We can do this by simply using the other Region
+   as a Mapping. If the two component Regions are ORed together, we want to
+   remove the position that fall within (rather than outside) the other
+   Region. To do this we need to negate the other region  first. */
+            if( this->oper == AST__OR ) {
+               uother = astGetNegation( other );
+            } else {
+               uother = astClone( other );
+            }
+
+/* Now transform the points on the boundary of the selected Region in
+   order to set invalid those positions which are not on the boundary of
+   the supplied CmpRegion. */
+            pset2 = astTransform( uother, pset1, 1, NULL );
+
+/* Annul the negation pointer */
+            uother = astAnnul( uother );
+
+/* Modify the distance array by setting invalid each element that is not
+   on the boundary of the CmpRegion. */
+            ptr2 = astGetPoints( pset2 );
+            if( astOK ) {
+               p = ptr2[ 0 ];
+               q = ptr2[ 1 ];
+               for( i = 0; i < NP; i++,p++,q++ ) {
+                  if( *p == AST__BAD || *q == AST__BAD ) d[ i ] = AST__BAD;
+               }
+
+/* At each good/bad junction in this list, extend the good section by one
+   point. This ensures that the good sections of the curve do in fact
+   touch each other (they may in fact overlap a little but that does not
+   matter). */
+               prevgood = ( d[ 0 ] != AST__BAD );
+               for( i = 1; i < NP; i++,p++,q++ ) {
+                  if( d[ i ] == AST__BAD ) {
+                     if( prevgood ) d[ i ] = i*delta;
+                     prevgood = 0;
+
+                  } else {
+                     if( !prevgood ) d[ i - 1 ] = ( i - 1 )*delta;
+                     prevgood = 1;
+                  }
+               }
+
+/* Find the total geodesic distance around the border. This is only an
+   approximation but it is only used to give a relative weight to this
+   component within the CmpFrame, and so does not need to be very accurate. */
+               frm = astGetFrame( reg->frameset, AST__CURRENT );
+               p0 = ptr1[ 0 ];
+               p1 = ptr1[ 1 ];
+               totdist = 0;
+               pnt1[ 0 ] = *(p0++);
+               pnt1[ 1 ] = *(p1++);
+               for( i = 1; i < NP; i++ ) {
+                  pnt2[ 0 ] = *(p0++);
+                  pnt2[ 1 ] = *(p1++);
+                  dist = astDistance( frm, pnt1, pnt2 );
+                  if( dist != AST__BAD ) totdist += dist;
+                  pnt1[ 0 ] = pnt2[ 0 ];
+                  pnt1[ 1 ] = pnt2[ 1 ];
+               }
+
+/* Change delta so that it represents a geodesic distance, rather than a
+   normalised distance in the range zero to one. Working in geodesic distance
+   (e.g. Radians on a SkyFrame) prevents Regions higher up in a complex nested
+   CmpRegion being given higher priority than a lower Region. */
+               delta *= totdist;
+
+/* Now create two arrays - "rvals" holds the distance travelled around
+   the used parts of the border at which breaks occur, "offs" holds the jump
+   in distance around the complete border at each break. The distance
+   around the complete border is normalised to the range [0.0,1.0].
+   Therefore the total distance around the used parts of the border will in
+   general be less than 1.0 */
+               if( d[ 0 ] == AST__BAD ) {
+                  nn = 1;
+                  j = 0;
+                  rvals = astMalloc( sizeof( double ) );
+                  offs = astMalloc( sizeof( double ) );
+                  if( astOK ) rvals[ 0 ] = -0.5*delta;
+                  rbad = 0.5;
+                  prevgood = 0;
+                  rval = -0.5*delta;
+
+               } else {
+                  nn = 0;
+                  rvals = NULL;
+                  offs = NULL;
+                  prevgood = 1;
+                  rbad = 0.0;
+                  rval = 0.0;
+               }
+
+               for( i = 1; i < NP; i++,p++,q++ ) {
+
+                  if( d[ i ] == AST__BAD ) {
+                     if( prevgood ) {
+                        j = nn++;
+                        rvals = astGrow( rvals, nn, sizeof( double ) );
+                        offs = astGrow( offs, nn, sizeof( double ) );
+                        if( astOK ) {
+                           rvals[ j ] = rval + 0.5*delta;
+                           rbad = 0.0;
+                        } else {
+                           break;
+                        }
+                        prevgood = 0;
+                     }
+
+                     rbad += 1.0;
+
+                  } else {
+                     if( !prevgood ) {
+                        offs[ j ] = rbad*delta;
+                        prevgood = 1;
+                     }
+                     rval += delta;
+                  }
+               }
+
+               if( !prevgood ) {
+                  rval += 0.5*delta;
+                  offs[ j ] = rbad*delta;
+               }
+
+/* Record the information in the CmpRegion structure. */
+               this->rvals[ comp ] = rvals;
+               this->offs[ comp ] = offs;
+               this->nbreak[ comp ] = nn;
+               this->d0[ comp ] = rval;
+               this->dtot[ comp ] = totdist;
+            }
+
+/* Free resources. */
+            pset2 = astAnnul( pset2 );
+         }
+
+         pset1 = astAnnul( pset1 );
+         d = astFree( d );
+
+      }
+   }
+}
+
+#undef NP
+
+static void SetRegFS( AstRegion *this_region, AstFrame *frm, int *status ) {
+/*
+*  Name:
+*     SetRegFS
+
+*  Purpose:
+*     Stores a new FrameSet in a Region
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     void SetRegFS( AstRegion *this_region, AstFrame *frm, int *status )
+
+*  Class Membership:
+*     CmpRegion method (over-rides the astSetRegFS method inherited from
+*     the Region class).
+
+*  Description:
+*     This function creates a new FrameSet and stores it in the supplied
+*     Region. The new FrameSet contains two copies of the supplied
+*     Frame, connected by a UnitMap.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     frm
+*        The Frame to use.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstRegion *creg;        /* Pointer to component Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Invoke the parent method to store the FrameSet in the parent Region
+   structure. */
+   (* parent_setregfs)( this_region, frm, status );
+
+/* If either component Region has a dummy FrameSet use this method
+   recursively to give them the same FrameSet. */
+   creg = ((AstCmpRegion *) this_region )->region1;
+   if( creg && !astGetRegionFS( creg ) ) astSetRegFS( creg, frm );
+
+   creg = ((AstCmpRegion *) this_region )->region2;
+   if( creg && !astGetRegionFS( creg ) ) astSetRegFS( creg, frm );
+
+}
+
+static AstMapping *Simplify( AstMapping *this_mapping, int *status ) {
+/*
+*  Name:
+*     Simplify
+
+*  Purpose:
+*     Simplify a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstMapping *Simplify( AstMapping *this, int *status )
+
+*  Class Membership:
+*     CmpRegion method (over-rides the astSimplify method inherited from
+*     the Region class).
+
+*  Description:
+*     This function simplifies a CmpRegion to eliminate redundant
+*     computational steps, or to merge separate steps which can be
+*     performed more efficiently in a single operation.
+
+*  Parameters:
+*     this
+*        Pointer to the original Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A new pointer to the (possibly simplified) Region.
+
+*  Notes:
+*     - A NULL pointer value will be returned if this function is
+*     invoked with the AST error status set, or if it should fail for
+*     any reason.
+
+*  Deficiencies:
+*     - Currently, this function does not attempt to map the component
+*     Regions into the current Frame of the parent Region structure.
+*     Both components should be mapped into the current Frame, and if the
+*     resulting base->current Mappings in *both* remapped component Regions are
+*     UnitMaps, then a new CmpRegion should be created from the re-mapped
+*     Regions.
+*/
+
+/* Local Variables: */
+   AstCmpRegion *newb;           /* New CmpRegion defined in base Frame */
+   AstCmpRegion *newc;           /* New CmpRegion defined in current Frame */
+   AstFrame *frm;                /* Current Frame */
+   AstMapping *map;              /* Base->current Mapping */
+   AstMapping *result;           /* Result pointer to return */
+   AstRegion *csreg1;            /* Copy of simplified first component Region */
+   AstRegion *csreg2;            /* Copy of simplified second component Region */
+   AstRegion *nullreg;           /* Null or infinfite Region */
+   AstRegion *othereg;           /* Non-Null and non-infinfite Region */
+   AstRegion *reg1;              /* First component Region */
+   AstRegion *reg2;              /* Second component Region */
+   AstRegion *sreg1;             /* Simplified first component Region */
+   AstRegion *sreg2;             /* Simplified second component Region */
+   int neg1;                     /* Negated flag to use with first component */
+   int neg2;                     /* Negated flag to use with second component */
+   int oper;                     /* Boolean operator used to combine components */
+   int overlap;                  /* Nature of overlap between components */
+   int simpler;                  /* Has any simplification taken place? */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Invoke the parent Simplify method inherited from the Region class. This
+   will simplify the encapsulated FrameSet and uncertainty Region. The
+   returned pointer identifies a region within the current Frame of the
+   FrameSet encapsulated by the parent Region structure. Note this by
+   storing the pointer in the "newc" ("c" for "current") variable. */
+   newc = (AstCmpRegion *) (*parent_simplify)( this_mapping, status );
+
+/* Note if any simplification took place. This is assumed to be the case
+   if the pointer returned by the above call is different to the supplied
+   pointer. */
+   simpler = ( (AstMapping *) newc != this_mapping );
+
+/* Below we may create a new simplified region which identifies a region
+   within the base Frame of the FrameSet encapsulated by the parent Region
+   structure. Such a result will need to be mapped into the current Frame
+   before being returned. The "newb" variable ("b" for "base") will be
+   used to store a pointer to such a result. Initialise this variable to
+   indicate that we do not yet have a base Frame result. */
+   newb = NULL;
+
+/* Get the component Regions, how they should be combined, and the
+   Negated values which should be used with them. The returned values
+   take account of whether the supplied CmpRegion has itself been Negated
+   or not. The returned Regions represent regions within the base Frame
+   of the FrameSet encapsulated by the parent Region structure. */
+   GetRegions( newc, &reg1, &reg2, &oper, &neg1, &neg2, status );
+
+/* If the first component Region does not have the required value for
+   its "Negated" attribute, use the negation of "reg1" in place of "reg1"
+   itself. */
+   if( neg1 != astGetNegated( reg1 ) ) {
+      AstRegion *tmp = astGetNegation( reg1 );
+      (void) astAnnul( reg1 );
+      reg1 = tmp;
+   }
+
+/* If the second component Region does not have the required value for
+   its "Negated" attribute, use the negation of "reg2" in place of "reg2"
+   itself. */
+   if( neg2 != astGetNegated( reg2 ) ) {
+      AstRegion *tmp = astGetNegation( reg2 );
+      (void) astAnnul( reg2 );
+      reg2 = tmp;
+   }
+
+/* Simplify each of the two components. */
+   sreg1 = astSimplify( reg1 );
+   sreg2 = astSimplify( reg2 );
+
+/* Note if any simplification took place. */
+   simpler = simpler || ( sreg1 != reg1 || sreg2 != reg2 );
+
+/* If either component is null or infinite we can exclude it from the
+   returned Region. */
+   if( astIsANullRegion( sreg1 ) || astIsANullRegion( sreg2 ) ) {
+
+/* Get a pointer to the non-null Region. The following is still valid
+   even if both regions are null or infinite. */
+      if( astIsANullRegion( sreg1 ) ){
+         nullreg = sreg1;
+         othereg = sreg2;
+      } else {
+         nullreg = sreg2;
+         othereg = sreg1;
+      }
+
+/* If null.. */
+      if( !astGetNegated( nullreg ) ){
+         if( oper == AST__AND ) {
+            newb = (AstCmpRegion *) astNullRegion( othereg,
+                                             astGetUnc( othereg, 0 ), "", status );
+
+         } else if( oper == AST__OR ) {
+            newb = astCopy( othereg );
+
+         } else {
+            astError( AST__INTER, "astSimplify(%s): The %s refers to an "
+                      "unknown boolean operator with identifier %d (internal "
+                      "AST programming error).", status, astGetClass( newc ),
+                      astGetClass( newc ), oper );
+         }
+
+/* If infinite.. */
+      } else {
+         if( oper == AST__AND ) {
+            newb = astCopy( othereg );
+
+         } else if( oper == AST__OR ) {
+            newb = (AstCmpRegion *) astNullRegion( othereg,
+                                      astGetUnc( othereg, 0 ), "negated=1", status );
+
+         } else {
+            astError( AST__INTER, "astSimplify(%s): The %s refers to an "
+                      "unknown boolean operator with identifier %d (internal "
+                      "AST programming error).", status, astGetClass( newc ),
+                      astGetClass( newc ), oper );
+         }
+      }
+
+/* Flag that we have done some simplication.*/
+      simpler = 1;
+
+/* If neither component is null or infinite, see if it is possible to
+   remove one or both of the components on the basis of the overlap
+   between them. */
+   } else {
+      overlap = astOverlap( sreg1, sreg2 );
+
+/* If the components have no overlap, and they are combined using AND, then
+   the CmpRegion is null. */
+      if( ( overlap == 1 || overlap == 6 ) && oper == AST__AND ) {
+         newb = (AstCmpRegion *) astNullRegion( sreg1, astGetUnc( sreg1, 0 ),
+                                                "", status );
+         simpler = 1;
+
+/* If one component is the negation of the other component, and they are
+   combined using OR, then the CmpRegion is infinite. This is represented
+   by a negated null region.*/
+      } else if( overlap == 6 && oper == AST__OR ) {
+         newb = (AstCmpRegion  *) astNullRegion( sreg1, astGetUnc( sreg1, 0 ),
+                                                 "negated=1", status );
+         simpler = 1;
+
+/* If the two components are identical... */
+      } else if( overlap == 5 ) {
+         simpler = 1;
+
+/* If combined with AND or OR, the CmpRegion can be replaced by the first
+   (or second) component Region. */
+         if( oper == AST__AND || oper == AST__OR ) {
+            newb = astCopy( sreg1 );
+         } else {
+            astError( AST__INTER, "astSimplify(%s): The %s refers to an "
+                      "unknown boolean operator with identifier %d (internal "
+                      "AST programming error).", status, astGetClass( newc ),
+                      astGetClass( newc ), oper );
+         }
+
+/* If the first component is entirely contained within the second
+   component, and they are combined using AND or OR, then the CmpRegion
+   can be replaced by the first or second component. */
+      } else if( overlap == 2 && ( oper == AST__AND || oper == AST__OR ) ){
+         newb = astCopy( ( oper == AST__AND ) ? sreg1 : sreg2 );
+         simpler = 1;
+
+/* If the second component is entirely contained within the first
+   component, and they are combined using AND or OR, then the CmpRegion
+   can be replaced by the second or first component. */
+      } else if( overlap == 3 && ( oper == AST__AND || oper == AST__OR ) ){
+         newb = astCopy( ( oper == AST__AND ) ? sreg2 : sreg1 );
+         simpler = 1;
+
+/* Otherwise, no further simplication is possible, so either create a new
+   CmpRegion or leave the "newb" pointer NULL (which will cause "newc" to
+   be used), depending on whether the components were simplified. */
+      } else if( simpler ){
+         csreg1 = astCopy( sreg1 );
+         csreg2 = astCopy( sreg2 );
+         newb = astCmpRegion( csreg1, csreg2, oper, "", status );
+         csreg1 = astAnnul( csreg1 );
+         csreg2 = astAnnul( csreg2 );
+
+      }
+   }
+
+/* If any simplification took place, decide whether to use the "newc" or
+   "newb" pointer for the returned Mapping. If "newb" is non-NULL we use
+   it, otherwise we use "newc". If "newb" is used we must first map the
+   result Region from the base Frame of the FrameSet encapsulated
+   by the parent Region structure, to the current Frame. */
+   if( simpler ) {
+      if( newb ){
+         frm = astGetFrame( ((AstRegion *) newc)->frameset, AST__CURRENT );
+         map = astGetMapping( ((AstRegion *) newc)->frameset, AST__BASE, AST__CURRENT );
+         result = astMapRegion( newb, map, frm );
+         frm = astAnnul( frm );
+         map = astAnnul( map );
+         newb = astAnnul( newb );
+      } else {
+         result = astClone( newc );
+      }
+
+/* If no simplification took place, return a clone of the supplied pointer. */
+   } else {
+      result = astClone( this_mapping );
+   }
+
+/* Free resources. */
+   reg1 = astAnnul( reg1 );
+   reg2 = astAnnul( reg2 );
+   sreg1 = astAnnul( sreg1 );
+   sreg2 = astAnnul( sreg2 );
+   newc = astAnnul( newc );
+
+/* If an error occurred, annul the returned Mapping. */
+   if ( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+static AstPointSet *Transform( AstMapping *this_mapping, AstPointSet *in,
+                               int forward, AstPointSet *out, int *status ) {
+/*
+*  Name:
+*     Transform
+
+*  Purpose:
+*     Apply a CmpRegion to transform a set of points.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     AstPointSet *Transform( AstMapping *this, AstPointSet *in,
+*                             int forward, AstPointSet *out, int *status )
+
+*  Class Membership:
+*     CmpRegion member function (over-rides the astTransform method inherited
+*     from the Region class).
+
+*  Description:
+*     This function takes a CmpRegion and a set of points encapsulated in a
+*     PointSet and transforms the points so as to apply the required Region.
+*     This implies applying each of the CmpRegion's component Regions in turn,
+*     either in series or in parallel.
+
+*  Parameters:
+*     this
+*        Pointer to the CmpRegion.
+*     in
+*        Pointer to the PointSet associated with the input coordinate values.
+*     forward
+*        A non-zero value indicates that the forward coordinate transformation
+*        should be applied, while a zero value requests the inverse
+*        transformation.
+*     out
+*        Pointer to a PointSet which will hold the transformed (output)
+*        coordinate values. A NULL value may also be given, in which case a
+*        new PointSet will be created by this function.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to the output (possibly new) PointSet.
+
+*  Notes:
+*     -  A null pointer will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+*     -  The number of coordinate values per point in the input PointSet must
+*     match the number of coordinates for the CmpRegion 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: */
+   AstCmpRegion *this;           /* Pointer to the CmpRegion structure */
+   AstPointSet *ps1;             /* Pointer to PointSet for first component */
+   AstPointSet *ps2;             /* Pointer to PointSet for second component */
+   AstPointSet *pset_tmp;        /* Pointer to PointSet holding base Frame positions*/
+   AstPointSet *result;          /* Pointer to output PointSet */
+   AstRegion *reg1;              /* Pointer to first component Region */
+   AstRegion *reg2;              /* Pointer to second component Region */
+   double **ptr1;                /* Pointer to first component axis values */
+   double **ptr2;                /* Pointer to second component axis values */
+   double **ptr_out;             /* Pointer to output coordinate data */
+   int coord;                    /* Zero-based index for coordinates */
+   int good;                     /* Is the point inside the CmpRegion? */
+   int ncoord_out;               /* No. of coordinates per output point */
+   int ncoord_tmp;               /* No. of coordinates per base Frame point */
+   int neg1;                     /* Negated value for first component Region */
+   int neg2;                     /* Negated value for second component Region */
+   int npoint;                   /* No. of points */
+   int oper;                     /* Boolean operator to use */
+   int point;                    /* Loop counter for points */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a Pointer to the CmpRegion structure */
+   this = (AstCmpRegion *) this_mapping;
+
+/* Get the component Regions, how they should be combined, and the
+   Negated values which should be used with them. The returned values
+   take account of whether the supplied CmpRegion has itself been Negated
+   or not. The returned Regions represent regions within the base Frame
+   of the FrameSet encapsulated by the parent Region structure. */
+   GetRegions( this, &reg1, &reg2, &oper, &neg1, &neg2, status );
+
+/* If the first component Region does not have the required value for
+   its "Negated" attribute, use the negation of "reg1" in place of "reg1"
+   itself. */
+   if( neg1 != astGetNegated( reg1 ) ) {
+      AstRegion *tmp = astGetNegation( reg1 );
+      (void) astAnnul( reg1 );
+      reg1 = tmp;
+   }
+
+/* If the second component Region does not have the required value for
+   its "Negated" attribute, use the negation of "reg2" in place of "reg2"
+   itself. */
+   if( neg2 != astGetNegated( reg2 ) ) {
+      AstRegion *tmp = astGetNegation( reg2 );
+      (void) astAnnul( reg2 );
+      reg2 = tmp;
+   }
+
+/* Apply the parent mapping using the stored pointer to the Transform member
+   function inherited from the parent Region class. This function validates
+   all arguments and generates an output PointSet if necessary, containing
+   a copy of the input PointSet. */
+   result = (*parent_transform)( this_mapping, in, forward, out, status );
+
+/* We will now extend the parent astTransform method by performing the
+   calculations needed to generate the output coordinate values. */
+
+/* First use the encapsulated FrameSet in the parent Region structure to
+   transform the supplied positions from the current Frame in the
+   encapsulated FrameSet (the Frame represented by the CmpRegion), to the
+   base Frame (the Frame in which the component Regions are defined). Note,
+   the returned pointer may be a clone of the "in" pointer, and so we
+   must be carefull not to modify the contents of the returned PointSet. */
+   pset_tmp = astRegTransform( this, in, 0, NULL, NULL );
+
+/* Now transform this PointSet using each of the two component Regions in
+   turn. */
+   ps1 = astTransform( reg1, pset_tmp, 0, NULL );
+   ps2 = astTransform( reg2, pset_tmp, 0, NULL );
+
+/* Determine the numbers of points and coordinates per point for these base
+   Frame PointSets and obtain pointers for accessing the base Frame and output
+   coordinate values. */
+   npoint = astGetNpoint( pset_tmp );
+   ncoord_tmp = astGetNcoord( pset_tmp );
+   ptr1 = astGetPoints( ps1 );
+   ptr2 = astGetPoints( ps2 );
+   ncoord_out = astGetNcoord( result );
+   ptr_out = astGetPoints( result );
+
+/* Perform coordinate arithmetic. */
+/* ------------------------------ */
+   if ( astOK ) {
+
+/* First deal with ANDed Regions */
+      if( oper == AST__AND ) {
+         for ( point = 0; point < npoint; point++ ) {
+            good = 0;
+
+            for ( coord = 0; coord < ncoord_tmp; coord++ ) {
+               if( ptr1[ coord ][ point ] != AST__BAD &&
+                   ptr2[ coord ][ point ] != AST__BAD ) {
+                  good = 1;
+                  break;
+               }
+            }
+
+            if( !good ) {
+               for ( coord = 0; coord < ncoord_out; coord++ ) {
+                  ptr_out[ coord ][ point ] = AST__BAD;
+               }
+            }
+         }
+
+/* Now deal with ORed Regions */
+      } else if( oper == AST__OR ) {
+         for ( point = 0; point < npoint; point++ ) {
+            good = 0;
+
+            for ( coord = 0; coord < ncoord_tmp; coord++ ) {
+               if( ptr1[ coord ][ point ] != AST__BAD ||
+                   ptr2[ coord ][ point ] != AST__BAD ) {
+                  good = 1;
+                  break;
+               }
+            }
+
+            if( !good ) {
+               for ( coord = 0; coord < ncoord_out; coord++ ) {
+                  ptr_out[ coord ][ point ] = AST__BAD;
+               }
+            }
+         }
+
+/* Report error for any unknown operator. */
+      } else if( astOK ) {
+         astError( AST__INTER, "astTransform(%s): The %s refers to an unknown "
+                   "boolean operator with identifier %d (internal AST "
+                   "programming error).", status, astGetClass( this ),
+                    astGetClass( this ), oper );
+      }
+   }
+
+/* Free resources. */
+   reg1 = astAnnul( reg1 );
+   reg2 = astAnnul( reg2 );
+   ps1 = astAnnul( ps1 );
+   ps2 = astAnnul( ps2 );
+   pset_tmp = astAnnul( pset_tmp );
+
+/* If an error occurred, clean up by deleting the output PointSet (if
+   allocated by this function) and setting a NULL result pointer. */
+   if ( !astOK ) {
+      if ( !out ) result = astDelete( result );
+      result = NULL;
+   }
+
+/* Return a pointer to the output PointSet. */
+   return result;
+}
+
+static void XORCheck( AstCmpRegion *this, int *status ) {
+/*
+*  Name:
+*     XORCheck
+
+*  Purpose:
+*     Check if the supplied CmpRegion represents an XOR operation.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*      void XORCheck( AstCmpRegion *this, int *status )
+
+*  Class Membership:
+*     CmpRegion method
+
+*  Decription:
+*     This function analyses the component Regions within the supplied
+*     CmpRegion to see if the CmpRegion is equivalent to an XOR operation
+*     on two other Regions. If it is, teh Regions that are XORed are
+*     stored in the supplied CmpRegion.
+
+*  Parameters:
+*     this
+*        Pointer to the CmpRegion.
+
+*/
+
+/* Local Variables: */
+   AstCmpRegion *cmpreg1;
+   AstCmpRegion *cmpreg2;
+   int xor;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* If the CmpRegion is already known to be an XOR operation, return
+   without action. */
+   if( this->xor1 ) return;
+
+/* To be equivalent to an XOR operation, the supplied CmpRegion must be an
+   OR operation and each component Region must be a CmpRegion. */
+   if( this->oper == AST__OR && astIsACmpRegion( this->region1 )
+                             && astIsACmpRegion( this->region2 ) ) {
+      cmpreg1 = (AstCmpRegion *) this->region1;
+      cmpreg2 = (AstCmpRegion *) this->region2;
+
+/* Each component CmpRegion must be an AND operation. */
+      if( cmpreg1->oper == AST__AND && cmpreg2->oper == AST__AND ) {
+
+/* Temporarily negate the first component of the first CmpRegion. */
+         astNegate( cmpreg1->region1 );
+
+/* Initially, assume the supplied CmpRegion is not equivalent to an XOR
+   operation. */
+         xor = 0;
+
+/* This negated region must be equal to one of the two component Regions
+   in the second component CmpRegion. Check the first. */
+         if( astEqual( cmpreg1->region1, cmpreg2->region1 ) ) {
+
+/* We now check that the other two Regions are equal (after negating the
+   first). If so, set "xor" non-zero. */
+            astNegate( cmpreg1->region2 );
+            if( astEqual( cmpreg1->region2, cmpreg2->region2 ) ) xor = 1;
+            astNegate( cmpreg1->region2 );
+
+/* Do equiovalent checks the other way round. */
+         } else if( astEqual( cmpreg1->region1, cmpreg2->region2 ) ) {
+            astNegate( cmpreg1->region2 );
+            if( astEqual( cmpreg1->region2, cmpreg2->region1 ) ) xor = 1;
+            astNegate( cmpreg1->region2 );
+         }
+
+/* Re-instate the original state of the Negated attribute in the first
+   component of the first CmpRegion. */
+         astNegate( cmpreg1->region1 );
+
+/* If the supplied CmpRegion is equivalent to an XOR operation, store
+   copies of the components in the supplied CmpRegion. */
+         if( xor ) {
+            this->xor1 = astCopy( cmpreg1->region1 );
+            this->xor2 = astCopy( cmpreg1->region2 );
+
+/* We need to negate one of these two Region (it doesn't matter which),
+   and we choose to negate which ever of them is already negated (so that
+   it becomes un-negated). */
+            if( astGetNegated( this->xor1 ) ) {
+               astNegate( this->xor1 );
+            } else {
+               astNegate( this->xor2 );
+            }
+         }
+      }
+   }
+}
+
+/* Copy constructor. */
+/* ----------------- */
+static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
+/*
+*  Name:
+*     Copy
+
+*  Purpose:
+*     Copy constructor for CmpRegion objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Copy( const AstObject *objin, AstObject *objout, int *status )
+
+*  Description:
+*     This function implements the copy constructor for CmpRegion objects.
+
+*  Parameters:
+*     objin
+*        Pointer to the object to be copied.
+*     objout
+*        Pointer to the object being constructed.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     void
+
+*  Notes:
+*     -  This constructor makes a deep copy, including a copy of the component
+*     Regions within the CmpRegion.
+*/
+
+/* Local Variables: */
+   AstCmpRegion *in;                /* Pointer to input CmpRegion */
+   AstCmpRegion *out;               /* Pointer to output CmpRegion */
+   int i;                           /* Loop count */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain pointers to the input and output CmpRegions. */
+   in = (AstCmpRegion *) objin;
+   out = (AstCmpRegion *) objout;
+
+/* For safety, start by clearing any memory references in the output
+   Region that were copied from the input Region. */
+   out->region1 = NULL;
+   out->region2 = NULL;
+   out->xor1 = NULL;
+   out->xor2 = NULL;
+
+   for( i = 0; i < 2; i++ ) {
+      out->rvals[ i ] = NULL;
+      out->offs[ i ] = NULL;
+   }
+
+/* Make copies of these Regions and store pointers to them in the output
+   CmpRegion structure. */
+   out->region1 = astCopy( in->region1 );
+   out->region2 = astCopy( in->region2 );
+   if( in->xor1 ) out->xor1 = astCopy( in->xor1 );
+   if( in->xor2 ) out->xor2 = astCopy( in->xor2 );
+
+/* Copy cached arrays. */
+   for( i = 0; i < 2; i++ ) {
+      out->rvals[ i ] = astStore( NULL, in->rvals[ i ], in->nbreak[ i ]*sizeof( **in->rvals ) );
+      out->offs[ i ] = astStore( NULL, in->offs[ i ], in->nbreak[ i ]*sizeof( **in->offs ) );
+   }
+}
+
+/* Destructor. */
+/* ----------- */
+static void Delete( AstObject *obj, int *status ) {
+/*
+*  Name:
+*     Delete
+
+*  Purpose:
+*     Destructor for CmpRegion objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Delete( AstObject *obj, int *status )
+
+*  Description:
+*     This function implements the destructor for CmpRegion objects.
+
+*  Parameters:
+*     obj
+*        Pointer to the object to be deleted.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     void
+
+*  Notes:
+*     This function attempts to execute even if the global error status is
+*     set.
+*/
+
+/* Local Variables: */
+   AstCmpRegion *this;              /* Pointer to CmpRegion */
+   int i;
+
+/* Obtain a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) obj;
+
+/* Free arrays holding cached information. */
+   for( i = 0; i < 2; i++ ) {
+      this->rvals[ i ] = astFree( this->rvals[ i ] );
+      this->offs[ i ] = astFree( this->offs[ i ] );
+   }
+
+/* Annul the pointers to the component Regions. */
+   this->region1 = astAnnul( this->region1 );
+   this->region2 = astAnnul( this->region2 );
+   if( this->xor1 ) this->xor1 = astAnnul( this->xor1 );
+   if( this->xor2 ) this->xor2 = astAnnul( this->xor2 );
+}
+
+/* Dump function. */
+/* -------------- */
+static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
+/*
+*  Name:
+*     Dump
+
+*  Purpose:
+*     Dump function for CmpRegion objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Dump( AstObject *this, AstChannel *channel, int *status )
+
+*  Description:
+*     This function implements the Dump function which writes out data
+*     for the CmpRegion class to an output Channel.
+
+*  Parameters:
+*     this
+*        Pointer to the CmpRegion whose data are being written.
+*     channel
+*        Pointer to the Channel to which the data are being written.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstRegion *reg1;              /* First Region to include in dump */
+   AstRegion *reg2;              /* Second Region to include in dump */
+   AstCmpRegion *this;           /* Pointer to the CmpRegion structure */
+   const char *comment;          /* Pointer to comment string */
+   int ival;                     /* Integer value */
+   int oper;                     /* The operator to include in the dump */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the CmpRegion structure. */
+   this = (AstCmpRegion *) this_object;
+
+/* Check if this CmpRegion has an equivalent XOR representation. Is so,
+   store details of the XOR representation in the CmpRegion. */
+   XORCheck( this, status );
+
+/* Choose the operator and component regions to include in the dump. If
+   the CmpRegion originally used an XOR operator, then save the XORed
+   regions. Otherwise, store the real component Regions. */
+   if( this->xor1 ) {
+      oper = AST__XOR;
+      reg1 = this->xor1;
+      reg2 = this->xor2;
+   } else {
+      oper = this->oper;
+      reg1 = this->region1;
+      reg2 = this->region2;
+   }
+
+/* Write out values representing the instance variables for the CmpRegion
+   class.  Accompany these with appropriate comment strings, possibly
+   depending on the values being written.*/
+
+/* In the case of attributes, we first use the appropriate (private)
+   Test...  member function to see if they are set. If so, we then use
+   the (private) Get... function to obtain the value to be written
+   out.
+
+   For attributes which are not set, we use the astGet... method to
+   obtain the value instead. This will supply a default value
+   (possibly provided by a derived class which over-rides this method)
+   which is more useful to a human reader as it corresponds to the
+   actual default attribute value.  Since "set" will be zero, these
+   values are for information only and will not be read back. */
+
+/* Oper */
+/* ------- */
+   ival = oper;
+   if( ival == AST__AND ) {
+      comment = "Regions combined using Boolean AND";
+   } else if( ival == AST__OR ) {
+      comment = "Regions combined using Boolean OR";
+   } else if( ival == AST__XOR ) {
+      comment = "Regions combined using Boolean XOR";
+   } else {
+      comment = "Regions combined using unknown operator";
+   }
+   astWriteInt( channel, "Operator", 1, 0, ival, comment );
+
+/* First Region. */
+/* -------------- */
+   astWriteObject( channel, "RegionA", 1, 1, reg1,
+                   "First component Region" );
+
+/* Second Region. */
+/* --------------- */
+   astWriteObject( channel, "RegionB", 1, 1, reg2,
+                   "Second component Region" );
+}
+
+/* Standard class functions. */
+/* ========================= */
+/* Implement the astIsACmpRegion and astCheckCmpRegion functions using the
+   macros defined for this purpose in the "object.h" header file. */
+astMAKE_ISA(CmpRegion,Region)
+astMAKE_CHECK(CmpRegion)
+
+AstCmpRegion *astCmpRegion_( void *region1_void, void *region2_void, int oper,
+                             const char *options, int *status, ...) {
+/*
+*+
+*  Name:
+*     astCmpRegion
+
+*  Purpose:
+*     Create a CmpRegion.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     AstCmpRegion *astCmpRegion( AstRegion *region1, AstRegion *region2,
+*                                 int oper, const char *options, ..., int *status )
+
+*  Class Membership:
+*     CmpRegion constructor.
+
+*  Description:
+*     This function creates a new CmpRegion and optionally initialises its
+*     attributes.
+
+*  Parameters:
+*     region1
+*        Pointer to the first Region.
+*     region2
+*        Pointer to the second Region.
+*     oper
+*        The boolean operator with which to combine the two Regions. Either
+*        AST__AND or AST__OR.
+*     options
+*        Pointer to a null terminated string containing an optional
+*        comma-separated list of attribute assignments to be used for
+*        initialising the new CmpRegion. The syntax used is the same as for the
+*        astSet method and may include "printf" format specifiers identified
+*        by "%" symbols in the normal way.
+*     status
+*        Pointer to the inherited status variable.
+*     ...
+*        If the "options" string contains "%" format specifiers, then an
+*        optional list of arguments may follow it in order to supply values to
+*        be substituted for these specifiers. The rules for supplying these
+*        are identical to those for the astSet method (and for the C "printf"
+*        function).
+
+*  Returned Value:
+*     A pointer to the new CmpRegion.
+
+*  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.
+*-
+
+*  Implementation Notes:
+*     - This function implements the basic CmpRegion constructor which is
+*     available via the protected interface to the CmpRegion class.  A
+*     public interface is provided by the astCmpRegionId_ function.
+*     - Because this function has a variable argument list, it is
+*     invoked by a macro that evaluates to a function pointer (not a
+*     function invocation) and no checking or casting of arguments is
+*     performed before the function is invoked. Because of this, the
+*     "region1" and "region2" parameters are of type (void *) and are
+*     converted and validated within the function itself.
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   AstCmpRegion *new;              /* Pointer to new CmpRegion */
+   AstRegion *region1;             /* Pointer to first Region structure */
+   AstRegion *region2;             /* Pointer to second Region structure */
+   va_list args;                   /* Variable argument list */
+
+/* Initialise. */
+   new = NULL;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* Check the global status. */
+   if ( !astOK ) return new;
+
+/* Obtain and validate pointers to the Region structures provided. */
+   region1 = astCheckRegion( region1_void );
+   region2 = astCheckRegion( region2_void );
+   if ( astOK ) {
+
+/* Initialise the CmpRegion, allocating memory and initialising the
+   virtual function table as well if necessary. */
+      new = astInitCmpRegion( NULL, sizeof( AstCmpRegion ), !class_init,
+                              &class_vtab, "CmpRegion", region1, region2,
+                              oper );
+
+/* 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 CmpRegion's
+   attributes. */
+         va_start( args, status );
+         astVSet( new, options, NULL, args );
+         va_end( args );
+
+/* If an error occurred, clean up by deleting the new object. */
+         if ( !astOK ) new = astDelete( new );
+      }
+   }
+
+/* Return a pointer to the new CmpRegion. */
+   return new;
+}
+
+AstCmpRegion *astCmpRegionId_( void *region1_void, void *region2_void,
+                               int oper, const char *options, ... ) {
+/*
+*++
+*  Name:
+c     astCmpRegion
+f     AST_CMPREGION
+
+*  Purpose:
+*     Create a CmpRegion.
+
+*  Type:
+*     Public function.
+
+*  Synopsis:
+c     #include "cmpregion.h"
+c     AstCmpRegion *astCmpRegion( AstRegion *region1, AstRegion *region2,
+c                                 int oper, const char *options, ... )
+f     RESULT = AST_CMPREGION( REGION1, REGION2, OPER, OPTIONS, STATUS )
+
+*  Class Membership:
+*     CmpRegion constructor.
+
+*  Description:
+*     This function creates a new CmpRegion and optionally initialises
+*     its attributes.
+*
+*     A CmpRegion is a Region which allows two component
+*     Regions (of any class) to be combined to form a more complex
+*     Region. This combination may be performed a boolean AND, OR
+*     or XOR (exclusive OR) operator. If the AND operator is
+*     used, then a position is inside the CmpRegion only if it is
+*     inside both of its two component Regions. If the OR operator is
+*     used, then a position is inside the CmpRegion if it is inside
+*     either (or both) of its two component Regions. If the XOR operator
+*     is used, then a position is inside the CmpRegion if it is inside
+*     one but not both of its two component Regions. Other operators can
+*     be formed by negating one or both component Regions before using
+*     them to construct a new CmpRegion.
+*
+*     The two component Region need not refer to the same coordinate
+*     Frame, but it must be possible for the
+c     astConvert
+f     AST_CONVERT
+*     function to determine a Mapping between them (an error will be
+*     reported otherwise when the CmpRegion is created). For instance,
+*     a CmpRegion may combine a Region defined within an ICRS SkyFrame
+*     with a Region defined within a Galactic SkyFrame. This is
+*     acceptable because the SkyFrame class knows how to convert between
+*     these two systems, and consequently the
+c     astConvert
+f     AST_CONVERT
+*     function will also be able to convert between them. In such cases,
+*     the second component Region will be mapped into the coordinate Frame
+*     of the first component Region, and the Frame represented by the
+*     CmpRegion as a whole will be the Frame of the first component Region.
+*
+*     Since a CmpRegion is itself a Region, it can be used as a
+*     component in forming further CmpRegions. Regions of arbitrary
+*     complexity may be built from simple individual Regions in this
+*     way.
+
+*  Parameters:
+c     region1
+f     REGION1 = INTEGER (Given)
+*        Pointer to the first component Region.
+c     region2
+f     REGION2 = INTEGER (Given)
+*        Pointer to the second component Region. This Region will be
+*        transformed into the coordinate Frame of the first region before
+*        use. An error will be reported if this is not possible.
+c     oper
+f     OPER = INTEGER (Given)
+*        The boolean operator with which to combine the two Regions. This
+*        must be one of the symbolic constants AST__AND, AST__OR or AST__XOR.
+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 CmpRegion. 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 CmpRegion. 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     astCmpRegion()
+f     AST_CMPREGION = INTEGER
+*        A pointer to the new CmpRegion.
+
+*  Notes:
+*     - If one of the supplied Regions has an associated uncertainty,
+*     that uncertainty will also be used for the returned CmpRegion.
+*     If both supplied Regions have associated uncertainties, the
+*     uncertainty associated with the first Region will be used for the
+*     returned CmpRegion.
+*     - Deep copies are taken of the supplied Regions. This means that
+*     any subsequent changes made to the component Regions using the
+*     supplied pointers will have no effect on the CmpRegion.
+*     - 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.
+*--
+
+*  Implementation Notes:
+*     - This function implements the external (public) interface to
+*     the astCmpRegion constructor function. It returns an ID value
+*     (instead of a true C pointer) to external users, and must be
+*     provided because astCmpRegion_ has a variable argument list which
+*     cannot be encapsulated in a macro (where this conversion would
+*     otherwise occur).
+*     - Because no checking or casting of arguments is performed
+*     before the function is invoked, the "region1" and "region2" parameters
+*     are of type (void *) and are converted from an ID value to a
+*     pointer and validated within the function itself.
+*     - The variable argument list also prevents this function from
+*     invoking astCmpRegion_ directly, so it must be a re-implementation
+*     of it in all respects, except for the conversions between IDs
+*     and pointers on input/output of Objects.
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   AstCmpRegion *new;              /* Pointer to new CmpRegion */
+   AstRegion *region1;             /* Pointer to first Region structure */
+   AstRegion *region2;             /* Pointer to second Region structure */
+   va_list args;                   /* Variable argument list */
+
+   int *status;                  /* Pointer to inherited status value */
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* Initialise. */
+   new = NULL;
+
+/* Get a pointer to the inherited status value. */
+   status = astGetStatusPtr;
+
+/* Check the global status. */
+   if ( !astOK ) return new;
+
+/* Obtain the Region pointers from the ID's supplied and validate the
+   pointers to ensure they identify valid Regions. */
+   region1 = astVerifyRegion( astMakePointer( region1_void ) );
+   region2 = astVerifyRegion( astMakePointer( region2_void ) );
+   if ( astOK ) {
+
+/* Initialise the CmpRegion, allocating memory and initialising the
+   virtual function table as well if necessary. */
+      new = astInitCmpRegion( NULL, sizeof( AstCmpRegion ), !class_init,
+                              &class_vtab, "CmpRegion", region1, region2,
+                              oper );
+
+/* 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 CmpRegion's
+   attributes. */
+         va_start( args, options );
+         astVSet( new, options, NULL, args );
+         va_end( args );
+
+/* If an error occurred, clean up by deleting the new object. */
+         if ( !astOK ) new = astDelete( new );
+      }
+   }
+
+/* Return an ID value for the new CmpRegion. */
+   return astMakeId( new );
+}
+
+AstCmpRegion *astInitCmpRegion_( void *mem, size_t size, int init,
+                                 AstCmpRegionVtab *vtab, const char *name,
+                                 AstRegion *region1, AstRegion *region2,
+                                 int oper, int *status ) {
+/*
+*+
+*  Name:
+*     astInitCmpRegion
+
+*  Purpose:
+*     Initialise a CmpRegion.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     AstCmpRegion *astInitCmpRegion_( void *mem, size_t size, int init,
+*                                      AstCmpRegionVtab *vtab, const char *name,
+*                                      AstRegion *region1, AstRegion *region2,
+*                                      int oper )
+
+*  Class Membership:
+*     CmpRegion initialiser.
+
+*  Description:
+*     This function is provided for use by class implementations to initialise
+*     a new CmpRegion object. It allocates memory (if necessary) to
+*     accommodate the CmpRegion plus any additional data associated with the
+*     derived class. It then initialises a CmpRegion 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 CmpRegion at the start of
+*     the memory passed via the "vtab" parameter.
+
+*  Parameters:
+*     mem
+*        A pointer to the memory in which the CmpRegion is to be initialised.
+*        This must be of sufficient size to accommodate the CmpRegion data
+*        (sizeof(CmpRegion)) 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 CmpRegion (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
+*        CmpRegion structure, so a valid value must be supplied even if not
+*        required for allocating memory.
+*     init
+*        A logical flag indicating if the CmpRegion'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 CmpRegion.
+*     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 Object
+*        astClass function).
+*     region1
+*        Pointer to the first Region.
+*     region2
+*        Pointer to the second Region.
+*     oper
+*        The boolean operator to use. Must be one of AST__AND, AST__OR or
+*        AST__XOR.
+
+*  Returned Value:
+*     A pointer to the new CmpRegion.
+
+*  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: */
+   AstCmpRegion *new;            /* Pointer to new CmpRegion */
+   AstFrame *frm;                /* Frame encapsulated by first Region */
+   AstFrameSet *fs;              /* FrameSet connecting supplied Regions */
+   AstMapping *map;              /* Mapping between two supplied Regions */
+   AstMapping *smap;             /* Simplified Mapping between two supplied Regions */
+   AstRegion *new_reg1;          /* Replacement for first region */
+   AstRegion *new_reg2;          /* Replacement for second region */
+   AstRegion *reg1;              /* First Region to store in the CmpRegion */
+   AstRegion *reg2;              /* Second Region to store in the CmpRegion */
+   AstRegion *xor1;              /* Copy of first supplied Region or NULL */
+   AstRegion *xor2;              /* Copy of second supplied Region or NULL */
+   int i;                        /* Loop count */
+   int used_oper;                /* The boolean operation actually used */
+
+/* Check the global status. */
+   if ( !astOK ) return NULL;
+
+/* If necessary, initialise the virtual function table. */
+   if ( init ) astInitCmpRegionVtab( vtab, name );
+
+/* Initialise. */
+   new = NULL;
+
+/* Check the supplied oper value. */
+   if( oper != AST__AND && oper != AST__OR && oper != AST__XOR && astOK ) {
+      astError( AST__INTRD, "astInitCmpRegion(%s): Illegal "
+                "boolean operator value (%d) supplied.", status, name, oper );
+   }
+
+/* Take copies of the supplied Regions. */
+   reg1 = astCopy( region1 );
+   reg2 = astCopy( region2 );
+
+/* Get the Mapping from the second to the first Region. */
+   fs = astConvert( reg2, reg1, "" );
+
+/* Report an error if not possible. */
+   if( fs == NULL ) {
+      frm = NULL;
+      if( astOK ) astError( AST__INTRD, "astInitCmpRegion(%s): No Mapping can "
+                            "be found between the two supplied Regions.", status, name );
+
+/* Otherwise, map the second Region into the Frame of the first (unless
+   they are already in the same Frame). This results in both component
+   Frames having the same current Frame. This current Frame is used as the
+   encapsulated Frame within the parent Region structure. */
+   } else {
+      frm = astGetFrame( fs, AST__CURRENT );
+      map = astGetMapping( fs, AST__BASE, AST__CURRENT );
+      smap = astSimplify( map );
+      if( !astIsAUnitMap( smap ) ) {
+         new_reg2 = astMapRegion( reg2, smap, frm );
+         (void) astAnnul( reg2 );
+         reg2 = new_reg2;
+      }
+      smap = astAnnul( smap );
+      map = astAnnul( map );
+      fs = astAnnul( fs );
+   }
+
+/* The CmpRegion class does not implement XOR directly (as it does for
+   AND and OR). Instead, when requested to create an XOR CmpRegion, it
+   creates a CmpRegion that uses AND and OR to simulate XOR. The top
+   level XOR CmpRegion actually uses AST__OR and the two component
+   regions within it are CmpRegions formed by combing the two supplied
+   Regions (one being negated first) using AND. Create the required
+   component Regions. */
+   if( oper == AST__XOR ) {
+      astNegate( reg1 );
+      new_reg1 = (AstRegion *) astCmpRegion( reg1, reg2, AST__AND, " ",
+                                             status );
+      astNegate( reg1 );
+
+      astNegate( reg2 );
+      new_reg2 = (AstRegion *) astCmpRegion( reg1, reg2, AST__AND, " ",
+                                             status );
+      astNegate( reg2 );
+
+      xor1 = reg1;
+      xor2 = reg2;
+
+      reg1 = new_reg1;
+      reg2 = new_reg2;
+
+      used_oper = AST__OR;
+
+/* For AND and OR, use the supplied operator. */
+   } else {
+      xor1 = NULL;
+      xor2 = NULL;
+      used_oper = oper;
+   }
+
+/* Initialise a Region structure (the parent class) as the first component
+   within the CmpRegion structure, allocating memory if necessary. A NULL
+   PointSet is suppled as the two component Regions will perform the function
+   of defining the Region shape. The base Frame of the FrameSet in the
+   parent Region structure will be the same as the current Frames of the
+   FrameSets in the two component Regions. */
+   if ( astOK ) {
+      new = (AstCmpRegion *) astInitRegion( mem, size, 0,
+                                          (AstRegionVtab *) vtab, name,
+                                          frm, NULL, NULL );
+
+/* Initialise the CmpRegion data. */
+/* --------------------------- */
+/* Store pointers to the component Regions. */
+      new->region1 = astClone( reg1 );
+      new->region2 = astClone( reg2 );
+
+/* Note the operator used to combine the somponent Regions. */
+      new->oper = used_oper;
+
+/* If we are creating an XOR CmpRegion, save copies of the supplied
+   Regions (i.e. the supplied Regions which are XORed). These will not
+   be the same as "reg1" and "reg2" since each of those two regions will
+   be CmpRegions that combine the supplied Regions using AST__AND. */
+      if( oper == AST__XOR ) {
+         new->xor1 = xor1;
+         new->xor2 = xor2;
+      } else {
+         new->xor1 = NULL;
+         new->xor2 = NULL;
+      }
+
+/* Initialised cached values to show they have not yet been found. */
+      for( i = 0; i < 2; i++ ) {
+         new->rvals[ i ] = NULL;
+         new->offs[ i ] = NULL;
+         new->nbreak[ i ] = 0;
+         new->d0[ i ] = AST__BAD;
+         new->dtot[ i ] = AST__BAD;
+      }
+      new->bounded = -INT_MAX;
+
+/* If the base->current Mapping in the FrameSet within each component Region
+   is a UnitMap, then the FrameSet does not need to be included in the
+   Dump of the new CmpRegion. Set the RegionFS attribute of the component
+   Region to zero to flag this. */
+      map = astGetMapping( reg1->frameset, AST__BASE, AST__CURRENT );
+      if( astIsAUnitMap( map ) ) astSetRegionFS( reg1, 0 );
+      map = astAnnul( map );
+
+      map = astGetMapping( reg2->frameset, AST__BASE, AST__CURRENT );
+      if( astIsAUnitMap( map ) ) astSetRegionFS( reg2, 0 );
+      map = astAnnul( map );
+
+/* Copy attribute values from the first component Region to the parent
+   Region. */
+      if( astTestMeshSize( new->region1 ) ) {
+         astSetMeshSize( new,  astGetMeshSize( new->region1 ) );
+      }
+      if( astTestClosed( new->region1 ) ) {
+         astSetClosed( new,  astGetClosed( new->region1 ) );
+      }
+
+/* If an error occurred, clean up by annulling the Region pointers and
+   deleting the new object. */
+      if ( !astOK ) {
+         new->region1 = astAnnul( new->region1 );
+         new->region2 = astAnnul( new->region2 );
+         new = astDelete( new );
+      }
+   }
+
+/* Free resources */
+   reg1 = astAnnul( reg1 );
+   reg2 = astAnnul( reg2 );
+   if( frm ) frm = astAnnul( frm );
+
+/* Return a pointer to the new object. */
+   return new;
+}
+
+AstCmpRegion *astLoadCmpRegion_( void *mem, size_t size,
+                                 AstCmpRegionVtab *vtab, const char *name,
+                                 AstChannel *channel, int *status ) {
+/*
+*+
+*  Name:
+*     astLoadCmpRegion
+
+*  Purpose:
+*     Load a CmpRegion.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "cmpregion.h"
+*     AstCmpRegion *astLoadCmpRegion( void *mem, size_t size,
+*                                     AstCmpRegionVtab *vtab, const char *name,
+*                                     AstChannel *channel )
+
+*  Class Membership:
+*     CmpRegion loader.
+
+*  Description:
+*     This function is provided to load a new CmpRegion 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
+*     CmpRegion 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 CmpRegion at the start of the memory
+*     passed via the "vtab" parameter.
+
+
+*  Parameters:
+*     mem
+*        A pointer to the memory into which the CmpRegion is to be
+*        loaded.  This must be of sufficient size to accommodate the
+*        CmpRegion data (sizeof(CmpRegion)) 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 CmpRegion (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 CmpRegion 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(AstCmpRegion) is used instead.
+*     vtab
+*        Pointer to the start of the virtual function table to be
+*        associated with the new CmpRegion. If this is NULL, a pointer to
+*        the (static) virtual function table for the CmpRegion 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 "CmpRegion" is used instead.
+
+*  Returned Value:
+*     A pointer to the new CmpRegion.
+
+*  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: */
+   AstCmpRegion *new;            /* Pointer to the new CmpRegion */
+   AstRegion *reg1;              /* First Region read from dump */
+   AstRegion *reg2;              /* Second Region read from dump */
+   AstFrame *f1;                 /* Base Frame in parent Region */
+   AstRegion *creg;              /* Pointer to component Region */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   int i;                        /* Loop count */
+   int oper;                     /* The operator to include in the dump */
+
+/* Initialise. */
+   new = NULL;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(channel);
+
+/* 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 CmpRegion. In this case the
+   CmpRegion belongs to this class, so supply appropriate values to be
+   passed to the parent class loader (and its parent, etc.). */
+   if ( !vtab ) {
+      size = sizeof( AstCmpRegion );
+      vtab = &class_vtab;
+      name = "CmpRegion";
+
+/* If required, initialise the virtual function table for this class. */
+      if ( !class_init ) {
+         astInitCmpRegionVtab( 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 CmpRegion. */
+   new = astLoadRegion( mem, size, (AstRegionVtab *) vtab, name,
+                         channel );
+
+   if ( astOK ) {
+
+/* Read input data. */
+/* ================ */
+/* Request the input Channel to read all the input data appropriate to
+   this class into the internal "values list". */
+      astReadClassData( channel, "CmpRegion" );
+
+/* Now read each individual data item from this list and use it to
+   initialise the appropriate instance variable(s) for this class. */
+
+/* In the case of attributes, we first read the "raw" input value,
+   supplying the "unset" value as the default. If a "set" value is
+   obtained, we then use the appropriate (private) Set... member
+   function to validate and set the value properly. */
+
+/* Operator */
+/* -------- */
+      oper = astReadInt( channel, "operator", AST__AND );
+
+/* First Region. */
+/* -------------- */
+      reg1 = astReadObject( channel, "regiona", NULL );
+
+/* Second Region. */
+/* --------------- */
+      reg2 = astReadObject( channel, "regionb", NULL );
+
+/* Initialised cached values to show they have not yet been found. */
+      for( i = 0; i < 2; i++ ) {
+         new->rvals[ i ] = NULL;
+         new->offs[ i ] = NULL;
+         new->nbreak[ i ] = 0;
+         new->d0[ i ] = AST__BAD;
+         new->dtot[ i ] = AST__BAD;
+      }
+      new->bounded = -INT_MAX;
+
+/* The CmpRegion class does not implement XOR directly (as it does for
+   AND and OR). Instead, when requested to create an XOR CmpRegion, it
+   creates a CmpRegion that uses AND and OR to simulate XOR. The top
+   level XOR CmpRegion actually uses AST__OR and the two component
+   regions within it are CmpRegions formed by combing the two supplied
+   Regions (one being negated first) using AND. Create the required
+   component Regions. */
+      if( oper == AST__XOR ) {
+         astNegate( reg1 );
+         new->region1 = (AstRegion *) astCmpRegion( reg1, reg2, AST__AND,
+                                                    " ", status );
+         astNegate( reg1 );
+
+         astNegate( reg2 );
+         new->region2 = (AstRegion *) astCmpRegion( reg1, reg2, AST__AND,
+                                                    " ", status );
+         astNegate( reg2 );
+
+         new->xor1 = reg1;
+         new->xor2 = reg2;
+
+         new->oper = AST__OR;
+
+/* For AND and OR, use the supplied Regions and operator. */
+      } else {
+         new->region1 = reg1;
+         new->region2 = reg2;
+         new->xor1 = NULL;
+         new->xor2 = NULL;
+         new->oper = oper;
+      }
+
+/* If either component Region has a dummy FrameSet rather than the correct
+   FrameSet, the correct FrameSet will have copies of the base Frame of the
+   new CmpRegion as both its current and base Frames, connected by a UnitMap
+   (this is equivalent to a FrameSet containing a single Frame). However if
+   the new CmpRegion being loaded has itself got a dummy FrameSet, then we do
+   not do this since we do not yet know what the correct FrameSet is. In this
+   case we wait until the parent Region invokes the astSetRegFS method on the
+   new CmpRegion. */
+      if( !astRegDummyFS( new ) ) {
+         f1 = astGetFrame( ((AstRegion *) new)->frameset, AST__BASE );
+         creg = new->region1;
+         if( astRegDummyFS( creg ) ) astSetRegFS( creg, f1 );
+         creg = new->region2;
+         if( astRegDummyFS( creg ) ) astSetRegFS( creg, f1 );
+         f1 = astAnnul( f1 );
+      }
+
+/* If an error occurred, clean up by deleting the new CmpRegion. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return the new CmpRegion pointer. */
+   return new;
+}
+
+/* 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 astCmpRegionList_( AstCmpRegion *this, int *nreg, AstRegion ***reg_list,
+                       int *status ) {
+   if ( !astOK ) return AST__AND;
+   return (**astMEMBER(this,CmpRegion,CmpRegionList))( this, nreg, reg_list,
+                                                       status );
+}
+
+
+
+
+
+