upgrade AST

1 files changed, 13502 insertions, 0 deletions

diff --git a/ast/region.c b/ast/region.c
new file mode 100644
index 0000000..675a1ad
--- /dev/null
+++ b/ast/region.c
@@ -0,0 +1,13502 @@
+/*
+*class++
+*  Name:
+*     Region
+
+*  Purpose:
+*     Represents a region within a coordinate system.
+
+*  Constructor Function:
+*     None.
+
+*  Description:
+*     This class provides the basic facilities for describing a region within
+*     a specified coordinate system. However, the Region class does not
+*     have a constructor function of its own, as it is simply a container
+*     class for a family of specialised sub-classes such as Circle, Box, etc,
+*     which implement Regions with particular shapes.
+*
+*     All sub-classes of Region require a Frame to be supplied when the Region
+*     is created. This Frame describes the coordinate system in which the
+*     Region is defined, and is referred to as the "encapsulated Frame" below.
+*     Constructors will also typically required one or more positions to be
+*     supplied which define the location and extent of the region. These
+*     positions must be supplied within the encapsulated Frame.
+*
+*     The Region class inherits from the Frame class, and so a Region can be
+*     supplied where-ever a Frame is expected. In these cases, supplying a
+*     Region is equivalent to supplying a reference to its encapsulated Frame.
+*     Thus all the methods of the Frame class can be used on the Region class.
+*     For instance, the
+c     astFormat function
+f     AST_FORMAT routine
+*     may be used on a Region to format an axis value.
+*
+*     In addition, since Frame inherits from Mapping, a Region is also a sort
+*     of Mapping. Transforming positions by supplying a Region to one of the
+c     astTran<X> functions
+f     AST_TRAN<X> routines
+*     is the way to determine if a given position is inside or outside the
+*     Region. When used as a Mapping, most classes of Frame are equivalent to
+*     a UnitMap. However, the Region class modifies this behaviour so that a
+*     Region acts like a UnitMap only for input positions which are within the
+*     area represented by the Region. Input positions which are outside the
+*     area produce bad output values (i.e. the output values are equal to
+*     AST__BAD). This behaviour is the same for both the forward and the
+*     inverse transformation. In this sense the "inverse transformation"
+*     is not a true inverse of the forward transformation, since applying
+*     the forward transformation to a point outside the Region, and then
+*     applying the inverse transformation results, in a set of AST__BAD axis
+*     values rather than the original axis values. If required, the
+c     astRemoveRegions
+f     AST_REMOVEREGIONS
+*     function can be used to remove the "masking" effect of any Regions
+*     contained within a compound Mapping or FrameSet. It does this by
+*     replacing each Region with a UnitMap or equivalent Frame (depending
+*     on the context in which the Region is used).
+*
+*     If the coordinate system represented by the Region is changed (by
+*     changing the values of one or more of the attribute which the Region
+*     inherits from its encapsulated Frame), the area represented by
+*     the Region is mapped into the new coordinate system. For instance, let's
+*     say a Circle (a subclass of Region) is created, a SkyFrame being
+*     supplied to the constructor so that the Circle describes a circular
+*     area on the sky in FK4 equatorial coordinates. Since Region inherits
+*     from Frame, the Circle will have a System attribute and this attribute
+*     will be set to "FK4". If the System attribute of the Region is then
+*     changed from FK4 to FK5, the circular area represented by the Region
+*     will automatically be mapped from the FK4 system into the FK5 system.
+*     In general, changing the coordinate system in this way may result in the
+*     region changing shape - for instance, a circle may change into an
+*     ellipse if the transformation from the old to the new coordinate system
+*     is linear but with different scales on each axis. Thus the specific
+*     class of a Region cannot be used as a guarantee of the shape in any
+*     particular coordinate system. If the
+c     astSimplify function
+f     AST_SIMPLIFY routine
+*     is used on a Region, it will endeavour to return a new Region of
+*     a sub-class which accurately describes the shape in the current
+*     coordinate system of the Region (but this may not always be possible).
+*
+*     It is possible to negate an existing Region so that it represents all
+*     areas of the encapsulated Frame except for the area specified when
+*     the Region was created.
+
+*  Inheritance:
+*     The Region class inherits from the Frame class.
+
+*  Attributes:
+*     In addition to those attributes common to all Frames, every
+*     Region also has the following attributes:
+*
+*     - Adaptive: Should the area adapt to changes in the coordinate system?
+*     - Negated: Has the original region been negated?
+*     - Closed: Should the boundary be considered to be inside the region?
+*     - MeshSize: Number of points used to create a mesh covering the Region
+*     - FillFactor: Fraction of the Region which is of interest
+*     - Bounded: Is the Region bounded?
+*
+*     Every Region also inherits any further attributes that belong
+*     to the encapsulated Frame, regardless of that Frame's class. (For
+*     example, the Equinox attribute, defined by the SkyFrame class, is
+*     inherited by any Region which represents a SkyFrame.)
+
+*  Functions:
+c     In addition to those functions applicable to all Frames, the
+c     following functions may also be applied to all Regions:
+f     In addition to those routines applicable to all Frames, the
+f     following routines may also be applied to all Regions:
+*
+c     - astGetRegionBounds: Get the bounds of a Region
+f     - AST_GETREGIONBOUNDS: Get the bounds of a Region
+c     - astGetRegionFrame: Get a copy of the Frame represent by a Region
+f     - AST_GETREGIONFRAME: Get a copy of the Frame represent by a Region
+c     - astGetRegionFrameSet: Get a copy of the Frameset encapsulated by a Region
+f     - AST_GETREGIONFRAMESET: Get a copy of the Frameset encapsulated by a Region
+c     - astGetRegionMesh: Get a mesh of points covering a Region
+f     - AST_GETREGIONMESH: Get a mesh of points covering a Region
+c     - astGetRegionPoints: Get the positions that define a Region
+f     - AST_GETREGIONPOINTS: Get the positions that define a Region
+c     - astGetUnc: Obtain uncertainty information from a Region
+f     - AST_GETUNC: Obtain uncertainty information from a Region
+c     - astMapRegion: Transform a Region into a new coordinate system
+f     - AST_MAPREGION: Transform a Region into a new coordinate system
+c     - astNegate: Toggle the value of the Negated attribute
+f     - AST_NEGATE: Toggle the value of the Negated attribute
+c     - astOverlap: Determines the nature of the overlap between two Regions
+f     - AST_OVERLAP: Determines the nature of the overlap between two Regions
+c     - astMask<X>: Mask a region of a data grid
+f     - AST_MASK<X>: Mask a region of a data grid
+c     - astSetUnc: Associate a new uncertainty with a Region
+f     - AST_SETUNC: Associate a new uncertainty with a Region
+c     - astShowMesh: Display a mesh of points on the surface of a Region
+f     - AST_SHOWMESH: Display a mesh of points on the surface of a Region
+
+*  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:
+*     3-DEC-2003 (DSB):
+*        Original version.
+*     12-MAY-2005 (DSB):
+*        Override astNormBox method.
+*     12-AUG-2005 (DSB):
+*        Override ObsLat and ObsLon accessor methods.
+*     14-FEB-2006 (DSB):
+*        Override astGetObjSize.
+*     2-MAR-2006 (DSB):
+*        Changed AST_LONG_DOUBLE to HAVE_LONG_DOUBLE.
+*     14-MAR-2006 (DSB):
+*        Added astGetRefFS.
+*     28-MAY-2007 (DSB):
+*        - Added protected function astBndMesh.
+*     14-JAN-2009 (DSB):
+*        Override the astIntersect method.
+*     20-JAN-2009 (DSB):
+*        Change astPickAxes so that it returns a Region rather than a
+*        Frame if possible. This included adding method astRegBasePick.
+*     9-FEB-2009 (DSB):
+*        Move PointList methods astGetEnclosure and astSetEnclosure to
+*        Region.
+*     18-FEB-2009 (DSB):
+*        Remove methods astGetEnclosure and astSetEnclosure.
+*     15-JUN-2009 (DSB):
+*        Modify MapRegion to use FrameSets properly.
+*     18-JUN-2009 (DSB):
+*        Override ObsAlt accessor methods.
+*     7-SEP-2009 (DSB):
+*        Fix astMask to avoid reading variance values from the data array.
+*     8-SEP-2009 (DSB):
+*        Fix bugs in astOverlap that could result in wrong results if
+*        either region is unbounded.
+*     4-JAN-2010 (DSB):
+*        Fix bug in GetRegionBounds (it was assumed implicitly that the base
+*        Frame had the same number of axes as the current Frame).
+*     18-MAR-2011 (DSB):
+*        Added astGetRegionMesh public method.
+*     22-MAR-2011 (DSB):
+*        Improve uniformity of points produced by astRegBaseGrid method.
+*     29-APR-2011 (DSB):
+*        Prevent astFindFrame from matching a subclass template against a
+*        superclass target.
+*     17-MAY-2011 (DSB):
+*        In RegBaseGrid, accept the final try even if it is not within 5%
+*        of the required meshsize.
+*     27-APR-2012 (DSB):
+*        Store a negated copy of itself with each Region. Changing the Negated
+*        attribute of a Region causes the cached information to be reset, and
+*        re-calculating it can be an expensive operation. So instead of changing
+*        "Negatated" in "this", access the negated copy of "this" using the
+*        new protected method astGetNegation.
+*     7-JUN-2012 (DSB):
+*        Added protected astRegSplit method to split a Region into disjoint
+*        component regions.
+*     15-JUN-2012 (DSB):
+*        Guard against division by zero in RegBase Grid if "ipr" is zero.
+*     7-NOV-2013 (DSB):
+*        Added method astGetRegionFrameSet.
+*     3-FEB-2014 (DSB):
+*        Fix bug masking regions that have no overlap with the supplied array.
+*     17-APR-2015 (DSB):
+*        Added Centre.
+*     26-OCT-2016 (DSB):
+*        - Override the astAxNorm method.
+*        - Use astAxNorm to fix a bug in astGetRegionBounds for cases where
+*        the Region cross a longitude=0 singularity.
+*     11-NOV-2016 (DSB):
+*        When loading a Region, use the dimensionality of the base Frame
+*        of the FrameSet (rather than the current Frame as it used to be)
+*        to define the number of axes required in the PointSet.
+*     1-DEC-2016 (DSB):
+*        Changed MapRegion to remove any unnecessary base frame axes in
+*        the returned Region.
+*class--
+
+*  Implementation Notes:
+*     - All sub-classes must over-ride the following abstract methods declared
+*     in this class: astRegBaseBox, astRegBaseMesh, astRegPins, astRegCentre.
+*     They must also extend the astTransform method. In addition they should
+*     usually extend astSimplify.
+
+*/
+
+/* 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 Region
+
+/* Value for Ident attribute of of an encapsulated FrameSet which
+   indicates that it is a dummy FrameSet (see astRegDummy). */
+#define DUMMY_FS "ASTREGION-DUMMY"
+
+/*
+*  Name:
+*     MAKE_CLEAR
+
+*  Purpose:
+*     Define a function to clear an attribute value for a Region.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_CLEAR(attribute)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static void Clear<Attribute>( AstFrame *this )
+*
+*     that clears the value of a specified attribute for the encapsulated
+*     FrameSet within a Region (this). This function is intended to over-ride
+*     the astClear<Attribute> method inherited from the Frame class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*/
+
+/* Define the macro. */
+#define MAKE_CLEAR(attribute) \
+static void Clear##attribute( AstFrame *this_frame, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;            /* Pointer to the Region structure */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Obtain a pointer to the encapsulated FrameSet and invoke its \
+   astClear method. The protected astClear##attribute method is not used \
+   because we want the current Frame of the FrameSet tp be re-mapped if \
+   necessary. */ \
+   astClear( this->frameset, #attribute ); \
+}
+
+/*
+*  Name:
+*     MAKE_CLEAR_AXIS
+
+*  Purpose:
+*     Define a function to clear an attribute value for a Region axis.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_CLEAR_AXIS(attribute)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static void Clear<Attribute>( AstFrame *this, int axis )
+*
+*     that clears the value of a specified attribute for an axis of
+*     the encapsulated FrameSet within a Region (this). This function is
+*     intended to over-ride the astClear<Attribute> method inherited
+*     from the Frame class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*/
+
+/* Define the macro. */
+#define MAKE_CLEAR_AXIS(attribute) \
+static void Clear##attribute( AstFrame *this_frame, int axis, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;            /* Pointer to the Region structure */ \
+   char buf[100];              /* Buffer for attribute name */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Validate the axis index supplied. */ \
+   (void) astValidateAxis( this, axis, 1, "astClear" #attribute ); \
+\
+/* We use the public astSetx method rather than the protected \
+   astSet#attribute method so that the current Frame in the encapsulated \
+   FrameSet will be re-mapped if necessary. Construct the attribute name. */ \
+   sprintf( buf, "%s(%d)", #attribute, axis + 1 ); \
+\
+/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \
+   astClear method. The protected astClear#attribute method is notused \
+   since we want the current Frame of the encapsulated FrameSet to be \
+   remapped if required. */ \
+   astClear( this->frameset, buf ); \
+}
+
+/*
+*  Name:
+*     MAKE_GET
+
+*  Purpose:
+*     Define a function to get an attribute value for a Region.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_GET(attribute,type)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static <type> Get<Attribute>( AstFrame *this )
+*
+*     that gets the value of a specified attribute for the encapsulated
+*     FrameSet of a Region (this). This function is intended to over-ride
+*     the astGet<Attribute> method inherited from the Frame class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*     type
+*        The C type of the attribute.
+*/
+
+/* Define the macro. */
+#define MAKE_GET(attribute,type) \
+static type Get##attribute( AstFrame *this_frame, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;            /* Pointer to the Region structure */ \
+   type result;                /* Value to return */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return (type) 0; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Obtain a pointer to the encapsulated FrameSet and invoke its \
+   astGet<Attribute> method.  */ \
+   result = astGet##attribute( this->frameset ); \
+\
+/* If an error occurred, clear the result value. */ \
+   if ( !astOK ) result = (type) 0; \
+\
+/* Return the result. */ \
+   return result; \
+}
+
+/*
+*  Name:
+*     MAKE_GET_AXIS
+
+*  Purpose:
+*     Define a function to get an attribute value for a Region axis.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_GET_AXIS(attribute,type)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static <type> Get<Attribute>( AstFrame *this, int axis )
+*
+*     that gets the value of a specified attribute for an axis of the
+*     encapsulated FrameSet within a Region (this). This function is intended
+*     to over-ride the astGet<Attribute> method inherited from the Frame
+*     class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*     type
+*        The C type of the attribute.
+*/
+
+/* Define the macro. */
+#define MAKE_GET_AXIS(attribute,type) \
+static type Get##attribute( AstFrame *this_frame, int axis, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;            /* Pointer to the Region structure */ \
+   type result;                /* Value to return */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return (type) 0; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Validate the axis index supplied. */ \
+   (void) astValidateAxis( this, axis, 1, "astGet" #attribute ); \
+\
+/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \
+   astGet<Attribute> method.  */ \
+   result = astGet##attribute( this->frameset, axis ); \
+\
+/* If an error occurred, clear the result value. */ \
+   if ( !astOK ) result = (type) 0; \
+\
+/* Return the result. */ \
+   return result; \
+}
+
+/*
+*  Name:
+*     MAKE_SET_SYSTEM
+
+*  Purpose:
+*     Define a function to set a System attribute value for a Region.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_SET_SYSTEM(attribute)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static void Set<Attribute>( AstFrame *this, AstSystemType value )
+*
+*     that sets the value of a specified attribute for the encapsulated
+*     FrameSet of a Region (this). This function is intended to over-ride the
+*     astSet<Attribute> method inherited from the Frame class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*/
+
+/* Define the macro. */
+#define MAKE_SET_SYSTEM(attribute) \
+static void Set##attribute( AstFrame *this_frame, AstSystemType value, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;            /* Pointer to the Region structure */ \
+   const char *text;           /* Pointer to system string */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Convert the supplied value to a string using the astSystemString
+   method of the current Frame in the encapsulated FrameSet. */ \
+   text = astSystemString( this->frameset, value ); \
+\
+/* Set the value by invoking the public astSetC method on the encapusulated \
+   FrameSet. This ensures that the current Frame of the encapsulated \
+   FrameSet is re-mapped if necessary. */ \
+   astSetC( this->frameset, #attribute, text ); \
+}
+
+/*
+*  Name:
+*     MAKE_SET
+
+*  Purpose:
+*     Define a function to set an attribute value for a Region.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_SET(attribute,type,x)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static void Set<Attribute>( AstFrame *this, <type> value )
+*
+*     that sets the value of a specified attribute for the encapsulated
+*     FrameSet of a Region (this). This function is intended to over-ride the
+*     astSet<Attribute> method inherited from the Frame class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*     type
+*        The C type of the attribute.
+*     x
+*        The single character code for the astSetx function for the given C
+*        type.
+*/
+
+/* Define the macro. */
+#define MAKE_SET(attribute,type,x) \
+static void Set##attribute( AstFrame *this_frame, type value, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;            /* Pointer to the Region structure */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Set the value by invoking the public astSetx method on the encapusulated \
+   FrameSet. This ensures that the current Frame of the encapsulated \
+   FrameSet is re-mapped if necessary. */ \
+   astSet##x( this->frameset, #attribute, value ); \
+}
+
+/*
+*  Name:
+*     MAKE_SET_AXIS
+
+*  Purpose:
+*     Define a function to set an attribute value for a Region axis.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_SET_AXIS(attribute,type,x)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static void Set<Attribute>( AstFrame *this, int axis, <type> value )
+*
+*     that sets the value of a specified attribute for an axis of the
+*     encapsulated FrameSet within a Region (this). This function is intended
+*     to over-ride the astSet<Attribute> method inherited from the Frame
+*     class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*     type
+*        The C type of the attribute.
+*     x
+*        The single character code for the astSetx function for the given C
+*        type.
+*/
+
+/* Define the macro. */
+#define MAKE_SET_AXIS(attribute,type,x) \
+static void Set##attribute( AstFrame *this_frame, int axis, type value, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;            /* Pointer to the Region structure */ \
+   char buf[100];              /* Buffer for attribute name */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Validate the axis index supplied. */ \
+   (void) astValidateAxis( this, axis, 1, "astSet" #attribute ); \
+\
+/* We use the public astSetx method rather than the protected \
+   astSet#attribute method so that the current Frame in the encapsulated \
+   FrameSet will be re-mapped if necessary. Construct the attribute name. */ \
+   sprintf( buf, "%s(%d)", #attribute, axis + 1 ); \
+\
+/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \
+   astSet<x> method.  */ \
+   astSet##x( this->frameset, buf, value ); \
+}
+
+/*
+*  Name:
+*     MAKE_TEST
+
+*  Purpose:
+*     Define a function to test if an attribute value is set for a Region.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_TEST(attribute)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static int Test<Attribute>( AstFrame *this )
+*
+*     that returns a boolean result (0 or 1) to indicate if the value
+*     of a specified attribute for the encapsulated FrameSet within a
+*     Region (this) is set. This function is intended to over-ride the
+*     astTest<Attribute> method inherited from the Frame class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*/
+
+/* Define the macro. */
+#define MAKE_TEST(attribute) \
+static int Test##attribute( AstFrame *this_frame, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;            /* Pointer to Region structure */ \
+   int result;                 /* Result to return */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return 0; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \
+   astTest<Attribute> method.  */ \
+   result = astTest##attribute( this->frameset ); \
+\
+/* If an error occurred, clear the result value. */ \
+   if ( !astOK ) result = 0; \
+\
+/* Return the result. */ \
+   return result; \
+}
+
+/*
+*  Name:
+*     MAKE_TEST_AXIS
+
+*  Purpose:
+*     Define a function to test if an attribute value is set for a Region
+*     axis.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "region.h"
+*     MAKE_TEST_AXIS(attribute)
+
+*  Class Membership:
+*     Defined by the Region class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function
+*     of the form:
+*
+*        static int Test<Attribute>( AstFrame *this, int axis )
+*
+*     that returns a boolean result (0 or 1) to indicate if the value
+*     of a specified attribute for an axis of the encapsulated FrameSet
+*     within a Region (this) is set. This function is intended to over-ride
+*     the astTest<Attribute> method inherited from the Frame class.
+
+*  Parameters:
+*     attribute
+*        Name of the attribute, as it appears in the function name.
+*/
+
+/* Define the macro. */
+#define MAKE_TEST_AXIS(attribute) \
+static int Test##attribute( AstFrame *this_frame, int axis, int *status ) { \
+\
+/* Local Variables: */ \
+   AstRegion *this;              /* Pointer to the Region structure */ \
+   int result;                   /* Value to return */ \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return 0; \
+\
+/* Obtain a pointer to the Region structure. */ \
+   this = (AstRegion *) this_frame; \
+\
+/* Validate the axis index supplied. */ \
+   (void) astValidateAxis( this, axis, 1, "astTest" #attribute ); \
+\
+/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \
+   astTest<Attribute> method.  */ \
+   result = astTest##attribute( this->frameset, axis ); \
+\
+/* If an error occurred, clear the result value. */ \
+   if ( !astOK ) result = 0; \
+\
+/* Return the result. */ \
+   return result; \
+}
+
+/* Header 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 "mapping.h"             /* Coordinate Mappings */
+#include "unitmap.h"             /* Unit Mappings */
+#include "permmap.h"             /* Coordinate permutation Mappings */
+#include "cmpmap.h"              /* Compound Mappings */
+#include "frame.h"               /* Parent Frame class */
+#include "frameset.h"            /* Interconnected coordinate systems */
+#include "region.h"              /* Interface definition for this class */
+#include "circle.h"              /* Circular regions */
+#include "box.h"                 /* Box regions */
+#include "cmpregion.h"           /* Compound regions */
+#include "ellipse.h"             /* Elliptical regions */
+#include "pointset.h"            /* Sets of points */
+#include "globals.h"             /* Thread-safe global data access */
+
+/* Error code definitions. */
+/* ----------------------- */
+#include "ast_err.h"             /* AST error codes */
+
+/* C header files. */
+/* --------------- */
+#include <ctype.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+/* Module Variables. */
+/* ================= */
+
+/* Address of this static variable is used as a unique identifier for
+   member of this class. */
+static int class_check;
+
+/* Pointers to parent class methods which are extended by this class. */
+static int (* parent_getobjsize)( AstObject *, int * );
+static int (* parent_getusedefs)( AstObject *, int * );
+
+#if defined(THREAD_SAFE)
+static int (* parent_managelock)( AstObject *, int, int, AstObject **, int * );
+#endif
+
+/* Define macros for accessing each item of thread specific global data. */
+#ifdef THREAD_SAFE
+
+/* Define how to initialise thread-specific globals. */
+#define GLOBAL_inits \
+   globals->Class_Init = 0; \
+   globals->GetAttrib_Buff[ 0 ] = 0;
+
+/* Create the function that initialises global data for this module. */
+astMAKE_INITGLOBALS(Region)
+
+/* Define macros for accessing each item of thread specific global data. */
+#define class_init astGLOBAL(Region,Class_Init)
+#define class_vtab astGLOBAL(Region,Class_Vtab)
+#define getattrib_buff astGLOBAL(Region,GetAttrib_Buff)
+
+
+
+/* If thread safety is not needed, declare and initialise globals at static
+   variables. */
+#else
+
+static char getattrib_buff[ 101 ];
+
+
+/* Define the class virtual function table and its initialisation flag
+   as static variables. */
+static AstRegionVtab class_vtab;   /* Virtual function table */
+static int class_init = 0;       /* Virtual function table initialised? */
+
+#endif
+
+/* Prototypes for Private Member Functions. */
+/* ======================================== */
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+static int MaskLD( AstRegion *, AstMapping *, int, int, const int[], const int ubnd[], long double [], long double, int * );
+#endif
+static int MaskB( AstRegion *, AstMapping *, int, int, const int[], const int[], signed char[], signed char, int * );
+static int MaskD( AstRegion *, AstMapping *, int, int, const int[], const int[], double[], double, int * );
+static int MaskF( AstRegion *, AstMapping *, int, int, const int[], const int[], float[], float, int * );
+static int MaskI( AstRegion *, AstMapping *, int, int, const int[], const int[], int[], int, int * );
+static int MaskL( AstRegion *, AstMapping *, int, int, const int[], const int[], long int[], long int, int * );
+static int MaskS( AstRegion *, AstMapping *, int, int, const int[], const int[], short int[], short int, int * );
+static int MaskUB( AstRegion *, AstMapping *, int, int, const int[], const int[], unsigned char[], unsigned char, int * );
+static int MaskUI( AstRegion *, AstMapping *, int, int, const int[], const int[], unsigned int[], unsigned int, int * );
+static int MaskUL( AstRegion *, AstMapping *, int, int, const int[], const int[], unsigned long int[], unsigned long int, int * );
+static int MaskUS( AstRegion *, AstMapping *, int, int, const int[], const int[], unsigned short int[], unsigned short int, int * );
+
+static AstAxis *GetAxis( AstFrame *, int, int * );
+static AstFrame *GetRegionFrame( AstRegion *, int * );
+static AstFrameSet *GetRegionFrameSet( AstRegion *, int * );
+static AstFrame *PickAxes( AstFrame *, int, const int[], AstMapping **, int * );
+static AstFrame *RegFrame( AstRegion *, int * );
+static AstFrameSet *Conv( AstFrameSet *, AstFrameSet *, int * );
+static AstFrameSet *Convert( AstFrame *, AstFrame *, const char *, int * );
+static AstFrameSet *ConvertX( AstFrame *, AstFrame *, const char *, int * );
+static AstFrameSet *FindFrame( AstFrame *, AstFrame *, const char *, int * );
+static AstFrameSet *GetRegFS( AstRegion *, int * );
+static AstLineDef *LineDef( AstFrame *, const double[2], const double[2], int * );
+static AstMapping *RegMapping( AstRegion *, int * );
+static AstMapping *RemoveRegions( AstMapping *, int * );
+static AstMapping *Simplify( AstMapping *, int * );
+static AstObject *Cast( AstObject *, AstObject *, int * );
+static AstPointSet *BTransform( AstRegion *, AstPointSet *, int, AstPointSet *, int * );
+static AstPointSet *BndBaseMesh( AstRegion *, double *, double *, int * );
+static AstPointSet *BndMesh( AstRegion *, double *, double *, int * );
+static AstPointSet *GetSubMesh( int *, AstPointSet *, int * );
+static AstPointSet *RegBaseGrid( AstRegion *, int * );
+static AstPointSet *RegBaseMesh( AstRegion *, int * );
+static AstPointSet *RegGrid( AstRegion *, int * );
+static AstPointSet *RegMesh( AstRegion *, int * );
+static AstPointSet *RegTransform( AstRegion *, AstPointSet *, int, AstPointSet *, AstFrame **, int * );
+static AstPointSet *ResolvePoints( AstFrame *, const double [], const double [], AstPointSet *, AstPointSet *, int * );
+static AstRegion *MapRegion( AstRegion *, AstMapping *, AstFrame *, int * );
+static AstRegion *RegBasePick( AstRegion *, int, const int *, int * );
+static AstRegion **RegSplit( AstRegion *, int *, int * );
+static AstSystemType SystemCode( AstFrame *, const char *, int * );
+static AstSystemType ValidateSystem( AstFrame *, AstSystemType, const char *, int * );
+static const char *Abbrev( AstFrame *, int, const char *, const char *, const char *, int * );
+static const char *Format( AstFrame *, int, double, int * );
+static const char *SystemString( AstFrame *, AstSystemType, int * );
+static const int *GetPerm( AstFrame *, int * );
+static double *RegCentre( AstRegion *, double *, double **, int, int, int * );
+static double Angle( AstFrame *, const double[], const double[], const double[], int * );
+static double AxAngle( AstFrame *, const double[], const double[], int, int * );
+static double AxDistance( AstFrame *, int, double, double, int * );
+static double AxOffset( AstFrame *, int, double, double, int * );
+static double Distance( AstFrame *, const double[], const double[], int * );
+static double Centre( AstFrame *, int, double, double, int * );
+static double Gap( AstFrame *, int, double, int *, int * );
+static double Offset2( AstFrame *, const double[2], double, double, double[2], int * );
+static int Equal( AstObject *, AstObject *, int * );
+static int GetNaxes( AstFrame *, int * );
+static int GetObjSize( AstObject *, int * );
+static int GetUseDefs( AstObject *, int * );
+static int IsUnitFrame( AstFrame *, int * );
+static int LineContains( AstFrame *, AstLineDef *, int, double *, int * );
+static int LineCrossing( AstFrame *, AstLineDef *, AstLineDef *, double **, int * );
+static int Match( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
+static int Overlap( AstRegion *, AstRegion *, int * );
+static int OverlapX( AstRegion *, AstRegion *, int * );
+static int RegDummyFS( AstRegion *, int * );
+static int RegPins( AstRegion *, AstPointSet *, AstRegion *, int **, int * );
+static int SubFrame( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
+static int RegTrace( AstRegion *, int, double *, double **, int * );
+static int Unformat( AstFrame *, int, const char *, double *, int * );
+static int ValidateAxis( AstFrame *, int, int, const char *, int * );
+static void AxNorm( AstFrame *, int, int, int, double *, int * );
+static void CheckPerm( AstFrame *, const int *, const char *, int * );
+static void Copy( const AstObject *, AstObject *, int * );
+static void Delete( AstObject *, int * );
+static void Dump( AstObject *, AstChannel *, int * );
+static void GetRegionBounds( AstRegion *, double *, double *, int * );
+static void GetRegionBounds2( AstRegion *, double *, double *, int * );
+static void GetRegionMesh( AstRegion *, int, int, int, int *, double *, int * );
+static void GetRegionPoints( AstRegion *, int, int, int *, double *, int * );
+static void Intersect( AstFrame *, const double[2], const double[2], const double[2], const double[2], double[2], int * );
+static void LineOffset( AstFrame *, AstLineDef *, double, double, double[2], int * );
+static void MatchAxes( AstFrame *, AstFrame *, int *, int * );
+static void MatchAxesX( AstFrame *, AstFrame *, int *, int * );
+static void Negate( AstRegion *, int * );
+static void Norm( AstFrame *, double[], int * );
+static void NormBox( AstFrame *, double[], double[], AstMapping *, int * );
+static void Offset( AstFrame *, const double[], const double[], double, double[], int * );
+static void Overlay( AstFrame *, const int *, AstFrame *, int * );
+static void PermAxes( AstFrame *, const 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 RegOverlay( AstRegion *, AstRegion *, int, int * );
+static void RegSetAttrib( AstRegion *, const char *, char **, int * );
+static void ReportPoints( AstMapping *, int, AstPointSet *, AstPointSet *, int * );
+static void ResetCache( AstRegion *, int * );
+static void Resolve( AstFrame *, const double [], const double [], const double [], double [], double *, double *, int * );
+static void SetAxis( AstFrame *, int, AstAxis *, int * );
+static void SetRegFS( AstRegion *, AstFrame *, int * );
+static void ShowMesh( AstRegion *, int, const char *, int * );
+static void ValidateAxisSelection( AstFrame *, int, const int *, const char *, int * );
+static AstRegion *GetNegation( AstRegion *, int * );
+
+static int GetBounded( AstRegion *, int * );
+static AstRegion *GetDefUnc( AstRegion *, int * );
+
+static AstRegion *GetUncFrm( AstRegion *, int, int * );
+static AstRegion *GetUnc( AstRegion *, int, int * );
+static int TestUnc( AstRegion *, int * );
+static void ClearUnc( AstRegion *, int * );
+static void SetUnc( AstRegion *, AstRegion *, int * );
+
+static const char *GetDomain( AstFrame *, int * );
+static int TestDomain( AstFrame *, int * );
+static void ClearDomain( AstFrame *, int * );
+static void SetDomain( AstFrame *, const char *, int * );
+
+static const char *GetFormat( AstFrame *, int, int * );
+static int TestFormat( AstFrame *, int, int * );
+static void ClearFormat( AstFrame *, int, int * );
+static void SetFormat( AstFrame *, int, const char *, int * );
+
+static const char *GetLabel( AstFrame *, int, int * );
+static int TestLabel( AstFrame *, int, int * );
+static void ClearLabel( AstFrame *, int, int * );
+static void SetLabel( AstFrame *, int, const char *, int * );
+
+static const char *GetSymbol( AstFrame *, int, int * );
+static int TestSymbol( AstFrame *, int, int * );
+static void ClearSymbol( AstFrame *, int, int * );
+static void SetSymbol( AstFrame *, int, const char *, int * );
+
+static const char *GetTitle( AstFrame *, int * );
+static void SetTitle( AstFrame *, const char *, int * );
+static void ClearTitle( AstFrame *, int * );
+static int TestTitle( AstFrame *, int * );
+
+static const char *GetUnit( AstFrame *, int, int * );
+static int TestUnit( AstFrame *, int, int * );
+static void ClearUnit( AstFrame *, int, int * );
+static void SetUnit( AstFrame *, int, const char *, int * );
+
+static int GetDigits( AstFrame *, int * );
+static int TestDigits( AstFrame *, int * );
+static void ClearDigits( AstFrame *, int * );
+static void SetDigits( AstFrame *, int, int * );
+
+static int GetDirection( AstFrame *, int, int * );
+static int TestDirection( AstFrame *, int, int * );
+static void ClearDirection( AstFrame *, int, int * );
+static void SetDirection( AstFrame *, int, int, int * );
+
+static int GetActiveUnit( AstFrame *, int * );
+static int TestActiveUnit( AstFrame *, int * );
+static void SetActiveUnit( AstFrame *, int, int * );
+
+static int GetMatchEnd( AstFrame *, int * );
+static int TestMatchEnd( AstFrame *, int * );
+static void ClearMatchEnd( AstFrame *, int * );
+static void SetMatchEnd( AstFrame *, int, int * );
+
+static int GetMaxAxes( AstFrame *, int * );
+static int TestMaxAxes( AstFrame *, int * );
+static void ClearMaxAxes( AstFrame *, int * );
+static void SetMaxAxes( AstFrame *, int, int * );
+
+static int GetMinAxes( AstFrame *, int * );
+static int TestMinAxes( AstFrame *, int * );
+static void ClearMinAxes( AstFrame *, int * );
+static void SetMinAxes( AstFrame *, int, int * );
+
+static int GetPermute( AstFrame *, int * );
+static int TestPermute( AstFrame *, int * );
+static void ClearPermute( AstFrame *, int * );
+static void SetPermute( AstFrame *, int, int * );
+
+static int GetPreserveAxes( AstFrame *, int * );
+static int TestPreserveAxes( AstFrame *, int * );
+static void ClearPreserveAxes( AstFrame *, int * );
+static void SetPreserveAxes( AstFrame *, int, int * );
+
+static double GetBottom( AstFrame *, int, int * );
+static int TestBottom( AstFrame *, int, int * );
+static void ClearBottom( AstFrame *, int, int * );
+static void SetBottom( AstFrame *, int, double, int * );
+
+static double GetTop( AstFrame *, int, int * );
+static int TestTop( AstFrame *, int, int * );
+static void ClearTop( AstFrame *, int, int * );
+static void SetTop( AstFrame *, int, double, int * );
+
+static double GetEpoch( AstFrame *, int * );
+static int TestEpoch( AstFrame *, int * );
+static void ClearEpoch( AstFrame *, int * );
+static void SetEpoch( AstFrame *, double, int * );
+
+static double GetObsAlt( AstFrame *, int * );
+static int TestObsAlt( AstFrame *, int * );
+static void ClearObsAlt( AstFrame *, int * );
+static void SetObsAlt( AstFrame *, double, int * );
+
+static double GetObsLat( AstFrame *, int * );
+static int TestObsLat( AstFrame *, int * );
+static void ClearObsLat( AstFrame *, int * );
+static void SetObsLat( AstFrame *, double, int * );
+
+static double GetObsLon( AstFrame *, int * );
+static int TestObsLon( AstFrame *, int * );
+static void ClearObsLon( AstFrame *, int * );
+static void SetObsLon( AstFrame *, double, int * );
+
+static AstSystemType GetSystem( AstFrame *, int * );
+static int TestSystem( AstFrame *, int * );
+static void ClearSystem( AstFrame *, int * );
+static void SetSystem( AstFrame *, AstSystemType, int * );
+
+static AstSystemType GetAlignSystem( AstFrame *, int * );
+static int TestAlignSystem( AstFrame *, int * );
+static void ClearAlignSystem( AstFrame *, int * );
+static void SetAlignSystem( AstFrame *, AstSystemType, int * );
+
+static const char *GetAttrib( AstObject *, const char *, int * );
+static int TestAttrib( AstObject *, const char *, int * );
+static void ClearAttrib( AstObject *, const char *, int * );
+static void SetAttrib( AstObject *, const char *, int * );
+
+static int GetNegated( AstRegion *, int * );
+static int TestNegated( AstRegion *, int * );
+static void ClearNegated( AstRegion *, int * );
+static void SetNegated( AstRegion *, int, int * );
+
+static int GetClosed( AstRegion *, int * );
+static int TestClosed( AstRegion *, int * );
+static void ClearClosed( AstRegion *, int * );
+static void SetClosed( AstRegion *, int, int * );
+
+static int GetMeshSize( AstRegion *, int * );
+static int TestMeshSize( AstRegion *, int * );
+static void ClearMeshSize( AstRegion *, int * );
+static void SetMeshSize( AstRegion *, int, int * );
+
+static double GetFillFactor( AstRegion *, int * );
+static int TestFillFactor( AstRegion *, int * );
+static void ClearFillFactor( AstRegion *, int * );
+static void SetFillFactor( AstRegion *, double, int * );
+
+static int GetRegionFS( AstRegion *, int * );
+static int TestRegionFS( AstRegion *, int * );
+static void ClearRegionFS( AstRegion *, int * );
+static void SetRegionFS( AstRegion *, int, int * );
+
+static int GetAdaptive( AstRegion *, int * );
+static int TestAdaptive( AstRegion *, int * );
+static void ClearAdaptive( AstRegion *, int * );
+static void SetAdaptive( AstRegion *, int, int * );
+
+#if defined(THREAD_SAFE)
+static int ManageLock( AstObject *, int, int, AstObject **, int * );
+#endif
+
+
+/* Member functions. */
+/* ================= */
+
+static const char *Abbrev( AstFrame *this_frame, int axis, const char *fmt,
+                           const char *str1, const char *str2, int *status ) {
+/*
+*  Name:
+*     Abbrev
+
+*  Purpose:
+*     Abbreviate a formatted Region axis value by skipping leading fields.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     const char *Abbrev( AstFrame *this, int axis, const char *fmt,
+*                         const char *str1, const char *str2, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astAbbrev
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function compares two Region axis values that have been
+*     formatted (using astFormat) and determines if they have any
+*     redundant leading fields (i.e. leading fields in common which
+*     can be suppressed when tabulating the values or plotting them on
+*     the axis of a graph).
+
+*  Parameters:
+*     this
+*        Pointer to the Region
+*     axis
+*        The number of the Region axis for which the values have
+*        been formatted (axis numbering starts at zero for the first
+*        axis).
+*     fmt
+*        Pointer to a constant null-terminated string containing the
+*        format specification used to format the two values.
+*     str1
+*        Pointer to a constant null-terminated string containing the
+*        first formatted value.
+*     str1
+*        Pointer to a constant null-terminated string containing the
+*        second formatted value.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer into the "str2" string which locates the first
+*     character in the first field that differs between the two
+*     formatted values.
+*
+*     If the two values have no leading fields in common, the returned
+*     value will point at the start of string "str2". If the two
+*     values are equal, it will point at the terminating null at the
+*     end of this string.
+
+*  Notes:
+*     - This function assumes that the format specification used was
+*     the same when both values were formatted and that they both
+*     apply to the same Region axis.
+*     - A pointer to the start of "str2" 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 *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   const char *result;           /* Pointer value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return str2;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astAbbrev" );
+
+/* Obtain a pointer to the Region's current Frame and invoke this
+   Frame's astAbbrev method to perform the processing. Annul the Frame
+   pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astAbbrev( fr, axis, fmt, str1, str2 );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result. */
+   if ( !astOK ) result = str2;
+
+/* Return the result. */
+   return result;
+}
+
+static double Angle( AstFrame *this_frame, const double a[],
+                     const double b[], const double c[], int *status ) {
+/*
+*  Name:
+*     Angle
+
+*  Purpose:
+*     Calculate the angle subtended by two points at a third point.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double Angle( AstFrame *this, const double a[], const double b[],
+*                   const double c[], int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astAngle
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function finds the angle at point B between the line joining points
+*     A and B, and the line joining points C and B. These lines will in fact be
+*     geodesic curves appropriate to the Frame in use. For instance, in
+*     SkyFrame, they will be great circles.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     a
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute) containing the coordinates of the first point.
+*     b
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute) containing the coordinates of the second point.
+*     c
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute) containing the coordinates of the third point.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     astAngle
+*        The angle in radians, from the line AB to the line CB. If the
+*        Frame is 2-dimensional, it will be in the range $\pm \pi$,
+*        and positive rotation is in the same sense as rotation from
+*        the positive direction of axis 2 to the positive direction of
+*        axis 1. If the Frame has more than 2 axes, a positive value will
+*        always be returned in the range zero to $\pi$.
+
+*  Notes:
+*     - A value of AST__BAD will also be returned if points A and B are
+*     co-incident, or if points B and C are co-incident.
+*     - A value of AST__BAD will also be returned if this function is
+*     invoked with the AST error status set, or if it should fail for
+*     any reason.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double result;                /* Value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke this
+   Frame's astAngle method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astAngle( fr, a, b, c );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result. */
+   if ( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+static double AxAngle( AstFrame *this_frame, const double a[], const double b[], int axis, int *status ) {
+/*
+*  Name:
+*     AxAngle
+
+*  Purpose:
+*     Returns the angle from an axis, to a line through two points.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double AxAngle( AstFrame *this, const double a[], const double b[], int axis, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astAxAngle
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function finds the angle, as seen from point A, between the positive
+*     direction of a specified axis, and the geodesic curve joining point
+*     A to point B.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     a
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute) containing the coordinates of the first point.
+*     b
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute) containing the coordinates of the second point.
+*     axis
+*        The number of the Frame axis from which the angle is to be
+*        measured (one-based)
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*        The angle in radians, from the positive direction of the
+*        specified axis, to the line AB. If the Frame is 2-dimensional,
+*        it will be in the range $\pm \pi$, and positive rotation is in
+*        the same sense as rotation from the positive direction of axis 2
+*        to the positive direction of axis 1. If the Frame has more than 2
+*        axes, a positive value will always be returned in the range zero
+*        to $\pi$.
+
+*  Notes:
+*     - The geodesic curve used by this function is the path of
+*     shortest distance between two points, as defined by the
+*     astDistance function.
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value, or if the require
+*     position angle is undefined.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double result;                /* Value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis - 1, 1, "astAxAngle" );
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke the
+   astAxAngle method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astAxAngle( fr, a, b, axis );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+static double AxDistance( AstFrame *this_frame, int axis, double v1, double v2, int *status ) {
+/*
+*  Name:
+*     AxDistance
+
+*  Purpose:
+*     Find the distance between two axis values.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double AxDistance( AstFrame *this, int axis, double v1, double v2, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astAxDistance
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a signed value representing the axis increment
+*     from axis value v1 to axis value v2.
+*
+*     For a simple Frame, this is a trivial operation returning the
+*     difference between the two axis values. But for other derived classes
+*     of Frame (such as a SkyFrame) this is not the case.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     axis
+*        The index of the axis to which the supplied values refer. The
+*        first axis has index 1.
+*     v1
+*        The first axis value.
+*     v2
+*        The second axis value.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The distance between the two axis values.
+
+*  Notes:
+*     - This function will return a "bad" result value (AST__BAD) if
+*     any of the input vaues has this value.
+*     - A "bad" value will also be returned if this function is
+*     invoked with the AST error status set, or if it should fail for
+*     any reason.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double result;                /* Value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis - 1, 1, "astAxDistance" );
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke the
+   astAxDistance method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astAxDistance( fr, axis, v1, v2 );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+static void AxNorm( AstFrame *this_frame, int axis, int oper, int nval,
+                    double *values, int *status ){
+/*
+*  Name:
+*     AxNorm
+
+*  Purpose:
+*     Normalise an array of axis values.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void AxNorm( AstFrame *this, int axis, int oper, int nval,
+*                  double *values, int *status )
+
+*  Class Membership:
+*     FrameSet member function (over-rides the protected astAxNorm
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function modifies a supplied array of axis values so that
+*     they are normalised in the manner indicated by parameter "oper".
+*
+*     No normalisation is possible for a simple Frame and so the supplied
+*     values are returned unchanged. However, this may not be the case for
+*     specialised sub-classes of Frame. For instance, a SkyFrame has a
+*     discontinuity at zero longitude and so a longitude value can be
+*     expressed in the range [-Pi,+PI] or the range [0,2*PI].
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     axis
+*        The index of the axis to which the supplied values refer. The
+*        first axis has index 1.
+*     oper
+*        Indicates the type of normalisation to be applied. If zero is
+*        supplied, the normalisation will be the same as that performed by
+*        function astNorm. If 1 is supplied, the normalisation will be
+*        chosen automatically so that the resulting list has the smallest
+*        range.
+*     nval
+*        The number of points in the values array.
+*     values
+*        On entry, the axis values to be normalised. Modified on exit to
+*        hold the normalised values.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis - 1, 1, "astAxNorm" );
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke
+   the astAxNorm method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astAxNorm( fr, axis, oper, nval, values );
+   fr = astAnnul( fr );
+}
+
+static double AxOffset( AstFrame *this_frame, int axis, double v1, double dist, int *status ) {
+/*
+*  Name:
+*     AxOffset
+
+*  Purpose:
+*     Add an increment onto a supplied axis value.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double AxOffset( AstFrame *this, int axis, double v1, double dist, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astAxOffset
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns an axis value formed by adding a signed axis
+*     increment onto a supplied axis value.
+*
+*     For a simple Frame, this is a trivial operation returning the
+*     sum of the two supplied values. But for other derived classes
+*     of Frame (such as a SkyFrame) this is not the case.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     axis
+*        The index of the axis to which the supplied values refer. The
+*        first axis has index 1.
+*     v1
+*        The original axis value.
+*     dist
+*        The axis increment to add to the original axis value.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The incremented axis value.
+
+*  Notes:
+*     - This function will return a "bad" result value (AST__BAD) if
+*     any of the input vaues has this value.
+*     - A "bad" value will also be returned if this function is
+*     invoked with the AST error status set, or if it should fail for
+*     any reason.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double result;                /* Value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis - 1, 1, "astAxOffset" );
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke the
+   astAxOffset method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astAxOffset( fr, axis, v1, dist );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+static AstPointSet *BndBaseMesh( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+/*
+*+
+*  Name:
+*     astBndBaseMesh
+
+*  Purpose:
+*     Return a PointSet containing points spread around part of the boundary
+*     of a Region, in the base Frame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *astBndBaseMesh( AstRegion *this, double *lbnd, double *ubnd )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a PointSet containing a set of points on the
+*     boundary of the intersection between the supplied Region and the
+*     supplied (current Frame) box. The mesh points refer to the base
+*     Frame. If the boundary of the supplied Region does not intersect the
+*     supplied box, then a PointSet containing a single bad point is
+*     returned.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     lbnd
+*        Pointer to an array holding the lower limits of the axis values
+*        within the required box. Defined in the current Frame of the Region.
+*     ubnd
+*        Pointer to an array holding the upper limits of the axis values
+*        within the required box. Defined in the current Frame of the Region.
+
+*  Returned Value:
+*     Pointer to the PointSet holding the base Frame mesh. The axis values
+*     in this PointSet will have associated accuracies derived from the
+*     uncertainties which were supplied when the Region was created.
+*
+*     If the Region does not intersect the supplied box, the returned
+*     PointSet will contain a single point with a value of AST__BAD on
+*     every axis.
+
+*  Notes:
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*-
+*/
+
+/* Local Variables: */
+   AstBox *box;
+   AstCmpRegion *cmpreg;
+   AstPointSet *result;
+   double **ptr;
+   int ic;
+   int nc;
+
+/* Check the local error status. */
+   if ( !astOK ) return NULL;
+
+/* Form a Box describing the required box. */
+   box = astBox( this, 1, lbnd, ubnd, NULL, "", status );
+
+/* Check there is partial overlap between the Regions.*/
+   if( astOverlap( this, box ) > 3 ) {
+
+/* Form a CmpRegion representing the intersection between the supplied
+   Region and the above box. */
+      cmpreg = astCmpRegion( this, box, AST__AND, "", status );
+
+/* Get the boundary mesh. */
+      result = astRegBaseMesh( cmpreg );
+
+/* Free resources. */
+      cmpreg = astAnnul( cmpreg );
+
+/* If the boundary of the supplied Region does not intersect the box,
+   return a PointSet containing a single bad position. */
+   } else {
+      nc = astGetNin( this->frameset );
+      result = astPointSet( 1, nc, "", status );
+      ptr = astGetPoints( result );
+      if( ptr ) {
+         for( ic = 0; ic < nc; ic++ ) ptr[ ic ][ 0 ] = AST__BAD;
+      }
+   }
+
+/* Free resources. */
+   box = astAnnul( box );
+
+/* Return NULL if an error occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the required pointer. */
+   return result;
+}
+
+static AstPointSet *BndMesh( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+/*
+*+
+*  Name:
+*     astBndMesh
+
+*  Purpose:
+*     Return a PointSet containing points spread around part of the boundary
+*     of a Region, in the current Frame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *astBndMesh( AstRegion *this, double *lbnd, double *ubnd )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a PointSet containing a set of points on the
+*     boundary of the intersection between the supplied Region and the
+*     supplied box. The points refer to the current Frame of the
+*     encapsulated FrameSet. If the boundary of the supplied Region does
+*     not intersect the supplied box, then a PointSet containing a single
+*     bad point is returned.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     lbnd
+*        Pointer to an array holding the lower limits of the axis values
+*        within the required box. Defined in the current Frame of the Region.
+*     ubnd
+*        Pointer to an array holding the upper limits of the axis values
+*        within the required box. Defined in the current base Frame of the
+*        Region.
+
+*  Returned Value:
+*     Pointer to the PointSet. The axis values in this PointSet will have
+*     associated accuracies derived from the uncertainties which were
+*     supplied when the Region was created.
+*
+*    If the Region does not intersect the supplied box, the returned
+*    PointSet will contain a single point with a value of AST__BAD on
+*    every axis.
+
+*  Notes:
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*-
+*/
+
+/* Local Variables: */
+   AstMapping *map;
+   AstPointSet *ps1;
+   AstPointSet *result;
+
+/* Initialise */
+   result = NULL;
+
+/* Check the local error status. */
+   if ( !astOK ) return result;
+
+/* Get the current->base Mapping from the Region. */
+   map = astGetMapping( this->frameset, AST__CURRENT, AST__BASE );
+
+/* Use astBndBaseMesh to get a mesh of base Frame points within this base
+   Frame bounding box. */
+   ps1 = astBndBaseMesh( this, lbnd, ubnd );
+
+/* Transform it into the current Frame. */
+   if( ps1 ) result = astTransform( map, ps1, 0, NULL );
+
+/* Free resources. */
+   map = astAnnul( map );
+   ps1 = astAnnul( ps1 );
+
+/* Return NULL if an error occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the required pointer. */
+   return result;
+}
+
+static AstPointSet *BTransform( AstRegion *this, AstPointSet *in,
+                                int forward, AstPointSet *out, int *status ) {
+/*
+*+
+*  Name:
+*     astBTransform
+
+*  Purpose:
+*     Use a Region to transform a set of points in the base Frame.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "circle.h"
+*     AstPointSet *astBTransform( AstRegion *this, AstPointSet *in,
+                                  int forward, AstPointSet *out )
+
+*  Class Membership:
+*     Region member function
+
+*  Description:
+*     This function takes a Region and a set of points within the base
+*     Frame of the Region, and transforms the points by setting axis values
+*     to AST__BAD for all points which are outside the region. Points inside
+*     the region are copied unchanged from input to output.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     in
+*        Pointer to the PointSet holding the input coordinate data.
+*     forward
+*        A non-zero value indicates that the forward coordinate transformation
+*        should be applied, while a zero value requests the inverse
+*        transformation.
+*     out
+*        Pointer to a PointSet which will hold the transformed (output)
+*        coordinate values. A NULL value may also be given, in which case a
+*        new PointSet will be created by this function.
+
+*  Returned Value:
+*     Pointer to the output (possibly new) PointSet.
+
+*  Notes:
+*     -  This is identical to the astTransform method for a Region except
+*     that the supplied and returned points refer to the base Frame of
+*     the Region, rather than the current Frame.
+*-
+*/
+
+/* Local Variables: */
+   AstPointSet *result;          /* Pointer to output PointSet */
+   int old;                      /* Origial value of "nomap" flag */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Save the current value of the "nomap" flag for this Region,and then
+   set it. Doing this tells the astRegMapping function (called by
+   astRegTransform) to assume a unit map connects base and current Frame. */
+   old = this->nomap;
+   this->nomap = 1;
+
+/* Invoke the usual astTransform method. The above setting of the "nomap"
+   flag will cause the astTransform method to treat the base Frame as the
+   current Frame. */
+   result = astTransform( this, in, forward, out );
+
+/* Reset the "nomap" flag. */
+   this->nomap = old;
+
+/* Return a pointer to the output PointSet. */
+   return result;
+}
+
+static AstObject *Cast( AstObject *this_object, AstObject *obj, int *status ) {
+/*
+*  Name:
+*     Cast
+
+*  Purpose:
+*     Cast an Object into an instance of a sub-class.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstObject *Cast( AstObject *this, AstObject *obj, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astCast
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a deep copy of an ancestral component of the
+*     supplied object. The required class of the ancestral component is
+*     specified by another object. Specifically, if "this" and "new" are
+*     of the same class, a copy of "this" is returned. If "this" is an
+*     instance of a subclass of "obj", then a copy of the component
+*     of "this" that matches the class of "obj" is returned. Otherwise,
+*     a NULL pointer is returned without error.
+
+*  Parameters:
+*     this
+*        Pointer to the Object to be cast.
+*     obj
+*        Pointer to an Object that defines the class of the returned Object.
+*        The returned Object will be of the same class as "obj".
+
+*  Returned Value:
+*     A pointer to the new Object. NULL if "this" is not a sub-class of
+*     "obj", or if an error occurs.
+
+*  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 *cfrm;
+   AstObject *new;
+   astDECLARE_GLOBALS
+   int generation_gap;
+
+/* Initialise */
+   new = NULL;
+
+/* Check inherited status */
+   if( !astOK ) return new;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* See how many steps up the class inheritance ladder it is from "obj"
+   to this class (Region). A positive value is returned if Region is
+   a sub-class of "obj". A negative value is returned if "obj" is a
+   sub-class of Region. Zero is returned if "obj" is a Region.
+   AST__COUSIN is returned if "obj" is not on the same line of descent
+   as Region. */
+   generation_gap = astClassCompare( (AstObjectVtab *) &class_vtab,
+                                     astVTAB( obj ) );
+
+/* If "obj" is a Region or a sub-class of Region, we can cast by
+   truncating the vtab for "this" so that it matches the vtab of "obJ",
+   and then taking a deep copy of "this". */
+   if( generation_gap <= 0 && generation_gap != AST__COUSIN ) {
+      new = astCastCopy( this_object, obj );
+
+/* If "obj" is not a Region or a sub-class of Region (e.g. a Frame or
+   some sub-class of Frame), we attempt to cast the current Frame of the
+   encapsulated FrameSet into the class indicated by "obj". */
+   } else {
+      cfrm = astGetFrame( ((AstRegion *) this_object)->frameset, AST__CURRENT );
+      new = astCast( cfrm, obj );
+      cfrm = astAnnul( cfrm );
+   }
+
+/* Return the new pointer. */
+   return new;
+}
+
+static double Centre( AstFrame *this_frame, int axis, double value, double gap, int *status ) {
+/*
+*  Name:
+*     Centre
+
+*  Purpose:
+*     Find a "nice" central value for tabulating Frame axis values.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double  Centre( AstFrame *this_frame, int axis, double value,
+*                     double gap, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astCentre method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function returns an axis value which produces a nice formatted
+*     value suitable for a major tick mark on a plot axis, close to the
+*     supplied axis value.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     axis
+*        The number of the axis (zero-based) for which a central value
+*        is to be found.
+*     value
+*        An arbitrary axis value in the section that is being plotted.
+*     gap
+*        The gap size.
+
+*  Returned Value:
+*     The nice central axis value.
+
+*  Notes:
+*     - A value of zero is returned if the supplied gap size is zero.
+*     - A value of zero 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 *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double result;                /* Value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0.0;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astCentre" );
+
+/* Obtain a pointer to the Region's current Frame and invoke this
+   Frame's astCentre method to obtain the required value. Annul the
+   Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astCentre( fr, axis, value, gap );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result. */
+   if ( !astOK ) result = 0.0;
+
+/* Return the result. */
+   return result;
+}
+
+static void CheckPerm( AstFrame *this_frame, const int *perm, const char *method, int *status ) {
+/*
+*  Name:
+*     CheckPerm
+
+*  Purpose:
+*     Check that an array contains a valid permutation.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void CheckPerm( AstFrame *this, const int *perm, const char *method, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astCheckPerm
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function checks the validity of a permutation array that
+*     will be used to permute the order of a Frame's axes. If the
+*     permutation specified by the array is not valid, an error is
+*     reported and the global error status is set. Otherwise, the
+*     function returns without further action.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     perm
+*        Pointer to an array of integers with the same number of
+*        elements as there are axes in the Frame. For each axis, the
+*        corresponding integer gives the (zero based) axis index to be
+*        used to identify the information for that axis (using the
+*        un-permuted axis numbering). To be valid, the integers in
+*        this array should therefore all lie in the range zero to
+*        (naxes-1) inclusive, where "naxes" is the number of Frame
+*        axes, and each value should occur exactly once.
+*     method
+*        Pointer to a constant null-terminated character string
+*        containing the name of the method that invoked this function
+*        to validate a permutation array. This method name is used
+*        solely for constructing error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - Error messages issued by this function refer to the external
+*     (public) numbering system used for axes (which is one-based),
+*     whereas zero-based axis indices are used internally.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke this
+   Frame's astCheckPerm method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astCheckPerm( fr, perm, method );
+   fr = astAnnul( fr );
+
+}
+
+static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     ClearAttrib
+
+*  Purpose:
+*     Clear an attribute value for a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void ClearAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astClearAttrib protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function clears the value of a specified attribute for a
+*     Region, so that the default value will subsequently be used.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     attrib
+*        Pointer to a null terminated string specifying the attribute
+*        name.  This should be in lower case with no surrounding white
+*        space.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstRegion *this;            /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_object;
+
+/* Check the attribute name and clear the appropriate attribute. */
+
+/* We first handle attributes that apply to the Region as a whole
+   (rather than to the encapsulated FrameSet). */
+
+/* Negated */
+/* ------- */
+   if ( !strcmp( attrib, "negated" ) ) {
+      astClearNegated( this );
+
+/* Closed */
+/* ------ */
+   } else if ( !strcmp( attrib, "closed" ) ) {
+      astClearClosed( this );
+
+/* FillFactor */
+/* ---------- */
+   } else if ( !strcmp( attrib, "fillfactor" ) ) {
+      astClearFillFactor( this );
+
+/* MeshSize */
+/* -------- */
+   } else if ( !strcmp( attrib, "meshsize" ) ) {
+      astClearMeshSize( this );
+
+/* Adaptive */
+/* -------- */
+   } else if ( !strcmp( attrib, "adaptive" ) ) {
+      astClearAdaptive( this );
+
+
+/* We now check for atttributes of superclasses which apply to the Region
+   as a whole. We do not want to pass these on to the encapsulated FrameSet. */
+
+/* ID. */
+/* --- */
+   } else if ( !strcmp( attrib, "id" ) ) {
+      astClearID( this );
+
+/* Ident. */
+/* ------ */
+   } else if ( !strcmp( attrib, "ident" ) ) {
+      astClearIdent( this );
+
+/* Invert. */
+/* ------- */
+   } else if ( !strcmp( attrib, "invert" ) ) {
+      astClearInvert( this );
+
+/* Report. */
+/* ------- */
+   } else if ( !strcmp( attrib, "report" ) ) {
+      astClearReport( this );
+
+
+/* If the name was not recognised, test if it matches any of the
+   read-only attributes of this class (including those of all superclasses).
+   If it does, then report an error. */
+   } else if ( !strcmp( attrib, "class" ) ||
+               !strcmp( attrib, "nin" ) ||
+               !strcmp( attrib, "nobject" ) ||
+               !strcmp( attrib, "nout" ) ||
+               !strcmp( attrib, "bounded" ) ||
+               !strcmp( attrib, "refcount" ) ||
+               !strcmp( attrib, "tranforward" ) ||
+               !strcmp( attrib, "traninverse" ) ) {
+      astError( AST__NOWRT, "astClear: Invalid attempt to clear the \"%s\" "
+                "value for a %s.", status, attrib, astGetClass( this ) );
+      astError( AST__NOWRT, "This is a read-only attribute." , status);
+
+/* Pass unrecognised attributes on to the Region's encapsulated FrameSet for
+   further interpretation. Do not pass on FrameSet attributes since we
+   pretend to the outside world that the encapsulated FrameSet is actually a
+   Frame. */
+   } else if ( strcmp( attrib, "base" ) &&
+               strcmp( attrib, "current" ) &&
+               strcmp( attrib, "nframe" ) ) {
+
+/* If the Region is to adapt to coordinate system chanmges, use the public
+   astClear method so that the current Frame in the encapsulated FrameSet will
+   be re-mapped if the attribute changes require it. */
+      if( astGetAdaptive( this ) ) {
+         astClear( this->frameset, attrib );
+
+/* If the Region is not to adapt to coordinate system chanmges, use the
+   astRegSetAttrib method which assigns the attribute setting to both
+   current and base Frames in the FrameSet without causing any remapping to
+   be performed. */
+      } else {
+         astRegClearAttrib( this, attrib, NULL );
+      }
+   }
+}
+
+static AstFrameSet *Conv( AstFrameSet *from, AstFrameSet *to, int *status ){
+/*
+*  Name:
+*     Conv
+
+*  Purpose:
+*     Find Mapping between Frames
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstFrameSet *Conv( AstFrameSet *from, AstFrameSet *to, int *status );
+
+*  Class Membership:
+*     Region member function
+
+*  Description:
+*     This function provides a convenient interface for astConvert.
+*     It is like astConvert except it does not alter the base Frames of
+*     the supplied FrameSets and does not require a Domain list.
+
+*  Parameters:
+*     from
+*        Pointer to the source FrameSet.
+*     to
+*        Pointer to the source FrameSet.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*        The conversion FrameSet (see astConvert).
+
+*/
+
+/* Local Variables: */
+   AstFrameSet *result;        /* FrameSet to return */
+   int from_base;              /* Index of original base Frame in "from" */
+   int to_base;                /* Index of original base Frame in "to" */
+
+/* Check the global error status. */
+   if( !astOK ) return NULL;
+
+/* Note the indices of the base Frames in the FrameSets. */
+   to_base = astGetBase( to );
+   from_base = astGetBase( from );
+
+/* Invoke astConvert. */
+   result = astConvert( from, to, "" );
+
+/* Re-instate original base Frames. */
+   astSetBase( to, to_base );
+   astSetBase( from, from_base );
+
+/* Return the result. */
+   return result;
+}
+
+static AstFrameSet *Convert( AstFrame *from, AstFrame *to,
+                             const char *domainlist, int *status ) {
+/*
+*  Name:
+*     Convert
+
+*  Purpose:
+*     Determine how to convert between two coordinate systems.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstFrameSet *Convert( AstFrame *from, AstFrame *to,
+*                           const char *domainlist, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the public astConvert
+*     method inherited fromm the Frame class).
+
+*  Description:
+*     This function compares two Regions and determines whether it
+*     is possible to convert between the coordinate systems which
+*     their current Frames represent. If conversion is possible, it
+*     returns a FrameSet which describes the conversion and which may
+*     be used (as a Mapping) to transform coordinate values in either
+*     direction.
+
+*  Parameters:
+*     from
+*        Pointer to a Region whose current Frame represents the
+*        "source" coordinate system.  Note that the Base attribute of
+*        the Region may be modified by this function.
+*     to
+*        Pointer to a Region whose current Frame represents the
+*        "destination" coordinate system.  Note that the Base
+*        attribute of the Region may be modified by this function.
+*     domainlist
+*        Pointer to a null-terminated character string containing a
+*        comma-separated list of Frame domains. This may be used to
+*        define a priority order for the different intermediate
+*        coordinate systems that might be used to perform the
+*        conversion.
+*
+*        The function will first try to obtain a conversion by making
+*        use only of intermediate Frames whose Domain attribute
+*        matches the first domain in this list. If this fails, the
+*        second domain in the list will be used, and so on, until
+*        conversion is achieved. A blank domain (e.g. two consecutive
+*        commas) indicates that all Frames should be considered,
+*        regardless of their Domain attributes. The list is
+*        case-insensitive and all white space is ignored.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*        If the requested coordinate conversion is possible, the
+*        function returns a pointer to a FrameSet which describes the
+*        conversion. Otherwise, a null Object pointer (AST__NULL) is
+*        returned without error.
+*
+*        If a FrameSet is returned, it will contain two Frames. Frame
+*        number 1 (its base Frame) will describe the source coordinate
+*        system, corresponding to the "from" parameter. Frame number 2
+*        (its current Frame) will describe the destination coordinate
+*        system, corresponding to the "to" parameter. The Mapping
+*        which inter-relates these Frames will perform the required
+*        conversion between the two coordinate systems.
+
+*  Notes:
+*     - The returned FrameSet will not contain any Regions. If one or
+*     more of the supplied Frames are in fact Regions, the corresponding
+*     Frames in any returned FrameSet will described the encapsulated
+*     Frame, without any region information.
+*     - 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: */
+   AstFrameSet *result;       /* Returned FrameSet */
+
+/* Check the inherited status. */
+   if ( !astOK ) return NULL;
+
+/* If the "from" pointer is a Region, get a pointer to the current Frame of
+   the encapsulated FrameSet and use it instead of the supplied pointer. */
+   if( astIsARegion( from ) ) {
+      from = astGetFrame( ((AstRegion *) from)->frameset, AST__CURRENT );
+   } else {
+      from = astClone( from );
+   }
+
+/* If the "to" pointer is a Region, get a pointer to the current Frame of
+   the encapsulated FrameSet and use it instead of the supplied pointer. */
+   if( astIsARegion( to ) ) {
+      to = astGetFrame( ((AstRegion *) to)->frameset, AST__CURRENT );
+   } else {
+      to = astClone( to );
+   }
+
+/* Now invoke astConvert on the above Frames. */
+   result = astConvert( from, to, domainlist );
+
+/* Annul the pointers used above. */
+   from = astAnnul( from );
+   to = astAnnul( to );
+
+/* Return the result */
+   return result;
+}
+
+static AstFrameSet *ConvertX( AstFrame *to, AstFrame *from,
+                              const char *domainlist, int *status ) {
+/*
+*  Name:
+*     ConvertX
+
+*  Purpose:
+*     Determine how to convert between two coordinate systems.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstFrameSet *astConvertX( AstFrame *to, AstFrame *from,
+*                               const char *domainlist )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astConvertX
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function performs the processing for the public astConvert
+*     method and has exactly the same interface except that the order
+*     of the first two arguments is swapped. This is a trick to allow
+*     the astConvert method to be over-ridden by derived classes on
+*     the basis of the class of either of its first two arguments.
+*
+*     See the astConvert method for details of the interface.
+*-
+*/
+
+/* Local Variables: */
+   AstFrameSet *result;       /* Returned FrameSet */
+
+/* Check the inherited status. */
+   if ( !astOK ) return NULL;
+
+/* If the "to" pointer is a Region, get a pointer to the current Frame of
+   the encapsulated FrameSet and use it instead of the supplied pointer. */
+   if( astIsARegion( to ) ) {
+      to = astGetFrame( ((AstRegion *) to)->frameset, AST__CURRENT );
+   } else {
+      to = astClone( to );
+   }
+
+/* If the "from" pointer is a Region, get a pointer to the current Frame of
+   the encapsulated FrameSet and use it instead of the supplied pointer. */
+   if( astIsARegion( from ) ) {
+      from = astGetFrame( ((AstRegion *) from)->frameset, AST__CURRENT );
+   } else {
+      from = astClone( from );
+   }
+
+/* Now invoke astConvertX on the above Frames. */
+   result = astConvertX( to, from, domainlist );
+
+/* Annul the pointers used above. */
+   from = astAnnul( from );
+   to = astAnnul( to );
+
+/* Return the result */
+   return result;
+}
+
+static double Distance( AstFrame *this_frame, const double point1[],
+                        const double point2[], int *status ) {
+/*
+*  Name:
+*     Distance
+
+*  Purpose:
+*     Calculate the distance between two points.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double Distance( AstFrame *this, const double point1[],
+*                      const double point2[], int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astDistance
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function finds the distance between two points whose
+*     Region coordinates are given. The distance calculated is that
+*     along the geodesic curve that joins the two points.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     point1
+*        An array of double, with one element for each Region axis
+*        containing the coordinates of the first point.
+*     point2
+*        An array of double, with one element for each Region axis
+*        containing the coordinates of the second point.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The distance between the two points.
+
+*  Notes:
+*     - This function will return a "bad" result value (AST__BAD) if
+*     any of the input coordinates has this value.
+*     - A "bad" value will also be returned if this function is
+*     invoked with the AST error status set or if it should fail for
+*     any reason.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double result;                /* Value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's current Frame and invoke this
+   Frame's astDistance method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astDistance( fr, point1, point2 );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result. */
+   if ( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+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 "region.h"
+*     int Equal( AstObject *this_object, AstObject *that_object, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astEqual protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a boolean result (0 or 1) to indicate whether
+*     two Regions are equivalent.
+
+*  Parameters:
+*     this
+*        Pointer to the first Region.
+*     that
+*        Pointer to the second Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     One if the Regions are equivalent, zero otherwise.
+
+*  Notes:
+*     - The Regions are equivalent if they are of the same class, have
+*     equal PointSets, have equal base Frames, have equal current Frames,
+*     and if the Mapping between base Frames is a UnitMap. In addition, the
+*     Negated attribute must have the same value in both Regions, as must
+*     the Closed attribute.
+*     - 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: */
+   AstFrame *bf1;
+   AstFrame *bf2;
+   AstFrame *cf1;
+   AstFrame *cf2;
+   AstMapping *m1;
+   AstMapping *m2;
+   AstRegion *that;
+   AstRegion *this;
+   const char *class1;
+   const char *class2;
+   int result;
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Check that the two objects have the same class. */
+   class1 = astGetClass( this_object );
+   class2 = astGetClass( that_object );
+   if( astOK && !strcmp( class1, class2 ) ) {
+
+/* Obtain pointers to the two Region structures. */
+      this = (AstRegion *) this_object;
+      that = (AstRegion *) that_object;
+
+/* Test their PointSets for equality. */
+      if( astEqual( this->points, that->points ) ){
+
+/* Test their base Frames for equality. */
+         bf1 = astGetFrame( this->frameset, AST__BASE );
+         bf2 = astGetFrame( that->frameset, AST__BASE );
+         if( astEqual( bf1, bf2 ) ){
+
+/* Test their current Frames for equality. */
+            cf1 = astGetFrame( this->frameset, AST__CURRENT );
+            cf2 = astGetFrame( that->frameset, AST__CURRENT );
+            if( astEqual( cf1, cf2 ) ){
+
+/* Get the two Mappings and check that they are equal */
+               m1 = astGetMapping( this->frameset, AST__BASE, AST__CURRENT );
+               m2 = astGetMapping( that->frameset, AST__BASE, AST__CURRENT );
+               if( astEqual( m1, m2 ) ) {
+
+/* Test the Negated and Closed flags are equal */
+                  if( astGetNegated( this ) == astGetNegated( that ) &&
+                       astGetClosed( this ) == astGetClosed( that ) ) {
+                     result = 1;
+                  }
+               }
+
+/* Free resources. */
+               m1 = astAnnul( m1 );
+               m2 = astAnnul( m2 );
+            }
+
+            cf1 = astAnnul( cf1 );
+            cf2 = astAnnul( cf2 );
+         }
+
+         bf1 = astAnnul( bf1 );
+         bf2 = astAnnul( bf2 );
+      }
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result, */
+   return result;
+}
+
+static void ClearUnc( AstRegion *this, int *status ){
+/*
+*+
+*  Name:
+*     astClearUnc
+
+*  Purpose:
+*     Erase any uncertainty information in a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astClearUnc( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function erases all uncertainty information, whether default
+*     or not, from a Region.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*-
+*/
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* Annul any user-supplied uncertainty. Also indicate that cached
+   information may now be out of date. */
+   if( this->unc ) {
+      this->unc = astAnnul( this->unc );
+      astResetCache( this );
+   }
+
+/* Annul any default uncertainty. */
+   if( this->defunc ) this->defunc = astAnnul( this->defunc );
+
+}
+
+static AstFrameSet *FindFrame( AstFrame *target_frame, AstFrame *template,
+                               const char *domainlist, int *status ) {
+/*
+*  Name:
+*     FindFrame
+
+*  Purpose:
+*     Find a coordinate system with specified characteristics.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstFrameSet *FindFrame( AstFrame *target, AstFrame *template,
+*                             const char *domainlist, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astFindFrame method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function uses a "template" Frame to search a Region to
+*     identify a coordinate system which has a specified set of
+*     characteristics. If a suitable coordinate system can be found,
+*     the function returns a pointer to a FrameSet which describes the
+*     required coordinate system and how to convert coordinates to and
+*     from it.
+
+*  Parameters:
+*     target
+*        Pointer to the target Region.
+*     template
+*        Pointer to the template Frame, which should be an instance of
+*        the type of Frame you wish to find.
+*     domainlist
+*        Pointer to a null-terminated character string containing a
+*        comma-separated list of Frame domains. This may be used to
+*        establish a priority order for the different types of
+*        coordinate system that might be found.
+*
+*        The function will first try to find a suitable coordinate
+*        system whose Domain attribute equals the first domain in this
+*        list. If this fails, the second domain in the list will be
+*        used, and so on, until a result is obtained. A blank domain
+*        (e.g. two consecutive commas) indicates that any coordinate
+*        system is acceptable (subject to the template) regardless of
+*        its domain.
+*
+*        This list is case-insensitive and all white space is ignored.
+*        If you do not wish to restrict the domain in this way, you
+*        should supply an empty string.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     If the search is successful, the function returns a pointer to a
+*     FrameSet which contains the Frame found and a description of how
+*     to convert to (and from) the coordinate system it
+*     represents. Otherwise, a null Object pointer (AST__NULL) is
+*     returned without error.
+*
+*     If a FrameSet is returned, it will contain two Frames. Frame
+*     number 1 (its base Frame) represents the target coordinate
+*     system and will be the same as the target. Frame number 2 (its
+*     current Frame) will be a Frame representing the coordinate system
+*     which the function found. The Mapping which inter-relates these two
+*     Frames will describe how to convert between their respective coordinate
+*     systems. Note, the Frames in this FrameSet will not be Regions -
+*     that is, they will be simple Frames or other derived classes.
+
+*  Notes:
+*     - A null Object pointer (AST__NULL) will be returned if this
+*     function is invoked with the AST error status set, or if it
+*     should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstFrameSet *result;          /* Pointer to result FrameSet */
+   AstFrame *fr;                 /* Pointer to encapsulated Frame */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Invoke the astFindFrame method on the current Frame of the
+   encapsulated FrameSet within the target Region. */
+   fr = astGetFrame( ((AstRegion *) target_frame)->frameset, AST__CURRENT );
+   result = astFindFrame( fr, template, domainlist );
+   fr = astAnnul( fr );
+
+/* Return the result. */
+   return result;
+}
+
+static const char *Format( AstFrame *this_frame, int axis, double value, int *status ) {
+/*
+*  Name:
+*     Format
+
+*  Purpose:
+*     Format a coordinate value for a Region axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     const char *Format( AstFrame *this, int axis, double value, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astFormat method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function returns a pointer to a string containing the
+*     formatted (character) version of a coordinate value for a
+*     Region axis. The formatting applied is that specified by a
+*     previous invocation of the astSetFormat method. A suitable
+*     default format is applied if necessary.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     axis
+*        The number of the axis (zero-based) for which formatting is
+*        to be performed.
+*     value
+*        The coordinate value to be formatted.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer to a null-terminated string containing the formatted
+*     value.
+
+*  Notes:
+*     - The returned string pointer may point at memory allocated
+*     within the Region object, or at static memory. The contents of
+*     the string may be over-written or the pointer may become invalid
+*     following a further invocation of the same function or deletion
+*     of the Region. A copy of the string should therefore be made
+*     if necessary.
+*     - A NULL pointer will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   const char *result;           /* Pointer value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astFormat" );
+
+/* Obtain a pointer to the Region's current Frame and invoke the
+   astFormat method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astFormat( fr, axis, value );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+static double Gap( AstFrame *this_frame, int axis, double gap, int *ntick, int *status ) {
+/*
+*  Name:
+*     Gap
+
+*  Purpose:
+*     Find a "nice" gap for tabulating Region axis values.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double Gap( AstFrame *this, int axis, double gap, int *ntick, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astGap method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function returns a gap size which produces a nicely spaced
+*     series of formatted values for a Region axis, the returned gap
+*     size being as close as possible to the supplied target gap
+*     size. It also returns a convenient number of divisions into
+*     which the gap can be divided.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     axis
+*        The number of the axis (zero-based) for which a gap is to be found.
+*     gap
+*        The target gap size.
+*     ntick
+*        Address of an int in which to return a convenient number of
+*        divisions into which the gap can be divided.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The nice gap size.
+
+*  Notes:
+*     - A value of zero is returned if the target gap size is zero.
+*     - A negative gap size is returned if the supplied gap size is negative.
+*     - A value of zero 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 *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double result;                /* Gap value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0.0;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astGap" );
+
+/* Obtain a pointer to the Region's current Frame and invoke this
+   Frame's astGap method to obtain the required gap value. Annul the
+   Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astGap( fr, axis, gap, ntick );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result. */
+   if ( !astOK ) result = 0.0;
+
+/* 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 "region.h"
+*     int GetObjSize( AstObject *this, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astGetObjSize protected
+*     method inherited from the parent class).
+
+*  Description:
+*     This function returns the in-memory size of the supplied Region,
+*     in bytes.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     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: */
+   AstRegion *this;         /* Pointer to Region structure */
+   int result;                /* Result value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointers to the Region structure. */
+   this = (AstRegion *) this_object;
+
+/* Invoke the GetObjSize method inherited from the parent class, and then
+   add on any components of the class structure defined by thsi class
+   which are stored in dynamically allocated memory. */
+   result = (*parent_getobjsize)( this_object, status );
+
+   result += astGetObjSize( this->frameset );
+   result += astGetObjSize( this->points );
+   result += astGetObjSize( this->basemesh );
+   result += astGetObjSize( this->basegrid );
+   result += astGetObjSize( this->unc );
+   result += astGetObjSize( this->negation );
+   result += astGetObjSize( this->defunc );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result, */
+   return result;
+}
+
+static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     GetAttrib
+
+*  Purpose:
+*     Get the value of a specified attribute for a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astGetAttrib
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the value of a specified
+*     attribute for a Region, formatted as a character string.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     attrib
+*        Pointer to a null-terminated string containing the name of
+*        the attribute whose value is required. This name should be in
+*        lower case, with all white space removed.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     - Pointer to a null-terminated string containing the attribute
+*     value.
+
+*  Notes:
+*     - The returned string pointer may point at memory allocated
+*     within the Region, or at static memory. The contents of the
+*     string may be over-written or the pointer may become invalid
+*     following a further invocation of the same function or any
+*     modification of the Region. A copy of the string should
+*     therefore be made if necessary.
+*     - A NULL pointer will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS           /* Pointer to thread-specific global data */
+   AstRegion *this;              /* Pointer to the Region structure */
+   const char *result;           /* Pointer value to return */
+   double dval;                  /* Floating point attribute value */
+   int ival;                     /* Integer attribute value */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(this_object);
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_object;
+
+/* Compare "attrib" with each recognised attribute name in turn,
+   obtaining the value of the required attribute. If necessary, write
+   the value into "getattrib_buff" as a null-terminated string in an appropriate
+   format.  Set "result" to point at the result string. */
+
+/* We first handle attributes that apply to the Region as a whole
+   (rather than to the encapsulated FrameSet). */
+
+/* Negated */
+/* ------- */
+   if ( !strcmp( attrib, "negated" ) ) {
+      ival = astGetNegated( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Closed */
+/* ------ */
+   } else if ( !strcmp( attrib, "closed" ) ) {
+      ival = astGetClosed( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Adaptive */
+/* -------- */
+   } else if ( !strcmp( attrib, "adaptive" ) ) {
+      ival = astGetAdaptive( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* FillFactor */
+/* ---------- */
+   } else if ( !strcmp( attrib, "fillfactor" ) ) {
+      dval = astGetFillFactor( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%.*g", DBL_DIG, dval );
+         result = getattrib_buff;
+      }
+
+/* MeshSize */
+/* -------- */
+   } else if ( !strcmp( attrib, "meshsize" ) ) {
+      ival = astGetMeshSize( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Bounded */
+/* ------- */
+   } else if ( !strcmp( attrib, "bounded" ) ) {
+      ival = astGetBounded( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Now get the values of attributes inherited from parent classes. We do
+   this to avoid the request being passed on to the encapsulated FrameSet
+   below. */
+
+/* Class. */
+/* ------ */
+   } else if ( !strcmp( attrib, "class" ) ) {
+      result = astGetClass( this );
+
+/* ID. */
+/* --- */
+   } else if ( !strcmp( attrib, "id" ) ) {
+      result = astGetID( this );
+
+/* Ident. */
+/* ------ */
+   } else if ( !strcmp( attrib, "ident" ) ) {
+      result = astGetIdent( this );
+
+/* Invert. */
+/* ------- */
+   } else if ( !strcmp( attrib, "invert" ) ) {
+      ival = astGetInvert( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Nin. */
+/* ---- */
+   } else if ( !strcmp( attrib, "nin" ) ) {
+      ival = astGetNin( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Nobject. */
+/* -------- */
+   } else if ( !strcmp( attrib, "nobject" ) ) {
+      ival = astGetNobject( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Nout. */
+/* ----- */
+   } else if ( !strcmp( attrib, "nout" ) ) {
+      ival = astGetNout( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* RefCount. */
+/* --------- */
+   } else if ( !strcmp( attrib, "refcount" ) ) {
+      ival = astGetRefCount( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Report. */
+/* ------- */
+   } else if ( !strcmp( attrib, "report" ) ) {
+      ival = astGetReport( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* TranForward. */
+/* ------------ */
+   } else if ( !strcmp( attrib, "tranforward" ) ) {
+      ival = astGetTranForward( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* TranInverse. */
+/* ------------ */
+   } else if ( !strcmp( attrib, "traninverse" ) ) {
+      ival = astGetTranInverse( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* Pass unrecognised attributes on to the Region's encapsulated FrameSet for
+   further interpretation. Do not pass on FrameSet attributes since we
+   pretend to the outside world that the encapsulated FrameSet is actually a
+   Frame. */
+   } else if ( strcmp( attrib, "base" ) &&
+               strcmp( attrib, "current" ) &&
+               strcmp( attrib, "nframe" ) ) {
+      result = astGetAttrib( this->frameset, attrib );
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+static int GetBounded( AstRegion *this, int *status ) {
+/*
+*+
+*  Name:
+*     astGetBounded
+
+*  Purpose:
+*     Is the Region bounded?
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     int astGetBounded( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  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.
+
+*  Returned Value:
+*     Non-zero if the Region is bounded. Zero otherwise.
+
+*-
+*/
+
+/* For Regions which are defined by one or more closed curves such as Circles,
+   Boxes, etc, the Region is bounded so long as it has not been negated.
+   Classes for which this is not true should over-ride this implementation. */
+   return !astGetNegated( this );
+}
+
+static AstAxis *GetAxis( AstFrame *this_frame, int axis, int *status ) {
+/*
+*  Name:
+*     GetAxis
+
+*  Purpose:
+*     Obtain a pointer to a specified Axis from a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstAxis *GetAxis( AstFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astGetAxis method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the Axis object associated
+*     with one of the axes of the current Frame of a Region. This
+*     object describes the quantity which is represented along that
+*     axis.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     axis
+*        The number of the axis (zero-based) for which an Axis pointer
+*        is required.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer to the requested Axis object.
+
+*  Notes:
+*     - The reference count of the requested Axis object will be
+*     incremented by one to reflect the additional pointer returned by
+*     this function.
+*     - 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: */
+   AstAxis *result;              /* Pointer to Axis */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astGetAxis" );
+
+/* Obtain a pointer to the Region's encapsulated FrameSet and invoke
+   this FrameSet's astGetAxis method to obtain the required Axis
+   pointer. */
+   result = astGetAxis( this->frameset, axis );
+
+/* If an error occurred, annul the result. */
+   if ( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+static AstRegion *GetDefUnc( AstRegion *this, int *status ) {
+/*
+*+
+*  Name:
+*     astGetDefUnc
+
+*  Purpose:
+*     Obtain a pointer to the default uncertainty Region for a given Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion *astGetDefUnc( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     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: */
+   AstFrame *bfrm;            /* Base Frame of supplied Region */
+   AstRegion *result;         /* Returned pointer */
+   double *lbnd;              /* Ptr. to array holding axis lower bounds */
+   double *ubnd;              /* Ptr. to array holding axis upper bounds */
+   double c;                  /* Central axis value */
+   double hw;                 /* Half width of uncertainty interval */
+   int i;                     /* Axis index */
+   int nax;                   /* Number of base Frame axes */
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the base Frame in the supplied Region. */
+   bfrm = astGetFrame( this->frameset, AST__BASE );
+
+/* Get the number of base Frame axes. */
+   nax = astGetNaxes( bfrm );
+
+/* Get the base frame bounding box of the supplied Region. The astRegBaseBox
+   assumes the supplied Region has not been inverted. But if the Region
+   contains other Regions (e.g. a Prism or CmpRegion, etc) then this
+   assumption needs to be propagated to the component Regions, which
+   astRegBaseBox does not do. For this reason we use astRegBaseBox2
+   instead. */
+   lbnd = astMalloc( sizeof( double)*(size_t) nax );
+   ubnd = astMalloc( sizeof( double)*(size_t) nax );
+   astRegBaseBox2( this, lbnd, ubnd );
+
+/* Create a Box covering 1.0E-6 of this bounding box, centred on the
+   centre of the box. */
+   if( astOK ) {
+      for( i = 0; i < nax; i++ ) {
+         if( ubnd[ i ] != DBL_MAX && lbnd[ i ] != -DBL_MAX ) {
+            hw = fabs( 0.5E-6*(  ubnd[ i ] - lbnd[ i ] ) );
+            c = 0.5*(  ubnd[ i ] + lbnd[ i ] );
+            if( hw == 0.0 ) hw = c*0.5E-6;
+            ubnd[ i ] = c + hw;
+            lbnd[ i ] = c - hw;
+         } else {
+            ubnd[ i ] = 0.0;
+            lbnd[ i ] = 0.0;
+         }
+      }
+      result = (AstRegion *) astBox( bfrm, 1, lbnd, ubnd, NULL, "", status );
+   }
+
+/* Free resources. */
+   lbnd = astFree( lbnd );
+   ubnd = astFree( ubnd );
+   bfrm = astAnnul( bfrm );
+
+/* Return NULL if an error occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the required pointer. */
+   return result;
+}
+
+static AstRegion *GetNegation( AstRegion *this, int *status ) {
+/*
+*+
+*  Name:
+*     astGetNegation
+
+*  Purpose:
+*     Obtain a pointer to a negated copy of the supplied Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion *GetNegation( AstRegion *this, int *status )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a pointer to a Region which is a negated
+*     copy of "this". The copy is cached in the Region structure for
+*     future use.
+
+*  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.
+*-
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* If the Region struture does not contain a pointer to a negated copy of
+   itself, create one now. */
+   if( ! this->negation ) {
+      this->negation = astCopy( this );
+      astNegate( this->negation );
+   }
+
+/* Return a clone of the negation pointer. */
+   return astClone( this->negation );
+}
+
+static AstFrameSet *GetRegFS( AstRegion *this, int *status ) {
+/*
+*+
+*  Name:
+*     astGetRegFS
+
+*  Purpose:
+*     Obtain a pointer to the FrameSet encapsulated within a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstFrameSet *astGetRegFS( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function
+
+*  Description:
+*     This function returns a pointer to the FrameSet encapsulated by the
+*     Region. This is a clone, not a deep copy, of the pointer stored
+*     in the Region.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     A pointer to the FrameSet.
+
+*  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.
+*-
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Return the required pointer. */
+   return astClone( this->frameset );
+}
+
+static AstPointSet *GetSubMesh( int *mask, AstPointSet *in, int *status ) {
+/*
+*  Name:
+*     GetSubMesh
+
+*  Purpose:
+*     Extract a selection of points from a PointSet.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *GetSubMesh( int *mask, AstPointSet *in, int *status )
+
+*  Class Membership:
+*     Region member function
+
+*  Description:
+*     This function creates a new PointSet holding points selected from a
+*     supplied PointSet. An integer mask is supplied to indicate which
+*     points should be selected.
+
+*  Parameters:
+*     mask
+*        Pointer to a mask array, Its size should be equal to the number
+*        of points in the supplied PointSet. Each corresponding point will
+*        be copied if the mask value is zero.
+*     in
+*        Pointer to the PointSet holding the input positions.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to the output 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.
+*/
+
+/* Local Variables: */
+   AstPointSet *result;          /* Pointer to output PointSet */
+   double **ptr_in;              /* Pointers to input axis values */
+   double **ptr_out;             /* Pointers to output axis values */
+   double *pin;                  /* Pointer to next input axis value */
+   double *pout;                 /* Pointer to next output axis value */
+   int *m;                       /* Pointer to next mask element */
+   int ic;                       /* Axis index */
+   int ip;                       /* Point index */
+   int nc;                       /* Number of axes in both PointSets */
+   int npin;                     /* Number of points in input PointSet */
+   int npout;                    /* Number of points in output PointSet */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get the length of the mask. */
+   npin = astGetNpoint( in );
+
+/* Count the number of zeros in the mask. */
+   npout = 0;
+   m = mask;
+   for( ip = 0; ip < npin; ip++ ) {
+      if( *(m++) == 0 ) npout++;
+   }
+
+/* Create the output PointSet and get pointers to its data arrays. */
+   nc = astGetNcoord( in );
+   result = astPointSet( npout, nc, "", status );
+   ptr_in = astGetPoints( in );
+   ptr_out = astGetPoints( result );
+
+/* Check pointers can be dereferenced safely. */
+   if( astOK ) {
+
+/* Copy the required axis values from the input to the output. */
+      for( ic = 0; ic < nc; ic++ ) {
+         pin = ptr_in[ ic ];
+         pout = ptr_out[ ic ];
+         m = mask;
+         for( ip = 0; ip < npin; ip++, pin++, m++ ) {
+            if( *m == 0 ) *(pout++) = *pin;
+         }
+      }
+   }
+
+/* Return a pointer to the output PointSet. */
+   return result;
+
+}
+
+static AstRegion *GetUnc( AstRegion *this, int def, int *status ){
+/*
+*++
+*  Name:
+c     astGetUnc
+f     AST_GETUNC
+
+*  Purpose:
+*     Obtain uncertainty information from a Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     AstRegion *astGetUnc( AstRegion *this, int def )
+f     RESULT = AST_GETUNC( THIS, DEF, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function returns a Region which represents the uncertainty
+*     associated with positions within the supplied Region. See
+c     astSetUnc
+f     AST_SETUNC
+*     for more information about Region uncertainties and their use.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+c     def
+f     DEF = LOGICAL (Given)
+*        Controls what is returned if no uncertainty information has been
+*        associated explicitly with the supplied Region. If
+c        a non-zero value
+f        .TRUE.
+*        is supplied, then the default uncertainty Region used internally
+*        within AST is returned (see "Applicability" below). If
+c        zero is supplied, then NULL
+f        .FALSE. is supplied, then AST__NULL
+*        will be returned (without error).
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astGetUnc()
+f     AST_GETUNC = INTEGER
+*        A pointer to a Region describing the uncertainty in the supplied
+*        Region.
+
+*  Applicability:
+*     CmpRegion
+*        The default uncertainty for a CmpRegion is taken from one of the
+*        two component Regions. If the first component Region has a
+*        non-default uncertainty, then it is used as the default uncertainty
+*        for the parent CmpRegion. Otherwise, if the second component Region
+*        has a non-default uncertainty, then it is used as the default
+*        uncertainty for the parent CmpRegion. If neither of the
+*        component Regions has non-default uncertainty, then the default
+*        uncertainty for the CmpRegion is 1.0E-6 of the bounding box of
+*        the CmpRegion.
+*     Prism
+*        The default uncertainty for a Prism is formed by combining the
+*        uncertainties from the two component Regions. If a component
+*        Region does not have a non-default uncertainty, then its default
+*        uncertainty will be used to form the default uncertainty of the
+*        parent Prism.
+*     Region
+*        For other classes of Region, the default uncertainty is 1.0E-6
+*        of the bounding box of the Region. If the bounding box has zero
+*        width on any axis, then the uncertainty will be 1.0E-6 of the
+*        axis value.
+
+*  Notes:
+*     - If uncertainty information is associated with a Region, and the
+*     coordinate system described by the Region is subsequently changed
+*     (e.g. by changing the value of its System attribute, or using the
+c     astMapRegion
+f     AST_MAPREGION
+*     function), then the uncertainty information returned by this function
+*     will be modified so that it refers to the coordinate system currently
+*     described by the supplied Region.
+f     - A null Object pointer (AST__NULL) will be returned if this
+f     function is invoked with STATUS set to an error value, or if it
+c     - A null Object pointer (NULL) will be returned if this
+c     function is invoked with the AST error status set, or if it
+*     should fail for any reason.
+
+*--
+*/
+
+/* Local Variables: */
+   AstRegion *result;       /* Pointer to returned uncertainty Region */
+   AstRegion *unc;          /* Pointer to original uncertainty Region */
+
+/* Initialise */
+   result = NULL;
+
+/* Check inherited status */
+   if( !astOK ) return result;
+
+/* Check that we have an uncertainty Region to return (either assigned or
+   default). */
+   if( def || astTestUnc( this ) ) {
+
+/* Obtain the uncertainty Region and take a copy so that we can modify it
+   without affecting the supplied Region. */
+      unc = astGetUncFrm( this, AST__CURRENT );
+      result = astCopy( unc );
+      unc = astAnnul( unc );
+
+/* In its current context, the uncertainty region is known to refer to
+   the Frame of the supplied Region and so its RegionFS attribute will be
+   set to zero, indicating that the uncertainty FrameSet need not be
+   dumped. However, outside of AST this information cannot be implied, so
+   clear the RegionFS attribute so that the returned pointer will include
+   Frame information if it is dumped to a Channel. */
+      astClearRegionFS( result );
+
+   }
+
+/* Return the result. */
+   return result;
+
+}
+
+static AstRegion *GetUncFrm( AstRegion *this, int ifrm, int *status ) {
+/*
+*+
+*  Name:
+*     astGetUncFrm
+
+*  Purpose:
+*     Obtain a pointer to the uncertainty Region for a given Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion *astGetUncFrm( AstRegion *this, int ifrm )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a pointer to a Region which represents the
+*     uncertainty associated with a position on the boundary of the given
+*     Region. The returned Region can refer to the either the base or
+*     the current Frame within the FrameSet encapsulated by the supplied
+*     Region as specified by the "ifrm" parameter. If the returned Region is
+*     re-centred at some point on the boundary of the supplied Region, then
+*     the re-centred Region will represent the region in which the true
+*     boundary position could be.
+
+*  Parameters:
+*     this
+*        Pointer to the 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.
+
+*  Returned Value:
+*     A pointer to the Region. This should be annulled (using astAnnul)
+*     when no longer needed.
+
+*  Notes:
+*     - A default uncertainty Region will be created if the supplied Region
+*     does not have an uncertainty Region.
+*     - 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 supplied Region */
+   AstMapping *map;           /* Supplied to uncertainty Mapping */
+   AstRegion *result;         /* Returned pointer */
+   AstRegion *unc;            /* Base frame uncertainty Region to use */
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* If the Region has an explicitly assigned base-frame uncertainty Region,
+   use it. */
+   if( this->unc ) {
+      unc = this->unc;
+
+/* If not, use the default base-frame uncertainty Region, creating it if
+   necessary. */
+   } else {
+      if( !this->defunc ) this->defunc = astGetDefUnc( this );
+      unc = this->defunc;
+   }
+
+/* If the uncertainty Region is the base Frame is required, just return a
+   clone of the uncertainty Region pointer. The Frame represented by an
+   uncertainty Region will always (barring bugs!) be the base Frame of
+   its parent Region. */
+   if( ifrm == AST__BASE ) {
+      result = astClone( unc );
+
+/* If the uncertainty Region is the current Frame is required... */
+   } else {
+
+/* Get a Mapping from the Frame represented by the uncertainty Region
+   (the Region base Frame) to the Region current Frame. */
+      map = astGetMapping( this->frameset, AST__BASE, AST__CURRENT );
+
+/* If this is a UnitMap, the uncertainty Region is already in the correct
+   Frame, so just return the stored pointer. */
+      if( astIsAUnitMap( map ) ) {
+         result = astClone( unc );
+
+/* Otherwise, use this Mapping to map the uncertainty Region into the current
+   Frame. */
+      } else {
+         frm = astGetFrame( this->frameset, AST__CURRENT );
+         result = astMapRegion( unc, map, frm );
+
+/* Free resources. */
+         frm = astAnnul( frm );
+      }
+
+      map = astAnnul( map );
+   }
+
+/* Return NULL if an error occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the required pointer. */
+   return result;
+}
+
+static int GetUseDefs( AstObject *this_object, int *status ) {
+/*
+*  Name:
+*     GetUseDefs
+
+*  Purpose:
+*     Get the value of the UseDefs attribute for a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int GetUseDefs( AstObject *this_object, int *status ) {
+
+*  Class Membership:
+*     Region member function (over-rides the protected astGetUseDefs
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns the value of the UseDefs attribute for a
+*     Region. supplying a suitable default.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     - The USeDefs value.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   int result;                   /* Value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_object;
+
+/* If the UseDefs value for the Region has been set explicitly, use the
+   Get method inherited from the parent Frame class to get its value. */
+   if( astTestUseDefs( this ) ) {
+      result = (*parent_getusedefs)( this_object, status );
+
+/* Otherwise, supply a default value equal to the UseDefs value of the
+   encapsulated Frame. */
+   } else {
+      fr = astGetFrame( this->frameset, AST__CURRENT );
+      result = astGetUseDefs( fr );
+      fr = astAnnul( fr );
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static int TestUnc( AstRegion *this, int *status ) {
+/*
+*+
+*  Name:
+*     astTestUnc
+
+*  Purpose:
+*     Does the Region contain non-default uncertainty information?
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     int astTestUnc( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a flag indicating if the uncertainty Region in
+*     the supplied Region was supplied explicit (i.e. is not a default
+*     uncertainty Region).
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     Non-zero if the uncertainty Region was supplied explicitly.
+*     Zero otherwise.
+
+*  Notes:
+*     - Classes of Region that encapsulate two or more other Regions
+*     inherit their default uncertainty from the encapsulated Regions.
+*     Non-default uncertainty in the component Regions does not imply
+*     that the parent Region has non-default uncertainty.
+*-
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+   return ( this->unc != NULL );
+}
+
+static AstFrame *RegFrame( AstRegion *this, int *status ) {
+/*
+*+
+*  Name:
+*     astRegFrame
+
+*  Purpose:
+*     Obtain a pointer to the current Frame for a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstFrame *astRegFrame( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function
+
+*  Description:
+*     This function returns a pointer to the current Frame in the encapsulated
+*     FrameSet. This is a clone, not a deep copy, of the pointer stored
+*     in the FrameSet. For a deep copy, use astGetRegionFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     A pointer to the Frame.
+
+*  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.
+*-
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Return the required pointer. */
+   return astGetFrame( this->frameset, AST__CURRENT );
+}
+
+static AstMapping *RegMapping( AstRegion *this, int *status ) {
+/*
+*+
+*  Name:
+*     astRegMapping
+
+*  Purpose:
+*     Obtain a pointer to the simplified base->current Mapping for a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstMapping *astRegMapping( AstRegion *this )
+
+*  Class Membership:
+*     Region member function
+
+*  Description:
+*     This function returns a pointer to the Mapping from the base to the
+*     current Frame int he encapsulated FrameSet. The returned Mapping is
+*     simplified before being returned.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     A pointer to the Mapping.
+
+*  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: */
+   AstMapping *map;           /* Unsimplified Mapping */
+   AstMapping *result;        /* Simplified Mapping */
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* If the "nomap" flag is set in the Region structure, re return a
+   UnitMap. */
+   if( this->nomap ) {
+      result = (AstMapping *) astUnitMap( astGetNin( this->frameset ), "", status );
+
+/* Otherwise use the Mapping from the Region's FrameSet. */
+   } else {
+
+/* Get the Mapping */
+      map = astGetMapping( this->frameset, AST__BASE, AST__CURRENT );
+
+/* Simplify it. */
+      result = astSimplify( map );
+
+/* Annul the pointer to the unsimplified Mapping */
+      map = astAnnul( map );
+   }
+
+/* Return the required pointer. */
+   return result;
+}
+
+static int GetNaxes( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetNaxes
+
+*  Purpose:
+*     Determine how many axes a Region has.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int GetNaxes( AstFrame *this, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astGetNaxes method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function returns the number of axes for a Region. This is equal
+*     to the number of axes in its current Frame.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The number of Region axes (zero or more).
+
+*  Notes:
+*     - A value of zero 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 *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   int result;                   /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's current Frame. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+
+/* Obtain the number of axes in this Frame. */
+   result = astGetNaxes( fr );
+
+/* Annul the current Frame pointer. */
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result. */
+   return result;
+}
+
+static const int *GetPerm( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetPerm
+
+*  Purpose:
+*     Access the axis permutation array for the current Frame of a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     const int *GetPerm( AstFrame *this, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astGetPerm protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the axis permutation array
+*     for the current Frame of a Region. This array constitutes a
+*     lookup-table that converts between an axis number supplied
+*     externally and the corresponding index in the Frame's internal
+*     axis arrays.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to the current Frame's axis permutation array (a
+*     constant array of int).  Each element of this contains the
+*     (zero-based) internal axis index to be used in place of the
+*     external index which is used to address the permutation
+*     array. If the current Frame has zero axes, this pointer will be
+*     NULL.
+
+*  Notes:
+*     - The pointer returned by this function gives direct access to
+*     data internal to the Frame object. It remains valid only so long
+*     as the Frame exists. The permutation array contents may be
+*     modified by other functions which operate on the Frame and this
+*     may render the returned pointer invalid.
+*     - 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 *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to Region structure */
+   const int *result;            /* Result pointer value */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's current Frame and then obtain a
+   pointer to its axis permutation array. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astGetPerm( fr );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+static AstFrame *GetRegionFrame( AstRegion *this, int *status ) {
+/*
+*++
+*  Name:
+c     astGetRegionFrame
+f     AST_GETREGIONFRAME
+
+*  Purpose:
+*     Obtain a pointer to the encapsulated Frame within a Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     AstFrame *astGetRegionFrame( AstRegion *this )
+f     RESULT = AST_GETREGIONFRAME( THIS, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function returns a pointer to the Frame represented by a
+*     Region.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astGetRegionFrame()
+f     AST_GETREGIONFRAME = INTEGER
+*        A pointer to a deep copy of the Frame represented by the Region.
+*        Using this pointer to modify the Frame will have no effect on
+*        the Region. To modify the Region, use the Region pointer directly.
+
+*  Notes:
+*     - A null Object pointer (AST__NULL) will be returned if this
+c     function is invoked with the AST error status set, or if it
+f     function is invoked with STATUS set to an error value, or if it
+*     should fail for any reason.
+*--
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstFrame *result;             /* Pointer value to return */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the current Frame of the encapsulated FrameSet. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+
+/* Take a deep copy of it, and then annul the original pointer. */
+   result = astCopy( fr );
+   fr = astAnnul( fr );
+
+/* If not OK, annul the returned pointer. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+static AstFrameSet *GetRegionFrameSet( AstRegion *this, int *status ) {
+/*
+*++
+*  Name:
+c     astGetRegionFrameSet
+f     AST_GETREGIONFRAMESET
+
+*  Purpose:
+*     Obtain a pointer to the encapsulated FrameSet within a Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     AstFrame *astGetRegionFrameSet( AstRegion *this )
+f     RESULT = AST_GETREGIONFRAMESET( THIS, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function returns a pointer to the FrameSet encapsulated by a
+*     Region. The base Frame is the Frame in which the box was originally
+*     defined, and the current Frame is the Frame into which the Region
+*     is currently mapped (i.e. it will be the same as the Frame returned
+c     by astGetRegionFrame).
+f     by AST_GETREGIONFRAME).
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astGetRegionFrameSet()
+f     AST_GETREGIONFRAMESET = INTEGER
+*        A pointer to a deep copy of the FrameSet represented by the Region.
+*        Using this pointer to modify the FrameSet will have no effect on
+*        the Region.
+
+*  Notes:
+*     - A null Object pointer (AST__NULL) will be returned if this
+c     function is invoked with the AST error status set, or if it
+f     function is invoked with STATUS set to an error value, or if it
+*     should fail for any reason.
+*--
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Return a deep copy of the encapsulated FrameSet. */
+   return astCopy( this->frameset );
+}
+
+void astInitRegionVtab_(  AstRegionVtab *vtab, const char *name, int *status ) {
+/*
+*+
+*  Name:
+*     astInitRegionVtab
+
+*  Purpose:
+*     Initialise a virtual function table for a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astInitRegionVtab( AstRegionVtab *vtab, const char *name )
+
+*  Class Membership:
+*     Region vtab initialiser.
+
+*  Description:
+*     This function initialises the component of a virtual function
+*     table which is used by the Region 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 */
+   AstFrameVtab *frame;          /* Pointer to Frame component of Vtab */
+   AstMappingVtab *mapping;      /* Pointer to Mapping component of Vtab */
+   AstObjectVtab *object;        /* Pointer to Object 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. */
+   astInitFrameVtab( (AstFrameVtab *) vtab, name );
+
+/* Store a unique "magic" value in the virtual function table. This
+   will be used (by astIsARegion) 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 = &(((AstFrameVtab *) vtab)->id);
+
+/* Initialise member function pointers. */
+/* ------------------------------------ */
+
+/* Store pointers to the member functions (implemented here) that
+   provide virtual methods for this class. */
+   vtab->ClearNegated = ClearNegated;
+   vtab->GetNegated = GetNegated;
+   vtab->SetNegated = SetNegated;
+   vtab->TestNegated = TestNegated;
+
+   vtab->ClearRegionFS = ClearRegionFS;
+   vtab->GetRegionFS = GetRegionFS;
+   vtab->SetRegionFS = SetRegionFS;
+   vtab->TestRegionFS = TestRegionFS;
+
+   vtab->ClearClosed = ClearClosed;
+   vtab->GetClosed = GetClosed;
+   vtab->SetClosed = SetClosed;
+   vtab->TestClosed = TestClosed;
+
+   vtab->ClearMeshSize = ClearMeshSize;
+   vtab->GetMeshSize = GetMeshSize;
+   vtab->SetMeshSize = SetMeshSize;
+   vtab->TestMeshSize = TestMeshSize;
+
+   vtab->ClearAdaptive = ClearAdaptive;
+   vtab->GetAdaptive = GetAdaptive;
+   vtab->SetAdaptive = SetAdaptive;
+   vtab->TestAdaptive = TestAdaptive;
+
+   vtab->ClearFillFactor = ClearFillFactor;
+   vtab->GetFillFactor = GetFillFactor;
+   vtab->SetFillFactor = SetFillFactor;
+   vtab->TestFillFactor = TestFillFactor;
+
+   vtab->ResetCache = ResetCache;
+   vtab->RegTrace = RegTrace;
+   vtab->GetBounded = GetBounded;
+   vtab->TestUnc = TestUnc;
+   vtab->ClearUnc = ClearUnc;
+   vtab->GetRegionFrame = GetRegionFrame;
+   vtab->GetRegionFrameSet = GetRegionFrameSet;
+   vtab->MapRegion = MapRegion;
+   vtab->Overlap = Overlap;
+   vtab->OverlapX = OverlapX;
+   vtab->Negate = Negate;
+   vtab->BndMesh = BndMesh;
+   vtab->BndBaseMesh = BndBaseMesh;
+   vtab->RegBaseGrid = RegBaseGrid;
+   vtab->RegBaseMesh = RegBaseMesh;
+   vtab->RegSplit = RegSplit;
+   vtab->RegBaseBox = RegBaseBox;
+   vtab->RegBaseBox2 = RegBaseBox2;
+   vtab->RegBasePick = RegBasePick;
+   vtab->RegCentre = RegCentre;
+   vtab->RegGrid = RegGrid;
+   vtab->RegMesh = RegMesh;
+   vtab->RegClearAttrib = RegClearAttrib;
+   vtab->RegSetAttrib = RegSetAttrib;
+   vtab->GetDefUnc = GetDefUnc;
+   vtab->GetNegation = GetNegation;
+   vtab->GetUncFrm = GetUncFrm;
+   vtab->SetUnc = SetUnc;
+   vtab->GetUnc = GetUnc;
+   vtab->ShowMesh = ShowMesh;
+   vtab->GetRegionBounds = GetRegionBounds;
+   vtab->GetRegionBounds2 = GetRegionBounds2;
+   vtab->GetRegionMesh = GetRegionMesh;
+   vtab->GetRegionPoints = GetRegionPoints;
+   vtab->RegOverlay = RegOverlay;
+   vtab->RegFrame = RegFrame;
+   vtab->RegDummyFS = RegDummyFS;
+   vtab->RegMapping = RegMapping;
+   vtab->RegPins = RegPins;
+   vtab->RegTransform = RegTransform;
+   vtab->BTransform = BTransform;
+   vtab->GetRegFS = GetRegFS;
+   vtab->SetRegFS = SetRegFS;
+   vtab->MaskB = MaskB;
+   vtab->MaskD = MaskD;
+   vtab->MaskF = MaskF;
+   vtab->MaskI = MaskI;
+   vtab->MaskL = MaskL;
+   vtab->MaskS = MaskS;
+   vtab->MaskUB = MaskUB;
+   vtab->MaskUI = MaskUI;
+   vtab->MaskUL = MaskUL;
+   vtab->MaskUS = MaskUS;
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+   vtab->MaskLD = MaskLD;
+#endif
+
+/* Save the inherited pointers to methods that will be extended, and store
+   replacement pointers for methods which will be over-ridden by new member
+   functions implemented here. */
+   object = (AstObjectVtab *) vtab;
+   mapping = (AstMappingVtab *) vtab;
+   frame = (AstFrameVtab *) vtab;
+
+   parent_getobjsize = object->GetObjSize;
+   object->GetObjSize = GetObjSize;
+
+   parent_getusedefs = object->GetUseDefs;
+   object->GetUseDefs = GetUseDefs;
+
+#if defined(THREAD_SAFE)
+   parent_managelock = object->ManageLock;
+   object->ManageLock = ManageLock;
+#endif
+
+   object->Cast = Cast;
+   object->Equal = Equal;
+   object->ClearAttrib = ClearAttrib;
+   object->GetAttrib = GetAttrib;
+   object->SetAttrib = SetAttrib;
+   object->TestAttrib = TestAttrib;
+
+   mapping->ReportPoints = ReportPoints;
+   mapping->RemoveRegions = RemoveRegions;
+   mapping->Simplify = Simplify;
+
+   frame->Abbrev = Abbrev;
+   frame->Angle = Angle;
+   frame->AxAngle = AxAngle;
+   frame->AxDistance = AxDistance;
+   frame->AxNorm = AxNorm;
+   frame->AxOffset = AxOffset;
+   frame->CheckPerm = CheckPerm;
+   frame->ClearDigits = ClearDigits;
+   frame->ClearDirection = ClearDirection;
+   frame->ClearDomain = ClearDomain;
+   frame->ClearFormat = ClearFormat;
+   frame->ClearLabel = ClearLabel;
+   frame->ClearMatchEnd = ClearMatchEnd;
+   frame->ClearMaxAxes = ClearMaxAxes;
+   frame->ClearMinAxes = ClearMinAxes;
+   frame->ClearPermute = ClearPermute;
+   frame->ClearPreserveAxes = ClearPreserveAxes;
+   frame->ClearSymbol = ClearSymbol;
+   frame->ClearTitle = ClearTitle;
+   frame->ClearUnit = ClearUnit;
+   frame->Convert = Convert;
+   frame->ConvertX = ConvertX;
+   frame->Distance = Distance;
+   frame->FindFrame = FindFrame;
+   frame->Format = Format;
+   frame->Centre = Centre;
+   frame->Gap = Gap;
+   frame->GetAxis = GetAxis;
+   frame->GetDigits = GetDigits;
+   frame->GetDirection = GetDirection;
+   frame->GetDomain = GetDomain;
+   frame->GetFormat = GetFormat;
+   frame->GetLabel = GetLabel;
+   frame->GetMatchEnd = GetMatchEnd;
+   frame->GetMaxAxes = GetMaxAxes;
+   frame->GetMinAxes = GetMinAxes;
+   frame->GetNaxes = GetNaxes;
+   frame->GetPerm = GetPerm;
+   frame->GetPermute = GetPermute;
+   frame->GetPreserveAxes = GetPreserveAxes;
+   frame->GetSymbol = GetSymbol;
+   frame->GetTitle = GetTitle;
+   frame->GetUnit = GetUnit;
+   frame->Intersect = Intersect;
+   frame->IsUnitFrame = IsUnitFrame;
+   frame->Match = Match;
+   frame->Norm = Norm;
+   frame->NormBox = NormBox;
+   frame->Offset = Offset;
+   frame->Offset2 = Offset2;
+   frame->Overlay = Overlay;
+   frame->PermAxes = PermAxes;
+   frame->PickAxes = PickAxes;
+   frame->Resolve = Resolve;
+   frame->ResolvePoints = ResolvePoints;
+   frame->SetAxis = SetAxis;
+   frame->SetDigits = SetDigits;
+   frame->SetDirection = SetDirection;
+   frame->SetDomain = SetDomain;
+   frame->SetFormat = SetFormat;
+   frame->SetLabel = SetLabel;
+   frame->SetMatchEnd = SetMatchEnd;
+   frame->SetMaxAxes = SetMaxAxes;
+   frame->SetMinAxes = SetMinAxes;
+   frame->SetPermute = SetPermute;
+   frame->SetPreserveAxes = SetPreserveAxes;
+   frame->SetSymbol = SetSymbol;
+   frame->SetTitle = SetTitle;
+   frame->SetUnit = SetUnit;
+   frame->SubFrame = SubFrame;
+   frame->SystemCode = SystemCode;
+   frame->SystemString = SystemString;
+   frame->TestDigits = TestDigits;
+   frame->TestDirection = TestDirection;
+   frame->TestDomain = TestDomain;
+   frame->TestFormat = TestFormat;
+   frame->TestLabel = TestLabel;
+   frame->TestMatchEnd = TestMatchEnd;
+   frame->TestMaxAxes = TestMaxAxes;
+   frame->TestMinAxes = TestMinAxes;
+   frame->TestPermute = TestPermute;
+   frame->TestPreserveAxes = TestPreserveAxes;
+   frame->TestSymbol = TestSymbol;
+   frame->TestTitle = TestTitle;
+   frame->TestUnit = TestUnit;
+   frame->Unformat = Unformat;
+   frame->ValidateAxis = ValidateAxis;
+   frame->ValidateAxisSelection = ValidateAxisSelection;
+   frame->ValidateSystem = ValidateSystem;
+   frame->LineDef = LineDef;
+   frame->LineContains = LineContains;
+   frame->LineCrossing = LineCrossing;
+   frame->LineOffset = LineOffset;
+   frame->MatchAxes = MatchAxes;
+   frame->MatchAxesX = MatchAxesX;
+
+   frame->GetActiveUnit = GetActiveUnit;
+   frame->SetActiveUnit = SetActiveUnit;
+   frame->TestActiveUnit = TestActiveUnit;
+
+   frame->GetTop = GetTop;
+   frame->SetTop = SetTop;
+   frame->TestTop = TestTop;
+   frame->ClearTop = ClearTop;
+
+   frame->GetBottom = GetBottom;
+   frame->SetBottom = SetBottom;
+   frame->TestBottom = TestBottom;
+   frame->ClearBottom = ClearBottom;
+
+   frame->GetEpoch = GetEpoch;
+   frame->SetEpoch = SetEpoch;
+   frame->TestEpoch = TestEpoch;
+   frame->ClearEpoch = ClearEpoch;
+
+   frame->ClearObsAlt = ClearObsAlt;
+   frame->TestObsAlt = TestObsAlt;
+   frame->GetObsAlt = GetObsAlt;
+   frame->SetObsAlt = SetObsAlt;
+
+   frame->ClearObsLat = ClearObsLat;
+   frame->TestObsLat = TestObsLat;
+   frame->GetObsLat = GetObsLat;
+   frame->SetObsLat = SetObsLat;
+
+   frame->ClearObsLon = ClearObsLon;
+   frame->TestObsLon = TestObsLon;
+   frame->GetObsLon = GetObsLon;
+   frame->SetObsLon = SetObsLon;
+
+   frame->GetSystem = GetSystem;
+   frame->SetSystem = SetSystem;
+   frame->TestSystem = TestSystem;
+   frame->ClearSystem = ClearSystem;
+
+   frame->GetAlignSystem = GetAlignSystem;
+   frame->SetAlignSystem = SetAlignSystem;
+   frame->TestAlignSystem = TestAlignSystem;
+   frame->ClearAlignSystem = ClearAlignSystem;
+
+/* Declare the copy constructor, destructor and class dump
+   functions. */
+   astSetDelete( vtab, Delete );
+   astSetCopy( vtab, Copy );
+   astSetDump( vtab, Dump, "Region",
+               "An area within a coordinate system" );
+
+/* If we have just initialised the vtab for the current class, indicate
+   that the vtab is now initialised, and store a pointer to the class
+   identifier in the base "object" level of the vtab. */
+   if( vtab == &class_vtab ) {
+      class_init = 1;
+      astSetVtabClassIdentifier( vtab, &(vtab->id) );
+   }
+}
+
+static void Intersect( AstFrame *this_frame, const double a1[2],
+                       const double a2[2], const double b1[2],
+                       const double b2[2], double cross[2],
+                       int *status ) {
+/*
+*  Name:
+*     Intersect
+
+*  Purpose:
+*     Find the point of intersection between two geodesic curves.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void Intersect( AstFrame *this_frame, const double a1[2],
+*                      const double a2[2], const double b1[2],
+*                      const double b2[2], double cross[2],
+*                      int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astIntersect method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function finds the coordinate values at the point of
+*     intersection between two geodesic curves. Each curve is specified
+*     by two points on the curve.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     a1
+*        An array of double, with one element for each Frame axis.
+*        This should contain the coordinates of a point on the first
+*        geodesic curve.
+*     a2
+*        An array of double, with one element for each Frame axis.
+*        This should contain the coordinates of a second point on the
+*        first geodesic curve.
+*     b1
+*        An array of double, with one element for each Frame axis.
+*        This should contain the coordinates of a point on the second
+*        geodesic curve.
+*     b2
+*        An array of double, with one element for each Frame axis.
+*        This should contain the coordinates of a second point on
+*        the second geodesic curve.
+*     cross
+*        An array of double, with one element for each Frame axis
+*        in which the coordinates of the required intersection
+*        point will be returned. These will be AST__BAD if the curves do
+*        not intersect.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - The geodesic curve used by this function is the path of
+*     shortest distance between two points, as defined by the
+*     astDistance function.
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value.
+*     - For SkyFrames each curve will be a great circle, and in general
+*     each pair of curves will intersect at two diametrically opposite
+*     points on the sky. The returned position is the one which is
+*     closest to point "a1".
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke the
+   astIntersect method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astIntersect( fr, a1, a2, b1, b2, cross );
+   fr = astAnnul( fr );
+}
+
+static int IsUnitFrame( AstFrame *this, int *status ){
+/*
+*  Name:
+*     IsUnitFrame
+
+*  Purpose:
+*     Is this Frame equivalent to a UnitMap?
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int IsUnitFrame( AstFrame *this, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astIsUnitFrame
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a flag indicating if the supplied Frame is
+*     equivalent to a UnitMap when treated as a Mapping (note, the Frame
+*     class inherits from Mapping and therefore every Frame is also a Mapping).
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if the supplied Frame is equivalent to
+*     a UnitMap when treated as a Mapping.
+
+*-
+*/
+
+/* Check the global error status. */
+   if( !astOK ) return 0;
+
+/* The Region class is never equivalent to a UnitMap. */
+   return 0;
+}
+
+static int LineContains( AstFrame *this_frame, AstLineDef *l, int def, double *point, int *status ) {
+/*
+*  Name:
+*     LineContains
+
+*  Purpose:
+*     Determine if a line contains a point.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int LineContains( AstFrame *this, AstLineDef *l, int def, double *point, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astLineContains
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function determines if the supplied point is on the supplied
+*     line within the supplied Frame. The start point of the line is
+*     considered to be within the line, but the end point is not. The tests
+*     are that the point of closest approach of the line to the point should
+*     be between the start and end, and that the distance from the point to
+*     the point of closest aproach should be less than 1.0E-7 of the length
+*     of the line.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     l
+*        Pointer to the structure defining the line.
+*     def
+*        Should be set non-zero if the "point" array was created by a
+*        call to astLineCrossing (in which case it may contain extra
+*        information following the axis values),and zero otherwise.
+*     point
+*        Point to an array containing the axis values of the point to be
+*        tested, possibly followed by extra cached information (see "def").
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if the line contains the point.
+
+*  Notes:
+*     - The pointer supplied for "l" should have been created using the
+*     astLineDef method. These structures contained cached information about
+*     the lines which improve the efficiency of this method when many
+*     repeated calls are made. An error will be reported if the structure
+*     does not refer to the Frame specified by "this".
+*     - Zero 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 *fr;                 /* Pointer to current Frame */
+   int result;                   /* Returned value */
+
+/* Initialise */
+   result =0;
+
+/* Obtain a pointer to the Region's current Frame and then invoke the
+   method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT );
+   result = astLineContains( fr, l, def, point );
+   fr = astAnnul( fr );
+
+/* Return the result. */
+   return result;
+}
+
+static int LineCrossing( AstFrame *this_frame, AstLineDef *l1, AstLineDef *l2,
+                         double **cross, int *status ) {
+/*
+*  Name:
+*     LineCrossing
+
+*  Purpose:
+*     Determine if two lines cross.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int LineCrossing( AstFrame *this, AstLineDef *l1, AstLineDef *l2,
+*                       double **cross, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astLineCrossing
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function determines if the two suplied line segments cross,
+*     and if so returns the axis values at the point where they cross.
+*     A flag is also returned indicating if the crossing point occurs
+*     within the length of both line segments, or outside one or both of
+*     the line segments.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     l1
+*        Pointer to the structure defining the first line.
+*     l2
+*        Pointer to the structure defining the second line.
+*     cross
+*        Pointer to a location at which to put a pointer to a dynamically
+*        alocated array containing the axis values at the crossing. If
+*        NULL is supplied no such array is returned. Otherwise, the returned
+*        array should be freed using astFree when no longer needed. If the
+*        lines are parallel (i.e. do not cross) then AST__BAD is returned for
+*        all axis values. Note usable axis values are returned even if the
+*        lines cross outside the segment defined by the start and end points
+*        of the lines. The order of axes in the returned array will take
+*        account of the current axis permutation array if appropriate. Note,
+*        sub-classes such as SkyFrame may append extra values to the end
+*        of the basic frame axis values. A NULL pointer is returned if an
+*        error occurs.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if the lines cross at a point which is
+*     within the [start,end) segment of both lines. If the crossing point
+*     is outside this segment on either line, or if the lines are parallel,
+*     zero is returned. Note, the start point is considered to be inside
+*     the length of the segment, but the end point is outside.
+
+*  Notes:
+*     - The pointers supplied for "l1" and "l2" should have been created
+*     using the astLineDef method. These structures contained cached
+*     information about the lines which improve the efficiency of this method
+*     when many repeated calls are made. An error will be reported if
+*     either structure does not refer to the Frame specified by "this".
+*     - Zero 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 *fr;                 /* Pointer to current Frame */
+   int result;                   /* Returned value */
+
+/* Initialise */
+   result =0;
+
+/* Obtain a pointer to the Region's current Frame and then invoke the
+   method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT );
+   result = astLineCrossing( fr, l1, l2, cross );
+   fr = astAnnul( fr );
+
+/* Return the result. */
+   return result;
+}
+
+static AstLineDef *LineDef( AstFrame *this_frame, const double start[2],
+                            const double end[2], int *status ) {
+/*
+*  Name:
+*     LineDef
+
+*  Purpose:
+*     Creates a structure describing a line segment in a 2D Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstLineDef *LineDef( AstFrame *this, const double start[2],
+*                             const double end[2], int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astLineDef
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function creates a structure containing information describing a
+*     given line segment within the supplied 2D Frame. This may include
+*     information which allows other methods such as astLineCrossing to
+*     function more efficiently. Thus the returned structure acts as a
+*     cache to store intermediate values used by these other methods.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame. Must have 2 axes.
+*     start
+*        An array of 2 doubles marking the start of the line segment.
+*     end
+*        An array of 2 doubles marking the end of the line segment.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to the memory structure containing the description of the
+*     line. This structure should be freed using astFree when no longer
+*     needed. A NULL pointer is returned (without error) if any of the
+*     supplied axis values are AST__BAD.
+
+*  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 *fr;                 /* Pointer to current Frame */
+   AstLineDef *result;           /* Returned value */
+
+/* Initialise */
+   result = NULL;
+
+/* Obtain a pointer to the Region's current Frame and then invoke the
+   method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT );
+   result = astLineDef( fr, start, end );
+   fr = astAnnul( fr );
+
+/* Return the result. */
+   return result;
+}
+
+static void LineOffset( AstFrame *this_frame, AstLineDef *line, double par,
+                        double prp, double point[2], int *status ){
+/*
+*  Name:
+*     LineOffset
+
+*  Purpose:
+*     Find a position close to a line.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void LineOffset( AstFrame *this, AstLineDef *line, double par,
+*                      double prp, double point[2], int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astLineOffset
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a position formed by moving a given distance along
+*     the supplied line, and then a given distance away from the supplied line.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     line
+*        Pointer to the structure defining the line.
+*     par
+*        The distance to move along the line from the start towards the end.
+*     prp
+*        The distance to move at right angles to the line. Positive
+*        values result in movement to the left of the line, as seen from
+*        the observer, when moving from start towards the end.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - The pointer supplied for "line" should have been created using the
+*     astLineDef method. This structure contains cached information about the
+*     line which improves the efficiency of this method when many repeated
+*     calls are made. An error will be reported if the structure does not
+*     refer to the Frame specified by "this".
+*/
+
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+
+/* Obtain a pointer to the Region's current Frame and then invoke the
+   method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT );
+   astLineOffset( fr, line, par, prp, point );
+   fr = astAnnul( fr );
+}
+
+
+#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:
+*     Region 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: */
+   AstRegion *this;       /* Pointer to Region 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 Region structure. */
+   this = (AstRegion *) 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->frameset, mode, extra, fail );
+   if( !result ) result = astManageLock( this->points, mode, extra, fail );
+   if( !result ) result = astManageLock( this->unc, mode, extra, fail );
+   if( !result ) result = astManageLock( this->negation, mode, extra, fail );
+   if( !result ) result = astManageLock( this->defunc, mode, extra, fail );
+   if( !result ) result = astManageLock( this->basemesh, mode, extra, fail );
+   if( !result ) result = astManageLock( this->basegrid, mode, extra, fail );
+
+   return result;
+
+}
+#endif
+
+static AstRegion *MapRegion( AstRegion *this, AstMapping *map0,
+                             AstFrame *frame0, int *status ) {
+/*
+*+
+*  Name:
+*     astMapRegion
+
+*  Purpose:
+*     Transform a Region into a new Frame using a given Mapping.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion *astMapRegion( AstRegion *this, AstMapping *map,
+*                              AstFrame *frame )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function returns a pointer to a new Region which corresponds to
+*     supplied Region in some other specified coordinate system. A
+*     Mapping is supplied which transforms positions between the old and new
+*     coordinate systems. The new Region may not be of the same class as
+*     the original region.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     map
+*        Pointer to a Mapping which transforms positions from the
+*        coordinate system represented by the supplied Region to the
+*        coordinate system specified by "frame". The supplied Mapping should
+*        define both forward and inverse transformations, and these
+*        transformations should form a genuine inverse pair. That is,
+*        transforming a position using the forward transformation and then
+*        using the inverse transformation should produce the original input
+*        position. Some Mapping classes (such as PermMap, MathMap, SphMap)
+*        can result in Mappings for which this is not true.
+*     frame
+*        Pointer to a Frame describing the coordinate system in which
+*        the new Region is required.
+
+*  Returned Value:
+*     astMapRegion()
+*        A pointer to a new Region. This Region will represent the area
+*        within the coordinate system specified by "frame" which corresponds
+*        to the supplied Region.
+
+*  Notes:
+*     - This is the protected implementation of this function - it does
+*     not simplify the returned Region. The public implementation is
+*     astMapRegionID, which simplifies the returned Region.
+*     - A null Object pointer (AST__NULL) will be returned if this
+*     function is invoked with the AST error status set, or if it
+*     should fail for any reason.
+*-
+*/
+
+/* Local Variables: */
+   AstFrame *frame;
+   AstFrameSet *fs;
+   AstMapping *tmap;
+   AstMapping *usemap;
+   AstMapping *map;
+   AstPointSet *ps1;
+   AstPointSet *pst;
+   AstPointSet *ps2;
+   AstRegion *usethis;
+   AstRegion *result;
+   double **ptr1;
+   double **ptr2;
+   int *axflags;
+   int *inax;
+   int *keep;
+   int *outax;
+   int i;
+   int icurr;
+   int j;
+   int nax1;
+   int nkept;
+   int nnew;
+   int nold;
+   int np;
+   int ntotal;
+   int ok;
+
+/* Initialise returned value. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Initialise local variables */
+   axflags = NULL;
+
+/* If a FrameSet was supplied for the Mapping, use the base->current
+   Mapping */
+   if( astIsAFrameSet( map0 ) ) {
+      map = astGetMapping( (AstFrameSet *) map0, AST__BASE, AST__CURRENT );
+   } else {
+      map = astClone( map0 );
+   }
+
+/* If a FrameSet was supplied for the Frame, use the current Frame. */
+   if( astIsAFrameSet( frame0 ) ) {
+      frame = astGetFrame( (AstFrameSet *) frame0, AST__CURRENT );
+   } else {
+      frame = astClone( frame0 );
+   }
+
+/* First check the Mapping is suitable. It must defined both a forward
+   and an inverse Mapping. */
+   if( !astGetTranInverse( map ) ) {
+      astError( AST__NODEF, "astMapRegion(%s): The supplied %s does not "
+                "define an inverse transformation.", status, astGetClass( this ),
+                astGetClass( map ) );
+   } else if( !astGetTranForward( map ) ) {
+      astError( AST__NODEF, "astMapRegion(%s): The supplied %s does not "
+                "define a forward transformation.", status, astGetClass( this ),
+                astGetClass( map ) );
+   }
+
+
+/* Get the number of axes in the supplied Region. */
+   nold = astGetNaxes( this );
+
+/* Get the number of axes in the returned Region. */
+   nnew = astGetNaxes( frame );
+
+/* The forward transformation must not introduce any bad axis values. We
+   can only perform this test reliably if the supplied Region has no bad
+   axis values. */
+   ps1 = this->points;
+   if( ps1 ) {
+      nax1 = astGetNcoord( ps1 );
+      np = astGetNpoint( ps1 );
+      ptr1 = astGetPoints( ps1 );
+      if( ptr1 ) {
+
+/* Check the axis values defining the Region are good. */
+         ok = 1;
+         for( i = 0; i < nax1 && ok; i++ ){
+            for( j = 0; j < np; j++ ) {
+               if( ptr1[ i ][ j ] == AST__BAD ){
+                  ok = 0;
+                  break;
+               }
+            }
+         }
+         if( ok ) {
+
+/* Transform the points defining the supplied Region into the current Frame
+   of the Region. */
+            pst = astRegTransform( this, ps1, 1, NULL, NULL );
+
+/* The use the supplied Mapping to transfom them into the new Frame. */
+            ps2 = astTransform( map, pst, 1, NULL );
+
+/* Test if any of these axis values are bad. */
+            ptr2 = astGetPoints( ps2 );
+            if( ptr2 ) {
+               for( i = 0; i < nnew && ok; i++ ){
+                  for( j = 0; j < np; j++ ) {
+                     if( ptr2[ i ][ j ] == AST__BAD ){
+                        ok = 0;
+                        break;
+                     }
+                  }
+               }
+               if( !ok ) {
+                  astError( AST__NODEF, "astMapRegion(%s): The region which "
+                            "results from using the supplied %s to transform "
+                            "the supplied %s is undefined.", status, astGetClass( this ),
+                            astGetClass( map ), astGetClass( this ) );
+
+/* If all axis values are good, use the inverse transformation of the
+   supplied Mapping to transform them back to the Frame of the supplied
+   Region. */
+               } else {
+                  pst = astAnnul( pst );
+                  pst = astTransform( map, ps2, 0, NULL );
+
+/* Get a flag for each input of the supplied Mapping (i.e. each axis of
+   the supplied Region) which is non-zero if the inverse transformation
+   of the Mapping has produced any good axis values. */
+                  ptr1 = astGetPoints( pst );
+                  axflags = astCalloc( nold, sizeof(int) );
+                  if( astOK ) {
+                     for( i = 0; i < nold; i++ ){
+                        for( j = 0; j < np; j++ ) {
+                           if( ptr1[ i ][ j ] != AST__BAD ){
+                              axflags[ i ] = 1;
+                              break;
+                           }
+                        }
+                     }
+                  }
+               }
+            }
+            ps2 = astAnnul( ps2 );
+            pst = astAnnul( pst );
+         }
+      }
+   }
+
+/* Assume we will be using the supplied Region (this) and Mapping (map). */
+   usethis = astClone( this );
+   usemap = astClone( map );
+
+/* If the new Frame for the Region has fewer axes than the old Frame, see
+   if we can discard some base-frame axes. We only do this if the inverse
+   transformation would otherwise supply bad values for the unused axes.
+   Using bad axis values is not a good idea as some operations cannot be
+   performed if any bad values are supplied. Also having more axes than
+   needed is bad as it results in fewer mesh points per axis. */
+   if( nnew < nold ) {
+
+/* First invert the Mapping since astMapSplit only allows selection of
+   inputs, and we want to select outputs. */
+      astInvert( map );
+
+/* Create an array holding the indices of the required inputs. */
+      inax = astMalloc( nnew*sizeof(int) );
+      if( astOK ) for( i = 0; i < nnew; i++ ) inax[i] = i;
+
+/* Attempt to split the mapping to extract a new mapping that omits any
+   unnecessary outputs (i.e. outputs that are indepenent of the selected
+   inputs). Check the Mapping was split successfully. */
+      outax = astMapSplit( map, nnew, inax, &tmap );
+      if( outax ) {
+
+/* Get the number of old axes that have been retained in the Mapping. */
+         nkept = astGetNout( tmap );
+
+/* Now we need to ensure that any unused axes for which the Mapping
+   creates non-bad values are retained (such values are significant
+   since they may determine whether the new Region is null or not).
+   We only need to do this if any of the outputs that were split off
+   above have been found to generate good values, as indicated by the
+   "axflags" array. Count the number of extra axes that need to be kept,
+   over and above those that are kept by the Mapping returned by
+   astMapSplit above. */
+         ntotal = 0;
+         keep = NULL;
+         if( axflags ) {
+            keep = astMalloc( nold*sizeof(int) );
+            if( astOK ) {
+
+/* Loop round each axis in the supplied Region. */
+               for( i = 0; i < nold; i++ ) {
+
+/* Search the "outax" array to see if this axis was retained by astMapSplit.
+   If it was, append its index to the total list of axes to keep. */
+                  ok = 0;
+                  for( j = 0; j < nkept; j++ ) {
+                     if( outax[ j ] == i ) {
+                        keep[ ntotal++ ] = i;
+                        ok = 1;
+                        break;
+                     }
+                  }
+
+/* If the axis was not retained by astMapSplit, but generates good axis
+   values, also append its index to the total list of axes to keep. */
+                  if( !ok && axflags[ i ] ) {
+                     keep[ ntotal++ ] = i;
+                  }
+               }
+            }
+         }
+
+/* If there are no extra axes to keep, then the Mapping returned by
+   astMapSplit above can be used as it is. */
+         if( ntotal == nkept ) {
+
+/* The values in the "outax" array will hold the zero-based indices of
+   the original old axes that are retained by the new Mapping. We need to
+   create a copy of the supplied Region that includes only these axes. */
+            usethis = astAnnul( usethis );
+            usethis = astPickAxes( this, nkept, outax, NULL );
+
+/* Use the temportary Mapping returned by astMapSplit in place of the
+   supplied Mapping (remember to invert to undo the inversion performed
+   above). */
+            usemap = astAnnul( usemap );
+            usemap = astClone( tmap );
+            astInvert( usemap );
+
+/* Free temporary resources. */
+            tmap = astAnnul( tmap );
+            outax = astFree( outax );
+
+/* If we need to retain some extra axes because they generate good values
+   (even though they are independent of the new Frame axes)... */
+         } else if( ntotal > nkept ){
+
+/* We know the old Frame axes that we want to keep, so use astMapSplit
+   in the opposite direction - i.e. use it on the Mapping form old to
+   new.  */
+            astInvert( map );
+
+            tmap = astAnnul( tmap );
+            outax = astFree( outax );
+
+            outax = astMapSplit( map, ntotal, keep, &tmap );
+            if( outax ) {
+
+               usethis = astAnnul( usethis );
+               usethis = astPickAxes( this, ntotal, keep, NULL );
+
+               usemap = astAnnul( usemap );
+               usemap = astClone( tmap );
+
+               tmap = astAnnul( tmap );
+               outax = astFree( outax );
+
+            }
+
+            astInvert( map );
+         }
+         keep = astFree( keep );
+      }
+      inax = astFree( inax );
+
+/* Invert the Mapping again to bring it back to its original state. */
+      astInvert( map );
+   }
+
+/* Take a deep copy of the supplied Region. */
+   result = astCopy( usethis );
+
+/* Get a pointer to the encapsulated FrameSet. */
+   if( astOK ) {
+      fs = result->frameset;
+
+/* Add in the new Frame and Mapping. First note the index of the original
+   current Frame. */
+      icurr = astGetCurrent( fs );
+      astAddFrame( fs, AST__CURRENT, usemap, frame );
+
+/* Remove the original current Frame. */
+      astRemoveFrame( fs, icurr );
+
+/* The base and current Frames of the resulting FrameSet are now (in
+   general) different and so the Region should include its FrameSet in any
+   Dump. */
+      astSetRegionFS( result, 1 );
+   }
+
+/* Since the Mapping has been changed, any cached information calculated
+   on the basis of the Mapping properties may no longer be up to date. */
+   astResetCache( result );
+
+/* Free resources */
+   usemap = astAnnul( usemap );
+   usethis = astAnnul( usethis );
+   map = astAnnul( map );
+   frame = astAnnul( frame );
+   axflags = astFree( axflags );
+
+/* If not OK, annul the returned pointer. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+/*
+*++
+*  Name:
+c     astMask<X>
+f     AST_MASK<X>
+
+*  Purpose:
+*     Mask a region of a data grid.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     int astMask<X>( AstRegion *this, AstMapping *map, int inside, int ndim,
+c                     const int lbnd[], const int ubnd[], <Xtype> in[],
+c                     <Xtype> val )
+f     RESULT = AST_MASK<X>( THIS, MAP, INSIDE, NDIM, LBND, UBND, IN, VAL,
+f                           STATUS )
+
+*  Class Membership:
+*     Mapping method.
+
+*  Description:
+*     This is a set of functions for masking out regions within gridded data
+*     (e.g. an image). The functions modifies a given data grid by
+*     assigning a specified value to all samples which are inside (or outside
+c     if "inside" is zero)
+f     if INSIDE is .FALSE.)
+*     the specified Region.
+*
+*     You should use a masking function which matches the numerical
+*     type of the data you are processing by replacing <X> in
+c     the generic function name astMask<X> by an appropriate 1- or
+f     the generic function name AST_MASK<X> by an appropriate 1- or
+*     2-character type code. For example, if you are masking data
+c     with type "float", you should use the function astMaskF (see
+f     with type REAL, you should use the function AST_MASKR (see
+*     the "Data Type Codes" section below for the codes appropriate to
+*     other numerical types).
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to a Region.
+c     map
+f     MAP = INTEGER (Given)
+*        Pointer to a Mapping. The forward transformation should map
+*        positions in the coordinate system of the supplied Region
+*        into pixel coordinates as defined by the
+c        "lbnd" and "ubnd" parameters. A NULL pointer
+f        LBND and UBND arguments. A value of AST__NULL
+*        can be supplied if the coordinate system of the supplied Region
+*        corresponds to pixel coordinates. This is equivalent to
+*        supplying a UnitMap.
+*
+*        The number of inputs for this Mapping (as given by its Nin attribute)
+*        should match the number of axes in the supplied Region (as given
+*        by the Naxes attribute of the Region).
+*        The number of outputs for the Mapping (as given by its Nout attribute)
+*        should match the number of
+c        grid dimensions given by the value of "ndim"
+f        grid dimensions given by the value of NDIM
+*        below.
+c     inside
+f     INSIDE = INTEGER (Given)
+*        A boolean value which indicates which pixel are to be masked. If
+c        a non-zero value
+f        .TRUE.
+*        is supplied, then all grid pixels with centres inside the supplied
+*        Region are assigned the value given by
+c        "val",
+f        VAL,
+*        and all other pixels are left unchanged. If
+c        zero
+f        .FALSE.
+*        is supplied, then all grid pixels with centres not inside the supplied
+*        Region are assigned the value given by
+c        "val",
+f        VAL,
+*        and all other pixels are left unchanged. Note, the Negated
+*        attribute of the Region is used to determine which pixel are
+*        inside the Region and which are outside. So the inside of a Region
+*        which has not been negated is the same as the outside of the
+*        corresponding negated Region.
+*
+*        For types of Region such as PointList which have zero volume,
+*        pixel centres will rarely fall exactly within the Region. For
+*        this reason, the inclusion criterion is changed for zero-volume
+*        Regions so that pixels are included (or excluded) if any part of
+*        the Region passes through the pixel. For a PointList, this means
+*        that pixels are included (or excluded) if they contain at least
+*        one of the points listed in the PointList.
+c     ndim
+f     NDIM = INTEGER (Given)
+*        The number of dimensions in the input grid. This should be at
+*        least one.
+c     lbnd
+f     LBND( NDIM ) = INTEGER (Given)
+c        Pointer to an array of integers, with "ndim" elements,
+f        An array
+*        containing the coordinates of the centre of the first pixel
+*        in the input grid along each dimension.
+c     ubnd
+f     UBND( NDIM ) = INTEGER (Given)
+c        Pointer to an array of integers, with "ndim" elements,
+f        An array
+*        containing the coordinates of the centre of the last pixel in
+*        the input grid along each dimension.
+*
+c        Note that "lbnd" and "ubnd" together define the shape
+f        Note that LBND and UBND together define the shape
+*        and size of the input grid, its extent along a particular
+c        (j'th) dimension being ubnd[j]-lbnd[j]+1 (assuming the
+c        index "j" to be zero-based). They also define
+f        (J'th) dimension being UBND(J)-LBND(J)+1. They also define
+*        the input grid's coordinate system, each pixel having unit
+*        extent along each dimension with integral coordinate values
+*        at its centre.
+c     in
+f     IN( * ) = <Xtype> (Given and Returned)
+c        Pointer to an array, with one element for each pixel in the
+f        An array, with one element for each pixel in the
+*        input grid, containing the data to be masked.  The
+*        numerical type of this array should match the 1- or
+*        2-character type code appended to the function name (e.g. if
+c        you are using astMaskF, the type of each array element
+c        should be "float").
+f        you are using AST_MASKR, the type of each array element
+f        should be REAL).
+*
+*        The storage order of data within this array should be such
+*        that the index of the first grid dimension varies most
+*        rapidly and that of the final dimension least rapidly
+c        (i.e. Fortran array indexing is used).
+f        (i.e. normal Fortran array storage order).
+*
+*        On exit, the samples specified by
+c        "inside" are set to the value of "val".
+f        INSIDE are set to the value of VAL.
+*        All other samples are left unchanged.
+c     val
+f     VAL = <Xtype> (Given)
+*        This argument should have the same type as the elements of
+c        the "in" array. It specifies the value used to flag the
+f        the IN array. It specifies the value used to flag the
+*        masked data (see
+c        "inside").
+f        INSIDE).
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astMask<X>()
+f     AST_MASK<X> = INTEGER
+*        The number of pixels to which a value of
+c        "badval"
+f        BADVAL
+*        has been assigned.
+
+*  Notes:
+*     - A value of zero will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*     - An error will be reported if the overlap of the Region and
+*     the array cannot be determined.
+
+*  Data Type Codes:
+*     To select the appropriate masking function, you should
+c     replace <X> in the generic function name astMask<X> with a
+f     replace <X> in the generic function name AST_MASK<X> with a
+*     1- or 2-character data type code, so as to match the numerical
+*     type <Xtype> of the data you are processing, as follows:
+c     - D: double
+c     - F: float
+c     - L: long int
+c     - UL: unsigned long int
+c     - I: int
+c     - UI: unsigned int
+c     - S: short int
+c     - US: unsigned short int
+c     - B: byte (signed char)
+c     - UB: unsigned byte (unsigned char)
+f     - D: DOUBLE PRECISION
+f     - R: REAL
+f     - I: INTEGER
+f     - UI: INTEGER (treated as unsigned)
+f     - S: INTEGER*2 (short integer)
+f     - US: INTEGER*2 (short integer, treated as unsigned)
+f     - B: BYTE (treated as signed)
+f     - UB: BYTE (treated as unsigned)
+*
+c     For example, astMaskD would be used to process "double"
+c     data, while astMaskS would be used to process "short int"
+c     data, etc.
+f     For example, AST_MASKD would be used to process DOUBLE
+f     PRECISION data, while AST_MASKS would be used to process
+f     short integer data (stored in an INTEGER*2 array), etc.
+f
+f     For compatibility with other Starlink facilities, the codes W
+f     and UW are provided as synonyms for S and US respectively (but
+f     only in the Fortran interface to AST).
+
+*--
+*/
+/* Define a macro to implement the function for a specific data
+   type. */
+#define MAKE_MASK(X,Xtype) \
+static int Mask##X( AstRegion *this, AstMapping *map, int inside, int ndim, \
+                    const int lbnd[], const int ubnd[], \
+                    Xtype in[], Xtype val, int *status ) { \
+\
+/* Local Variables: */ \
+   AstFrame *grid_frame;         /* Pointer to Frame describing grid coords */ \
+   AstRegion *used_region;       /* Pointer to Region to be used by astResample */ \
+   Xtype *c;                     /* Pointer to next array element */ \
+   Xtype *d;                     /* Pointer to next array element */ \
+   Xtype *out;                   /* Pointer to the array used for resample output */ \
+   Xtype *tmp_out;               /* Pointer to temporary output array */ \
+   double *lbndgd;               /* Pointer to array holding lower grid bounds */ \
+   double *ubndgd;               /* Pointer to array holding upper grid bounds */ \
+   int *lbndg;                   /* Pointer to array holding lower grid bounds */ \
+   int *ubndg;                   /* Pointer to array holding upper grid bounds */ \
+   int idim;                     /* Loop counter for coordinate dimensions */ \
+   int ipix;                     /* Loop counter for pixel index */ \
+   int nax;                      /* Number of Region axes */ \
+   int nin;                      /* Number of Mapping input coordinates */ \
+   int nout;                     /* Number of Mapping output coordinates */ \
+   int npix;                     /* Number of pixels in supplied array */ \
+   int npixg;                    /* Number of pixels in bounding box */ \
+   int result;                   /* Result value to return */ \
+\
+/* Initialise. */ \
+   result = 0; \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return result; \
+\
+/* Obtain value for the Naxes attribute of the Region. */ \
+   nax = astGetNaxes( this ); \
+\
+/* If supplied, obtain values for the Nin and Nout attributes of the Mapping. */ \
+   if( map ) { \
+      nin = astGetNin( map ); \
+      nout = astGetNout( map ); \
+\
+/* If OK, check that the number of mapping inputs matches the \
+   number of axes in the Region. Report an error if necessary. */ \
+      if ( astOK && ( nax != nin ) ) { \
+         astError( AST__NGDIN, "astMask"#X"(%s): Bad number of mapping " \
+                   "inputs (%d).", status, astGetClass( this ), nin ); \
+         astError( AST__NGDIN, "The %s given requires %d coordinate value%s " \
+                   "to specify a position.", status, \
+                   astGetClass( this ), nax, ( nax == 1 ) ? "" : "s" ); \
+      } \
+\
+/* If OK, check that the number of mapping outputs matches the \
+   number of grid dimensions. Report an error if necessary. */ \
+      if ( astOK && ( ndim != nout ) ) { \
+         astError( AST__NGDIN, "astMask"#X"(%s): Bad number of mapping " \
+                   "outputs (%d).", status, astGetClass( this ), nout ); \
+         astError( AST__NGDIN, "The pixel grid requires %d coordinate value%s " \
+                   "to specify a position.", status, \
+                   ndim, ( ndim == 1 ) ? "" : "s" ); \
+      } \
+\
+/* Create a new Region by mapping the supplied Region with the supplied \
+   Mapping. The resulting Region represents a region in grid coordinates. */ \
+      grid_frame = astFrame( ndim, "Domain=grid", status ); \
+      used_region = astMapRegion( this, map, grid_frame ); \
+      grid_frame = astAnnul( grid_frame ); \
+\
+/* If no Mapping was supplied check that the number of grid dimensions \
+   matches the number of axes in the Region.*/ \
+   } else if ( astOK && ( ( ndim != nax ) || ( ndim < 1 ) ) ) { \
+      used_region = NULL; \
+      astError( AST__NGDIN, "astMask"#X"(%s): Bad number of input grid " \
+                "dimensions (%d).", status, astGetClass( this ), ndim ); \
+      if ( ndim != nax ) { \
+         astError( AST__NGDIN, "The %s given requires %d coordinate value%s " \
+                   "to specify an input position.", status, \
+                   astGetClass( this ), nax, ( nax == 1 ) ? "" : "s" ); \
+      } \
+\
+/* If no Mapping was supplied and the parameters look OK, clone the \
+   supplied Region pointer for use later on. */ \
+   } else { \
+      used_region = astClone( this ); \
+   } \
+\
+/* Check that the lower and upper bounds of the input grid are \
+   consistent. Report an error if any pair is not. */ \
+   if ( astOK ) { \
+      for ( idim = 0; idim < ndim; idim++ ) { \
+         if ( lbnd[ idim ] > ubnd[ idim ] ) { \
+            astError( AST__GBDIN, "astMask"#X"(%s): Lower bound of " \
+                      "input grid (%d) exceeds corresponding upper bound " \
+                      "(%d).", status, astGetClass( this ), \
+                      lbnd[ idim ], ubnd[ idim ] ); \
+            astError( AST__GBDIN, "Error in input dimension %d.", status, \
+                      idim + 1 ); \
+            break; \
+         } \
+      } \
+   } \
+\
+/* Allocate memory, and then get the bounding box of this new Region in its \
+   current Frame (grid coordinates). This bounding box assumes the region \
+   has not been negated. */ \
+   lbndg = astMalloc( sizeof( int )*(size_t) ndim ); \
+   ubndg = astMalloc( sizeof( int )*(size_t) ndim ); \
+   lbndgd = astMalloc( sizeof( double )*(size_t) ndim ); \
+   ubndgd = astMalloc( sizeof( double )*(size_t) ndim ); \
+   if( astOK ) { \
+      astGetRegionBounds( used_region, lbndgd, ubndgd ); \
+\
+/* We convert the floating point bounds to integer pixel bounds, and at \
+   the same time expand the box by 2 pixels at each edge to ensure that \
+   rounding errors etc do not cause any of the Region to fall outside (or \
+   on) the box. Do not let the expanded box extend outside the supplied \
+   array bounds. Also note the total number of pixels in the supplied \
+   array, and in the bounding box. */ \
+      npix = 1; \
+      npixg = 1; \
+      for ( idim = 0; idim < ndim; idim++ ) { \
+         if( lbndgd[ idim ] != AST__BAD && ubndgd[ idim ] != AST__BAD ) { \
+            lbndg[ idim ] = astMAX( lbnd[ idim ], (int)( lbndgd[ idim ] + 0.5 ) - 2 ); \
+            ubndg[ idim ] = astMIN( ubnd[ idim ], (int)( ubndgd[ idim ] + 0.5 ) + 2 ); \
+         } else { \
+            lbndg[ idim ] = lbnd[ idim ]; \
+            ubndg[ idim ] = ubnd[ idim ]; \
+         } \
+         npix *= ( ubnd[ idim ] - lbnd[ idim ] + 1 ); \
+         if( npixg >= 0 ) npixg *= ( ubndg[ idim ] - lbndg[ idim ] + 1 ); \
+      } \
+\
+/* If the bounding box is null, fill the mask with the supplied value if \
+   we assigning the value to the outside of the region (do the opposite if \
+   the Region has been negated). */ \
+      if( npixg <= 0 && astOK ) { \
+         if( ( inside != 0 ) == ( astGetNegated( used_region ) != 0 ) ) { \
+            c = in; \
+            for( ipix = 0; ipix < npix; ipix++ ) *(c++) = val; \
+            result = npix; \
+         } \
+\
+/* If the bounding box is null, return without action. */ \
+      } else if( npixg > 0 && astOK ) { \
+\
+/* All points outside this box are either all inside, or all outside, the \
+   Region. So we can speed up processing by setting all the points which are \
+   outside the box to the supplied data value (if required). This is \
+   faster than checking each point individually using the Transform method \
+   of the Region. We do this by supplying an alternative output array to \
+   the resampling function below, which has been pre-filled with "val" at \
+   every pixel. */ \
+         if( ( inside != 0 ) == ( astGetNegated( used_region ) != 0 ) ) { \
+\
+/* Allocate memory for the alternative output array, and fill it with \
+   "val". */ \
+            tmp_out = astMalloc( sizeof( Xtype )*(size_t) npix ); \
+            if( tmp_out ) { \
+               c = tmp_out; \
+               for( ipix = 0; ipix < npix; ipix++ ) *(c++) = val; \
+               result = npix - npixg; \
+            } \
+\
+/* Indicate that we will use this temporary array rather than the \
+   supplied array. */ \
+            out = tmp_out; \
+\
+/* If the outside of the grid box is outside the region of interest it \
+   will be unchanged in the resturned array. Therefore we can use the \
+   supplied array as the output array below. */ \
+         } else { \
+            tmp_out = NULL; \
+            out = in; \
+         } \
+\
+/* Temporarily invert the Region if required. The Region Transform methods \
+   leave interior points unchanged and assign AST__BAD to exterior points. \
+   This is the opposite of what we want (which is to leave exterior \
+   points unchanged and assign VAL to interior points), so we negate the \
+   region if the inside is to be assigned the value VAL.*/ \
+         if( inside ) astNegate( used_region ); \
+\
+/* Invoke astResample to mask just the region inside the bounding box found \
+   above (specified by lbndg and ubndg), since all the points outside this \
+   box will already contain their required value. */ \
+         result += astResample##X( used_region, ndim, lbnd, ubnd, in, NULL, AST__NEAREST, \
+                                   NULL, NULL, 0, 0.0, 100, val, ndim, \
+                                   lbnd, ubnd, lbndg, ubndg, out, NULL ); \
+\
+/* Revert to the original setting of the Negated attribute. */ \
+         if( inside ) astNegate( used_region ); \
+\
+/* If required, copy the output data from the temporary output array to \
+   the supplied array, and then free the temporary output array. */ \
+         if( tmp_out ) { \
+            c = tmp_out; \
+            d = in; \
+            for( ipix = 0; ipix < npix; ipix++ ) *(d++) = *(c++); \
+            tmp_out = astFree( tmp_out ); \
+         }\
+      }\
+   } \
+\
+/* Free resources */ \
+   ubndg = astFree( ubndg ); \
+   lbndg = astFree( lbndg ); \
+   ubndgd = astFree( ubndgd ); \
+   lbndgd = astFree( lbndgd ); \
+   used_region = astAnnul( used_region ); \
+\
+/* If an error occurred, clear the returned result. */ \
+   if ( !astOK ) result = 0; \
+\
+/* Return the result. */ \
+   return result; \
+}
+
+/* Expand the above macro to generate a function for each required
+   data type. */
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+MAKE_MASK(LD,long double)
+#endif
+MAKE_MASK(D,double)
+MAKE_MASK(L,long int)
+MAKE_MASK(UL,unsigned long int)
+MAKE_MASK(I,int)
+MAKE_MASK(UI,unsigned int)
+MAKE_MASK(S,short int)
+MAKE_MASK(US,unsigned short int)
+MAKE_MASK(B,signed char)
+MAKE_MASK(UB,unsigned char)
+MAKE_MASK(F,float)
+
+/* Undefine the macro. */
+#undef MAKE_MASK
+
+
+
+static int Match( AstFrame *this_frame, AstFrame *target, int matchsub,
+                  int **template_axes, int **target_axes,
+                  AstMapping **map, AstFrame **result, int *status ) {
+/*
+*  Name:
+*     Match
+
+*  Purpose:
+*     Determine if conversion is possible between two coordinate systems.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int Match( AstFrame *template, AstFrame *target, int matchsub,
+*                int **template_axes, int **target_axes,
+*                AstMapping **map, AstFrame **result, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astMatch
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function matches the current Frame of a "template" Region
+*     to a "target" frame and determines whether it is possible to
+*     convert coordinates between them.  If it is, a Mapping that
+*     performs the transformation is returned along with a new Frame
+*     that describes the coordinate system that results when this
+*     Mapping is applied to the current Frame of the target
+*     Region. In addition, information is returned to allow the axes
+*     in this "result" Frame to be associated with the corresponding
+*     axes in the target and template Frames from which they are
+*     derived.
+
+*  Parameters:
+*     template
+*        Pointer to the template Region, whose current Frame
+*        describes the coordinate system (or set of possible
+*        coordinate systems) into which we wish to convert our
+*        coordinates.
+*     target
+*        Pointer to the target Frame. This describes the coordinate
+*        system in which we already have coordinates.
+*     matchsub
+*        If zero then a match only occurs if the template is of the same
+*        class as the target, or of a more specialised class. If non-zero
+*        then a match can occur even if this is not the case.
+*     template_axes
+*        Address of a location where a pointer to int will be returned
+*        if the requested coordinate conversion is possible. This
+*        pointer will point at a dynamically allocated array of
+*        integers with one element for each axis of the "result" Frame
+*        (see below). It must be freed by the caller (using astFree)
+*        when no longer required.
+*
+*        For each axis in the result Frame, the corresponding element
+*        of this array will return the index of the axis in the
+*        template Region's current Frame from which it is
+*        derived. If it is not derived from any template Region
+*        axis, a value of -1 will be returned instead.
+*     target_axes
+*        Address of a location where a pointer to int will be returned
+*        if the requested coordinate conversion is possible. This
+*        pointer will point at a dynamically allocated array of
+*        integers with one element for each axis of the "result" Frame
+*        (see below). It must be freed by the caller (using astFree)
+*        when no longer required.
+*
+*        For each axis in the result Frame, the corresponding element
+*        of this array will return the index of the target Frame axis
+*        from which it is derived. If it is not derived from any
+*        target Frame axis, a value of -1 will be returned instead.
+*     map
+*        Address of a location where a pointer to a new Mapping will
+*        be returned if the requested coordinate conversion is
+*        possible. If returned, the forward transformation of this
+*        Mapping may be used to convert coordinates between the target
+*        Frame and the result Frame (see below) and the inverse
+*        transformation will convert in the opposite direction.
+*     result
+*        Address of a location where a pointer to a new Frame will be
+*        returned if the requested coordinate conversion is
+*        possible. If returned, this Frame describes the coordinate
+*        system that results from applying the returned Mapping
+*        (above) to the "target" coordinate system. In general, this
+*        Frame will combine attributes from (and will therefore be
+*        more specific than) both the target Frame and the current
+*        Frame of the template Region. In particular, when the
+*        template allows the possibility of transformaing to any one
+*        of a set of alternative coordinate systems, the "result"
+*        Frame will indicate which of the alternatives was used.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if the requested coordinate
+*     conversion is possible. Otherwise zero is returned (this will
+*     not in itself result in an error condition).
+
+*  Notes:
+*     - A value of zero 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 *fr;                 /* Pointer to Region's current Frame */
+   int match;                    /* Result to be returned */
+
+/* Initialise the returned values. */
+   *template_axes = NULL;
+   *target_axes = NULL;
+   *map = NULL;
+   *result = NULL;
+   match = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return match;
+
+/* Invoke the parent astMatch method on the current Frame within the
+   encapsulated FrameSet within the Region. */
+   fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT );
+   match = astMatch( fr, target, matchsub, template_axes, target_axes, map, result );
+   fr = astAnnul( fr );
+
+/* Return the result. */
+   return match;
+}
+
+static void MatchAxes( AstFrame *frm1_frame, AstFrame *frm2, int *axes,
+                       int *status ) {
+/*
+*  Name:
+*     MatchAxes
+
+*  Purpose:
+*     Find any corresponding axes in two Frames.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void MatchAxes( AstFrame *frm1, AstFrame *frm2, int *axes )
+*                     int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astMatchAxes
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function looks for corresponding axes within two supplied
+*     Frames. An array of integers is returned that contains an element
+*     for each axis in the second supplied Frame. An element in this array
+*     will be set to zero if the associated axis within the second Frame
+*     has no corresponding axis within the first Frame. Otherwise, it
+*     will be set to the index (a non-zero positive integer) of the
+*     corresponding axis within the first supplied Frame.
+
+*  Parameters:
+*     frm1
+*        Pointer to the first Frame.
+*     frm2
+*        Pointer to the second Frame.
+*     axes
+*        Pointer to an
+*        integer array in which to return the indices of the axes (within
+*        the second Frame) that correspond to each axis within the first
+*        Frame. Axis indices start at 1. A value of zero will be stored
+*        in the returned array for each axis in the first Frame that has
+*        no corresponding axis in the second Frame.
+*
+*        The number of elements in this array must be greater than or
+*        equal to the number of axes in the first Frame.
+*     status
+*        Pointer to inherited status value.
+
+*  Notes:
+*     -  Corresponding axes are identified by the fact that a Mapping
+*     can be found between them using astFindFrame or astConvert. Thus,
+*     "corresponding axes" are not necessarily identical. For instance,
+*     SkyFrame axes in two Frames will match even if they describe
+*     different celestial coordinate systems
+*/
+
+/* Local Variables: */
+   AstFrame *frm1;               /* Pointer to Region's current Frame */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Invoke the astMatchAxesX method on frm2, passing it the current Frame
+   within the encapsulated FrameSet within the Region as "frm1". */
+   frm1 = astGetFrame( ((AstRegion *) frm1_frame)->frameset, AST__CURRENT );
+   astMatchAxesX( frm2, frm1, axes );
+   frm1 = astAnnul( frm1 );
+}
+
+static void MatchAxesX( AstFrame *frm2_frame, AstFrame *frm1, int *axes,
+                        int *status ) {
+/*
+*  Name:
+*     MatchAxesX
+
+*  Purpose:
+*     Find any corresponding axes in two Frames.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void MatchAxesX( AstFrame *frm2, AstFrame *frm1, int *axes )
+*                      int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astMatchAxesX
+*     method inherited from the Frame class).
+
+*     This function looks for corresponding axes within two supplied
+*     Frames. An array of integers is returned that contains an element
+*     for each axis in the second supplied Frame. An element in this array
+*     will be set to zero if the associated axis within the second Frame
+*     has no corresponding axis within the first Frame. Otherwise, it
+*     will be set to the index (a non-zero positive integer) of the
+*     corresponding axis within the first supplied Frame.
+
+*  Parameters:
+*     frm2
+*        Pointer to the second Frame.
+*     frm1
+*        Pointer to the first Frame.
+*     axes
+*        Pointer to an integer array in which to return the indices of
+*        the axes (within the first Frame) that correspond to each axis
+*        within the second Frame. Axis indices start at 1. A value of zero
+*        will be stored in the returned array for each axis in the second
+*        Frame that has no corresponding axis in the first Frame.
+*
+*        The number of elements in this array must be greater than or
+*        equal to the number of axes in the second Frame.
+*     status
+*        Pointer to inherited status value.
+
+*  Notes:
+*     -  Corresponding axes are identified by the fact that a Mapping
+*     can be found between them using astFindFrame or astConvert. Thus,
+*     "corresponding axes" are not necessarily identical. For instance,
+*     SkyFrame axes in two Frames will match even if they describe
+*     different celestial coordinate systems
+*/
+
+/* Local Variables: */
+   AstFrame *frm2;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Get a pointer to the current Frame in the FrameSet. */
+   frm2 = astGetFrame( ((AstRegion *) frm2_frame)->frameset, AST__CURRENT );
+
+/* Invoke the astMatchAxesX on the current Frame. */
+   astMatchAxesX( frm2, frm1, axes );
+
+/* Free resources */
+   frm2 = astAnnul( frm2 );
+}
+
+static void Negate( AstRegion *this, int *status ) {
+/*
+*++
+*  Name:
+c     astNegate
+f     AST_NEGATE
+
+*  Purpose:
+*     Negate the area represented by a Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     void astNegate( AstRegion *this )
+f     CALL AST_NEGATE( THIS, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function negates the area represented by a Region. That is,
+*     points which were previously inside the region will then be
+*     outside, and points which were outside will be inside. This is
+*     acomplished by toggling the state of the Negated attribute for
+*     the supplied region.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*--
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Toggle the Negated attribute. */
+   astSetNegated( this, astGetNegated( this ) ? 0 : 1 );
+
+}
+
+static void Norm( AstFrame *this_frame, double value[], int *status ) {
+/*
+*  Name:
+*     Norm
+
+*  Purpose:
+*     Normalise a set of Region coordinates.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void Norm( AstAxis *this, double value[], int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astNorm method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function converts a set of coordinate values for the
+*     current Frame of a Region, which might potentially be
+*     unsuitable for display to a user (for instance, may lie outside
+*     the expected range of values) into a set of acceptable
+*     alternative values suitable for display.
+*
+*     Typically, for Frames whose axes represent cyclic values (such
+*     as angles or positions on the sky), this function wraps an
+*     arbitrary set of coordinates, so that they lie within the first
+*     cycle (say zero to 2*pi or -pi/2 to +pi/2). For Frames with
+*     ordinary linear axes, without constraints, this function will
+*     typically return the original coordinate values unchanged.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     value
+*        An array of double, with one element for each Region axis.
+*        This should contain the initial set of coordinate values,
+*        which will be modified in place.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to the current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's current Frame and invoke this
+   Frame's astNorm method to obtain the new values. Annul the Frame
+   pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astNorm( fr, value );
+   fr = astAnnul( fr );
+}
+
+static void NormBox( AstFrame *this_frame, double lbnd[], double ubnd[],
+                     AstMapping *reg, int *status ) {
+/*
+*  Name:
+*     NormBox
+
+*  Purpose:
+*     Extend a box to include effect of any singularities in the Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astNormBox( AstFrame *this, double lbnd[], double ubnd[],
+*                      AstMapping *reg, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astNormBox method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function modifies a supplied box to include the effect of any
+*     singularities in the co-ordinate system represented by the Frame.
+*     For a normal Cartesian coordinate system, the box will be returned
+*     unchanged. Other classes of Frame may do other things. For instance,
+*     a SkyFrame will check to see if the box contains either the north
+*     or south pole and extend the box appropriately.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     lbnd
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). Initially, this should contain a set of
+*        lower axis bounds for the box. They will be modified on exit
+*        to include the effect of any singularities within the box.
+*     ubnd
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). Initially, this should contain a set of
+*        upper axis bounds for the box. They will be modified on exit
+*        to include the effect of any singularities within the box.
+*     reg
+*        A Mapping which should be used to test if any singular points are
+*        inside or outside the box. The Mapping should leave an input
+*        position unchanged if the point is inside the box, and should
+*        set all bad if the point is outside the box.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to the current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's current Frame and invoke this
+   Frame's astNormBox method to obtain the new values. Annul the Frame
+   pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astNormBox( fr, lbnd, ubnd, reg );
+   fr = astAnnul( fr );
+}
+
+static void Offset( AstFrame *this_frame, const double point1[],
+                    const double point2[], double offset, double point3[], int *status ) {
+/*
+*  Name:
+*     Offset
+
+*  Purpose:
+*     Calculate an offset along a geodesic curve.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void Offset( AstFrame *this,
+*                  const double point1[], const double point2[],
+*                  double offset, double point3[], int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astOffset
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function finds the Region coordinate values of a point
+*     which is offset a specified distance along the geodesic curve
+*     between two other points.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     point1
+*        An array of double, with one element for each Region axis.
+*        This should contain the coordinates of the point marking the
+*        start of the geodesic curve.
+*     point2
+*        An array of double, with one element for each Region axis
+*        This should contain the coordinates of the point marking the
+*        end of the geodesic curve.
+*     offset
+*        The required offset from the first point along the geodesic
+*        curve. If this is positive, it will be towards the second
+*        point. If it is negative, it will be in the opposite
+*        direction. This offset need not imply a position lying
+*        between the two points given, as the curve will be
+*        extrapolated if necessary.
+*     point3
+*        An array of double, with one element for each Region axis
+*        in which the coordinates of the required point will be
+*        returned.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - The geodesic curve used by this function is the path of
+*     shortest distance between two points, as defined by the
+*     astDistance function.
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value.
+*     - "Bad" coordinate values will also be returned if the two
+*     points supplied are coincident (or otherwise fail to uniquely
+*     specify a geodesic curve) but the requested offset is non-zero.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's current Frame and invoke this
+   Frame's astOffset method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astOffset( fr, point1, point2, offset, point3 );
+   fr = astAnnul( fr );
+}
+
+static double Offset2( AstFrame *this_frame, const double point1[2],
+                       double angle, double offset, double point2[2], int *status ){
+/*
+*  Name:
+*     Offset2
+
+*  Purpose:
+*     Calculate an offset along a geodesic curve in a 2D Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double Offset2( AstFrame *this, const double point1[2], double angle,
+*                     double offset, double point2[2], int *status );
+
+*  Class Membership:
+*     Region member function (over-rides the protected astOffset2
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function finds the Frame coordinate values of a point which
+*     is offset a specified distance along the geodesic curve at a
+*     given angle from a specified starting point. It can only be
+*     used with 2-dimensional Frames.
+*
+*     For example, in a basic Frame, this offset will be along the
+*     straight line joining two points. For a more specialised Frame
+*     describing a sky coordinate system, however, it would be along
+*     the great circle passing through two sky positions.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     point1
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This should contain the coordinates of the
+*        point marking the start of the geodesic curve.
+*     angle
+*        The angle (in radians) from the positive direction of the second
+*        axis, to the direction of the required position, as seen from
+*        the starting position. Positive rotation is in the sense of
+*        rotation from the positive direction of axis 2 to the positive
+*        direction of axis 1.
+*     offset
+*        The required offset from the first point along the geodesic
+*        curve. If this is positive, it will be in the direction of the
+*        given angle. If it is negative, it will be in the opposite
+*        direction.
+*     point2
+*        An array of double, with one element for each Frame axis
+*        in which the coordinates of the required point will be returned.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The direction of the geodesic curve at the end point. That is, the
+*     angle (in radians) between the positive direction of the second
+*     axis and the continuation of the geodesic curve at the requested
+*     end point. Positive rotation is in the sense of rotation from
+*     the positive direction of axis 2 to the positive direction of axis 1.
+
+*  Notes:
+*     - The geodesic curve used by this function is the path of
+*     shortest distance between two points, as defined by the
+*     astDistance function.
+*     - An error will be reported if the Frame is not 2-dimensional.
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double result;                /* Value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke the
+   astOffset2 method for this Frame. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astOffset2( fr, point1, angle, offset, point2 );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+static int Overlap( AstRegion *this, AstRegion *that, int *status ){
+/*
+*++
+*  Name:
+c     astOverlap
+f     AST_OVERLAP
+
+*  Purpose:
+*     Test if two regions overlap each other.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     int astOverlap( AstRegion *this, AstRegion *that )
+f     RESULT = AST_OVERLAP( THIS, THAT, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function returns an integer value indicating if the two
+*     supplied Regions overlap. The two Regions are converted to a commnon
+*     coordinate system before performing the check. If this conversion is
+*     not possible (for instance because the two Regions represent areas in
+*     different domains), then the check cannot be performed and a zero value
+*     is returned to indicate this.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the first Region.
+c     that
+f     THAT = INTEGER (Given)
+*        Pointer to the second Region.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astOverlap()
+f     AST_OVERLAP = INTEGER
+*        A value indicating if there is any overlap between the two Regions.
+*        Possible values are:
+*
+*        0 - The check could not be performed because the second Region
+*            could not be mapped into the coordinate system of the first
+*            Region.
+*
+*        1 - There is no overlap between the two Regions.
+*
+*        2 - The first Region is completely inside the second Region.
+*
+*        3 - The second Region is completely inside the first Region.
+*
+*        4 - There is partial overlap between the two Regions.
+*
+*        5 - The Regions are identical to within their uncertainties.
+*
+*        6 - The second Region is the exact negation of the first Region
+*            to within their uncertainties.
+
+*  Notes:
+*     - The returned values 5 and 6 do not check the value of the Closed
+*     attribute in the two Regions.
+*     - A value of zero will be returned if this function is invoked with the
+*     AST error status set, or if it should fail for any reason.
+*--
+
+* Implementation Notes:
+*    This function is simply a wrap-up for the protected astOverlapX
+*    method which performs the required processing but swaps the order
+*    of the two arguments. This is a trick to allow the astOverlap method
+*    to be over-ridden by derived classes on the basis of the class of either
+*    of the two arguments.
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Invoke the "astOverlapX" method with the two arguments swapped. */
+   return astOverlapX( that, this );
+}
+
+static int OverlapX( AstRegion *that, AstRegion *this, int *status ){
+/*
+*+
+*  Name:
+*     astOverlapX
+
+*  Purpose:
+*     Test if two regions overlap each other.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int astOverlapX( AstRegion *that, AstRegion *this )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function performs the processing for the public astOverlap
+*     method and has exactly the same interface except that the order
+*     of the two arguments is swapped. This is a trick to allow
+*     the astOverlap method to be over-ridden by derived classes on
+*     the basis of the class of either of its two arguments.
+*
+*     See the astOverlap method for details of the interface.
+*-
+*/
+
+/* Local Variables: */
+   AstFrame *bfrm_reg1;           /* Pointer to base Frame in "reg1" Frame */
+   AstFrame *frm_reg1;            /* Pointer to current Frame in "reg1" Frame */
+   AstFrameSet *fs0;              /* FrameSet connecting Region Frames */
+   AstFrameSet *fs;               /* FrameSet connecting Region Frames */
+   AstMapping *cmap;              /* Mapping connecting Region Frames */
+   AstMapping *map;               /* Mapping form "reg2" current to "reg1" base */
+   AstMapping *map_reg1;          /* Pointer to current->base Mapping in "reg1" */
+   AstPointSet *ps1;              /* Mesh covering second Region */
+   AstPointSet *ps3;              /* Mesh covering first Region */
+   AstPointSet *ps4;              /* Mesh covering first Region */
+   AstPointSet *ps2;              /* Mesh covering second Region */
+   AstPointSet *reg2_mesh;        /* Mesh covering second Region */
+   AstPointSet *reg1_mesh;        /* Mesh covering first Region */
+   AstPointSet *reg2_submesh;     /* Second Region mesh minus boundary points */
+   AstRegion *reg1;               /* Region to use as the first Region */
+   AstRegion *reg2;               /* Region to use as the second Region */
+   AstRegion *unc1;               /* "unc" mapped into Frame of first Region */
+   AstRegion *unc;                /* Uncertainty in second Region */
+   double **ptr1;                 /* Pointer to mesh axis values */
+   double **ptr;                  /* Pointer to pointset data */
+   double *p;                     /* Pointer to next axis value */
+   int *mask;                     /* Mask identifying common boundary points */
+   int allbad;                    /* Were all axis values bad? */
+   int allgood;                   /* Were all axis values good? */
+   int bnd1;                      /* Does reg1 have a finite boundary */
+   int bnd2;                      /* Does reg2 have a finite boundary */
+   int bnd_that;                  /* Does "that" have a finite boundary */
+   int bnd_this;                  /* Does "this" have a finite boundary */
+   int case1;                     /* First region inside second region? */
+   int first;                     /* First pass? */
+   int good;                      /* Any good axis values found? */
+   int i;                         /* Mesh axis index */
+   int iax;                       /* Axis index */
+   int inv0;                      /* Original FrameSet Invert flag */
+   int ip;                        /* Index of point */
+   int j;                         /* Mesh point index */
+   int nc;                        /* Number of axis values per point */
+   int np;                        /* Number of points in mesh */
+   int result;                    /* Value to return */
+   int reg1_neg;                  /* Was "reg1" negated to make it bounded? */
+   int reg2_neg;                  /* Was "reg2" negated to make it bounded? */
+   int that_neg;                  /* Was "that" negated to make it bounded? */
+   int this_neg;                  /* Was "this" negated to make it bounded? */
+   int touch;                     /* Do the Regions touch? */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Return 5 if the two Regions are equal using the astEqual method. */
+   if( astEqual( this, that ) ) {
+      return 5;
+
+/* Return 6 if the two Regions are equal using the Equal method after
+   temporarily negating the first. */
+   } else {
+      astNegate( this );
+      result = astEqual( this, that );
+      astNegate( this );
+      if( result ) return 6;
+   }
+
+/* Get a FrameSet which connects the Frame represented by the second Region
+   to the Frame represented by the first Region. Check that the conection is
+   defined. */
+   fs0 = astConvert( that, this, "" );
+   if( !fs0 ) return 0;
+   inv0 = astGetInvert( fs0 );
+
+/* The rest of this function tests for overlap by representing one of the
+   Regions as a mesh of points along its boundary, and then checking to see
+   if any of the points in this mesh fall inside or outside the other Region.
+   This can only be done if the Region has a boundary of finite length (e.g.
+   Circles, Boxes, etc). Other Regions (e.g. some Intervals) do not have
+   finite boundaries and consequently report an error if an attempt is made
+   to represent them using a boundary mesh. We now therefore check to see if
+   either of the two Regions has a finite boundary length. This will be the
+   case if the region is bounded, or if it can be made bounded simply by
+   negating it. If a Region is unbounded regardless of the setting of its
+   Negated flag, then it does not have a finite boundary. We leave the
+   Negated attributes (temporaily) set to the values that cause the
+   Regions to be bounded. Set flags to indicate if the Regions have been
+   negated. */
+   bnd_this = astGetBounded( this );
+   if( !bnd_this ) {
+      astNegate( this );
+      bnd_this = astGetBounded( this );
+      if( ! bnd_this ) {
+         astNegate( this );
+         this_neg = 0;
+      } else {
+         this_neg = 1;
+      }
+   } else {
+      this_neg = 0;
+   }
+
+   bnd_that = astGetBounded( that );
+   if( !bnd_that ) {
+      astNegate( that );
+      bnd_that = astGetBounded( that );
+      if( ! bnd_that ) {
+         astNegate( that );
+         that_neg = 0;
+      } else {
+         that_neg = 1;
+      }
+   } else {
+      that_neg = 0;
+   }
+
+/* If neither Regions has a finite boundary, then we cannot currently
+   determine any overlap, so report an error. Given more time, it
+   is probably possible to think of some way of determining overlap
+   between two unbounded Regions, but it will probably not be a common
+   requirement and so is currently put off to a rainy day. */
+   if( !bnd_this && !bnd_that && astOK ) {
+      astError( AST__INTER, "astOverlap(Region): Neither of the two "
+                "supplied Regions (classes %s and %s) has a finite "
+                "boundary.", status, astGetClass(this), astGetClass(that) );
+      astError( AST__INTER, "The current implementation of astOverlap "
+                "cannot determine the overlap between two Regions "
+                "unless at least one of them has a finite boundary." , status);
+   }
+
+/* If only one of the two Regions has a finite boundary, we must use its
+   mesh first. Choose the finite boundary Region as the "second" region.
+   Also store a flag indicating if the first Region has a finite boundary. */
+   if( bnd_that ) {
+      reg1 = this;
+      reg2 = that;
+      bnd1 = bnd_this;
+      bnd2 = bnd_that;
+      reg1_neg = this_neg;
+      reg2_neg = that_neg;
+   } else {
+      reg1 = that;
+      reg2 = this;
+      bnd1 = bnd_that;
+      bnd2 = bnd_this;
+      reg1_neg = that_neg;
+      reg2_neg = this_neg;
+   }
+
+/* We may need to try again with the above selections swapped. We only do
+   this once though. Set a flag to indicate that we are about to start the
+   first pass. */
+   first = 1;
+L1:
+
+/* Get a FrameSet which connects the Frame represented by the second Region
+   to the Frame represented by the first Region. Check that the conection is
+   defined. */
+   fs = astClone( fs0 );
+   astSetInvert( fs, (reg2 == that ) ? inv0 : 1 - inv0 );
+   if( fs ) {
+
+/* Get a pointer to the Frame represented by the first Region. */
+      frm_reg1 = astGetFrame( reg1->frameset, AST__CURRENT );
+
+/* Get a pointer to the Mapping from current to base Frame in the first
+   Region. */
+      map_reg1 = astGetMapping( reg1->frameset, AST__CURRENT, AST__BASE );
+
+/* Get the Mapping from the current Frame of the second Region to the
+   current Frame of the first Region. */
+      cmap = astGetMapping( fs, AST__BASE, AST__CURRENT );
+
+/* Combine these Mappings to get the Mapping from current Frame of the
+   second region to the base Frame of the first Region. */
+      map = (AstMapping *) astCmpMap( cmap, map_reg1, 1, "", status );
+
+/* Get a mesh of points covering the second Region. These points are
+   within the current Frame of the second Region. */
+      reg2_mesh = astRegMesh( reg2 );
+
+/* Transform this mesh into the base Frame of the first Region. */
+      ps1 = astTransform( map, reg2_mesh, 1, NULL );
+
+/* Check there are some good points in the transformed pointset. */
+      good = 0;
+      np = astGetNpoint( ps1 );
+      nc = astGetNcoord( ps1 );
+      ptr1 = astGetPoints( ps1 );
+      if( ptr1 ) {
+         for( i = 0; i < nc && !good; i++ ) {
+            for( j = 0; j < np; j++ ) {
+               if( ptr1[ i ][ j ] != AST__BAD ) {
+                  good = 1;
+                  break;
+               }
+            }
+         }
+      }
+
+/* If the transformed mesh contains no good points, swap the regions and
+   try again. */
+      if( !good ) {
+         fs = astAnnul( fs );
+         frm_reg1 = astAnnul( frm_reg1 );
+         map_reg1 = astAnnul( map_reg1 );
+         cmap = astAnnul( cmap );
+         map = astAnnul( map );
+         reg2_mesh = astAnnul( reg2_mesh );
+         ps1 = astAnnul( ps1 );
+
+         if( first ) {
+            first = 0;
+
+            if( !bnd_that ) {
+               reg1 = this;
+               reg2 = that;
+               bnd1 = bnd_this;
+               bnd2 = bnd_that;
+               reg1_neg = this_neg;
+               reg2_neg = that_neg;
+            } else {
+               reg1 = that;
+               reg2 = this;
+               bnd1 = bnd_that;
+               bnd2 = bnd_this;
+               reg1_neg = that_neg;
+               reg2_neg = this_neg;
+            }
+            goto L1;
+
+         } else {
+            return 0;
+         }
+      }
+
+/* Also transform the Region describing the positional uncertainty within
+   the second supplied Region into the base Frame of the first supplied
+   Region. */
+      unc = astGetUncFrm( reg2, AST__CURRENT );
+      bfrm_reg1 = astGetFrame( reg1->frameset, AST__BASE );
+      unc1 = astMapRegion( unc, map, bfrm_reg1 );
+
+/* See if all points within this transformed mesh fall on the boundary of
+   the first Region, to within the joint uncertainty of the two Regions. If
+   so the two Regions have equivalent boundaries. We can only do this is
+   the first region is bounded. */
+      if( astRegPins( reg1, ps1, unc1, &mask ) && good ) {
+
+/* If the boundaries are equivalent, the Regions are either identical or
+   are mutually exclusive. To distinguish between these cases, we
+   looked at the Bounded attributes. If the Bounded attribute is the same
+   for both Regions then they are identical, otherwise they are mutually
+   exclusive. */
+         result = ( ( !reg1_neg && bnd1 ) == ( !reg2_neg && bnd2 ) ) ? 5 : 6;
+
+/* If the boundaries of the two Regions are not equivalent. */
+      } else {
+
+/* Create a new PointSet containing those points from the mesh which are
+   not on the boundary of the first Region. These points are identified by
+   the mask array created by the astRegPins method above. */
+         reg2_submesh = GetSubMesh( mask, reg2_mesh, status );
+
+/* Transform the points in the submesh of the second Region into the
+   current Frame of the first Region. */
+         (void ) astAnnul( ps1 );
+         ps1 = astTransform( cmap, reg2_submesh, 1, NULL );
+
+/* Transform this submesh using the first Region as a Mapping. Any points
+   outside the first region will be set bad in the output PointSet. */
+         ps2 = astTransform( (AstMapping *) reg1, ps1, 1, NULL );
+
+/* Get the number of axes and points in this PointSet. */
+         nc = astGetNcoord( ps2 );
+         np = astGetNpoint( ps2 );
+
+/* Note if there were any common points (i.e. points on the boundary of
+   both regions). */
+         touch = ( astGetNpoint( reg2_mesh ) != np );
+
+/* Get pointers to the axis data in this PointSet, and check they can be
+   used safely. */
+         ptr = astGetPoints( ps2 );
+         if( astOK ) {
+
+/* Loop round all points checking if the axis values are bad. We want a
+   flag saying if there are any good axis values and another flag saying if
+   there are any bad axis values. */
+            allbad = 1;
+            allgood = 1;
+            for( iax = 0; iax < nc; iax++ ) {
+               p = ptr[ iax ];
+               for( ip = 0; ip < np; ip++,p++ ) {
+                  if( *p == AST__BAD ) {
+                     allgood = 0;
+                     if( !allbad ) break;
+                  } else {
+                     allbad = 0;
+                     if( !allgood ) break;
+                  }
+               }
+            }
+
+/* If the entire mesh of the (potentially negated) second Region was either
+   on the boundary of, or inside, the (potentially negated) first region,
+   determine the result depending on whether the regions have been
+   negated and whether they are bounded. Check for impossible states (or
+   maybe just errors in my logic). */
+            if( allgood ) {
+
+/* Second region has a mesh so it must be bounded. */
+               if( !bnd2 && astOK ) {
+                     astError( AST__INTER, "astOverlap(%s): Inconsistent "
+                               "state 1 (internal AST programming error).",
+                               status, astGetClass( this ) );
+
+/* If the first region has been made bounded by negating it... */
+               } else if( reg1_neg ) {
+                  if( bnd1 ) {
+
+/* If the second region has been made bounded by negating it, then the
+   unnegated first region is completely inside the unnegated second region. */
+                     if( reg2_neg ) {
+                        result = 2;
+
+/* If the second region was bounded without negating it, then there is
+   no overlap between the unnegated first region and the second region. */
+                     } else {
+                        result = 1;
+                     }
+
+/* If the first region has been negated then it should not be unbounded.
+   This is ensured by the nature of the code that sets the "this_neg" and
+   "that_neg" flags above. */
+                  } else if( astOK ) {
+                     astError( AST__INTER, "astOverlap(%s): Inconsistent "
+                               "state 2 (internal AST programming error).",
+                               status, astGetClass( this ) );
+                  }
+
+/* If the first region was bounded without negating it, but the second
+   region was made bounded by negating it, there is partial overlap. */
+               } else if( reg2_neg ) {
+                  result = 4;
+
+/* If the first region was bounded without negating it, but the second
+   region was also bounded without negating it, the second region is
+   completely inside the first region. */
+               } else {
+                  result = 3;
+               }
+
+/* If part of the mesh of the second Region was inside the first region,
+   and part was outside, then there is partial ocverlap. */
+            } else if( !allbad ) {
+               result = 4;
+
+/* If no part of the mesh of the (possibly negated) second Region was inside
+   the (possibly negated) first region ... */
+            } else {
+
+/* First deal with cases where the first region is unbounded. */
+               if( !bnd1 ) {
+                  if( reg1_neg && astOK ) {
+                     astError( AST__INTER, "astOverlap(%s): Inconsistent "
+                               "state 5 (internal AST programming error).",
+                               status, astGetClass( this ) );
+                  } else if( reg2_neg ){
+                     result = 2;
+                  } else {
+                     result = 1;
+                  }
+
+/* The second region has a mesh so it must be bounded. */
+               } else if( !bnd2 && astOK ) {
+                     astError( AST__INTER, "astOverlap(%s): Inconsistent "
+                               "state 6 (internal AST programming error).",
+                               status, astGetClass( this ) );
+
+/* So now we know both (possibly negated) regions are bounded. */
+               } else {
+
+/* We know that none of the reg2 mesh points are inside the bounded reg1.
+   But this still leaves two cases: 1) reg1 could be contained completely
+   within reg2, or 2) there is no overlap between reg2 and reg1. To
+   distinguish between these two cases we use reg2 to transform a point
+   on the boundary of reg1. First get a mesh on the boundary of reg1. */
+                  reg1_mesh = astRegMesh( reg1 );
+
+/* Transform this mesh into the coordinate system of the second Region. */
+                  ps3 = astTransform( cmap, reg1_mesh, 0, NULL );
+
+/* Transform the points in this mesh using the second Region as a Mapping.
+   Any points outside the second region will be set bad in the output
+   PointSet. */
+                  ps4 = astTransform( (AstMapping *) reg2, ps3, 1, NULL );
+
+/* Get pointers to the axis data in this PointSet,and check they can be
+   used safely. */
+                  ptr = astGetPoints( ps4 );
+                  if( astOK ) {
+
+/* Test the firts point and set a flag indicating if we are in case 1 (if
+   not, we must be in case 2). */
+                     case1 = ( ptr[ 0 ][ 0 ] != AST__BAD );
+
+/* Apply logic similar to the other cases to determine the result. */
+                     if( reg1_neg ) {
+                        if( case1 == ( reg2_neg != 0 ) ) {
+                           result = 3;
+                        } else {
+                           result = 4;
+                        }
+                     } else {
+                        if( case1 == ( reg2_neg != 0 ) ) {
+                           result = 1;
+                        } else {
+                           result = 2;
+                        }
+                     }
+                  }
+
+/* Free resources. */
+                  reg1_mesh = astAnnul( reg1_mesh );
+                  ps3 = astAnnul( ps3 );
+                  ps4 = astAnnul( ps4 );
+               }
+	    }
+        }
+
+/* If there was no intersection or overlap, but the regions touch, then we
+   consider there to be an intersection if either region is closed. */
+	if( touch && result == 1 ) {
+	   if( astGetClosed( this) || astGetClosed( that ) ) result = 4;
+	}
+
+/* Free resources.*/
+         reg2_submesh = astAnnul( reg2_submesh );
+         ps2 = astAnnul( ps2 );
+      }
+
+/* Free resources.*/
+      fs = astAnnul( fs );
+      bfrm_reg1 = astAnnul( bfrm_reg1 );
+      frm_reg1 = astAnnul( frm_reg1 );
+      map_reg1 = astAnnul( map_reg1 );
+      cmap = astAnnul( cmap );
+      map = astAnnul( map );
+      ps1 = astAnnul( ps1 );
+      reg2_mesh = astAnnul( reg2_mesh );
+      unc = astAnnul( unc );
+      unc1 = astAnnul( unc1 );
+      if( mask) mask = astFree( mask );
+   }
+   fs0 = astAnnul( fs0 );
+
+/* The returned value should take account of whether "this" or "that" is
+   the first Region. If "this" was used as the first Region, then the
+   result value calculated above is already correct. If "that" was used as
+   the first Region, then we need to change the result to swap "this" and
+   "that". */
+   if( reg1 == that ) {
+      if( result == 2 ) {
+         result = 3;
+      } else if( result == 3 ) {
+         result = 2;
+      }
+   }
+
+/* Re-instate the original Negated flags. */
+   if( this_neg ) astNegate( this );
+   if( that_neg ) astNegate( that );
+
+/* If not OK, return zero. */
+   if( !astOK ) result = 0;
+
+/* Return the result. */
+   return result;
+}
+
+static void Overlay( AstFrame *template_frame, const int *template_axes,
+                     AstFrame *result, int *status ) {
+/*
+*  Name:
+*     Overlay
+
+*  Purpose:
+*     Overlay the attributes of a template Region on to another Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void Overlay( AstFrame *template, const int *template_axes,
+*                   AstFrame *result, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astOverlay
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function overlays attributes from the current Frame of a
+*     Region on to another Frame, so as to over-ride selected
+*     attributes of that second Frame. Normally only those attributes
+*     which have been specifically set in the template will be
+*     transferred. This implements a form of defaulting, in which a
+*     Frame acquires attributes from the template, but retains its
+*     original attributes (as the default) if new values have not
+*     previously been explicitly set in the template.
+
+*  Parameters:
+*     template
+*        Pointer to the template Region, for whose current Frame
+*        values should have been explicitly set for any attribute
+*        which is to be transferred.
+*     template_axes
+*        Pointer to an array of int, with one element for each axis of
+*        the "result" Frame (see below). For each axis in the result
+*        frame, the corresponding element of this array should contain
+*        the (zero-based) index of the axis in the current Frame of
+*        the template Region to which it corresponds. This array is
+*        used to establish from which template Frame axis any
+*        axis-dependent attributes should be obtained.
+*
+*        If any axis in the result Frame is not associated with a
+*        template Frame axis, the corresponding element of this array
+*        should be set to -1.
+*
+*        If a NULL pointer is supplied, the template and result axis
+*        indices are assumed to be identical.
+*     result
+*        Pointer to the Frame which is to receive the new attribute values.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the current Frame in the Region and invoke its
+   astOverlay method to overlay its attributes. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( ((AstRegion *) template_frame)->frameset, AST__CURRENT );
+   astOverlay( fr, template_axes, result );
+   fr = astAnnul( fr );
+}
+
+static void PermAxes( AstFrame *this_frame, const int perm[], int *status ) {
+/*
+*  Name:
+*     PermAxes
+
+*  Purpose:
+*     Permute the order of a Region's axes.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void PermAxes( AstFrame *this, const int perm[], int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astPermAxes method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function permutes the order in which the axes in the
+*     current Frame of a Region occur.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     perm
+*        An array of int (with one element for each axis of the
+*        Region's current Frame) which lists the axes in their new
+*        order. Each element of this array should be a (zero-based)
+*        axis index identifying the axes according to their old
+*        (un-permuted) order.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - Only genuine permutations of the axis order are permitted, so
+*     each axis must be referenced exactly once in the "perm" array.
+*     - If more than one axis permutation is applied to the same Frame
+*     in a Region, the effects are cumulative.
+*/
+
+/* Local Variables: */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Invoke the astPermAxes method on the encapsulated FrameSet. */
+   astPermAxes( this->frameset, perm );
+
+}
+
+static AstFrame *PickAxes( AstFrame *this_frame, int naxes, const int axes[],
+                           AstMapping **map, int *status ) {
+/*
+*  Name:
+*     PickAxes
+
+*  Purpose:
+*     Create a new Frame by picking axes from a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstFrame *PickAxes( AstFrame *this, int naxes, const int axes[],
+*                         AstMapping **map, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astPickAxes protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function creates a new Frame whose axes are copies of axes
+*     picked from the encapsulated Frame of an existing Region. Other
+*     Frame attributes are also copied from this existing Frame to the
+*     new Frame. Zero or more of the original axes may be picked in
+*     any order, but each can be used only once. Additional axes (with
+*     default characteristics) may be included in the new Frame if
+*     required.
+*
+*     Optionally, a Mapping that converts between the original Frame's
+*     axes and those of the new Frame may also be returned.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     naxes
+*        The number of axes required in the new Frame.
+*     axes
+*        Pointer to an array of int with naxes elements. This should
+*        contain (zero based) axis indices specifying the axes which
+*        are to be included in the new Frame, in the order
+*        required. Each axis index may occur only once.
+*
+*        If additional (default) axes are also to be included, the
+*        corresponding elements of this array should be set to -1.
+*     map
+*        Address of a location to receive a pointer to a new
+*        Mapping. This will be a PermMap (or a UnitMap as a special
+*        case) that describes the axis permutation that has taken
+*        place between the current Frame of the Region and the new
+*        Frame.  The forward transformation will convert from the
+*        original Region's axes to the new one's, and vice versa.
+*
+*        If this Mapping is not required, a NULL value may be supplied
+*        for this parameter.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to the new Frame.
+
+*  Notes:
+*     - The class of object returned may differ from that of the
+*     original current Frame, depending on which axes are
+*     selected. For example, if a single axis is picked from a
+*     SkyFrame (which always has two axes), the resulting Frame cannot
+*     be a valid SkyFrame, so will revert to the parent class (Frame)
+*     instead.
+*     - The new Frame contains a deep copy of all the data selected
+*     from the original current Frame. Modifying the new Frame will
+*     therefore not affect the Region or the Frames it contains.
+*     - 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 *cfrm;            /* Current Frame from input Region */
+   AstFrame *frame;           /* Pointer to Frame to be returned */
+   AstMapping *cbmap;         /* Base->current Mapping from input Region */
+   AstMapping *fsmap;         /* Mapping from selected current to base axes */
+   AstRegion *breg;           /* Region spanning selected base Frame axes */
+   AstRegion *creg;           /* Region spanning selected current Frame axes */
+   AstRegion *this;           /* Pointer to Region structure */
+   int *base_axes;            /* Holds selected base frame axis indices */
+   int def;                   /* Were any default axes requested? */
+   int i;                     /* Axis index */
+   int nbase;                 /* No. of selected base Frame axes */
+
+/* Initialise the returned pointers. */
+   if ( map ) *map = NULL;
+   frame = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return frame;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Check that a valid set of axes is being selected . */
+   astValidateAxisSelection( this, naxes, axes, "astPickAxes" );
+
+/* Pick the required axes from the current Frame of the encapsulated
+   FrameSet. */
+   cfrm = astGetFrame( this->frameset, AST__CURRENT );
+   frame = astPickAxes( cfrm, naxes, axes, map );
+
+/* See if any default axes are to be included in the returned Frame. */
+   def = 0;
+   for( i = 0; i < naxes; i++ ) {
+      if( axes[ i ] < 0 ) def = 1;
+   }
+
+/* Regions cannot yet include extra default axes in the returned Frame
+   so return a basic Frame if any default axes were requested. */
+   if( ! def ) {
+
+/* We now see if the requested set of current Frame axes correspond to a
+   unique set of base Frame axes. If they do, we may be able to return a
+   Region spanning the selected axes rather than just a Frame. The check
+   is performed by attempting to split the current->base Mapping. */
+      cbmap = astGetMapping( this->frameset, AST__CURRENT, AST__BASE );
+      base_axes = astMapSplit( cbmap, naxes, axes, &fsmap );
+
+/* Check the Mapping could be split. */
+      if( base_axes ) {
+
+/* Store the number of base Frame axes that correspond to the requested
+   set of current Frame axes. */
+         nbase = astGetNout( fsmap );
+
+/* Attempt to create a new Region that spans the corresponding set of
+   base Frame axes. */
+         breg = astRegBasePick( this, nbase, base_axes );
+         if( breg ) {
+
+/* Use the split Mapping to map the base Frame region into the requested
+   Frame. We invert the "fsmap" first so that it maps the selected base
+   Frame axes into the selected current Frame axes. */
+            astInvert( fsmap );
+            creg = astMapRegion( breg, fsmap, frame );
+
+/* Copy properties from the old Region to the new Region. */
+            astRegOverlay( creg, this, 0 );
+
+/* Return this new Region in place of the simple Frame found above. */
+            (void) astAnnul( frame );
+            frame = (AstFrame *) creg;
+
+/* Free resources */
+            breg = astAnnul( breg );
+         }
+         fsmap = astAnnul( fsmap );
+         base_axes = astFree( base_axes );
+      }
+      cbmap = astAnnul( cbmap );
+   }
+   cfrm = astAnnul( cfrm );
+
+/* If an error occurred, annul the Mapping pointer (if requested) and
+   the new Frame pointer. */
+   if ( !astOK ) {
+      if ( map ) *map = astAnnul( *map );
+      frame = astAnnul( frame );
+   }
+
+/* Return the pointer to the new Frame. */
+   return frame;
+}
+
+static void RegBaseBox( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+/*
+*+
+*  Name:
+*     astRegBaseBox
+
+*  Purpose:
+*     Returns the bounding box of an un-negated Region in the base Frame of
+*     the encapsulated FrameSet.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astRegBaseBox( AstRegion *this, double *lbnd, double *ubnd )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  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.
+
+*-
+*/
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* This abstract implementation simply reports an error. All sub-classes of
+   Region should over-ride this to return appropriate values. */
+   astError( AST__INTER, "astRegBaseBox(%s): The %s class does not implement "
+             "the astRegBaseBox method inherited from the Region class "
+             "(internal AST programming error).", status, astGetClass( this ),
+             astGetClass( this ) );
+}
+
+static void RegBaseBox2( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+/*
+*+
+*  Name:
+*     astRegBaseBox2
+
+*  Purpose:
+*     Returns the bounding box of an un-negated Region in the base Frame of
+*     the encapsulated FrameSet.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astRegBaseBox2( AstRegion *this, double *lbnd, double *ubnd )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  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.
+
+*-
+*/
+
+/* This base class implementation simply calls astRegBaseBox. Sub-classes
+   which contain component Regions should override it. */
+   astRegBaseBox( this, lbnd, ubnd );
+
+}
+
+static AstPointSet *RegBaseGrid( AstRegion *this, int *status ){
+/*
+*+
+*  Name:
+*     astRegBaseGrid
+
+*  Purpose:
+*     Return a PointSet containing points spread through the volume of a
+*     Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *astRegBaseGrid( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a PointSet containing a set of points spread
+*     through the volume of the Region. The points refer to the base Frame of
+*     the encapsulated FrameSet.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     Pointer to the PointSet. If the Region is unbounded, a NULL pointer
+*     will be returned.
+
+*  Notes:
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*-
+*/
+
+/* Local Variables: */
+   AstBox *box;
+   AstFrame *frmb;
+   AstPointSet *ps1;
+   AstPointSet *ps2;
+   AstPointSet *result;
+   double **ptr2;
+   double **ptr;
+   double *lbnd;
+   double *ubnd;
+   int good;
+   int ic;
+   int ip;
+   int ipr;
+   int meshsize;
+   int naxb;
+   int np;
+   int npnt2;
+   int ntry;
+
+/* Initialise */
+   result= NULL;
+
+/* Check the local error status. */
+   if ( !astOK ) return NULL;
+
+/* If the Region structure contains a pointer to a PointSet holding
+   positions spread over the volume of the Region in the base Frame,
+   return it. */
+   if( this->basegrid ) {
+      result = astClone( this->basegrid );
+
+/* Otherwise, check the Region is bounded. */
+   } else if( astGetBounded( this ) ) {
+
+/* Get the original MeshSize attribute. */
+      meshsize = astGetMeshSize( this );
+
+/* Get the base Frame bounding box. */
+      naxb = astGetNin( this->frameset );
+      lbnd = astMalloc( sizeof( double )*(size_t)naxb );
+      ubnd = astMalloc( sizeof( double )*(size_t)naxb );
+      astRegBaseBox( this, lbnd, ubnd );
+
+/* Create a Box covering this bounding box. */
+      frmb = astGetFrame( this->frameset, AST__BASE );
+      box = astBox( frmb, 1, lbnd, ubnd, NULL, "", status );
+
+/* Loop until we have a grid of nearly the right size. Make at most three
+   attempts. */
+      ipr = 0;
+      np = meshsize;
+      ntry = 0;
+      while( ntry++ < 3 ) {
+
+/* Copy the MeshSize attribute to the new Box since this will be used by
+   the invocation of astRegBaseGrid below. */
+         astSetMeshSize( box, np );
+
+/* Invoke the Box astRegGrid method. Note, the Box class overrides this
+   implementation of astRegBaseGrid and does not (must not) invoke this
+   implementation, in order to avoid an infinite loop. */
+         ps1 = astRegBaseGrid( box );
+
+/* Some of the base Frame points in the above bounding box will fall outside
+   the supplied Region. Use the Region as a Mapping to determine which they
+   are. Since the points are base Frame points, use astBTransform rather
+   than astTransform. */
+         ps2 = astBTransform( this, ps1, 1, NULL );
+
+/* We now create a PointSet which is a copy of "ps2" but with all the bad
+   points (i.e. the points in the bounding box grid which are not inside
+   the supplied Region) removed. Create a result PointSet which is the same
+   size as "ps2", then copy just the good points from "ps2" to the result
+   PointSet, keeping a record of the number of points copied. */
+         ptr2 = astGetPoints( ps2 );
+         npnt2 = astGetNpoint( ps2 );
+         result = astPointSet( npnt2, naxb, "", status );
+         ptr = astGetPoints( result );
+         if( astOK ) {
+
+/* Initialise the index of the next point to be stored in "result". */
+            ipr = 0;
+
+/* Loop round all points in "ps2" */
+            for( ip = 0; ip < npnt2; ip++ ) {
+
+/* Copy each axis value for this point from "ps2" to "result". If a bad
+   axis value is encountered, flag that the point is bad and break out of
+   the axis loop. */
+               good = 1;
+               for( ic = 0; ic < naxb; ic++ ) {
+                  if( ptr2[ ic ][ ip ] == AST__BAD ) {
+                     good = 0;
+                     break;
+                  } else {
+                     ptr[ ic ][ ipr ] = ptr2[ ic ][ ip ];
+                  }
+               }
+
+/* If the current point has no bad axis values, increment the index of
+   the next point to be stored in "result". */
+               if( good ) ipr++;
+            }
+         }
+
+/* Free resources */
+         ps1 = astAnnul( ps1 );
+         ps2 = astAnnul( ps2 );
+
+/* Leave the loop if an error has occurred. */
+         if( !astOK ) break;
+
+/* If the number of points in the grid is within 5% of the target value,
+   it is good enough, so break. */
+         if( fabs( (double)( ipr - meshsize ) )/meshsize < 0.05 ) break;
+
+/* Otherwise, adjust the target size of the grid by the ratio by which it
+   is in error. Don't do this if we have reached the maximum number of
+   re-tries. */
+         if( ntry < 3 ) {
+            if( ipr == 0 ) {
+               np *= 10;
+            } else {
+               np *= (double)meshsize/(double)ipr;
+            }
+            result = astAnnul( result );
+         }
+      }
+
+/* Truncate the "result" PointSet to exclude any unused space at the end
+   of the axis values arrays. */
+      if( astOK ) astSetNpoint( result, ipr );
+
+/* Free resources */
+      lbnd = astFree( lbnd );
+      ubnd = astFree( ubnd );
+      frmb = astAnnul( frmb );
+      box = astAnnul( box );
+
+/* Cache the new grid for future use. */
+      if( astOK ) this->basegrid = astClone( result );
+   }
+
+/* Annul the result if an error occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result */
+   return result;
+}
+
+static AstRegion **RegSplit( AstRegion *this, int *nlist, int *status ){
+/*
+*+
+*  Name:
+*     astRegSplit
+
+*  Purpose:
+*     Split a Region into a list of disjoint component Regions.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion **astRegSplit( AstRegion *this, int *nlist )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  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; */
+   AstRegion **result;
+
+/* Initialise. */
+   result = NULL;
+   *nlist = 0;
+
+/* Check the local error status. */
+   if ( !astOK ) return result;
+
+/* The base class just returns an array containing a clone of the
+   supplied Region pointer. */
+   result = astMalloc( sizeof( *result ) );
+   if( astOK ) {
+      result[ 0 ] = astClone( this );
+      *nlist = 1;
+   }
+
+   if( !astOK ) {
+      result = astFree( result );
+      *nlist = 0;
+   }
+
+   return result;
+}
+
+static AstPointSet *RegBaseMesh( AstRegion *this, int *status ){
+/*
+*+
+*  Name:
+*     astRegBaseMesh
+
+*  Purpose:
+*     Return a PointSet containing points spread around the boundary of a
+*     Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *astRegBaseMesh( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a PointSet containing a set 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.
+
+*  Returned Value:
+*     Pointer to the PointSet. The axis values in this PointSet will have
+*     associated accuracies derived from the uncertainties which were
+*     supplied when the Region was created.
+*
+*    If the Region has no boundary (i.e. is equivalent to a NullRegion), the
+*    returned PointSet will contain a single point with a value of AST__BAD
+*    on every axis.
+
+*  Notes:
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*-
+*/
+
+/* Check the local error status. */
+   if ( !astOK ) return NULL;
+
+/* This abstract method must be over-ridden by each concrete sub-class.
+   Report an error if this null imlementation is called.*/
+   astError( AST__INTER, "astRegBaseMesh(%s): The %s class does not implement "
+             "the astRegBaseMesh method inherited from the Region class "
+             "(internal AST programming error).", status, astGetClass( this ),
+             astGetClass( this ) );
+   return NULL;
+}
+
+static AstRegion *RegBasePick( AstRegion *this, int naxes, const int *axes,
+                               int *status ){
+/*
+*+
+*  Name:
+*     astRegBasePick
+
+*  Purpose:
+*     Return a Region formed by picking selected base Frame axes from the
+*     supplied Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion *astRegBasePick( AstRegion *this, int naxes, const int *axes )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  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.
+
+*  Returned Value:
+*     Pointer to the Region, or NULL if no region can be formed.
+
+*  Notes:
+*    - This base implementation returns NULL unless all base Frame axes
+*    are selected (possibly in a permuted order).
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*-
+*/
+/* Local Variables: */
+   AstFrame *fr;        /* Pointer to the Region's base Frame */
+   AstRegion *result;   /* The returned Region pointer */
+   int found;           /* Has the current axis index been found yet? */
+   int i;               /* Axis index */
+   int j;               /* Index into the "axes" array */
+   int nax;             /* No. of base Frame axes */
+   int ok;              /* Are we doing a genuine axis permutation? */
+   int unit;            /* Is the axis permutation a unit map? */
+
+/* Initialise */
+   result = NULL;
+
+/* Check the local error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the base Frame int he encapsulated FrameSet. */
+   fr = astGetFrame( this->frameset, AST__BASE );
+
+/* See how many axes it has. We only proceed if we are selecting all axes
+   in the base Frame. */
+   nax = astGetNaxes( fr );
+   if( nax == naxes ) {
+
+/* We now check that the axes array is a genuine permutation of all axes.
+   This means that all axis indices must occur once, and only once, within
+   the "axes" array. Look for each axis index in turn. */
+      unit = 1;
+      ok = 1;
+      for( i = 0; i < nax && ok; i++ ) {
+
+/* Check each element of the axes array to see if it holds the axis index
+   currently being looked for. */
+         found = 0;
+         for( j = 0; j < nax; j++ ) {
+
+/* If so, if this axis index has already been found, break out of the
+   loop. */
+            if( axes[ j ] == i ) {
+               if( found ) {
+                  ok = 0;
+                  break;
+               }
+               found = 1;
+
+/* Note if we do not have a unit map (i.e. each axis is permuted onto itself). */
+               if( i != j ) unit = 0;
+            }
+         }
+
+/* If the axis index was not found, we do not have a genuine axis
+   permutation. */
+         if( !found ) ok = 0;
+      }
+
+/* If we have a genuine axis permutation, create a Region which is a copy
+   of the supplied region and set it to represent its base Frame. */
+      if( ok ) {
+         result = astCopy( this );
+         astSetRegFS( result, fr );
+
+/* If the axis selection is not equivalent to a unit mapping, we now
+   permute the axes. */
+         if( !unit ) astPermAxes( result, axes );
+      }
+   }
+
+/* Free resources. */
+   fr = astAnnul( fr );
+
+/* Returned the result. */
+   return result;
+}
+
+static double *RegCentre( AstRegion *this, double *cen, double **ptr,
+                          int index, int ifrm, int *status ){
+/*
+*+
+*  Name:
+*     astRegCentre
+
+*  Purpose:
+*     Re-centre a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double *astRegCentre( AstRegion *this, double *cen, double **ptr,
+*                           int index, int ifrm )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function shifts the centre of the supplied Region to a
+*     specified position, or returns the current centre of the Region.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     cen
+*        Pointer to an array of axis values, giving the new centre.
+*        Supply a NULL value for this in order to use "ptr" and "index" to
+*        specify the new centre.
+*     ptr
+*        Pointer to an array of pointers, one for each axis in the Region.
+*        Each pointer locates an array of axis values. This is the format
+*        returned by the PointSet method astGetPoints. Only used if "cen"
+*        is NULL.
+*     index
+*        The index of the point within the arrays identified by "ptr" at
+*        which is stored the coords for the new centre position. Only used
+*        if "cen" is NULL.
+*     ifrm
+*        Should be AST__BASE or AST__CURRENT. Indicates whether the centre
+*        position is supplied and returned in the base or current Frame of
+*        the FrameSet encapsulated within "this".
+
+*  Returned Value:
+*     If both "cen" and "ptr" are NULL then a pointer to a newly
+*     allocated dynamic array is returned which contains the centre
+*     coords of the Region. This array should be freed using astFree when
+*     no longer needed. If either of "ptr" or "cen" is not NULL, then a
+*     NULL pointer is returned.
+
+*  Notes:
+*    - Any bad (AST__BAD) centre axis values are ignored. That is, the
+*    centre value on such axes is left unchanged.
+*    - Some Region sub-classes do not have a centre. Such classes will report
+*    an AST__INTER error code if this method is called with either "ptr" or
+*    "cen" not NULL. If "ptr" and "cen" are both NULL, then no error is
+*    reported if this method is invoked on a Region of an unsuitable class,
+*    but NULL is always returned.
+
+*-
+*/
+
+/* Local Variables: */
+   double *result;
+
+/* Initialise */
+   result = NULL;
+
+/* Check the local error status. */
+   if ( !astOK ) return result;
+
+/* This abstract method must be over-ridden by each concrete sub-class
+   which allows the centre to be shifted. Report an error if this null
+   imlementation is called to set a new centre. If it is called to
+   enquire the current centre, then return a NULL pointer. */
+   if( ptr || cen ) astError( AST__INTER, "astRegCentre(%s): The %s "
+                       "class does not implement the astRegCentre method "
+                       "inherited from the Region class (internal AST "
+                       "programming error).", status, astGetClass( this ),
+                       astGetClass( this ) );
+
+   return NULL;
+}
+
+static void RegClearAttrib( AstRegion *this, const char *aattrib,
+                            char **base_attrib, int *status ) {
+/*
+*+
+*  Name:
+*     astRegClearAttrib
+
+*  Purpose:
+*     Clear an attribute value for a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astRegClearAttrib( AstRegion *this, const char *aattrib,
+*                             char **base_attrib )
+
+*  Class Membership:
+*     Region virtual function
+
+*  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.
+*     aattrib
+*        Pointer to a null terminated string holding the attribute name.
+*     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.
+*-
+*/
+
+/* Local Variables: */
+   AstFrame *frm;
+   AstMapping *junkmap;
+   AstMapping *map;
+   AstRegion *unc;
+   char *attrib;
+   char *battrib;
+   char buf1[ 100 ];
+   int *outs;
+   int axis;
+   int baxis;
+   int i;
+   int len;
+   int nc;
+   int rep;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Produce a lower case version of the attribute name string */
+   nc = strlen( aattrib );
+   attrib = astMalloc( nc + 1 );
+   for( i = 0; i < nc; i++ ) attrib[ i ] = tolower( aattrib[ i ] );
+   attrib[ nc ] = 0;
+
+/* Clear the attribute in the current Frame in the encapsulated FrameSet.
+   Use the protected astClearAttrib method which does not cause the Frame
+   to be remapped within the FrameSet. */
+   frm = astGetFrame( this->frameset, AST__CURRENT );
+   astClearAttrib( frm, attrib );
+   frm = astAnnul( frm );
+
+/* Indicate that we should use the supplied attribute name  with the base Frame. */
+   battrib = NULL;
+
+/* If the attribute name contains an axis number, we need to create a new
+   attribute name which refers to the corresponding base Frame axis
+   (since the base<->current Mapping may permute the axes). First parse the
+   supplied attribute name to locate any axis index. */
+   len = strlen( attrib );
+   if( nc = 0, ( 2 == astSscanf( attrib, "%[^(](%d) %n", buf1, &axis,
+                                 &nc ) ) && ( nc >= len ) ) {
+
+/* If found, convert the axis index from one-based to zero-based. */
+      axis--;
+
+/* See if the specified current Frame axis is connected to one and only
+   one base Frame axis. If so, get the index of the base Frame axis. */
+      map = astGetMapping( this->frameset, AST__CURRENT, AST__BASE );
+      outs = astMapSplit( map, 1, &axis, &junkmap );
+      if( junkmap && astGetNout( junkmap ) == 1 ) {
+         baxis = outs[ 0 ];
+
+/* If the base Frame axis index is different to the current Frame axis
+   index, create a new attribute name string using the base Frame axis index. */
+         if( baxis != axis ) {
+            battrib = astMalloc( strlen( attrib ) + 10 );
+            if( battrib ) sprintf( battrib, "%s(%d)", buf1, baxis + 1 );
+         }
+
+/* If there is no one base Frame axis which corresponds to the supplied
+   current Frame axis, report an error. */
+      } else if( astOK ) {
+         astError( AST__INTER, "astRegClearAttrib(%s): Unable to clear "
+                   "attribute \"%s\" in the base Frame of the %s", status,
+                   astGetClass( this ), attrib, astGetClass( this ) );
+         astError( AST__INTER, "There is no base Frame axis corresponding "
+                   "to current Frame axis %d\n", status, axis + 1 );
+      }
+
+/* Free resources */
+      outs = astFree( outs );
+      if( junkmap ) junkmap = astAnnul( junkmap );
+      map = astAnnul( map );
+   }
+
+/* Clear the appropriate attribute name in the base Frame. This time ensure
+   that any error caused by the attribute name is annulled. Also clear it in
+   any uncertainty Region (the current Frame of the uncertainty Region is
+   assumed to be equivalent to the base Frame of the parent Region). */
+   frm = astGetFrame( this->frameset, AST__BASE );
+   if( frm ) {
+      rep = astReporting( 0 );
+      astClearAttrib( frm, battrib ? battrib : attrib );
+      if( astTestUnc( this ) ) {
+         unc = astGetUncFrm( this, AST__BASE );
+         astRegClearAttrib( unc, battrib ? battrib : attrib, NULL );
+         unc = astAnnul( unc );
+      }
+      if( astStatus == AST__BADAT ) astClearStatus;
+      astReporting( rep );
+   }
+   frm = astAnnul( frm );
+
+/* If required return the modified base Frame attribute name. Otherwise,
+   free it. */
+   if( base_attrib ) {
+      if( battrib ) {
+         *base_attrib = battrib;
+      } else {
+         *base_attrib = astStore( NULL, attrib, strlen( attrib ) + 1 );
+      }
+   } else {
+      battrib = astFree( battrib );
+   }
+
+/* Since the base Frame has been changed, any cached information calculated
+   on the basis of the base Frame properties may no longer be up to date. */
+   astResetCache( this );
+
+/* Free resources. */
+   attrib = astFree( attrib );
+
+}
+
+static AstPointSet *RegGrid( AstRegion *this, int *status ){
+/*
+*+
+*  Name:
+*     astRegGrid
+
+*  Purpose:
+*     Return a PointSet containing points spread through the volume of a
+*     Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *astRegGrid( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a PointSet containing a mesh of points spread
+*     throughout the volume of the Region. The points refer to the current
+*     Frame of the encapsulated FrameSet.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     Pointer to the PointSet. The axis values in this PointSet will have
+*     associated accuracies derived from the uncertainties which were
+*     supplied when the Region was created. Annul the pointer using
+*     astAnnul when it is no longer needed.
+
+*  Notes:
+*    - It should not be assumed that the returned points are evenly
+*    spaced withint he volume.
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*-
+*/
+
+/* Local Variables; */
+   AstMapping *map;          /* Base -> current Frame Mapping */
+   AstPointSet *result;      /* Pointer to returned PointSet */
+
+/* Initialise the returned pointer */
+   result = NULL;
+
+/* Check the local error status. */
+   if ( !astOK ) return result;
+
+/* If the Region structure does not contain a pointer to a PointSet holding
+   positions evenly spread over the volume of the Region in the base
+   Frame, create one now. Note, we cannot cache the grid in the current
+   Frame in this way since the current Frame grid depends on the proprties
+   of the current Frame (e.g. System) which can be changed at any time. */
+   if( !this->basegrid ) this->basegrid = astRegBaseGrid( this );
+
+/* Get the simplified base->current Mapping */
+   map = astRegMapping( this );
+
+/* If the Mapping is a UnitMap, just return a clone of the PointSet
+   pointer stored in the Region structure. */
+   if( astIsAUnitMap( map ) ){
+      result = astClone( this->basegrid );
+
+/* Otherwise, create a new PointSet holding the above points transformed
+   into the current Frame. */
+   } else {
+      result = astTransform( map, this->basegrid, 1, NULL );
+   }
+
+/* Free resources.*/
+   map = astAnnul( map );
+
+/* If an error has occurred, annul the returned PointSet. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+static AstPointSet *RegMesh( AstRegion *this, int *status ){
+/*
+*+
+*  Name:
+*     astRegMesh
+
+*  Purpose:
+*     Return a PointSet containing points spread over the boundary of a
+*     Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *astRegMesh( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a PointSet containing a mesh of points on the
+*     boundary of the Region. The points refer to the current Frame of
+*     the encapsulated FrameSet.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     Pointer to the PointSet. The axis values in this PointSet will have
+*     associated accuracies derived from the uncertainties which were
+*     supplied when the Region was created. Annul the pointer using
+*     astAnnul when it is no longer needed.
+
+*  Notes:
+*    - It should not be assumed that the returned points are evenly
+*    spaced on the boundary.
+*    - A NULL pointer is returned if an error has already occurred, or if
+*    this function should fail for any reason.
+*-
+*/
+
+/* Local Variables; */
+   AstMapping *map;          /* Base -> current Frame Mapping */
+   AstPointSet *bmesh;       /* Base Frame mesh */
+   AstPointSet *result;      /* Pointer to returned PointSet */
+
+/* Initialise the returned pointer */
+   result = NULL;
+
+/* Check the local error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to a PointSet holding positions evenly spread over the
+   boundary of the Region in the base Frame. */
+   bmesh = astRegBaseMesh( this );
+
+/* Get the simplified base->current Mapping */
+   map = astRegMapping( this );
+
+/* If the Mapping is a UnitMap, just return a clone of the mesh PointSet
+   pointer. */
+   if( astIsAUnitMap( map ) ){
+      result = astClone( bmesh );
+
+/* Otherwise, create a new PointSet holding the above points transformed
+   into the current Frame. */
+   } else {
+      result = astTransform( map, bmesh, 1, NULL );
+   }
+
+/* Free resources.*/
+   bmesh = astAnnul( bmesh );
+   map = astAnnul( map );
+
+/* If an error has occurred, annul the returned PointSet. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+static int RegDummyFS( AstRegion *this, int *status ){
+/*
+*+
+*  Name:
+*     astRegDummyFS
+
+*  Purpose:
+*     Check if a Region has a dummy FrameSet.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int astRegDummyFS( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a flag indicating if the supplied Region has
+*     a dummy FrameSet.
+*
+*     The astDump method for a Region may choose not to include the
+*     Region's FrameSet in the dump, depending on the value of the
+*     RegionFS attribute and the nature of the FrameSet. If the FrameSet
+*     is omitted from the Dump, then special action has to be taken when
+*     the dump is subsequently read in and used to re-create the Region.
+*     On encounterting such a dump, the astLoadRegion function will create
+*     a dummy FrameSet and associate it with the reconstructed  Region.
+*     The new Region should not be used however until this dummy FrameSet
+*     has been replaced by the correct FrameSet. Performing this replacement
+*     is the responsibility of the parent class (i.e. the class which choose
+*     to omit the FrameSet from the dump). These will usually be Region
+*     classes which encapsulate other Regions, such as CmpRegion, Prism,
+*     Stc, etc.
+*
+*     This function can be used by astLoad... methods in sub-classes to
+*     determine if a newly loaded component Region has a dummy FrameSet. If
+*     so the astLoad function should either use the astSetRegFS method to
+*     store a new FrameSet in the component Region. If the parent Region
+*     itself has a dummy FrameSet (i.e. is a component Region contained
+*     within a higher level Region) then it cannot do this and should
+*     ignore the presence of the dummy FrameSet (it then becomes the
+*     responsibility of hte parent Region to load appropriate FrameSets
+*     into all its components).
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+
+*  Returned Value:
+*     Non-zero if the Region has a dummy FrameSet.
+
+*-
+*/
+
+/* Check the inherited status. */
+   if( !astOK ) return 0;
+
+/* The Ident attribute of the FrameSet will be set to DUMMY_FS if the
+   FrameSet is a dummy. */
+   return !strcmp( astGetIdent( this->frameset ), DUMMY_FS );
+}
+
+static int RegPins( AstRegion *this, AstPointSet *pset, AstRegion *unc,
+                    int **mask, int *status ){
+/*
+*+
+*  Name:
+*     astRegPins
+
+*  Purpose:
+*     Check if a set of points fall on the boundary of a given Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int astRegPins( AstRegion *this, AstPointSet *pset, AstRegion *unc,
+*                     int **mask )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function returns a flag indicating if the supplied set of
+*     points all fall on the boundary of the given Region.
+*
+*     Some tolerance is allowed, as specified by the uncertainty Region
+*     stored in the supplied Region "this", and the supplied uncertainty
+*     Region "unc" which describes the uncertainty of the supplied points.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     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.
+
+*  Returned Value:
+*     Non-zero if the points all fall on the boundary of the given
+*     Region, to within the tolerance specified. Zero otherwise.
+
+*-
+*/
+
+/* Check the inherited status. */
+   if( !astOK ) return 0;
+
+/* This abstract implementation simply reports an error. All sub-classes of
+   Region should over-ride this to return appropriate values. */
+   astError( AST__INTER, "astRegPins(%s): The %s class does not implement "
+             "the astRegPins method inherited from the Region class "
+             "(internal AST programming error).", status, astGetClass( this ),
+             astGetClass( this ) );
+   return 0;
+}
+
+static void GetRegionBounds( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+/*
+*++
+*  Name:
+c     astGetRegionBounds
+f     AST_GETREGIONBOUNDS
+
+*  Purpose:
+*     Returns the bounding box of Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     void astGetRegionBounds( AstRegion *this, double *lbnd, double *ubnd )
+f     CALL AST_GETREGIONBOUNDS( THIS, LBND, UBND, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+c     This function
+f     This routine
+*     returns the upper and lower limits of a box which just encompasses
+*     the supplied Region. The limits are returned as axis values within
+*     the Frame represented by the Region. The value of the Negated
+*     attribute is ignored (i.e. it is assumed that the Region has not
+*     been negated).
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+c     lbnd
+f     LBND() = DOUBLE PRECISION (Returned)
+c        Pointer to an
+f        An
+*        array in which to return the lower axis bounds covered by the Region.
+*        It should have at least as many elements as there are axes in the
+*        Region. If an axis has no lower limit, the returned value will
+*        be the largest possible negative value.
+c     ubnd
+f     UBND() = DOUBLE PRECISION (Returned)
+c        Pointer to an
+f        An
+*        array in which to return the upper axis bounds covered by the Region.
+*        It should have at least as many elements as there are axes in the
+*        Region. If an axis has no upper limit, the returned value will
+*        be the largest possible positive value.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Notes:
+*    - The value of the Negated attribute is ignored (i.e. it is assumed that
+*    the Region has not been negated).
+*    - If an axis has no extent on an axis then the lower limit will be
+*    returned larger than the upper limit. Note, this is different to an
+*    axis which has a constant value (in which case both lower and upper
+*    limit will be returned set to the constant value).
+*    - If the bounds on an axis cannot be determined, AST__BAD is returned for
+*    both upper and lower bounds
+
+*--
+*/
+
+/* Local Variables: */
+   AstFrame *frm;             /* Current Frame */
+   AstMapping *smap;          /* Simplified base -> current Mapping */
+   AstPointSet *bmesh;        /* PointSet holding base Frame mesh */
+   AstPointSet *cmesh;        /* PointSet holding current Frame mesh */
+   double **bptr;             /* Pointer to PointSet coord arrays */
+   double **cptr;             /* Pointer to PointSet coord arrays */
+   double *blbnd;             /* Lower bounds in base Frame */
+   double *bubnd;             /* Upper bounds in base Frame */
+   double *p;                 /* Array of values for current axis */
+   double width;              /* Width of bounding box on i'th axis */
+   int i;                     /* Axis count */
+   int ip;                    /* Index of current corner */
+   int j;                     /* Timer for low/high swaps */
+   int jmax;                  /* Increment between low/high swaps */
+   int lo;                    /* Assign low bound to next corner? */
+   int nbase;                 /* Number of base Frame axes */
+   int ncur;                  /* Number of current Frame axes */
+   int npos;                  /* Number of box corners */
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* Get the simplified base to current Mapping. */
+   smap = astRegMapping( this );
+
+/* If the simplified Mapping is a UnitMap, just store the base box bounds
+   in the returned arrays */
+   if( astIsAUnitMap( smap ) ) {
+      astRegBaseBox( this, lbnd, ubnd );
+
+/* Otherwise, we get a mesh of points over the boundary of the Region within
+   the base Frame, transform them into the current Frame, and find their bounds. */
+   } else {
+
+/* If the Region is bounded, we can get a genuine mesh of points on the
+   boundary of the Region. */
+      if( astGetBounded( this ) ) {
+         bmesh = astRegBaseMesh( this );
+
+/* If the Region is not bounded, no mesh can be created so we use the
+   corners of the base frame bounding box instead. */
+      } else {
+
+/* Get workspace to hold the bounds of the region within the base Frame. */
+         nbase = astGetNin( smap );
+         blbnd = astMalloc( sizeof( double )*nbase );
+         bubnd = astMalloc( sizeof( double )*nbase );
+
+/* Get the base Frame bounding box. */
+         astRegBaseBox( this, blbnd, bubnd );
+
+/* Get the number of corners in the base Frame bounding box. */
+         npos = pow( 2, nbase );
+
+/* Create a PointSet to hold the positions at the corners in the base
+   frame box. */
+         bmesh = astPointSet( npos, nbase, " ", status );
+         bptr = astGetPoints( bmesh );
+         if( bptr ) {
+
+/* Store the coordinates of the box corners in the PointSet. */
+            jmax = 1;
+            for( i = 0; i < nbase; i++ ) {
+               p = bptr[ i ];
+
+               lo = 1;
+               j = 0;
+               for( ip = 0; ip < npos; ip++,j++ ) {
+                  if( j == jmax ) {
+                     lo = 1 - lo;
+                     j = 0;
+                  }
+                  p[ ip ] = lo ? blbnd[ i ] : bubnd[ i ];
+               }
+
+               jmax *= 2;
+            }
+         }
+
+/* Release resources. */
+         blbnd = astFree( blbnd );
+         bubnd = astFree( bubnd );
+      }
+
+/* Create a new PointSet holding the above points transformed into the
+   current Frame. */
+      cmesh = astTransform( smap, bmesh, 1, NULL );
+
+/* There is a possibility that these points may span a singularity in the
+   coordinate system such as the RA=0 line in a SkyFrame. So ensure the
+   axis values are normalised into the shortest possible range. */
+      frm = astGetFrame( this->frameset, AST__CURRENT );
+      ncur = astGetNaxes( frm );
+
+      cptr = astGetPoints( cmesh );
+      npos = astGetNpoint( cmesh );
+      for( i = 0; i < ncur; i++ ) {
+         astAxNorm( frm, i+1, 1, npos, cptr[i] );
+      }
+
+/* Get the axis bounds of this PointSet. */
+      astBndPoints( cmesh, lbnd, ubnd );
+
+/* There is again a possibility that these bounds may span a singularity in
+   the coordinate system such as the RA=0 line in a SkyFrame. So for each
+   axis we ensure the width (i.e. "ubnd-lbnd" ) is correct. */
+      for( i = 0; i < ncur; i++ ) {
+         width = astAxDistance( frm, i + 1, lbnd[ i ], ubnd[ i ] );
+         if( width != AST__BAD ) {
+            ubnd[ i ] = lbnd[ i ] + width;
+         } else {
+            ubnd[ i ] = AST__BAD;
+            lbnd[ i ] = AST__BAD;
+         }
+      }
+
+/* Release resources. */
+      frm = astAnnul( frm );
+      bmesh = astAnnul( bmesh );
+      cmesh = astAnnul( cmesh );
+   }
+   smap = astAnnul( smap );
+}
+
+static void GetRegionBounds2( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+/*
+*+
+*  Name:
+*     astGetRegionBounds
+
+*  Purpose:
+*     Returns the bounding box of Region.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astGetRegionBounds2( AstRegion *this, double *lbnd, double *ubnd )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function is like astGetRegionBounds, in that it returns the upper
+*     and lower limits of a box which just encompasses the supplied Region,
+*     as axis values within the Frame represented by the Region. 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. It should have at least as many elements
+*        as there are axes in the Region.
+*     ubnd
+*        Pointer to an array in which to return the upper axis bounds
+*        covered by the Region. It should have at least as many elements
+*        as there are axes in the Region.
+
+*  Notes:
+*    - The value of the Negated attribute is ignored (i.e. it is assumed that
+*    the Region has not been negated). The Nagated attributes of any
+*    component Regions are also ignored.
+
+*-
+*/
+
+/* Local Variables: */
+   AstMapping *smap;          /* Simplified base -> current Mapping */
+   double *lbndb;             /* Pointer to lower bounds on base box */
+   double *ubndb;             /* Pointer to upper bounds on base box */
+   int i;                     /* Axis count */
+   int nbase;                 /* Number of base Frame axes */
+   int ncur;                  /* Number of current Frame axes */
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* Find the number of axes in the base and current Frames of the
+   encapsulated FrameSet. */
+   nbase = astGetNin( this->frameset );
+   ncur = astGetNout( this->frameset );
+
+/* Get the bounding box in the base Frame of the encapsulated FrameSet. */
+   lbndb = astMalloc( sizeof( double )*(size_t) nbase );
+   ubndb = astMalloc( sizeof( double )*(size_t) nbase );
+   astRegBaseBox2( this, lbndb, ubndb );
+
+/* Get the simplified base to current Mapping. */
+   smap = astRegMapping( this );
+
+/* Check pointers can be used safely. */
+   if( smap ) {
+
+/* If the simplified Mapping is a UnitMap, just copy the base box bounds
+   to the returned arrays */
+      if( astIsAUnitMap( smap ) ) {
+         for( i = 0; i < ncur; i++ ) {
+            lbnd[ i ] = lbndb[ i ];
+            ubnd[ i ] = ubndb[ i ];
+         }
+
+/* Otherwise, use astMapBox to find the corresponding current Frame
+   limits. */
+      } else {
+         for( i = 0; i < ncur; i++ ) {
+            astMapBox( smap, lbndb, ubndb, 1, i, lbnd + i, ubnd + i,
+                       NULL, NULL );
+         }
+      }
+   }
+
+/* Release resources. */
+   smap = astAnnul( smap );
+   lbndb = astFree( lbndb );
+   ubndb = astFree( ubndb );
+}
+
+static void GetRegionMesh( AstRegion *this, int surface, int maxpoint,
+                           int maxcoord, int *npoint, double *points,
+                           int *status ){
+/*
+*++
+*  Name:
+c     astGetRegionMesh
+f     AST_GETREGIONMESH
+
+*  Purpose:
+*     Return a mesh of points covering the surface or volume of a Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     void astGetRegionMesh( AstRegion *this, int surface, int maxpoint,
+c                            int maxcoord, int *npoint, double *points )
+f     CALL AST_GETREGIONMESH( THIS, SURFACE, MAXPOINT, MAXCOORD, NPOINT,
+f                             POINTS, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+c     This function
+f     This routine
+*     returns the axis values at a mesh of points either covering the
+*     surface (i.e. boundary) of the supplied Region, or filling the
+*     interior (i.e. volume) of the Region. The number of points in
+*     the mesh is approximately equal to the MeshSize attribute.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+c     surface
+f     SURFACE = LOGICAL (Given)
+c        If non-zero,
+f        If .TRUE.,
+*        the returned points will cover the surface or the Region.
+*        Otherwise, they will fill the interior of the Region.
+c     maxpoint
+f     MAXPOINT = INTEGER (Given)
+*        If zero, the number of points in the mesh is returned in
+c        "*npoint",
+f        NPOINT,
+*        but no axis values are returned and all other parameters are ignored.
+*        If not zero, the supplied value should be the length of the
+c        second dimension of the "points"
+f        first dimension of the POINTS
+*        array. An error is reported if the number of points in the mesh
+*        exceeds this number.
+c     maxcoord
+f     MAXCOORD = INTEGER (Given)
+*        The length of the
+c        first dimension of the "points" array.
+f        second dimension of the POINTS array.
+*        An error is reported if the number of axes in the supplied Region
+*        exceeds this number.
+c     npoint
+f     NPOINT = INTEGER (Returned)
+c        A pointer to an integer in which to return the
+f        The
+*        number of points in the returned mesh.
+c     points
+f     POINTS( MAXPOINT, MAXCOORD ) = DOUBLE PRECISION (Returned)
+c        The address of the first element in a 2-dimensional array of
+c        shape "[maxcoord][maxpoint]", in which to return the coordinate
+c        values at the mesh positions. These are stored such that the
+c        value of coordinate number "coord" for point number "point" is
+c        found in element "points[coord][point]".
+f        An array in which to return the coordinates values at the mesh
+f        positions. These are stored such that the value of coordinate
+f        number COORD for point number POINT is found in element
+f        POINTS(POINT,COORD).
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Notes:
+*     - An error is reported if the Region is unbounded.
+*     - If the coordinate system represented by the Region has been
+*     changed since it was first created, the returned axis values refer
+*     to the new (changed) coordinate system, rather than the original
+*     coordinate system. Note however that if the transformation from
+*     original to new coordinate system is non-linear, the shape within
+*     the new coordinate system may be distorted, and so may not match
+*     that implied by the name of the Region subclass (Circle, Box, etc).
+
+*--
+*/
+
+/* Local Variables: */
+   AstPointSet *pset;       /* PointSet holding mesh/grid axis values */
+   double **ptr;            /* Pointer to mesh/grid axes values */
+   double *p;               /* Pointer to next input axis value */
+   double *q;               /* Pointer to next output axis value */
+   int j;                   /* Axis index */
+   int nc;                  /* No. of axes to copy */
+
+/* Initialise */
+   *npoint = 0;
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* Report an error if the Region is unbounded. */
+   if( !astGetBounded( this ) ) {
+      if( astOK ) astError( AST__MBBNF, "astGetRegionMesh(%s): The supplied %s"
+                            " is unbounded so no mesh can be created to cover "
+                            "it.", status, astGetClass( this ), astGetClass( this ) );
+   } else {
+
+/* Get the mesh or grid as required. If only the size of the mesh or grid
+   is required, get it in the base Frame as there is no need to spend the
+   extra time transforming it into the current Frame. */
+      if( maxpoint == 0  ){
+         if( surface ) {
+            pset = astRegBaseMesh( this );
+         } else {
+            pset = astRegBaseGrid( this );
+         }
+      } else {
+         if( surface ) {
+            pset = astRegMesh( this );
+         } else {
+            pset = astRegGrid( this );
+         }
+      }
+
+/* Return the number of points in the mesh or grid. */
+      *npoint = astGetNpoint( pset );
+
+/* Do nothing more unless a non-zero array size was supplied. */
+      if( *npoint > 0 && maxpoint != 0 && astOK ) {
+
+/* Check the supplied array is large enough. */
+         if( *npoint > maxpoint ) {
+            astError( AST__DIMIN, "astGetRegionMesh(%s): The supplied "
+                      "array can hold up to %d points but the %s supplied "
+                      "has %d points on its mesh (programming error).",
+                      status, astGetClass( this ), maxpoint, astGetClass( this ),
+                      *npoint );
+         }
+
+/* Get the dimensionality of the PointSet, and get a pointer to the axis
+   values. */
+         nc = astGetNcoord( pset );
+         ptr = astGetPoints( pset );
+
+/* Check pointers can be used safely. */
+         if ( astOK ) {
+
+/* Check the supplied array has room for all the axes. */
+            if( nc > maxcoord ) {
+               astError( AST__DIMIN, "astGetRegionMesh(%s): The supplied "
+                         "array can hold up to %d axes but the %s supplied "
+                         "has %d axes (programming error).", status,
+                         astGetClass( this ), maxcoord, astGetClass( this ), nc );
+
+/* If all is OK, copy the current Frame axis values into the supplied array. */
+            } else {
+
+/* Loop round the axes to be copied. */
+               for( j = 0; j < nc; j++ ) {
+
+/* Get points to the first element of the input and output arrays. */
+                  p = ptr[ j ];
+                  q = points + j*maxpoint;
+
+/* Copying the axis values. */
+                  (void) memcpy( q, p, sizeof( double )*( *npoint ) );
+               }
+            }
+         }
+      }
+
+/* Free resources. */
+      pset = astAnnul( pset );
+   }
+}
+
+static void GetRegionPoints( AstRegion *this, int maxpoint, int maxcoord,
+                             int *npoint, double *points, int *status ){
+/*
+*++
+*  Name:
+c     astGetRegionPoints
+f     AST_GETREGIONPOINTS
+
+*  Purpose:
+*     Returns the positions that define the given Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     void astGetRegionPoints( AstRegion *this, int maxpoint, int maxcoord,
+c                              int *npoint, double *points )
+f     CALL AST_GETREGIONPOINTS( THIS, MAXPOINT, MAXCOORD, NPOINT, POINTS,
+f                               STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+c     This function
+f     This routine
+*     returns the axis values at the points that define the supplied
+*     Region. The particular meaning of these points will depend on the
+*     type of class supplied, as listed below under "Applicability:".
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+c     maxpoint
+f     MAXPOINT = INTEGER (Given)
+*        If zero, the number of points needed to define the Region is
+*        returned in
+c        "*npoint",
+f        NPOINT,
+*        but no axis values are returned and all other parameters are ignored.
+*        If not zero, the supplied value should be the length of the
+c        second dimension of the "points"
+f        first dimension of the POINTS
+*        array. An error is reported if the number of points needed to define
+*        the Region exceeds this number.
+c     maxcoord
+f     MAXCOORD = INTEGER (Given)
+*        The length of the
+c        first dimension of the "points" array.
+f        second dimension of the POINTS array.
+*        An error is reported if the number of axes in the supplied Region
+*        exceeds this number.
+c     npoint
+f     NPOINT = INTEGER (Returned)
+c        A pointer to an integer in which to return the
+f        The
+*        number of points defining the Region.
+c     points
+f     POINTS( MAXPOINT, MAXCOORD ) = DOUBLE PRECISION (Returned)
+c        The address of the first element in a 2-dimensional array of
+c        shape "[maxcoord][maxpoint]", in which to return
+c        the coordinate values at the positions that define the Region.
+c        These are stored such that the value of coordinate number
+c        "coord" for point number "point" is found in element
+c        "points[coord][point]".
+f        An array in which to return the coordinates values at the
+f        positions that define the Region. These are stored such that the
+f        value of coordinate number COORD for point number POINT
+f        is found in element POINTS(POINT,COORD).
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Applicability:
+*     Region
+*        All Regions have this attribute.
+*     Box
+*        The first returned position is the Box centre, and the second is
+*        a Box corner.
+*     Circle
+*        The first returned position is the Circle centre, and the second is
+*        a point on the circumference.
+*     CmpRegion
+*        Returns a value of zero for
+c        "*npoint"
+f        NPOINT
+*        and leaves the supplied array contents unchanged. To find the
+*        points defining a CmpRegion, use this method on the component
+*        Regions, which can be accessed by invoking
+c        astDecompose
+f        AST_DECOMPOSE
+*        on the CmpRegion.
+*     Ellipse
+*        The first returned position is the Ellipse centre. The second is
+*        the end of one of the axes of the ellipse. The third is some
+*        other point on the circumference of the ellipse, distinct from
+*        the second point.
+*     Interval
+*        The first point corresponds to the lower bounds position, and
+*        the second point corresponds to the upper bounds position. These
+*        are reversed to indicate an extcluded interval rather than an
+*        included interval. See the Interval constructor for more
+*        information.
+*     NullRegion
+*        Returns a value of zero for
+c        "*npoint"
+f        NPOINT
+*        and leaves the supplied array contents unchanged.
+*     PointList
+*        The positions returned are those that were supplied when the
+*        PointList was constructed.
+*     Polygon
+*        The positions returned are the vertex positions that were supplied
+*        when the Polygon was constructed.
+*     Prism
+*        Returns a value of zero for
+c        "*npoint"
+f        NPOINT
+*        and leaves the supplied array contents unchanged. To find the
+*        points defining a Prism, use this method on the component
+*        Regions, which can be accessed by invoking
+c        astDecompose
+f        AST_DECOMPOSE
+*        on the CmpRegion.
+
+*  Notes:
+*     - If the coordinate system represented by the Region has been
+*     changed since it was first created, the returned axis values refer
+*     to the new (changed) coordinate system, rather than the original
+*     coordinate system. Note however that if the transformation from
+*     original to new coordinate system is non-linear, the shape within
+*     the new coordinate system may be distorted, and so may not match
+*     that implied by the name of the Region subclass (Circle, Box, etc).
+
+*--
+*/
+
+/* Local Variables: */
+   AstPointSet *pset;       /* PointSet holding PointList axis values */
+   double **ptr;            /* Pointer to axes values in the PointList */
+   double *p;               /* Pointer to next input axis value */
+   double *q;               /* Pointer to next output axis value */
+   int j;                   /* Axis index */
+   int nc;                  /* No. of axes to copy */
+
+/* Initialise */
+   *npoint = 0;
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* Return the number of points used to define the Region, if any. */
+   *npoint = this->points ? astGetNpoint( this->points ) : 0;
+
+/* Do nothing more unless a non-zero array size was supplied. */
+   if( *npoint > 0 && maxpoint != 0 ) {
+
+/* Transform the base Frame axis values into the current Frame. */
+      pset = astTransform( this->frameset, this->points, 1, NULL );
+
+/* Get the dimensionality of this PointList, and get a pointer to the axis
+   values. */
+      nc = astGetNcoord( pset );
+      ptr = astGetPoints( pset );
+
+/* Check pointers can be used safely. */
+      if ( astOK ) {
+
+/* Check the supplied array has room for all the axis values. */
+         if( nc > maxcoord ) {
+            astError( AST__DIMIN, "astGetRegionPoints(%s): The supplied "
+                      "array can hold up to %d axes but the %s supplied "
+                      "has %d axes (programming error).", status,
+                      astGetClass( this ), maxcoord, astGetClass( this ), nc );
+
+         } else if( *npoint > maxpoint ) {
+            astError( AST__DIMIN, "astGetRegionPoints(%s): The supplied "
+                      "array can hold up to %d points but the %s supplied "
+                      "requires %d points to describe it (programming "
+                      "error).", status, astGetClass( this ), maxpoint,
+                       astGetClass( this ), *npoint );
+
+/* If all is OK, copy the transformed axis values into the supplied array. */
+         } else {
+
+/* Loop round the axes to be copied. */
+            for( j = 0; j < nc; j++ ) {
+
+/* Get points to the first element of the input and output arrays. */
+               p = ptr[ j ];
+               q = points + j*maxpoint;
+
+/* Copying the axis values. */
+               (void) memcpy( q, p, sizeof( double )*( *npoint ) );
+            }
+         }
+      }
+
+/* Free resources. */
+      pset = astAnnul( pset );
+
+   }
+}
+
+static void RegOverlay( AstRegion *this, AstRegion *that, int unc, int *status ){
+/*
+*+
+*  Name:
+*     astRegOverlay
+
+*  Purpose:
+*     Copy properties from one Region to another.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astRegOverlay( AstRegion *this, AstRegion *that, int unc )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  Description:
+*     This function copies selected properties from "that" to "this".
+*     It is intended to be called by sub-classes which need to create a
+*     similar copy of an existing Region. For instance, subclass
+*     implementations of the Simplify method will usually use this
+*     function to ensure that the simplified Region loooks like the original
+*     Region.
+
+*  Parameters:
+*     this
+*        Pointer to the new Region.
+*     that
+*        Pointer to the old Region.
+*     unc
+*        If non-zero, any uncertainty in "this" is cleared if "that" has
+*        no uncertainty. If zero, any uncertainty in "this" is left
+*        unchanged.
+*-
+*/
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* Copy the required attribute values. */
+   this->negated = that->negated;
+   this->closed = that->closed;
+   this->regionfs = that->regionfs;
+   this->adaptive = that->adaptive;
+
+/* Clear things that depend on the number of axes. */
+   if( astGetNaxes( this ) == astGetNaxes( that ) ) {
+      if( astTestMeshSize( that ) ) astSetMeshSize( this, astGetMeshSize( that ) );
+      if( astTestFillFactor( that ) ) astSetFillFactor( this, astGetFillFactor( that ) );
+   } else {
+      astClearMeshSize( this );
+      astClearFillFactor( this );
+   }
+
+/* If required, clear uncertainty in "this" if "that" has no uncertainty. */
+   if( unc && !astTestUnc( that ) ) astClearUnc( this );
+
+}
+
+static void RegSetAttrib( AstRegion *this, const char *asetting,
+                          char **base_setting, int *status ) {
+/*
+*+
+*  Name:
+*     astRegSetAttrib
+
+*  Purpose:
+*     Set an attribute value for a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astRegSetAttrib( AstRegion *this, const char *asetting,
+*                           char **base_setting )
+
+*  Class Membership:
+*     Region virtual function
+
+*  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.
+*     asetting
+*        Pointer to a null terminated attribute setting string. 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.
+*-
+*/
+
+/* Local Variables: */
+   AstFrame *frm;
+   AstMapping *junkmap;
+   AstMapping *map;
+   AstRegion *unc;
+   char *setting;
+   char *bsetting;
+   char buf1[ 100 ];
+   int *outs;
+   int axis;
+   int baxis;
+   int i;
+   int len;
+   int nc;
+   int rep;
+   int value;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Produce a lower case version of the setting string */
+   nc = strlen( asetting );
+   setting = astMalloc( nc + 1 );
+   for( i = 0; i < nc; i++ ) setting[ i ] = tolower( asetting[ i ] );
+   setting[ nc ] = 0;
+
+/* Apply the setting to the current Frame in the encapsulated FrameSet.
+   Use the protected astSetAttrib method which does not cause the Frame
+   to be remapped within the FrameSet. */
+   frm = astGetFrame( this->frameset, AST__CURRENT );
+   astSetAttrib( frm, setting );
+   frm = astAnnul( frm );
+
+/* Indicate that we should use the supplied setting with the base Frame. */
+   bsetting = NULL;
+
+/* If the attribute name contains an axis number, we need to create a new
+   attribute setting which refers to the corresponding base Frame axis
+   (since the base<->current Mapping may permute the axes). First parse the
+   supplied attribute setting to locate any axis index. */
+   len = strlen( setting );
+   if( nc = 0, ( 2 == astSscanf( setting, "%[^(](%d)= %n%*s %n", buf1, &axis,
+                                 &value, &nc ) ) && ( nc >= len ) ) {
+
+/* If found, convert the axis index from one-based to zero-based. */
+      axis--;
+
+/* See if the specified current Frame axis is connected to one and only
+   one base Frame axis. If so, get the index of the base Frame axis. */
+      map = astGetMapping( this->frameset, AST__CURRENT, AST__BASE );
+      outs = astMapSplit( map, 1, &axis, &junkmap );
+      if( junkmap && astGetNout( junkmap ) == 1 ) {
+         baxis = outs[ 0 ];
+
+/* If the base Frame axis index is different to the current Frame axis
+   index, create a new setting string using the base Frame axis index. */
+         if( baxis != axis ) {
+            bsetting = astMalloc( strlen( setting ) + 10 );
+            if( bsetting ) {
+               sprintf( bsetting, "%s(%d)=%s", buf1, baxis + 1, setting + value );
+            }
+         }
+
+/* If there is no one base Frame axis which corresponds to the supplied
+   current Frame axis, report an error. */
+      } else if( astOK ) {
+         astError( AST__INTER, "astRegSetAttrib(%s): Unable to apply "
+                   "attribute setting \"%s\" to the base Frame in the %s", status,
+                   astGetClass( this ), setting, astGetClass( this ) );
+         astError( AST__INTER, "There is no base Frame axis corresponding "
+                   "to current Frame axis %d\n", status, axis + 1 );
+      }
+
+/* Free resources */
+      outs = astFree( outs );
+      if( junkmap ) junkmap = astAnnul( junkmap );
+      map = astAnnul( map );
+   }
+
+/* Apply the appropriate attribute setting to the base Frame. This time
+   ensure that any error caused by the attribute setting is annulled.
+   Also apply it to any uncertainty Region (the current Frame of the
+   uncertainty Region is assumed to be equivalent to the base Frame of the
+   parent Region). */
+   frm = astGetFrame( this->frameset, AST__BASE );
+   if( frm ) {
+      rep = astReporting( 0 );
+      astSetAttrib( frm, bsetting ? bsetting : setting );
+      if( astTestUnc( this ) ) {
+         unc = astGetUncFrm( this, AST__BASE );
+         astRegSetAttrib( unc, bsetting ? bsetting : setting, NULL );
+         unc = astAnnul( unc );
+      }
+      if( astStatus == AST__BADAT ) astClearStatus;
+      astReporting( rep );
+   }
+   frm = astAnnul( frm );
+
+/* If required return the modified base Frame setting. Otherwise, free it. */
+   if( base_setting ) {
+      if( bsetting ) {
+         *base_setting = bsetting;
+      } else {
+         *base_setting = astStore( NULL, setting, strlen( setting ) + 1 );
+      }
+   } else {
+      bsetting = astFree( bsetting );
+   }
+
+/* Since the base Frame has been changed, any cached information calculated
+   on the basis of the base Frame properties may no longer be up to date. */
+   astResetCache( this );
+
+/* Free resources. */
+   setting = astFree( setting );
+
+}
+
+static AstMapping *RemoveRegions( AstMapping *this_mapping, int *status ) {
+/*
+*  Name:
+*     RemoveRegions
+
+*  Purpose:
+*     Remove any Regions from a Mapping.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstMapping *RemoveRegions( AstMapping *this, int *status )
+
+*  Class Membership:
+*     Region method (over-rides the astRemoveRegions method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function searches the supplied Mapping (which may be a
+*     compound Mapping such as a CmpMap) for any component Mappings
+*     that are instances of the AST Region class. It then creates a new
+*     Mapping from which all Regions have been removed. If a Region
+*     cannot simply be removed (for instance, if it is a component of a
+*     parallel CmpMap), then it is replaced with an equivalent UnitMap
+*     in the returned Mapping.
+*
+*     The implementation provided by the Region class just returns the
+*     equivalent Frame.
+
+*  Parameters:
+*     this
+*        Pointer to the original Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer to the modified mapping.
+
+*  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.
+*/
+
+/* The Region class just returns a pointer to a deep copy of the Region's
+   equivalent Frame. */
+   return astGetRegionFrame( (AstRegion *)this_mapping );
+}
+
+static void ReportPoints( AstMapping *this_mapping, int forward,
+                          AstPointSet *in_points, AstPointSet *out_points, int *status ) {
+/*
+*  Name:
+*     ReportPoints
+
+*  Purpose:
+*     Report the effect of transforming a set of points using a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void ReportPoints( AstMapping *this, int forward,
+*                        AstPointSet *in_points, AstPointSet *out_points, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astReportPoints
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function reports the coordinates of a set of points before
+*     and after being transformed by a Region, by writing them to
+*     standard output.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     forward
+*        A non-zero value indicates that the Region's forward
+*        coordinate transformation has been applied, while a zero
+*        value indicates the inverse transformation.
+*     in_points
+*        Pointer to a PointSet which is associated with the
+*        coordinates of a set of points before the Region was
+*        applied.
+*     out_points
+*        Pointer to a PointSet which is associated with the
+*        coordinates of the same set of points after the Region has
+*        been applied.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_mapping;
+
+/* Obtain a pointer to the Region's current Frame and invoke its
+   astReportPoints method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astReportPoints( (AstMapping *) fr, forward, in_points, out_points );
+   fr = astAnnul( fr );
+
+}
+
+static void ResetCache( AstRegion *this, int *status ){
+/*
+*+
+*  Name:
+*     astResetCache
+
+*  Purpose:
+*     Clear cached information within the supplied Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astResetCache( AstRegion *this )
+
+*  Class Membership:
+*     Region virtual function
+
+*  Description:
+*     This function clears cached information from the supplied Region
+*     structure.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*-
+*/
+   if( this ) {
+      if( this->basemesh ) this->basemesh = astAnnul( this->basemesh );
+      if( this->basegrid ) this->basegrid = astAnnul( this->basegrid );
+      if( this->negation ) this->negation = astAnnul( this->negation );
+   }
+}
+
+
+static void Resolve( AstFrame *this_frame, const double point1[],
+                     const double point2[], const double point3[],
+                     double point4[], double *d1, double *d2, int *status ){
+/*
+*  Name:
+*     Resolve
+
+*  Purpose:
+*     Resolve a vector into two orthogonal components
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void Resolve( AstFrame *this, const double point1[],
+*                   const double point2[], const double point3[],
+*                   double point4[], double *d1, double *d2, int *status );
+
+*  Class Membership:
+*     Region member function (over-rides the protected astResolve
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function resolves a vector into two perpendicular components.
+*     The vector from point 1 to point 2 is used as the basis vector.
+*     The vector from point 1 to point 3 is resolved into components
+*     parallel and perpendicular to this basis vector. The lengths of the
+*     two components are returned, together with the position of closest
+*     aproach of the basis vector to point 3.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     point1
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the start of the basis vector,
+*        and of the vector to be resolved.
+*     point2
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the end of the basis vector.
+*     point3
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the end of the vector to be
+*        resolved.
+*     point4
+*        An array of double, with one element for each Frame axis
+*        in which the coordinates of the point of closest approach of the
+*        basis vector to point 3 will be returned.
+*     d1
+*        The address of a location at which to return the distance from
+*        point 1 to point 4 (that is, the length of the component parallel
+*        to the basis vector). Positive values are in the same sense as
+*        movement from point 1 to point 2.
+*     d2
+*        The address of a location at which to return the distance from
+*        point 4 to point 3 (that is, the length of the component
+*        perpendicular to the basis vector). The value is always positive.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - Each vector used in this function is the path of
+*     shortest distance between two points, as defined by the
+*     astDistance function.
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value, or if the required
+*     output values are undefined.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke this
+   Frame's astResolve method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astResolve( fr, point1, point2, point3, point4, d1, d2 );
+   fr = astAnnul( fr );
+
+}
+
+static AstPointSet *ResolvePoints( AstFrame *this_frame, const double point1[],
+                                   const double point2[], AstPointSet *in,
+                                   AstPointSet *out, int *status ) {
+/*
+*  Name:
+*     ResolvePoints
+
+*  Purpose:
+*     Resolve a set of vectors into orthogonal components
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *ResolvePoints( AstFrame *this, const double point1[],
+*                                 const double point2[], AstPointSet *in,
+*                                 AstPointSet *out )
+
+*  Class Membership:
+*     Region member function (over-rides the astResolvePoints method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function takes a Frame and a set of vectors encapsulated
+*     in a PointSet, and resolves each one into two orthogonal components,
+*     returning these two components in another PointSet.
+*
+*     This is exactly the same as the public astResolve method, except
+*     that this method allows many vectors to be processed in a single call,
+*     thus reducing the computational cost of overheads of many
+*     individual calls to astResolve.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     point1
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the start of the basis vector,
+*        and of the vectors to be resolved.
+*     point2
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the end of the basis vector.
+*     in
+*        Pointer to the PointSet holding the ends of the vectors to be
+*        resolved.
+*     out
+*        Pointer to a PointSet which will hold the length of the two
+*        resolved components. A NULL value may also be given, in which
+*        case a new PointSet will be created by this function.
+
+*  Returned Value:
+*     Pointer to the output (possibly new) PointSet. The first axis will
+*     hold the lengths of the vector components parallel to the basis vector.
+*     These values will be signed (positive values are in the same sense as
+*     movement from point 1 to point 2. The second axis will hold the lengths
+*     of the vector components perpendicular to the basis vector. These
+*     values will always be positive.
+
+*  Notes:
+*     - The number of coordinate values per point in the input
+*     PointSet must match the number of axes in the supplied Frame.
+*     - If an output PointSet is supplied, it must have space for
+*     sufficient number of points and 2 coordinate values per point.
+*     - 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: */
+   AstPointSet *result;          /* Pointer to output PointSet */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke this
+   Frame's astResolve method. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astResolvePoints( fr, point1, point2, in, out );
+   fr = astAnnul( fr );
+
+/* Return a pointer to the output PointSet. */
+   return result;
+
+}
+
+static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
+/*
+*  Name:
+*     SetAttrib
+
+*  Purpose:
+*     Set an attribute value for a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void SetAttrib( AstObject *this, const char *setting, int *status )
+
+*  Class Membership:
+*     Region member function (extends the astSetAttrib method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function assigns an attribute value for a Region, the
+*     attribute and its value being specified by means of a string of
+*     the form:
+*
+*        "attribute= value "
+*
+*     Here, "attribute" specifies the attribute name and should be in
+*     lower case with no white space present. The value to the right
+*     of the "=" should be a suitable textual representation of the
+*     value to be assigned and this will be interpreted according to
+*     the attribute's data type.  White space surrounding the value is
+*     only significant for string attributes.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     setting
+*        Pointer to a null terminated string specifying the new
+*        attribute value.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - This protected method is intended to be invoked by the Object
+*     astSet method and makes additional attributes accessible to it.
+*/
+
+/* Local Variables: */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double dval;                  /* Floating point attribute value */
+   int ival;                     /* Integer attribute value */
+   int id;                       /* Offset of ID string */
+   int len;                      /* Length of setting string */
+   int nc;                       /* Number of characters read by astSscanf */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_object;
+
+/* Obtain the length of the setting string. */
+   len = strlen( setting );
+
+/* Test for each recognised attribute in turn, using "astSscanf" to parse the
+   setting string and extract the attribute value (or an offset to it in the
+   case of string values). In each case, use the value set in "nc" to check
+   that the entire string was matched. Once a value has been obtained, use the
+   appropriate method to set it. */
+
+/* We first handle attributes that apply to the Region as a whole
+   (rather than to the encapsulated Frame). */
+
+/* Negated */
+/* ------- */
+   if ( nc = 0,
+        ( 1 == astSscanf( setting, "negated= %d %n", &ival, &nc ) )
+          && ( nc >= len ) ) {
+      astSetNegated( this, ival );
+
+/* Closed */
+/*------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "closed= %d %n", &ival, &nc ) )
+          && ( nc >= len ) ) {
+      astSetClosed( this, ival );
+
+/* FillFactor */
+/* ---------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "fillfactor= %lg %n", &dval, &nc ) )
+        && ( nc >= len ) ) {
+      astSetFillFactor( this, dval );
+
+/* MeshSize */
+/* -------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "meshsize= %d %n", &ival, &nc ) )
+          && ( nc >= len ) ) {
+      astSetMeshSize( this, ival );
+
+/* Adaptive */
+/* -------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "adaptive= %d %n", &ival, &nc ) )
+          && ( nc >= len ) ) {
+      astSetAdaptive( this, ival );
+
+/* Now do attributes inherited from parent classes. We do these here to
+   avoid the settings being passed on to the encapsulated FrameSet below. */
+
+/* ID. */
+/* --- */
+   } else if ( nc = 0, ( 0 == astSscanf( setting, "id=%n%*[^\n]%n", &id, &nc ) )
+                       && ( nc >= len ) ) {
+      astSetID( this, setting + id );
+
+/* Ident. */
+/* ------ */
+   } else if ( nc = 0, ( 0 == astSscanf( setting, "ident=%n%*[^\n]%n", &id, &nc ) )
+                       && ( nc >= len ) ) {
+      astSetIdent( this, setting + id );
+
+/* Invert. */
+/* ------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "invert= %d %n", &ival, &nc ) )
+        && ( nc >= len ) ) {
+      astSetInvert( this, ival );
+
+/* Report. */
+/* ------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "report= %d %n", &ival, &nc ) )
+        && ( nc >= len ) ) {
+      astSetReport( this, ival );
+
+/* Define macros to see if the setting string matches any of the
+   read-only attributes of this class. */
+#define MATCH(attrib) \
+        ( nc = 0, ( 0 == astSscanf( setting, attrib "=%*[^\n]%n", &nc ) ) && \
+                  ( nc >= len ) )
+
+#define AXISMATCH(attrib) \
+        ( nc = 0, ( 0 == astSscanf( setting, attrib "(%*d)=%*[^\n]%n", &nc ) ) && \
+                  ( nc >= len ) )
+
+/* If the attribute was not recognised, use this macro to report an error
+   if a read-only attribute has been specified. */
+   } else if ( MATCH( "class" ) ||
+               MATCH( "nin" ) ||
+               MATCH( "nobject" ) ||
+               MATCH( "bounded" ) ||
+               MATCH( "nout" ) ||
+               MATCH( "refcount" ) ||
+               MATCH( "tranforward" ) ||
+               MATCH( "traninverse" ) ) {
+      astError( AST__NOWRT, "astSet: The setting \"%s\" is invalid for a %s.", status,
+                setting, astGetClass( this ) );
+      astError( AST__NOWRT, "This is a read-only attribute." , status);
+
+/* Pass unrecognised attributes on to the Region's encapsulated FrameSet for
+   further interpretation. Do not pass on FrameSet attributes since we
+   pretend to the outside world that the encapsulated FrameSet is actually a
+   Frame. */
+   } else if ( !MATCH( "base" ) &&
+               !MATCH( "current" ) &&
+               !MATCH( "nframe" ) ) {
+
+/* If the Region is to adapt to coordinate system chanmges, use the public
+   astSet method so that the current Frame in the encapsulated FrameSet will
+   be re-mapped if the attribute changes require it. */
+      if( astGetAdaptive( this ) ) {
+         astSet( this->frameset, setting, status );
+
+/* If the Region is not to adapt to coordinate system chanmges, use the
+   astRegSetAttrib method which assigns the attribute setting to both
+   current and base Frames in the FrameSet without causing any remapping to
+   be performed. */
+      } else {
+         astRegSetAttrib( this, setting, NULL );
+      }
+   }
+
+/* Undefine macros local to this function. */
+#undef MATCH
+}
+
+static void SetAxis( AstFrame *this_frame, int axis, AstAxis *newaxis, int *status ) {
+/*
+*  Name:
+*     SetAxis
+
+*  Purpose:
+*     Set a new Axis for a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void SetAxis( AstFrame *this, int axis, AstAxis *newaxis, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astSetAxis method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function allows a new Axis object to be associated with one
+*     of the axes of the current Frame in a Region, replacing the
+*     previous one. Each Axis object contains a description of the
+*     quantity represented along one of the Frame's axes, so this
+*     function allows this description to be exchanged for another
+*     one.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     axis
+*        The index (zero-based) of the axis whose associated Axis
+*        object is to be replaced.
+*     newaxis
+*        Pointer to the new Axis object.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index supplied. */
+   (void) astValidateAxis( this, axis, 1, "astSetAxis" );
+
+/* Obtain a pointer to the Region's current Frame and invoke this
+   Frame's astSetAxis method to assign the new Axis object. Annul the
+   Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astSetAxis( fr, axis, newaxis );
+   fr = astAnnul( fr );
+}
+
+static void SetRegFS( AstRegion *this, AstFrame *frm, int *status ) {
+/*
+*+
+*  Name:
+*     astSetRegFS
+
+*  Purpose:
+*     Stores a new FrameSet in a Region
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void astSetRegFS( AstRegion *this, AstFrame *frm )
+
+*  Class Membership:
+*     Region virtual function.
+
+*  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.
+*-
+*/
+
+/* Local Variables: */
+   AstFrame *f1;         /* Copy of supplied Frame */
+   AstFrame *f2;         /* Copy of supplied Frame */
+   AstFrameSet *fs;      /* New FrameSet */
+   AstRegion *unc;       /* Uncertainty Region */
+   AstUnitMap *um;       /* UnitMap connecting base anc current Frames */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Take a copy of the supplied Frame. */
+   f1 = astCopy( frm );
+
+/* Create the new FrameSet. First take another copy of the supplied Frame
+   so that modifications using the supplied pointer will not affect the new
+   FrameSet. We create two copies (rather than 1) because the base and
+   current Frames must be independant objects - otherwise attribute changes
+   done to one will also appear in the other. Then construct the FrameSet
+   containing the two Frame copies connected by a UnitMap. */
+   f2 = astCopy( f1 );
+   fs = astFrameSet( f1, "", status );
+   um = astUnitMap( astGetNaxes( f1 ), "", status );
+   astAddFrame( fs, AST__BASE, um, f2 );
+   um = astAnnul( um );
+   f2 = astAnnul( f2 );
+
+/* Annul any existing FrameSet */
+   if( this->frameset ) (void) astAnnul( this->frameset );
+
+/* Use the new FrameSet */
+   this->frameset = fs;
+
+/* If any uncertainty Region has a zero value for its RegionFS attribute,
+   it will currently contain a dummy FrameSet rather than the correct
+   FrameSet. The correct FrameSet has copies of the base Frame of the new
+   Region as both its current and base Frames, and these are connected by
+   a UnitMap (this is equivalent to a FrameSet containing a single Frame). */
+   if( astTestUnc( this ) ) {
+      unc = astGetUncFrm( this, AST__BASE );
+      if( unc && !astGetRegionFS( unc ) ) astSetRegFS( unc, f1 );
+      unc = astAnnul( unc );
+   }
+
+/* Free remaining resourvces */
+   f1 = astAnnul( f1 );
+
+}
+
+static void SetUnc( AstRegion *this, AstRegion *unc, int *status ){
+/*
+*++
+*  Name:
+c     astSetUnc
+f     AST_SETUNC
+
+*  Purpose:
+*     Store uncertainty information in a Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     void astSetUnc( AstRegion *this, AstRegion *unc )
+f     CALL AST_SETUNC( THIS, UNC, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     Each Region (of any class) can have an "uncertainty" which specifies
+*     the uncertainties associated with the boundary of the Region. This
+*     information is supplied in the form of a second Region. The uncertainty
+*     in any point on the boundary of a Region is found by shifting the
+*     associated "uncertainty" Region so that it is centred at the boundary
+*     point being considered. The area covered by the shifted uncertainty
+*     Region then represents the uncertainty in the boundary position.
+*     The uncertainty is assumed to be the same for all points.
+*
+*     The uncertainty is usually specified when the Region is created, but
+*     this
+c     function
+f     routine
+*     allows it to be changed at any time.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region which is to be assigned a new uncertainty.
+c     unc
+f     UNC = INTEGER (Given)
+*        Pointer to the new uncertainty Region. This must be of a class for
+*        which all instances are centro-symetric (e.g. Box, Circle, Ellipse,
+*        etc.) or be a Prism containing centro-symetric component Regions.
+*        A deep copy of the supplied Region will be taken, so subsequent
+*        changes to the uncertainty Region using the supplied pointer will
+*        have no effect on the Region
+c        "this".
+f        THIS.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*--
+*/
+
+/* Local Variables: */
+   AstFrame *frm;           /* Current Frame from FrameSet */
+   AstFrameSet *fs2;        /* FrameSet from "unc" current Frame to "this" base Frame */
+   AstFrameSet *fs;         /* FrameSet in "this" supplied Region */
+   AstMapping *map2;        /* Base->current Mapping from FrameSet */
+   AstMapping *map;         /* Base->current Mapping from FrameSet */
+   AstMapping *smap;        /* Simplified base->current Mapping */
+   double *cen0;            /* Pointer to array holding original centre */
+   double **ptr_reg;        /* Pointer to axis values for Region's Pointset */
+   int changed;             /* Has the uncertainty been changed? */
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* Annul any existing uncertainty Region. */
+   if( this->unc ) {
+      this->unc = astIsAObject( this->unc ) ?
+                                astAnnul( this->unc ) : NULL;
+      changed = 1;
+   } else {
+      changed = 0;
+   }
+
+/* Check an uncertainty Region was supplied, and is of a usable class
+   (i.e. a class which can be re-centred). */
+   cen0 = unc ? astRegCentre( unc, NULL, NULL, 0, 0 ) : NULL;
+   if( cen0 ) {
+      cen0 = astFree( cen0 );
+
+/* Map it into the same Frame as that represented by the base Frame in
+   the supplied Region. */
+      fs = this->frameset;
+      astInvert( fs );
+      fs2 = Conv( unc->frameset, fs, status );
+      astInvert( fs );
+
+      if( fs2 ) {
+         map = astGetMapping( fs2, AST__BASE, AST__CURRENT );
+         frm = astGetFrame( fs2, AST__CURRENT );
+         this->unc = astMapRegion( unc, map, frm );
+         if( this->unc ) {
+
+/* Ensure the Region is bounded. We know that negating an unbounded
+   Region will make it bounded because we know that the Region consists of
+   Circles, Boxes and/or Ellipses, all of which have this property. */
+            if( !astGetBounded( this->unc ) ) astNegate( this->unc );
+
+/* If the base Frame in the uncertainty Region is the same as the base
+   Frame in the Region being dumped, then we do no need to include the
+   FrameSet in the dump of the uncertainty Region. Since the current
+   Frame in the uncertainty Region always corresponds to the base Frame of
+   its parent Region, we only need to check if the base->current Mapping
+   in the uncertainty Region's FrameSet is a UnitMap or not (after
+   simplification). If it is, set the RegionFS attribute of the uncertainty
+   Region to zero (i.e. false). This will cause the FrameSet to be omitted
+   from the Dump. */
+            map2 = astGetMapping( this->unc->frameset, AST__BASE, AST__CURRENT );
+            smap = astSimplify( map2 );
+            if( astIsAUnitMap( smap ) ) astSetRegionFS( this->unc, 0 );
+
+/* Re-centre the uncertainty Region at the first position in the PointSet
+   associated with the Region structure (if any). */
+            if( this->points ) {
+               ptr_reg = astGetPoints( this->points );
+               astRegCentre( this->unc, NULL, ptr_reg, 0, AST__CURRENT );
+            }
+
+/* Set a flag indicating that the uncertainty in the Region has changed. */
+            changed = 1;
+
+/* Free resources */
+            map2 = astAnnul( map2 );
+            smap = astAnnul( smap );
+         }
+         frm = astAnnul( frm );
+         fs2 = astAnnul( fs2 );
+         map = astAnnul( map );
+
+/* Report error if conversion between Frames is not possible. */
+      } else if( astOK ) {
+         astError( AST__BADIN, "astSetUnc(%s): Bad %d dimensional "
+                   "uncertainty Frame (%s %s) supplied.", status, astGetClass(this),
+                   astGetNaxes(unc), astGetDomain(unc), astGetTitle(unc) );
+         astError( AST__NCPIN, "Cannot convert it to the Frame of the "
+                   "new %s.", status, astGetClass( this ) );
+      }
+
+/* Report an error if it is not of a usable class. */
+   } else if( unc && astOK ){
+      astError( AST__BADIN, "astSetUnc(%s): Bad uncertainty shape "
+                "(%s) supplied.", status, astGetClass( this ), astGetClass(unc) );
+      astError( AST__NCPIN, "The uncertainty Region must be an instance of "
+                "a centro-symetric subclass of Region (e.g. Box, Circle, "
+                "Ellipse, etc)." , status);
+   }
+
+/* If the uncertainty in the Region has changed, indicate that any cached
+   information in the Region is now out of date. */
+   if( changed ) astResetCache( this );
+
+}
+
+static void ShowMesh( AstRegion *this, int format, const char *ttl, int *status ){
+/*
+*++
+*  Name:
+c     astShowMesh
+f     AST_SHOWMESH
+
+*  Purpose:
+*     Display a mesh of points covering the surface of a Region.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     void astShowMesh( AstRegion *this, int format, const char *ttl )
+f     CALL AST_SHOWMESH( THIS, FORMAT, TTL, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+c     This function
+f     This routine
+*     writes a table to standard output containing the axis values at a
+*     mesh of points covering the surface of the supplied Region. Each row
+*     of output contains a tab-separated list of axis values, one for
+*     each axis in the Frame encapsulated by the Region. The number of
+*     points in the mesh is determined by the MeshSize attribute.
+*
+*     The table is preceded by a given title string, and followed by a
+*     single line containing the word "ENDMESH".
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+c     format
+f     FORMAT = LOGICAL (Given)
+*        A boolean value indicating if the displayed axis values should
+*        be formatted according to the Format attribute associated with
+*        the Frame's axis. Otherwise, they are displayed as simple
+*        floating point values.
+c     ttl
+f     TTL = CHARACTER * ( * ) (Given)
+*        A title to display before displaying the first position.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*--
+*/
+
+/* Local Variables: */
+   AstPointSet *ps;           /* PointSet holding mesh */
+   char *buffer = NULL;       /* Buffer for line output text */
+   char buf[ 40 ];            /* Buffer for floating poitn value */
+   double **ptr;              /* Pointers to the mesh data */
+   int i;                     /* Axis index */
+   int j;                     /* Position index */
+   int nax;                   /* Number of axes */
+   int nc;                    /* Number of characters in buffer */
+   int np;                    /* Number of axis values per position */
+
+/* Check the inherited status. */
+   if( !astOK ) return;
+
+/* Get a PointSet holding the mesh */
+   ps = astRegMesh( this );
+   if( ps ) {
+
+/* Get the number of axis values per position, and the number of positions. */
+      nax = astGetNcoord( ps );
+      np = astGetNpoint( ps );
+
+/* Get a pointer to the mesh data, and check it can be used. */
+      ptr = astGetPoints( ps );
+      if( ptr ) {
+
+/* Display the title. */
+         if( ttl ) printf( "\n%s\n\n", ttl );
+
+/* Loop round all positions. */
+         for( j = 0; j < np; j++ ) {
+
+/* Reset the current buffer length to zero. */
+            nc = 0;
+
+/* Loop round all axes */
+            for( i = 0; i < nax; i++ ){
+
+/* If the axis value is bad, append "<bad> in the end of the output buffer. */
+               if( ptr[ i ][ j ] == AST__BAD ){
+                  buffer = astAppendString( buffer, &nc, "<bad>" );
+
+/* Otherwise, if required, append the formatted value to the end of the
+   buffer. */
+               } else if( format ){
+                  buffer = astAppendString( buffer, &nc,
+                                         astFormat( this, i, ptr[ i ][ j ] ) );
+
+/* Otherwise, append the floating point value to the end of the buffer. */
+               } else {
+                  sprintf( buf, "%g", ptr[ i ][ j ] );
+                  buffer = astAppendString( buffer, &nc, buf );
+               }
+/* Add a separating tab to the end of the buffer. */
+               buffer = astAppendString( buffer, &nc, "\t" );
+            }
+
+/* Display the line buffer. */
+            printf( "%s\n", buffer );
+         }
+      }
+
+/* Print out a marker for th eend of the list. */
+      printf( "ENDMESH\n\n" );
+
+/* Release resources. */
+      ps = astAnnul( ps );
+      buffer = astFree( buffer );
+   }
+}
+
+static AstMapping *Simplify( AstMapping *this_mapping, int *status ) {
+/*
+*  Name:
+*     Simplify
+
+*  Purpose:
+*     Simplify the Mapping represented by a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstMapping *Simplify( AstMapping *this, int *status )
+
+*  Class Membership:
+*     Region method (over-rides the astSimplify method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function simplifies the encapsulated FrameSet and any
+*     uncertainty Region in the supplied Region. This is different to
+*     the Simplify method in the parent Frame class which always returns
+*     a UnitMap.
+
+*  Parameters:
+*     this
+*        Pointer to the original Region.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer to the simplified Region. A cloned pointer to the
+*     supplied Region will be returned if no simplication could be
+*     performed.
+
+*  Notes:
+*     - This implementation just simplifies the encapsulated FrameSet
+*     and uncertainty Region. Sub-classes should usually provide their own
+*     implementation which invokes this implemetation, and then continues to
+*     check for further simplifications (such as fitting a new region to the
+*     current Frame).
+*     - 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.
+*/
+
+/* Local Variables: */
+   AstFrame *bfrm;               /* Pointer to "this" baseFrame */
+   AstFrameSet *fs;              /* Pointer to encapsulated FrameSet */
+   AstMapping *map;              /* Base->current Mapping for "this" */
+   AstMapping *result;           /* Result pointer to return */
+   AstPointSet *pset1;           /* Base Frame centre position */
+   AstPointSet *pset2;           /* Current Frame centre position */
+   AstRegion *new;               /* Pointer to simplified Region */
+   AstRegion *sunc;              /* Simplified uncertainty Region */
+   AstRegion *this;              /* Pointer to original Region structure */
+   AstRegion *unc;               /* Original uncertainty Region */
+   double **ptr1;                /* Pointer to axis values in "pset1" */
+   double *cen;                  /* Original centre of uncertainty Region */
+   double *lbnd;                 /* Lower bounds of "this" bounding box */
+   double *orig_cen;             /* Original centre for uncertainty Region */
+   double *s1_lbnd;              /* Lower bounds of "unc" when centred at lbnd */
+   double *s1_ubnd;              /* Upper bounds of "unc" when centred at lbnd */
+   double *s2_lbnd;              /* Lower bounds of "unc" when centred at ubnd */
+   double *s2_ubnd;              /* Upper bounds of "unc" when centred at ubnd */
+   double *ubnd;                 /* Upper bounds of "this" bounding box */
+   double delta;                 /* Half width of test box */
+   double w1;                    /* Width of "s1" bounding box */
+   double w2;                    /* Width of "s2" bounding box */
+   int ic;                       /* Axis index */
+   int naxb;                     /* No. of base Frame axes in "this" */
+   int nin;                      /* Number of base Frame axes in "this" */
+   int nout;                     /* Number of current Frame axes in "this" */
+   int ok;                       /* Can we use the simplified uncertainty? */
+   int simpler;                  /* Has some simplication taken place? */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_mapping;
+
+/* Take a deep copy of the supplied Region. This is so that the returned
+   pointer will have a diferent value to the supplied pointer if any
+   simplication takes place. */
+   new = astCopy( this );
+
+/* Simplify the encapsulated FrameSet, and note if any simplification took
+   place. */
+   fs = astSimplify( new->frameset );
+   simpler = ( fs != new->frameset );
+
+/* If so, annull the existing FrameSet and use the simpler FrameSet. */
+   if( simpler ) {
+      (void) astAnnul( new->frameset );
+      new->frameset = astClone( fs );
+   }
+   fs = astAnnul( fs );
+
+/* If the Region has default uncertainty, we simplify the uncertainty
+   Region simply by deleting it. It will be regenerated when needed,
+   using the simplified Region. */
+   if( new->defunc ) new->defunc = astAnnul( new->defunc );
+
+/* If the Region's uncertainty was supplied explicitly, try simplifying
+   the unncertainty Region. */
+   if( astTestUnc( new ) ){
+
+/* Obtain the Region's uncertainty. */
+      unc = astGetUncFrm( new, AST__BASE );
+
+/* Get the base->current Mapping from "this". */
+      map = astGetMapping( this->frameset, AST__BASE, AST__CURRENT );
+
+/* If it has different numbers of inputs and outputs (e.g. a PermMap used
+   to take a slice through a Region), we need to ensure that the
+   uncertainty Region is centred on the slice. */
+      nin = astGetNin( map );
+      nout = astGetNout( map );
+      if( nin != nout ) {
+
+/* Get the current centre of the uncertainty Region in its current Frame
+   (the same as the base Frame of "this"). */
+         cen = astRegCentre( unc, NULL, NULL, 0, AST__CURRENT );
+
+/* Store it in a PointSet so it can be transformed. */
+         pset1 = astPointSet( 1, nin, "", status );
+         ptr1 = astGetPoints( pset1 );
+         if( astOK ) for( ic = 0; ic < nin; ic++ ) ptr1[ ic ][ 0 ] = cen[ ic ];
+
+/* Transform into the curent Frame of "this", and then back into the base
+   Frame. */
+         pset2 = astTransform( map, pset1, 1, NULL );
+         (void) astTransform( map, pset2, 0, pset1 );
+
+/* Re-centre the uncertainty Region at this position. */
+         astRegCentre( unc, NULL, ptr1, 0, AST__CURRENT );
+
+/* Free resources. */
+         cen = astFree( cen );
+         pset1 = astAnnul( pset1 );
+         pset2 = astAnnul( pset2 );
+      }
+
+/* Free resources. */
+      map = astAnnul( map );
+
+/* Try simplifying the uncertainty. Only proceed if the uncertainty can
+   be simplified. */
+      sunc = astSimplify( unc );
+      if( sunc != unc ) {
+
+/* If the uncertainty can be simplified it means that the base->current
+   Mapping in the uncertainty Region is sufficiently linear to allow the
+   uncertainty shape to retain its form when transformed from the base to
+   the current Frane. But this has only been tested at the current centre
+   position in the uncertainty Region. The uncertainty Region should
+   describe the whole of "this" Region, and so we need to check that the
+   simplified uncertainty does not change as we move it around within "this"
+   Region. To do this, we re-centre the uncertainty region at opposite
+   corners of a large test box, and then we find the bounding box of the
+   re-centred uncertainty Region. If this uncertainty bounding box changes
+   from corner to corner of the test box, then we do not simplify the
+   uncertainty Region. If "this" is bounded, we use the bounding box of
+   "this" as the test box. Otherwise we use a box 100 times the size of the
+   uncertainty Region. */
+
+/* Note the original base Frame centre of the simplified uncertainty Region. */
+         orig_cen = astRegCentre( sunc, NULL, NULL, 0, AST__BASE );
+
+/* Allocate memory to hold the bounds of the test box. */
+         naxb = astGetNin( this->frameset );
+         lbnd = astMalloc( sizeof( double )*(size_t)naxb );
+         ubnd = astMalloc( sizeof( double )*(size_t)naxb );
+
+/* If possible, get the base Frame bounding box of "this" and use it as
+   the test box. */
+         if( astGetBounded( this ) ) {
+            astRegBaseBox( this, lbnd, ubnd );
+
+/* Otherwise, store the bounds of a box which is 100 times the size of
+   the uncertainty region, centred on the current centre of the uncertainty
+   region (we know all uncertainty regions are bounded). */
+         } else {
+            astGetRegionBounds( sunc, lbnd, ubnd );
+            for( ic = 0; ic < naxb; ic++ ) {
+               delta = 0.5*fabs( ubnd[ ic ] - lbnd[ ic ] );
+               lbnd[ ic ] = orig_cen[ ic ] - delta;
+               ubnd[ ic ] = orig_cen[ ic ] + delta;
+            }
+         }
+
+/* Re-centre it at the lower bounds of the test box. This is in the base Frame
+   of "this" which is the same as the current Frame of "sunc". */
+         astRegCentre( sunc, lbnd, NULL, 0, AST__CURRENT );
+
+/* Get the bounding box of the re-centred uncertainty Region, within its
+   current Frame, which is the same as the base Frame of "this". */
+         s1_lbnd = astMalloc( sizeof( double )*(size_t)naxb );
+         s1_ubnd = astMalloc( sizeof( double )*(size_t)naxb );
+         astGetRegionBounds( sunc, s1_lbnd, s1_ubnd );
+
+/* Now re-centre the uncertainty Region at the upper bounds of the test
+   box. */
+         astRegCentre( sunc, ubnd, NULL, 0, AST__CURRENT );
+
+/* Get the bounding box of the re-centred uncertainty Region. */
+         s2_lbnd = astMalloc( sizeof( double )*(size_t)naxb );
+         s2_ubnd = astMalloc( sizeof( double )*(size_t)naxb );
+         astGetRegionBounds( sunc, s2_lbnd, s2_ubnd );
+
+/* Get a pointer to the base Frame of "this". */
+         bfrm = astGetFrame( this->frameset, AST__BASE );
+
+/* The "ok" flag is initialised to indicate that the simplified uncertainty
+   Region should not be used. */
+         ok = 0;
+
+/* Check pointers can be referenced safely */
+         if( astOK ) {
+
+/* Now indicate that the simplified uncertainty Region should be used. */
+            ok = 1;
+
+/* Loop round all axes of the base Frame of "this". */
+            for( ic = 0; ic < naxb; ic++ ) {
+
+/* Get the width of the two bounding boxes on this axis. */
+               w1 = s1_ubnd[ ic ] - s1_lbnd[ ic ];
+               w2 = s2_ubnd[ ic ] - s2_lbnd[ ic ];
+
+/* If these differ by more than 0.1% then we determine that the simplified
+   uncertainty Region varies in size across the bounding box of "this", and
+   so we do not use the simplified uncertainty Region. The figure of 0.1%
+   is arbitrary. */
+               if( fabs( w1 - w2 ) > 0.005*( fabs( w1 ) + fabs( w2 ) ) ) {
+                  ok = 0;
+                  break;
+               }
+            }
+         }
+
+/* Reinstate the original base Frame centre of the simplified uncertainty Region. */
+         astRegCentre( sunc, orig_cen, NULL, 0, AST__BASE );
+
+/* Free resources. */
+         orig_cen = astFree( orig_cen );
+         lbnd = astFree( lbnd );
+         ubnd = astFree( ubnd );
+         s1_lbnd = astFree( s1_lbnd );
+         s1_ubnd = astFree( s1_ubnd );
+         s2_lbnd = astFree( s2_lbnd );
+         s2_ubnd = astFree( s2_ubnd );
+         bfrm = astAnnul( bfrm );
+
+/* If we can use the simplified uncertainty Region, indicate that we have
+   performed some simplification, and store the new uncertainty Region. */
+         if( ok ) {
+            simpler = 1;
+            astSetUnc( new, sunc );
+         }
+      }
+
+/* Free resources */
+      unc = astAnnul( unc );
+      sunc = astAnnul( sunc );
+   }
+
+/* If any simplification could be performed, return the new Region.
+   Otherwise, return a clone of the supplied pointer. */
+   if( simpler ){
+      result = (AstMapping *) new;
+   } else {
+      new = astAnnul( new );
+      result = astClone( this );
+   }
+
+/* If an error occurred, annul the returned pointer. */
+   if ( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+static int SubFrame( AstFrame *this_frame, AstFrame *template,
+                     int result_naxes,
+                     const int *target_axes, const int *template_axes,
+                     AstMapping **map, AstFrame **result, int *status ) {
+/*
+*  Name:
+*     SubFrame
+
+*  Purpose:
+*     Select axes from a Region and convert to the new coordinate system.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int SubFrame( AstFrame *target, AstFrame *template, int result_naxes,
+*                   const int *target_axes, const int *template_axes,
+*                   AstMapping **map, AstFrame **result, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astSubFrame
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function selects a requested sub-set (or super-set) of the
+*     axes from the current Frame of a "target" Region and creates a
+*     new Frame with copies of the selected axes assembled in the
+*     requested order. It then optionally overlays the attributes of a
+*     "template" Frame on to the result. It returns both the resulting
+*     Frame and a Mapping that describes how to convert between the
+*     coordinate systems described by the current Frame of the target
+*     Region and the result Frame. If necessary, this Mapping takes
+*     account of any differences in the Frames' attributes due to the
+*     influence of the template.
+
+*  Parameters:
+*     target
+*        Pointer to the target Region, from whose current Frame the
+*        axes are to be selected.
+*     template
+*        Pointer to the template Frame, from which new attributes for
+*        the result Frame are to be obtained. Optionally, this may be
+*        NULL, in which case no overlaying of template attributes will
+*        be performed.
+*     result_naxes
+*        Number of axes to be selected from the target Region. This
+*        number may be greater than or less than the number of axes in
+*        the Region's current Frame (or equal).
+*     target_axes
+*        Pointer to an array of int with result_naxes elements, giving
+*        a list of the (zero-based) axis indices of the axes to be
+*        selected from the current Frame of the target Region. The
+*        order in which these are given determines the order in which
+*        the axes appear in the result Frame. If any of the values in
+*        this array is set to -1, the corresponding result axis will
+*        not be derived from the target Region, but will be assigned
+*        default attributes instead.
+*     template_axes
+*        Pointer to an array of int with result_naxes elements. This
+*        should contain a list of the template axes (given as
+*        zero-based axis indices) with which the axes of the result
+*        Frame are to be associated. This array determines which axes
+*        are used when overlaying axis-dependent attributes of the
+*        template on to the result. If any element of this array is
+*        set to -1, the corresponding result axis will not receive any
+*        template attributes.
+*
+*        If the template argument is given as NULL, this array is not
+*        used and a NULL pointer may also be supplied here.
+*     map
+*        Address of a location to receive a pointer to the returned
+*        Mapping.  The forward transformation of this Mapping will
+*        describe how to convert coordinates from the coordinate
+*        system described by the current Frame of the target Region
+*        to that described by the result Frame. The inverse
+*        transformation will convert in the opposite direction.
+*     result
+*        Address of a location to receive a pointer to the result Frame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if coordinate conversion is
+*     possible between the current Frame of the target Region and
+*     the result Frame. Otherwise zero is returned and *map and
+*     *result are returned as NULL (but this will not in itself result
+*     in an error condition). In general, coordinate conversion should
+*     always be possible if no template Frame is supplied but may not
+*     always be possible otherwise.
+
+*  Notes:
+*     - A value of zero 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 *fr;                 /* Pointer to Region's current Frame */
+   int match;                    /* Result to be returned */
+
+/* Initialise. */
+   *map = NULL;
+   *result = NULL;
+   match = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return match;
+
+/* Invoke the parent astSubFrame method on the Frame represented by the
+   region. */
+   fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT );
+   match = astSubFrame( fr, template, result_naxes, target_axes, template_axes,
+                        map, result );
+   fr = astAnnul( fr );
+
+/* Return the result. */
+   return match;
+}
+
+static AstSystemType SystemCode( AstFrame *this_frame, const char *system, int *status ) {
+/*
+*  Name:
+*     SystemCode
+
+*  Purpose:
+*     Convert a string into a coordinate system type code.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstSystemType SystemCode( AstFrame *this, const char *system, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astSystemCode
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function converts a string used for the external description of
+*     a coordinate system into a Frame coordinate system type code (System
+*     attribute value). It is the inverse of the astSystemString function.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     system
+*        Pointer to a constant null-terminated string containing the
+*        external description of the coordinate system.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The System type code.
+
+*  Notes:
+*     - A value of AST__BADSYSTEM is returned if the coordinate system
+*     description was not recognised. This does not produce an error.
+*     - A value of AST__BADSYSTEM is also returned if this function
+*     is invoked with the global error status set or if it should fail
+*     for any reason.
+*/
+
+/* Local Variables: */
+   AstSystemType result;      /* Result value to return */
+   AstFrame *fr;              /* Pointer to FrameSet's current Frame */
+   AstRegion *this;           /* Pointer to the Region structure */
+
+/* Initialise. */
+   result = AST__BADSYSTEM;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke the
+   astSystemCode method for this Frame. Annul the Frame pointer afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astSystemCode( fr, system );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = AST__BADSYSTEM;
+
+/* Return the result. */
+   return result;
+}
+
+static const char *SystemString( AstFrame *this_frame, AstSystemType system, int *status ) {
+/*
+*  Name:
+*     SystemString
+
+*  Purpose:
+*     Convert a coordinate system type code into a string.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     const char *SystemString( AstFrame *this, AstSystemType system, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astSystemString
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function converts a Frame coordinate system type code
+*     (System attribute value) into a string suitable for use as an
+*     external representation of the coordinate system type.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     system
+*        The coordinate system type code.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to a constant null-terminated string containing the
+*     textual equivalent of the type code supplied.
+
+*  Notes:
+*     - A NULL pointer value is returned if the coordinate system
+*     code was not recognised. This does not produce an error.
+*     - A NULL pointer value is also returned if this function is
+*     invoked with the global error status set or if it should fail
+*     for any reason.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to FrameSet's current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   const char *result;           /* Pointer value to return */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke the
+   astSystemString method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astSystemString( fr, system );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result pointer. */
+   return result;
+
+}
+
+static int RegTrace( AstRegion *this, int n, double *dist, double **ptr, int *status ){
+/*
+*+
+*  Name:
+*     astRegTrace
+
+*  Purpose:
+*     Return requested positions on the boundary of a 2D Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int astRegTrace( AstRegion *this, int n, double *dist, double **ptr );
+
+*  Class Membership:
+*     Region virtual function
+
+*  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.
+
+*-
+*/
+
+/* Concrete sub-classes of Region must over-ride this method. */
+   return 0;
+}
+
+static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     TestAttrib
+
+*  Purpose:
+*     Test if a specified attribute value is set for a Region.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int TestAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the astTestAttrib protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a boolean result (0 or 1) to indicate whether
+*     a value has been set for one of a Region's attributes.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     attrib
+*        Pointer to a null terminated string specifying the attribute
+*        name.  This should be in lower case with no surrounding white
+*        space.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     One if a value has been set, otherwise zero.
+
+*  Notes:
+*     - A value of zero will be returned if this function is invoked
+*     with the global status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstRegion *this;              /* Pointer to the Region structure */
+   int result;                   /* Result value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_object;
+
+/* Check the attribute name and test the appropriate attribute. */
+
+/* We first handle attributes that apply to the Region as a whole
+   (rather than to the encapsulated FrameSet). */
+
+/* Negated. */
+/* -------- */
+   if ( !strcmp( attrib, "negated" ) ) {
+      result = astTestNegated( this );
+
+/* Closed. */
+/* ------- */
+   } else if ( !strcmp( attrib, "closed" ) ) {
+      result = astTestClosed( this );
+
+/* FillFactor */
+/* ---------- */
+   } else if ( !strcmp( attrib, "fillfactor" ) ) {
+      result = astTestFillFactor( this );
+
+/* MeshSize */
+/* -------- */
+   } else if ( !strcmp( attrib, "meshsize" ) ) {
+      result = astTestMeshSize( this );
+
+/* Adaptive */
+/* -------- */
+   } else if ( !strcmp( attrib, "adaptive" ) ) {
+      result = astTestAdaptive( this );
+
+/* Now do attributes inherited from parent classes. This is so that the
+   attribute test will not be passed on to the encpasulated FrameSet below. */
+
+/* ID. */
+/* --- */
+   } else if ( !strcmp( attrib, "id" ) ) {
+      result = astTestID( this );
+
+/* Ident. */
+/* ------ */
+   } else if ( !strcmp( attrib, "ident" ) ) {
+      result = astTestIdent( this );
+
+/* Invert. */
+/* ------- */
+   } else if ( !strcmp( attrib, "invert" ) ) {
+      result = astTestInvert( this );
+
+/* Report. */
+/* ------- */
+   } else if ( !strcmp( attrib, "report" ) ) {
+      result = astTestReport( this );
+
+/* If the name is not recognised, test if it matches any of the
+   read-only attributes of this class. If it does, then return
+   zero. */
+   } else if ( !strcmp( attrib, "class" ) ||
+               !strcmp( attrib, "nin" ) ||
+               !strcmp( attrib, "nobject" ) ||
+               !strcmp( attrib, "bounded" ) ||
+               !strcmp( attrib, "nout" ) ||
+               !strcmp( attrib, "refcount" ) ||
+               !strcmp( attrib, "tranforward" ) ||
+               !strcmp( attrib, "traninverse" ) ) {
+      result = 0;
+
+/* Pass unrecognised attributes on to the Region's encapsulated FrameSet for
+   further interpretation. Do not pass on FrameSet attributes since we
+   pretend to the outside world that the encapsulated FrameSet is actually a
+   Frame. */
+   } else if ( strcmp( attrib, "base" ) &&
+               strcmp( attrib, "current" ) &&
+               strcmp( attrib, "nframe" ) ) {
+      result = astTestAttrib( this->frameset, attrib );
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result, */
+   return result;
+}
+
+double *astRegTranPoint_( AstRegion *this, double *in, int np, int forward, int *status ){
+/*
+*+
+*  Name:
+*     astRegTranPoint
+
+*  Purpose:
+*     Transform points between the base and current Frames in a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     double *astRegTranPoint( AstRegion *this, double *in, int np, int forward )
+
+*  Class Membership:
+*     Region member function
+
+*  Description:
+*     This function transforms one or more points between the base and
+*     current Frames of the FrameSet encapsulated by the supplied Region.
+
+*  Parameters:
+*     this
+*        The Region pointer.
+*     in
+*        Pointer to a 1-d array holding the axis values to be transformed.
+*        If "forward" is non-zero, the number of axis values supplied for
+*        each position should equal the number of axes in the base Frame
+*        of the FrameSet encapsulated by "this". If "forward" is zero, the
+*        number of axis values supplied for each position should equal the
+*        number of axes in the current Frame of the FrameSet encapsulated by
+*        "this". All the axis values for a position should be in adjacent
+*        elements of the array.
+*     np
+*        The number of points supplied in "in".
+*     forward
+*        If non-zero, the supplied points are assumed to refer to the base
+*        Frame of the encapsulated FrameSet, and they are transformed to the
+*        current Frame. If zero, the supplied points are assumed to refer to
+*        the current Frame of the encapsulated FrameSet, and they are
+*        transformed to the base Frame.
+
+*  Returned Value:
+*     Pointer to a new dynamically allocated array holding the
+*     transformed axis values. If "forward" is non-zero, the number of axis
+*     values for each position will be equal the number of axes in the
+*     current Frame of the FrameSet encapsulated by "this". If "forward" is
+*     zero, the number of axis values for each position will be equal to the
+*     number of axes in the base Frame of the FrameSet encapsulated by "this".
+*     All the axis values for a position will be in adjacent elements of the
+*     array. The array should be freed using astFree when 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: */
+   AstMapping *map;
+   AstPointSet *pset_in;
+   AstPointSet *pset_out;
+   double **ptr_in;
+   double **ptr_out;
+   double *p;
+   double *result;
+   int ic;
+   int ip;
+   int naxin;
+   int naxout;
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the required Mapping. */
+   if( forward ) {
+      map = astGetMapping( this->frameset, AST__BASE, AST__CURRENT );
+   } else {
+      map = astGetMapping( this->frameset, AST__CURRENT, AST__BASE );
+   }
+
+/* Get the number of axis values per input and per output point. */
+   naxin = astGetNin( map );
+   naxout = astGetNout( map );
+
+/* Create a pointSet holding the supplied axis values. */
+   pset_in = astPointSet( np, naxin, "", status );
+
+/* Get pointers to the memory used to store axis values within this
+   PointSet. */
+   ptr_in = astGetPoints( pset_in );
+
+/* Allocate the output array. */
+   result = astMalloc( sizeof( double )*(size_t)( naxout*np ) );
+
+/* Check the pointers can be used. */
+   if( astOK ) {
+
+/* Store the supplied axis values in the PointSet memory. */
+      p = in;
+      for( ip = 0; ip < np; ip++ ) {
+         for( ic = 0; ic < naxin; ic++ ) ptr_in[ ic ][ ip ] = *(p++);
+      }
+
+/* Transform the PointSet. */
+      pset_out = astTransform( map, pset_in, 1, NULL );
+
+/* Get a pointer to the memory in the transformed PointSet. */
+      ptr_out = astGetPoints( pset_out );
+
+      if( pset_out && astStatus == AST__INTER ) {
+         p = in;
+         for( ip = 0; ip < np; ip++ ) {
+            for( ic = 0; ic < naxin; ic++ ) printf("%.*g\n", DBL_DIG, *(p++) );
+         }
+      }
+
+      if( astOK ) {
+
+/* Store the resulting axis values in the output array. */
+         p = result;
+         for( ip = 0; ip < np; ip++ ) {
+            for( ic = 0; ic < naxout; ic++ ) *(p++) = ptr_out[ ic ][ ip ];
+         }
+      }
+
+/* Free resources. */
+      pset_out = astAnnul( pset_out );
+   }
+   pset_in = astAnnul( pset_in );
+   map = astAnnul( map );
+
+/* Return NULL if anything went wrong. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result.*/
+   return result;
+}
+
+static AstPointSet *RegTransform( AstRegion *this, AstPointSet *in,
+                                  int forward, AstPointSet *out, AstFrame **frm, int *status ) {
+/*
+*+
+*  Name:
+*     astRegTransform
+
+*  Purpose:
+*     Transform a set of points using the encapsulated FrameSet.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstPointSet *astRegTransform( AstRegion *this, AstPointSet *in,
+*                                   int forward, AstPointSet *out,
+*                                   AstFrameSet **frm )
+
+*  Class Membership:
+*     Region virtual function
+
+*  Description:
+*     This function takes a Region and a set of points encapsulated
+*     in a PointSet, and applies either the forward or inverse
+*     coordinate transformation represented by the encapsulated FrameSet.
+*     It also returned a pointer to either the current or base Frame in
+*     the FrameSet.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     in
+*        Pointer to the PointSet holding the input coordinate data. If
+*        NULL then the "points" PointSet within the supplied Region
+*        ("this") is used.
+*     forward
+*        A non-zero value indicates that the forward coordinate transformation
+*        (from base to current) should be applied, while a zero value requests
+*        the inverse transformation (from current to base).
+*     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.
+*     frm
+*        Location at which to return a pointer to a Frame. If "forward"
+*        is non-zero, the current Frame in the encapsulated FrameSet will
+*        be returned. Otherwise, the base Frame is returned. The returned
+*        pointer should be annulled when no longer needed. May be NULL if
+*        no pointer is needed.
+
+*  Returned Value:
+*     Pointer to the output (possibly new) PointSet. If "out" is NULL,
+*     the returned pointer will be a clone of "in" if the Mapping is a
+*     UnitMap. If "out" is not NULL, then the supplied "out" PointSet will
+*     be used and returned.
+
+*  Notes:
+*     - An error will result if the Region supplied does not define
+*     the requested coordinate transformation (either forward or
+*     inverse).
+*     - The number of coordinate values per point in the input
+*     PointSet must match the number of input coordinates for the
+*     Region being applied (or number of output coordinates if the
+*     inverse transformation is requested).  This will be equal to the
+*     number of axes in the Region's base Frame (or the current
+*     Frame for the inverse transformation).
+*     - If an output PointSet is supplied, it must have space for
+*     sufficient number of points and coordinate values per point to
+*     accommodate the result (e.g. the number of Region output
+*     coordinates, or number of input coordinates if the inverse
+*     transformation is requested). Any excess space will be ignored.
+*     - 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: */
+   AstMapping *smap;           /* Pointer to simplified Mapping */
+   AstPointSet *result;        /* Pointer value to return */
+
+/* Initialise */
+   if( frm ) *frm = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* If no input PointSet was provided, use the PointSet in the Region. */
+   if( !in ) {
+      if( this->points ) {
+         in = this->points;
+      } else {
+         astError( AST__INTER, "astRegTransform(%s): No PointSet supplied "
+                   "and the supplied %s has no PointSet (internal AST "
+                   "programming error)", status, astGetClass( this ),astGetClass( this ) );
+      }
+   }
+
+/* Get the simplified Mapping from base to current Frame. */
+   smap = astRegMapping( this );
+
+/* If it is a UnitMap, return a clone of the input PointSet unless an
+   explicit output PointSet has been supplied. */
+   if( astIsAUnitMap( smap ) && !out ) {
+      result = astClone( in );
+
+/* Otherwise use the Mapping to transform the supplied positions. */
+   } else {
+      result = astTransform( smap, in, forward, out );
+   }
+
+/* Return a pointer to the appropriate Frame. */
+   if( frm ) *frm = astGetFrame( this->frameset, forward ? AST__CURRENT : AST__BASE );
+
+/* Release resources. */
+   smap = astAnnul( smap );
+
+/* Return a pointer to the output PointSet. */
+   return result;
+}
+
+static int Unformat( AstFrame *this_frame, int axis, const char *string,
+                     double *value, int *status ) {
+/*
+*  Name:
+*     Unformat
+
+*  Purpose:
+*     Read a formatted coordinate value for a Region axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int Unformat( AstFrame *this, int axis, const char *string,
+*                   double *value, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the public astUnformat
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function reads a formatted coordinate value for a Region
+*     axis (supplied as a string) and returns the equivalent numerical
+*     value as a double. It also returns the number of characters read
+*     from the string.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     axis
+*        The number of the Region axis for which the coordinate
+*        value is to be read (axis numbering starts at zero for the
+*        first axis).
+*     string
+*        Pointer to a constant null-terminated string containing the
+*        formatted coordinate value.
+*     value
+*        Pointer to a double in which the coordinate value read will be
+*        returned.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The number of characters read from the string to obtain the
+*     coordinate value.
+
+*  Notes:
+*     - Any white space at the beginning of the string will be
+*     skipped, as also will any trailing white space following the
+*     coordinate value read. The function's return value will reflect
+*     this.
+*     - A function value of zero (and no coordinate value) will be
+*     returned, without error, if the string supplied does not contain
+*     a suitably formatted value.
+*     - The string "<bad>" is recognised as a special case and will
+*     generate the value AST__BAD, without error. The test for this
+*     string is case-insensitive and permits embedded white space.
+*     - A function result of zero will be returned and no coordinate
+*     value will be returned via the "value" pointer if this function
+*     is invoked with the global error status set, or if it should
+*     fail for any reason.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   double coord;                 /* Coordinate value read */
+   int nc;                       /* Number of characters read */
+
+/* Initialise. */
+   nc = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return nc;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astUnformat" );
+
+/* Obtain a pointer to the Region's current Frame and invoke the
+   astUnformat method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   nc = astUnformat( fr, axis, string, &coord );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the number of characters read. */
+   if ( !astOK ) {
+      nc = 0;
+
+/* Otherwise, if characters were read, return the coordinate value. */
+   } else if ( nc ) {
+      *value = coord;
+   }
+
+/* Return the number of characters read. */
+   return nc;
+}
+
+static int ValidateAxis( AstFrame *this_frame, int axis, int fwd,
+                         const char *method, int *status ) {
+/*
+*  Name:
+*     ValidateAxis
+
+*  Purpose:
+*     Validate and permute a Region's axis index.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int ValidateAxis( AstFrame *this, int axis, int fwd, const char *method,
+*                       int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected
+*     astValidateAxis method inherited from the Frame class).
+
+*  Description:
+*     This function checks the validity of an index (zero-based) which
+*     is to be used to address one of the coordinate axes of the
+*     current Frame in a Region. If the index is valid, it is
+*     permuted using the axis permutation array associated with the
+*     Region's current Frame and the (zero-based) permuted axis
+*     index is returned.  This gives the index the axis had when the
+*     Frame was first created. If the axis index supplied is not
+*     valid, an error is reported and the global error status is set.
+
+*  Parameters:
+*     this
+*        Pointer to the Region.
+*     axis
+*        The axis index (zero-based) to be checked. To be valid, it
+*        must lie between zero and (naxes-1) inclusive, where "naxes"
+*        is the number of coordinate axes associated with the
+*        Region's current Frame.
+*     fwd
+*        If non-zero, the suppplied axis index is assumed to be an
+*        "external" axis index, and the corresponding "internal" axis index
+*        is returned as the function value. Otherwise, the suppplied axis
+*        index is assumed to be an "internal" axis index, and the
+*        corresponding "external" axis index is returned as the function
+*        value.
+*     method
+*        Pointer to a constant null-terminated character string
+*        containing the name of the method that invoked this function
+*        to validate an axis index. This method name is used solely
+*        for constructing error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The permuted axis index - either "internal" or "external" as
+*     specified by "fwd".
+
+*  Notes:
+*     - A value of zero 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 *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+   int naxes;                    /* Number of Region axes */
+   int result;                   /* Permuted axis index */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_frame;
+
+/* Determine the number of Region axes. */
+   naxes = astGetNaxes( this );
+   if ( astOK ) {
+
+/* If the Region has no axes, report an error (convert to 1-based
+   axis numbering for the benefit of the public interface). */
+      if ( naxes == 0 ) {
+         astError( AST__AXIIN, "%s(%s): Invalid attempt to use an axis index "
+                   "(%d) for a %s which has no axes.", status, method,
+                   astGetClass( this ), axis + 1, astGetClass( this ) );
+
+/* Otherwise, check the axis index for validity and report an error if
+   it is not valid (again, convert to 1-based axis numbering). */
+      } else if ( ( axis < 0 ) || ( axis >= naxes ) ) {
+         astError( AST__AXIIN, "%s(%s): Axis index (%d) invalid - it should "
+                   "be in the range 1 to %d.", status, method, astGetClass( this ),
+                   axis + 1, naxes );
+
+/* If the axis index was valid, obtain a pointer to the Region's
+   current Frame and invoke this Frame's astValidateAxis method to
+   obtain the permuted axis index. Annul the Frame pointer
+   afterwards. */
+      } else {
+         fr = astGetFrame( this->frameset, AST__CURRENT );
+         result = astValidateAxis( fr, axis, fwd, "astValidateAxis" );
+         fr = astAnnul( fr );
+      }
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result. */
+   return result;
+}
+
+static void ValidateAxisSelection( AstFrame *this_frame, int naxes,
+                                   const int *axes, const char *method, int *status ) {
+/*
+*  Name:
+*     ValidateAxisSelection
+
+*  Purpose:
+*     Check that a set of axes selected from a Frame is valid.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     void ValidateAxisSelection( AstFrame *this, int naxes,
+*                                 const int *axes, const char *method, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astValidateAxisSelection
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function checks the validity of an array of (zero-based)
+*     axis indices that specify a set of axes to be selected from a
+*     Frame. To be valid, no axis should be selected more than
+*     once. In assessing this, any axis indices that do not refer to
+*     valid Frame axes (e.g. are set to -1) are ignored.
+*
+*     If the axis selection is valid, this function returns without further
+*     action. Otherwise, an error is reported and the global error status is
+*     set.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     naxes
+*        The number of axes to be selected (may be zero).
+*     axes
+*        Pointer to an array of int with naxes elements that contains the
+*        (zero based) axis indices to be checked.
+*     method
+*        Pointer to a constant null-terminated character string
+*        containing the name of the method that invoked this function
+*        to validate an axis selection. This method name is used
+*        solely for constructing error messages.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to current Frame */
+   AstRegion *this;              /* Pointer to the Region structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke this
+   Frame's astValidateAxisSelection method. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   astValidateAxisSelection( fr, naxes, axes, method );
+   fr = astAnnul( fr );
+
+}
+
+static int ValidateSystem( AstFrame *this_frame, AstSystemType system, const char *method, int *status ) {
+/*
+*  Name:
+*     ValidateSystem
+
+*  Purpose:
+*     Validate a value for a Frame's System attribute.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "region.h"
+*     int ValidateSystem( AstFrame *this, AstSystemType system,
+*                         const char *method, int *status )
+
+*  Class Membership:
+*     Region member function (over-rides the protected astValidateSystem
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function checks the validity of the supplied system value.
+*     If the value is valid, it is returned unchanged. Otherwise, an
+*     error is reported and a value of AST__BADSYSTEM is returned.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     system
+*        The system value to be checked.
+*     method
+*        Pointer to a constant null-terminated character string
+*        containing the name of the method that invoked this function
+*        to validate an axis index. This method name is used solely
+*        for constructing error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The validated system value.
+
+*  Notes:
+*     - A value of AST_BADSYSTEM will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*-
+*/
+
+/* Local Variables: */
+   AstSystemType result;      /* Validated system value */
+   AstFrame *fr;              /* Pointer to FrameSet's current Frame */
+   AstRegion *this;           /* Pointer to the Region structure */
+
+/* Initialise. */
+   result = AST__BADSYSTEM;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the FrameSet structure. */
+   this = (AstRegion *) this_frame;
+
+/* Obtain a pointer to the Region's encapsulated Frame and invoke the
+   astValidateSystem method for this Frame. Annul the Frame pointer
+   afterwards. */
+   fr = astGetFrame( this->frameset, AST__CURRENT );
+   result = astValidateSystem( this, system, method );
+   fr = astAnnul( fr );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = AST__BADSYSTEM;
+
+/* Return the result. */
+   return result;
+}
+
+/* Region Attributes. */
+/* -------------------- */
+
+/*
+*att++
+*  Name:
+*     Adaptive
+
+*  Purpose:
+*     Should the area adapt to changes in the coordinate system?
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean).
+
+*  Description:
+*     The coordinate system represented by a Region may be changed by
+*     assigning new values to attributes such as System, Unit, etc.
+*     For instance, a Region representing an area on the sky in ICRS
+*     coordinates may have its System attribute changed so that it
+*     represents (say) Galactic coordinates instead of ICRS. This
+*     attribute controls what happens when the coordinate system
+*     represented by a Region is changed in this way.
+*
+*     If Adaptive is non-zero (the default), then area represented by the
+*     Region adapts to the new coordinate system. That is, the numerical
+*     values which define the area represented by the Region are changed
+*     by mapping them from the old coordinate system into the new coordinate
+*     system. Thus the Region continues to represent the same physical
+*     area.
+*
+*     If Adaptive is zero, then area represented by the Region does not adapt
+*     to the new coordinate system. That is, the numerical values which
+*     define the area represented by the Region are left unchanged. Thus
+*     the physical area represented by the Region will usually change.
+*
+*     As an example, consider a Region describe a range of wavelength from
+*     2000 Angstrom to 4000 Angstrom. If the Unit attribute for the Region
+*     is changed from Angstrom to "nm" (nanometre), what happens depends
+*     on the setting of Adaptive. If Adaptive is non-zero, the Mapping
+*     from the old to the new coordinate system is found. In this case it
+*     is a simple scaling by a factor of 0.1 (since 1 Angstrom is 0.1 nm).
+*     This Mapping is then used to modify the numerical values within the
+*     Region, changing 2000 to 200 and 4000 to 400. Thus the modified
+*     region represents 200 nm to 400 nm, the same physical space as
+*     the original 2000 Angstrom to 4000 Angstrom. However, if Adaptive
+*     had been zero, then the numerical values would not have been changed,
+*     resulting in the final Region representing 2000 nm to 4000 nm.
+*
+*     Setting Adaptive to zero can be necessary if you want correct
+*     inaccurate attribute settings in an existing Region. For instance,
+*     when creating a Region you may not know what Epoch value to use, so
+*     you would leave Epoch unset resulting in some default value being used.
+*     If at some later point in the application, the correct Epoch value
+*     is determined, you could assign the correct value to the Epoch
+*     attribute. However, you would first need to set Adaptive temporarily
+*     to zero, because otherwise the area represented by the Region would
+*     be Mapped from the spurious default Epoch to the new correct Epoch,
+*     which is not what is required.
+
+*  Applicability:
+*     Region
+*        All Regions have this attribute.
+*att--
+*/
+
+/* This is a boolean value (0 or 1) with a value of -INT_MAX when
+   undefined but yielding a default of 1. */
+astMAKE_CLEAR(Region,Adaptive,adaptive,-INT_MAX)
+astMAKE_GET(Region,Adaptive,int,1,( ( this->adaptive == -INT_MAX ) ?
+                                   1 : this->adaptive ))
+astMAKE_SET(Region,Adaptive,int,adaptive,( value != 0 ))
+astMAKE_TEST(Region,Adaptive,( this->adaptive != -INT_MAX ))
+
+/*
+*att++
+*  Name:
+*     Negated
+
+*  Purpose:
+*     Region negation flag.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean).
+
+*  Description:
+*     This attribute controls whether a Region represents the "inside" or
+*     the "outside" of the area which was supplied when the Region was
+*     created. If the attribute value is zero (the default), the Region
+*     represents the inside of the original area. However, if it is non-zero,
+*     it represents the outside of the original area. The value of this
+*     attribute may be toggled using the
+c     astNegate function.
+f     AST_NEGATE routine.
+
+*     Note, whether the boundary is considered to be inside the Region or
+*     not is controlled by the Closed attribute. Changing the value of
+*     the Negated attribute does not change the value of the Closed attribute.
+*     Thus, if Region is closed, then the boundary of the Region will be
+*     inside the Region, whatever the setting of the Negated attribute.
+
+*  Applicability:
+*     Region
+*        All Regions have this attribute.
+*att--
+*/
+
+/* This is a boolean value (0 or 1) with a value of -INT_MAX when
+   undefined but yielding a default of zero. */
+astMAKE_CLEAR(Region,Negated,negated,(astResetCache(this),-INT_MAX))
+astMAKE_GET(Region,Negated,int,0,( ( this->negated == -INT_MAX ) ?
+                                   0 : this->negated ))
+astMAKE_SET(Region,Negated,int,negated,(astResetCache(this),( value != 0 )))
+astMAKE_TEST(Region,Negated,( this->negated != -INT_MAX ))
+
+/*
+*att++
+*  Name:
+*     Bounded
+
+*  Purpose:
+*     Is the Region bounded?
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean), read-only.
+
+*  Description:
+*     This is a read-only attribute indicating if the Region is bounded.
+*     A Region is bounded if it is contained entirely within some
+*     finite-size bounding box.
+
+*  Applicability:
+*     Region
+*        All Regions have this attribute.
+*att--
+*/
+
+/*
+*att+
+*  Name:
+*     RegionFS
+
+*  Purpose:
+*     Should Region FrameSet be dumped?
+
+*  Type:
+*     Protected attribute.
+
+*  Synopsis:
+*     Integer (boolean).
+
+*  Description:
+*     This attribute indicates whether the FrameSet encapsulated by the
+*     Region should be included in the dump produced by the Dump function.
+*
+*     If set to a non-zero value (the default), the FrameSet in the Region
+*     will always be included in the dump as usual. If set to zero, the
+*     FrameSet will only be included in the dump if the Mapping from base
+*     to current Frame is not a UnitMap. If the base->current Mapping is
+*     a UnitMap, the FrameSet is omitted from the dump. If the dump is
+*     subsequently used to re-create the Region, the new Region will have a
+*     default FrameSet containing a single default Frame with the appropriate
+*     number of axes.
+*
+*     This facility is indended to reduce the size of textual dumps of
+*     Regions in situations where the Frame to which the Region refers can
+*     be implied by the context in which the Region is used. This is
+*     often the case when a Region is encapsulated within another Region.
+*     In such cases the current Frame of the encapsulated Region will
+*     usually be equivalent to the base Frame of the parent Region
+*     structure, and so can be re-instated (by calling the astSetRegFS
+*     method) even if the FrameSet is omitted from the dump of the
+*     encapsulated Region. Note if the base->current Mapping in the FrameSet
+*     in the encapsulated Region is not a UnitMap, then we should always
+*     dump the FrameSet regardless of the setting of RegionFS. This is because
+*     the parent Region structure will not know how to convert the PointSet
+*     stored in the encapsulated Region into its own base Frame if the
+*     FrameSet is not available.
+
+*  Applicability:
+*     Region
+*        All Regions have this attribute.
+*att-
+*/
+
+/* This is a boolean value (0 or 1) with a value of -INT_MAX when
+   undefined but yielding a default of one. */
+astMAKE_CLEAR(Region,RegionFS,regionfs,-INT_MAX)
+astMAKE_TEST(Region,RegionFS,( this->regionfs != -INT_MAX ))
+astMAKE_SET(Region,RegionFS,int,regionfs,( value != 0 ))
+astMAKE_GET(Region,RegionFS,int,1,( ( this->regionfs == -INT_MAX ) ?
+                                   1 : this->regionfs ))
+
+/*
+*att++
+*  Name:
+*     FillFactor
+
+*  Purpose:
+*     Fraction of the Region which is of interest.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Floating point.
+
+*  Description:
+*     This attribute indicates the fraction of the Region which is of
+*     interest. AST does not use this attribute internally for any purpose.
+*     Typically, it could be used to indicate the fraction of the Region for
+*     which data is available.
+*
+*     The supplied value must be in the range 0.0 to 1.0, and the default
+*     value is 1.0 (except as noted below).
+
+*  Applicability:
+*     Region
+*        All Regions have this attribute.
+*     CmpRegion
+*        The default FillFactor for a CmpRegion is the FillFactor of its
+*        first component Region.
+*     Prism
+*        The default FillFactor for a Prism is the product of the
+*        FillFactors of its two component Regions.
+*     Stc
+*        The default FillFactor for an Stc is the FillFactor of its
+*        encapsulated Region.
+*att--
+*/
+
+astMAKE_CLEAR(Region,FillFactor,fillfactor,AST__BAD)
+astMAKE_GET(Region,FillFactor,double,1.0,( ( this->fillfactor == AST__BAD ) ?
+                                        1.0 : this->fillfactor ))
+astMAKE_TEST(Region,FillFactor,( this->fillfactor != AST__BAD ))
+astMAKE_SET(Region,FillFactor,double,fillfactor,((value<0.0||value>1.0)?(
+       astError(AST__ATSER,"astSetFillFactor(%s): Invalid value (%g) supplied "
+                "for attribute FillFactor.", status,astGetClass(this),value),
+       astError(AST__ATSER,"FillFactor values should be in the range 0.0 to 1.0", status),
+       this->fillfactor):value))
+
+/*
+*att++
+*  Name:
+*     MeshSize
+
+*  Purpose:
+*     Number of points used to represent the boundary of a Region.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer.
+
+*  Description:
+*     This attribute controls how many points are used when creating a
+*     mesh of points covering the boundary or volume of a Region. Such a
+*     mesh is returned by the
+c     astGetRegionMesh
+f     AST_GETREGIONMESH
+*     method. The boundary mesh is also used when testing for overlap
+*     between two Regions: each point in the bomdary mesh of the first
+*     Region is checked to see if it is inside or outside the second Region.
+*     Thus, the reliability of the overlap check depends on the value assigned
+*     to this attribute. If the value used is very low, it is possible for
+*     overlaps to go unnoticed. High values produce more reliable results, but
+*     can result in the overlap test being very slow. The default value is 200
+*     for two dimensional Regions and 2000 for three or more dimensional
+*     Regions (this attribute is not used for 1-dimensional regions since the
+*     boundary of a simple 1-d Region can only ever have two points). A
+*     value of five is used if the supplied value is less than five.
+
+*  Applicability:
+*     Region
+*        All Regions have this attribute.
+*     CmpRegion
+*        The default MeshSize for a CmpRegion is the MeshSize of its
+*        first component Region.
+*     Stc
+*        The default MeshSize for an Stc is the MeshSize of its
+*        encapsulated Region.
+*att--
+*/
+/* If the value of MeshSize is set or cleared, annul the PointSet used to
+   cache a mesh of base Frame boundary points. This will force a new
+   PointSet to be created next time it is needed. See function RegMesh. */
+astMAKE_CLEAR(Region,MeshSize,meshsize,(astResetCache(this),-INT_MAX))
+astMAKE_SET(Region,MeshSize,int,meshsize,(astResetCache(this),( value > 5 ? value : 5 )))
+astMAKE_TEST(Region,MeshSize,( this->meshsize != -INT_MAX ))
+astMAKE_GET(Region,MeshSize,int,0,( ( this->meshsize == -INT_MAX)?((astGetNaxes(this)==1)?2:((astGetNaxes(this)==2)?200:2000)): this->meshsize ))
+
+/*
+*att++
+*  Name:
+*     Closed
+
+*  Purpose:
+*     Should the boundary be considered to be inside the region?
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean).
+
+*  Description:
+*     This attribute controls whether points on the boundary of a Region
+*     are considered to be inside or outside the region. If the attribute
+*     value is non-zero (the default), points on the boundary are considered
+*     to be inside the region (that is, the Region is "closed"). However,
+*     if the attribute value is zero, points on the bounary are considered
+*     to be outside the region.
+
+*  Applicability:
+*     Region
+*        All Regions have this attribute.
+*     PointList
+*        The value of the Closed attribute is ignored by PointList regions.
+*        If the PointList region has not been negated, then it is always
+*        assumed to be closed. If the PointList region has been negated, then
+*        it is always assumed to be open. This is required since points
+*        have zero volume and therefore consist entirely of boundary.
+*     CmpRegion
+*        The default Closed value for a CmpRegion is the Closed value of its
+*        first component Region.
+*     Stc
+*        The default Closed value for an Stc is the Closed value of its
+*        encapsulated Region.
+*att--
+*/
+/* This is a boolean value (0 or 1) with a value of -INT_MAX when
+   undefined but yielding a default of 1. */
+astMAKE_CLEAR(Region,Closed,closed,(astResetCache(this),-INT_MAX))
+astMAKE_GET(Region,Closed,int,1,( ( this->closed == -INT_MAX ) ?
+                                   1 : this->closed ))
+astMAKE_SET(Region,Closed,int,closed,(astResetCache(this),( value != 0 )))
+astMAKE_TEST(Region,Closed,( this->closed != -INT_MAX ))
+
+/* Access to attributes of the encapsulated Frame. */
+/* ----------------------------------------------- */
+/* Use the macros defined at the start of this file to implement
+   private member functions that give access to the attributes of the
+   encapsulated Frame of a Region and its axes. These functions over-ride
+   the attribute access methods inherited from the Frame class. */
+
+/* Clear, Get, Set and Test axis-independent Frame attributes. */
+MAKE_CLEAR(Digits)
+MAKE_CLEAR(Domain)
+MAKE_CLEAR(MatchEnd)
+MAKE_CLEAR(MaxAxes)
+MAKE_CLEAR(MinAxes)
+MAKE_CLEAR(Permute)
+MAKE_CLEAR(PreserveAxes)
+MAKE_CLEAR(Title)
+
+MAKE_GET(Digits,int)
+MAKE_GET(Domain,const char *)
+MAKE_GET(MatchEnd,int)
+MAKE_GET(MaxAxes,int)
+MAKE_GET(MinAxes,int)
+MAKE_GET(Permute,int)
+MAKE_GET(PreserveAxes,int)
+MAKE_GET(Title,const char *)
+MAKE_SET(Digits,int,I)
+MAKE_SET(Domain,const char *,C)
+MAKE_SET(MatchEnd,int,I)
+MAKE_SET(MaxAxes,int,I)
+MAKE_SET(MinAxes,int,I)
+MAKE_SET(Permute,int,I)
+MAKE_SET(PreserveAxes,int,I)
+MAKE_SET(Title,const char *,C)
+MAKE_TEST(Digits)
+MAKE_TEST(Domain)
+MAKE_TEST(MatchEnd)
+MAKE_TEST(MaxAxes)
+MAKE_TEST(MinAxes)
+MAKE_TEST(Permute)
+MAKE_TEST(PreserveAxes)
+MAKE_TEST(Title)
+
+MAKE_GET(ActiveUnit,int)
+MAKE_SET(ActiveUnit,int,I)
+MAKE_TEST(ActiveUnit)
+
+MAKE_GET(System,AstSystemType)
+MAKE_SET_SYSTEM(System)
+MAKE_TEST(System)
+MAKE_CLEAR(System)
+
+MAKE_GET(AlignSystem,AstSystemType)
+MAKE_SET_SYSTEM(AlignSystem)
+MAKE_TEST(AlignSystem)
+MAKE_CLEAR(AlignSystem)
+
+MAKE_GET(Epoch,double)
+MAKE_SET(Epoch,double,D)
+MAKE_TEST(Epoch)
+MAKE_CLEAR(Epoch)
+
+MAKE_GET(ObsLon,double)
+MAKE_SET(ObsLon,double,D)
+MAKE_TEST(ObsLon)
+MAKE_CLEAR(ObsLon)
+
+MAKE_GET(ObsLat,double)
+MAKE_SET(ObsLat,double,D)
+MAKE_TEST(ObsLat)
+MAKE_CLEAR(ObsLat)
+
+MAKE_GET(ObsAlt,double)
+MAKE_SET(ObsAlt,double,D)
+MAKE_TEST(ObsAlt)
+MAKE_CLEAR(ObsAlt)
+
+/* Clear, Get, Set and Test axis-dependent Frame attributes. */
+MAKE_CLEAR_AXIS(Direction)
+MAKE_CLEAR_AXIS(Format)
+MAKE_CLEAR_AXIS(Label)
+MAKE_CLEAR_AXIS(Symbol)
+MAKE_CLEAR_AXIS(Unit)
+MAKE_GET_AXIS(Direction,int)
+MAKE_GET_AXIS(Format,const char *)
+MAKE_GET_AXIS(Label,const char *)
+MAKE_GET_AXIS(Symbol,const char *)
+MAKE_GET_AXIS(Unit,const char *)
+MAKE_SET_AXIS(Direction,int,I)
+MAKE_SET_AXIS(Format,const char *,C)
+MAKE_SET_AXIS(Label,const char *,C)
+MAKE_SET_AXIS(Symbol,const char *,C)
+MAKE_SET_AXIS(Unit,const char *,C)
+MAKE_TEST_AXIS(Direction)
+MAKE_TEST_AXIS(Format)
+MAKE_TEST_AXIS(Label)
+MAKE_TEST_AXIS(Symbol)
+MAKE_TEST_AXIS(Unit)
+
+MAKE_GET_AXIS(Bottom,double)
+MAKE_SET_AXIS(Bottom,double,D)
+MAKE_TEST_AXIS(Bottom)
+MAKE_CLEAR_AXIS(Bottom)
+
+MAKE_GET_AXIS(Top,double)
+MAKE_SET_AXIS(Top,double,D)
+MAKE_TEST_AXIS(Top)
+MAKE_CLEAR_AXIS(Top)
+
+/* Copy constructor. */
+/* ----------------- */
+static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
+/*
+*  Name:
+*     Copy
+
+*  Purpose:
+*     Copy constructor for Region objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Copy( const AstObject *objin, AstObject *objout, int *status )
+
+*  Description:
+*     This function implements the copy constructor for Region objects.
+
+*  Parameters:
+*     objin
+*        Pointer to the object to be copied.
+*     objout
+*        Pointer to the object being constructed.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     -  This constructor makes a deep copy.
+*/
+
+/* Local Variables: */
+   AstRegion *in;                /* Pointer to input Region */
+   AstRegion *out;               /* Pointer to output Region */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain pointers to the input and output Regions. */
+   in = (AstRegion *) objin;
+   out = (AstRegion *) objout;
+
+/* For safety, first clear any references to the input memory from
+   the output Region. */
+   out->basemesh = NULL;
+   out->basegrid = NULL;
+   out->frameset = NULL;
+   out->points = NULL;
+   out->unc = NULL;
+   out->negation = NULL;
+   out->defunc = NULL;
+
+/* Now copy each of the above structures. */
+   out->frameset = astCopy( in->frameset );
+   if( in->points ) out->points = astCopy( in->points );
+   if( in->basemesh ) out->basemesh = astCopy( in->basemesh );
+   if( in->basegrid ) out->basegrid = astCopy( in->basegrid );
+   if( in->unc ) out->unc = astCopy( in->unc );
+   if( in->negation ) out->negation = astCopy( in->negation );
+   if( in->defunc ) out->defunc = astCopy( in->defunc );
+}
+
+
+/* Destructor. */
+/* ----------- */
+static void Delete( AstObject *obj, int *status ) {
+/*
+*  Name:
+*     Delete
+
+*  Purpose:
+*     Destructor for Region objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Delete( AstObject *obj, int *status )
+
+*  Description:
+*     This function implements the destructor for Region objects.
+
+*  Parameters:
+*     obj
+*        Pointer to the object to be deleted.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     This function attempts to execute even if the global error status is
+*     set.
+*/
+
+/* Local Variables: */
+   AstRegion *this;                 /* Pointer to Region */
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) obj;
+
+/* Annul all resources. */
+   this->frameset = astAnnul( this->frameset );
+   if( this->points ) this->points = astAnnul( this->points );
+   if( this->basemesh ) this->basemesh = astAnnul( this->basemesh );
+   if( this->basegrid ) this->basegrid = astAnnul( this->basegrid );
+   if( this->unc ) this->unc = astAnnul( this->unc );
+   if( this->negation ) this->negation = astAnnul( this->negation );
+   if( this->defunc ) this->defunc = astAnnul( this->defunc );
+}
+
+/* Dump function. */
+/* -------------- */
+static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
+/*
+*  Name:
+*     Dump
+
+*  Purpose:
+*     Dump function for Region 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 Region class to an output Channel.
+
+*  Parameters:
+*     this
+*        Pointer to the Region whose data are being written.
+*     channel
+*        Pointer to the Channel to which the data are being written.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Constants: */
+#define KEY_LEN 50               /* Maximum length of a keyword */
+#define COM_LEN 50               /* Maximum length of a comment */
+
+/* Local Variables: */
+   AstFrame *fr;                 /* Pointer to the current Frame */
+   AstMapping *smap;             /* Base->current Mapping */
+   AstRegion *this;              /* Pointer to the Region structure */
+   AstRegion *unc;               /* Pointer to the uncertainty Region */
+   double dval;                  /* Floating point attribute value */
+   int ival;                     /* Integer attribute value */
+   int set;                      /* Attribute value set? */
+   int unit;                     /* Base->current is unitmap? */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Region structure. */
+   this = (AstRegion *) this_object;
+
+/* Write out values representing the instance variables for the
+   Region 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. */
+
+/* Negated. */
+/* -------- */
+   set = TestNegated( this, status );
+   ival = set ? GetNegated( this, status ) : astGetNegated( this );
+   astWriteInt( channel, "Negate", (ival != 0), 0, ival,
+                ival ? "Region negated" : "Region not negated" );
+
+/* FillFactor */
+/* ---------- */
+   set = TestFillFactor( this, status );
+   dval = set ? GetFillFactor( this, status ) : astGetFillFactor( this );
+   astWriteDouble( channel, "Fill", set, 0, dval,"Region fill factor" );
+
+/* MeshSize. */
+/* --------- */
+   set = TestMeshSize( this, status );
+   ival = set ? GetMeshSize( this, status ) : astGetMeshSize( this );
+   astWriteInt( channel, "MeshSz", set, 0, ival,
+                "No. of points used to represent boundary" );
+
+/* Closed. */
+/* ------- */
+   set = TestClosed( this, status );
+   ival = set ? GetClosed( this, status ) : astGetClosed( this );
+   astWriteInt( channel, "Closed", set, 0, ival,
+                ival ? "Boundary is inside" : "Boundary is outside" );
+
+/* Adaptive */
+/* -------- */
+   set = TestAdaptive( this, status );
+   ival = set ? GetAdaptive( this, status ) : astGetAdaptive( this );
+   astWriteInt( channel, "Adapt", (ival != 0), 0, ival,
+                ival ? "Region adapts to coord sys changes" : "Region does not adapt to coord sys changes" );
+
+/* FrameSet */
+/* -------- */
+
+/* If the vertices are the same in both base and current Frames (i.e.
+   if the Frames are connected by a UnitMap), then just dump the current
+   Frame (unless the RegionFS attribute is zero, in which case the
+   current Frame can be determined from the higher level context of the
+   Region and so does not need to be dumped- e.g. if the Region is contained
+   within another Region the parent Region will define the current Frame).
+   Otherwise, dump the whole FrameSet. */
+   ival = astGetRegionFS( this );
+   smap = astRegMapping( this );
+   if( ( unit = astIsAUnitMap( smap ) ) ){
+      set = 0;
+      if( ival ) {
+         fr = astGetFrame( this->frameset, AST__CURRENT );
+         astWriteObject( channel, "Frm", 1, 1, fr, "Coordinate system" );
+         fr = astAnnul( fr );
+      }
+   } else {
+      set = ( ival == 0 );
+      astWriteObject( channel, "FrmSet", 1, 1, this->frameset,
+                      "Original & current coordinate systems" );
+   }
+
+/* Annul the Mapping pointers */
+   smap = astAnnul( smap );
+
+/* RegionFS */
+/* -------- */
+   astWriteInt( channel, "RegFS", set, 0, ival,
+                ival ? "Include Frame in dump" : "Do not include Frame in dump" );
+
+/* Points */
+/* ------ */
+   if( this->points ) {
+      astWriteObject( channel, "Points", 1, 1, this->points,
+                      "Points defining the shape" );
+
+/* If the FrameSet was not included in the dump, then the loader will use
+   the PointSet to determine the number of axes in the frame spanned by
+   the Region. If there is no PointSet, then we must explicitly include
+   an item giving the number of axes.*/
+   } else {
+      astWriteInt( channel, "RegAxes", 1, 1, astGetNaxes( this ),
+                   "Number of axes spanned by the Region" );
+   }
+
+/* Uncertainty */
+/* ----------- */
+/* Only dump the uncertinaty Region if required. */
+   if( astTestUnc( this ) ) {
+      unc = astGetUncFrm( this, AST__BASE );
+      astWriteObject( channel, "Unc", 1, 1, unc,
+                      "Region defining positional uncertainties." );
+      unc = astAnnul( unc );
+   }
+
+/* Undefine macros local to this function. */
+#undef KEY_LEN
+}
+
+
+/* Standard class functions. */
+/* ========================= */
+/* Implement the astIsARegion and astCheckRegion functions using
+   the macros defined for this purpose in the "object.h" header
+   file. */
+astMAKE_ISA(Region,Frame)
+astMAKE_CHECK(Region)
+
+AstRegion *astInitRegion_( void *mem, size_t size, int init,
+                           AstRegionVtab *vtab, const char *name,
+                           AstFrame *frame, AstPointSet *pset,
+                           AstRegion *unc, int *status ){
+/*
+*+
+*  Name:
+*     astInitRegion
+
+*  Purpose:
+*     Initialise a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion *astInitRegion( void *mem, size_t size, int init,
+*                               AstRegionVtab *vtab, const char *name,
+*                               AstFrame *frame, AstpointSet *pset,
+*                               AstRegion *unc )
+
+*  Class Membership:
+*     Region initialiser.
+
+*  Description:
+*     This function is provided for use by class implementations to
+*     initialise a new Region object. It allocates memory (if
+*     necessary) to accommodate the Region plus any additional data
+*     associated with the derived class.  It then initialises a
+*     Region 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 Region at the start of the memory passed
+*     via the "vtab" parameter.
+
+*  Parameters:
+*     mem
+*        A pointer to the memory in which the Region is to be
+*        created. This must be of sufficient size to accommodate the
+*        Region data (sizeof(Region)) 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 Region (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 Region structure, so a valid value must be
+*        supplied even if not required for allocating memory.
+*     init
+*        A logical flag indicating if the Region'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 Region.
+*     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).
+*     frame
+*        Pointer to the encapsulated Frame. A deep copy of this Frame is
+*        taken. This means that subsequent changes to the supplied Frame
+*        will have no effect on the new Region.
+*     pset
+*        A PointSet holding the points which define the Region. These
+*        positions should refer to the given Frame. May be NULL.
+*     unc
+*        A pointer to a Region which specifies the uncertainty in the
+*        supplied positions (all points on the boundary of the new Region
+*        being initialised are assumed to have the same uncertainty). A NULL
+*        pointer can be supplied, in which case default uncertainties equal to
+*        1.0E-6 of the dimensions of the new Region's bounding box are used.
+*        If an uncertainty Region is supplied, it must be of a class for
+*        which all instances are centro-symetric (e.g. Box, Circle, Ellipse,
+*        etc.) or be a Prism containing centro-symetric component Regions.
+*        Its encapsulated Frame must be related to the Frame supplied for
+*        parameter "frame" (i.e. astConvert should be able to find a Mapping
+*        between them). Two positions in the "frame" Frame are considered to be
+*        co-incident if their uncertainty Regions overlap. The centre of the
+*        supplied uncertainty Region is immaterial since it will be re-centred
+*        on the point being tested before use. A deep copy is taken of the
+*        supplied Region.
+
+*  Returned Value:
+*     A pointer to the new Region.
+
+*  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 *f0;                  /* Frame to use */
+   AstRegion *new;                /* Pointer to new Region */
+   int nax;                       /* No. of axes in supplied Frame */
+   int ncoord;                    /* Coords per point */
+
+/* Check the global status. */
+   if ( !astOK ) return NULL;
+
+/* If necessary, initialise the virtual function table. */
+   if( init ) astInitRegionVtab( vtab, name );
+
+/* Note the number of axes in the supplied Frame. */
+   nax = astGetNaxes( frame );
+
+/* Check the pointset if supplied. */
+   if( pset ) {
+
+/* Note the number of axes per point in the supplied PointSet */
+      ncoord = astGetNcoord( pset );
+
+/* If OK, check that the number of coordinates per point matches the number
+   of axes in the Frame. Report an error if these numbers do not match. */
+      if ( astOK && ( ncoord != nax ) ) {
+         astError( AST__NCPIN, "astInitRegion(%s): Bad number of coordinate "
+                   "values per point (%d).", status, name, ncoord );
+         astError( AST__NCPIN, "The %s given requires %d coordinate value(s) "
+                   "for each point.", status, astGetClass( frame ), nax );
+      }
+   }
+
+/* Initialise a Frame structure (the parent class) as the first
+   component within the Region structure, allocating memory if
+   necessary. Give this Frame zero axes as the Frame information will be
+   specified by the encapsulated FrameSet. */
+   new = (AstRegion *) astInitFrame( mem, size, 0, (AstFrameVtab *) vtab,
+                                     name, 0 );
+   if ( astOK ) {
+
+/* Initialise the Region data. */
+/* ----------------------------- */
+      new->frameset = NULL;
+      new->points = NULL;
+      new->unc = NULL;
+      new->meshsize = -INT_MAX;
+      new->adaptive = -INT_MAX;
+      new->basemesh = NULL;
+      new->basegrid = NULL;
+      new->negated = -INT_MAX;
+      new->closed = -INT_MAX;
+      new->regionfs = -INT_MAX;
+      new->fillfactor = AST__BAD;
+      new->defunc = NULL;
+      new->nomap = 0;
+      new->negation = NULL;
+
+/* If the supplied Frame is a Region, gets its encapsulated Frame. If a
+   FrameSet was supplied, use its current Frame, otherwise use the
+   supplied Frame. */
+      if( astIsARegion( frame ) ) {
+         f0 = astGetFrame( ((AstRegion *) frame)->frameset, AST__CURRENT );
+
+      } else if( astIsAFrameSet( frame ) ) {
+         f0 = astGetFrame( (AstFrameSet *) frame, AST__CURRENT );
+
+      } else {
+         f0 = astClone( frame );
+      }
+
+/* Store a clone of the supplied PointSet pointer. */
+      new->points = pset ? astClone( pset ) : NULL;
+
+
+#ifdef DEBUG
+      if( pset ) {
+         double **ptr;
+         double lim;
+         int ii,jj, np;
+         ptr = astGetPoints( pset );
+         np = astGetNpoint( pset );
+         lim = sqrt( DBL_MAX );
+         for( ii = 0; astOK && ii < ncoord; ii++ ) {
+            for( jj = 0; jj < np; jj++ ) {
+               if( fabs( ptr[ ii ][ jj ] ) > lim ) {
+                  if( !strcmp( name, "Interval" ) ) {
+                     if( ptr[ ii ][ jj ] != AST__BAD &&
+                         ptr[ ii ][ jj ] != DBL_MAX &&
+                         ptr[ ii ][ jj ] != -DBL_MAX ) {
+                        astError( AST__INTER, "astInitRegion(%s): suspicious "
+                          "axis value (%g) supplied.", status, name, ptr[ ii ][ jj ] );
+                        break;
+                     }
+                  } else {
+                     astError( AST__INTER, "astInitRegion(%s): suspicious "
+                            "axis value (%g) supplied.", status, name,
+                            ptr[ ii ][ jj ] );
+                     break;
+                  }
+               }
+            }
+         }
+      }
+#endif
+
+/* Form a FrameSet consisting of two copies of the supplied Frame connected
+   together by a UnitMap, and store in the Region structure. We use the
+   private SetRegFS rather than the protected astSetRegFS because this
+   initialiser may be being called from a subclass which over-rides
+   astSetRegFS. If this were the case, then the implementation of
+   astSetRegFS provided by the subclass may access information within the
+   subclass structure which has not yet been initialised. */
+      SetRegFS( new, f0, status );
+      f0 = astAnnul( f0 );
+
+/* Store any uncertainty Region. Use the private SetUnc rather than
+   astSetUnc to avoid subclass implementations using subclass data which
+   has not yet been initialised. */
+      SetUnc( new, unc, status );
+
+/* If an error occurred, clean up by deleting the new object. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return a pointer to the new object. */
+   return new;
+}
+
+AstRegion *astLoadRegion_( void *mem, size_t size,
+                           AstRegionVtab *vtab, const char *name,
+                           AstChannel *channel, int *status ) {
+/*
+*+
+*  Name:
+*     astLoadRegion
+
+*  Purpose:
+*     Load a Region.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "region.h"
+*     AstRegion *astLoadRegion( void *mem, size_t size,
+*                               AstRegionVtab *vtab, const char *name,
+*                               AstChannel *channel )
+
+*  Class Membership:
+*     Region loader.
+
+*  Description:
+*     This function is provided to load a new Region 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
+*     Region structure in this memory, using data read from the
+*     input Channel.
+
+*  Parameters:
+*     mem
+*        A pointer to the memory into which the Region is to be
+*        loaded.  This must be of sufficient size to accommodate the
+*        Region data (sizeof(Region)) 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 Region (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 Region 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(AstRegion) is used instead.
+*     vtab
+*        Pointer to the start of the virtual function table to be
+*        associated with the new Region. If this is NULL, a pointer
+*        to the (static) virtual function table for the Region 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 "Region" is used instead.
+
+*  Returned Value:
+*     A pointer to the new Region.
+
+*  Notes:
+*     - A null pointer will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*-
+*/
+
+/* Local Constants: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+#define KEY_LEN 50               /* Maximum length of a keyword */
+
+/* Local Variables: */
+   AstFrame *f1;                  /* Base Frame for encapsulated FrameSet */
+   AstRegion *new;                /* Pointer to the new Region */
+   int nax;                       /* No. of axes in Frame, or FrameSet base Frame */
+   int naxpt;                     /* No. of axes in per point */
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(channel);
+
+/* Initialise. */
+   new = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return new;
+
+/* If a NULL virtual function table has been supplied, then this is
+   the first loader to be invoked for this Region. In this case the
+   Region belongs to this class, so supply appropriate values to be
+   passed to the parent class loader (and its parent, etc.). */
+   if ( !vtab ) {
+      size = sizeof( AstRegion );
+      vtab = &class_vtab;
+      name = "Region";
+
+/* If required, initialise the virtual function table for this class. */
+      if ( !class_init ) {
+         astInitRegionVtab( 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 Region. */
+   new = astLoadFrame( mem, size, (AstFrameVtab *) 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, "Region" );
+
+/* 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. */
+
+/* Negated */
+/* ------- */
+      new->negated = astReadInt( channel, "negate", -INT_MAX );
+      if ( TestNegated( new, status ) ) SetNegated( new, new->negated, status );
+
+/* FillFactor */
+/* ---------- */
+      new->fillfactor = astReadDouble( channel, "fill", AST__BAD );
+      if ( TestFillFactor( new, status ) ) SetFillFactor( new, new->fillfactor, status );
+
+/* MeshSize */
+/* -------- */
+      new->meshsize = astReadInt( channel, "meshsz", -INT_MAX );
+      if ( TestMeshSize( new, status ) ) SetMeshSize( new, new->meshsize, status );
+
+/* Closed */
+/* ------ */
+      new->closed = astReadInt( channel, "closed", -INT_MAX );
+      if ( TestClosed( new, status ) ) SetClosed( new, new->closed, status );
+
+/* Adaptive */
+/* -------- */
+      new->adaptive = astReadInt( channel, "adapt", -INT_MAX );
+      if ( TestAdaptive( new, status ) ) SetAdaptive( new, new->adaptive, status );
+
+/* Points */
+/* ------ */
+      new->points = astReadObject( channel, "points", NULL );
+
+/* If some points were found, ensure that they are in a PointSet and get
+   the number of axis values per point. */
+      if( new->points ){
+         if( astIsAPointSet( new->points) ) {
+            naxpt = astGetNcoord( new->points );
+         } else {
+            naxpt = 0;
+            astError( AST__REGIN, "astLoadRegion(%s): Corrupt %s specifies points "
+                      "using a %s (should be a PointSet).", status, astGetClass( new ),
+                      astGetClass( new ), astGetClass( new->points ) );
+         }
+
+/* If no PointSet was loaded, attempt to determine the number of axes
+   spanned by the Region by reading the RegAxes value. */
+      } else {
+         naxpt = astReadInt( channel, "regaxes", 0 );
+      }
+
+/* Uncertainty */
+/* ----------- */
+      new->unc = astReadObject( channel, "unc", NULL );
+      new->defunc = NULL;
+
+/* FrameSet */
+/* -------- */
+/* First see if the dump contains a single Frame. If so, create a
+   FrameSet from it and a copy of itself, using a UnitMap to connect the
+   two. */
+      new->nomap = 0;
+      new->frameset = NULL;
+      f1 = astReadObject( channel, "frm", NULL );
+      if( f1 ) {
+         new->regionfs = 1;
+         nax = astGetNaxes( f1 );
+         astSetRegFS( new, f1 );
+         f1 = astAnnul( f1 );
+
+/* If no Frame was found in the dump, look for a FrameSet. Get the number
+   of axes spanning its base Frame ("Nin"). */
+      } else {
+         new->frameset = astReadObject( channel, "frmset", NULL );
+         if( new->frameset ) {
+            nax = astGetNin( new->frameset );
+
+/* If a FrameSet was found, the value of the RegionFS attribute is still
+   unknown and so we must read it from an attribute as normal. */
+            new->regionfs = astReadInt( channel, "regfs", 1 );
+            if ( TestRegionFS( new, status ) ) SetRegionFS( new, new->regionfs, status );
+
+         } else {
+            nax = 0;
+         }
+      }
+
+/* If neither a Frame nor a FrameSet was found, create a default FrameSet
+   and set the RegionFS attribute false, to indicate that the FrameSet
+   should not be used. */
+      if( !new->frameset ){
+         nax = naxpt ? naxpt : 1;
+         f1 = astFrame( nax, "", status );
+         new->frameset = astFrameSet( f1, "", status );
+         astSetIdent( new->frameset, DUMMY_FS );
+         f1 = astAnnul( f1 );
+         new->regionfs = 0;
+      }
+
+/* Report an error if the number of axis values per point in the pointset is
+   incorrect. */
+      if ( astOK && new->points && ( naxpt != nax ) ) {
+         astError( AST__REGIN, "astLoadRegion(%s): Corrupt %s contains "
+                   " incorrect number of coordinate values per point (%d).", status,
+                   astGetClass( new ), astGetClass( new ), naxpt );
+         astError( AST__REGIN, "The %s requires %d coordinate value(s) "
+                   "for each point.", status, astGetClass( new ), nax );
+      }
+
+/* Initialise other fields which are used as caches for values derived
+   from the attributes set above. */
+      new->basemesh = NULL;
+      new->basegrid = NULL;
+
+/* If an error occurred, clean up by deleting the new Region. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return the new Region pointer. */
+   return new;
+
+/* Undefine macros local to this function. */
+#undef KEY_LEN
+}
+
+/* Virtual function interfaces. */
+/* ============================ */
+/* These provide the external interface to the virtual functions defined by
+   this class. Each simply checks the global error status and then locates and
+   executes the appropriate member function, using the function pointer stored
+   in the object's virtual function table (this pointer is located using the
+   astMEMBER macro defined in "object.h").
+
+   Note that the member function may not be the one defined here, as it may
+   have been over-ridden by a derived class. However, it should still have the
+   same interface. */
+
+void astRegClearAttrib_( AstRegion *this, const char *attrib, char **base_attrib, int *status ) {
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,RegClearAttrib))( this, attrib, base_attrib, status );
+}
+void astRegSetAttrib_( AstRegion *this, const char *setting, char **base_setting, int *status ) {
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,RegSetAttrib))( this, setting, base_setting, status );
+}
+void astNegate_( AstRegion *this, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,Negate))( this, status );
+}
+AstFrame *astGetRegionFrame_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,GetRegionFrame))( this, status );
+}
+AstFrameSet *astGetRegionFrameSet_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,GetRegionFrameSet))( this, status );
+}
+AstRegion *astMapRegion_( AstRegion *this, AstMapping *map, AstFrame *frame, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,MapRegion))( this, map, frame, status );
+}
+int astOverlap_( AstRegion *this, AstRegion *that, int *status ){
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Region,Overlap))( this, that, status );
+}
+int astOverlapX_( AstRegion *that, AstRegion *this, int *status ){
+   if ( !astOK ) return 0;
+   return (**astMEMBER(that,Region,OverlapX))( that, this, status );
+}
+AstFrame *astRegFrame_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegFrame))( this, status );
+}
+AstRegion *astRegBasePick_( AstRegion *this, int naxes, const int *axes, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegBasePick))( this, naxes, axes, status );
+}
+AstPointSet *astBTransform_( AstRegion *this, AstPointSet *in,
+                             int forward, AstPointSet *out, int *status ) {
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,BTransform))( this, in, forward, out, status );
+}
+AstPointSet *astRegTransform_( AstRegion *this, AstPointSet *in,
+                               int forward, AstPointSet *out,
+                               AstFrame **frm, int *status ) {
+   if( frm ) *frm = NULL;
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegTransform))( this, in, forward, out, frm, status );
+}
+int astRegPins_( AstRegion *this, AstPointSet *pset, AstRegion *unc, int **mask, int *status ){
+   if( mask ) *mask = NULL;
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Region,RegPins))( this, pset, unc, mask, status );
+}
+AstMapping *astRegMapping_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegMapping))( this, status );
+}
+int astRegDummyFS_( AstRegion *this, int *status ){
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Region,RegDummyFS))( this, status );
+}
+int astGetBounded_( AstRegion *this, int *status ){
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Region,GetBounded))( this, status );
+}
+int astTestUnc_( AstRegion *this, int *status ){
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Region,TestUnc))( this, status );
+}
+void astClearUnc_( AstRegion *this, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,ClearUnc))( this, status );
+}
+void astRegBaseBox_( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,RegBaseBox))( this, lbnd, ubnd, status );
+}
+void astRegBaseBox2_( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,RegBaseBox2))( this, lbnd, ubnd, status );
+}
+void astResetCache_( AstRegion *this, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,ResetCache))( this, status );
+}
+int astRegTrace_( AstRegion *this, int n, double *dist, double **ptr, int *status ){
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Region,RegTrace))( this, n, dist, ptr, status );
+}
+void astGetRegionBounds_( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,GetRegionBounds))( this, lbnd, ubnd, status );
+}
+void astGetRegionMesh_( AstRegion *this, int surface, int maxpoint,
+                        int maxcoord, int *npoint, double *points,
+                        int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,GetRegionMesh))( this, surface, maxpoint, maxcoord,
+                                             npoint, points, status );
+}
+void astGetRegionPoints_( AstRegion *this, int maxpoint, int maxcoord,
+                          int *npoint, double *points, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,GetRegionPoints))( this, maxpoint, maxcoord,
+                                               npoint, points, status );
+}
+void astShowMesh_( AstRegion *this, int format, const char *ttl, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,ShowMesh))( this, format,ttl, status );
+}
+void astGetRegionBounds2_( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,GetRegionBounds2))( this, lbnd, ubnd, status );
+}
+void astRegOverlay_( AstRegion *this, AstRegion *that, int unc, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,RegOverlay))( this, that, unc, status );
+}
+AstPointSet *astRegGrid_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegGrid))( this, status );
+}
+AstPointSet *astRegMesh_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegMesh))( this, status );
+}
+double *astRegCentre_( AstRegion *this, double *cen, double **ptr, int index,
+                       int ifrm, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegCentre))( this, cen, ptr, index, ifrm, status );
+}
+AstRegion *astGetNegation_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,GetNegation))( this, status );
+}
+AstRegion *astGetUncFrm_( AstRegion *this, int ifrm, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,GetUncFrm))( this, ifrm, status );
+}
+AstRegion *astGetDefUnc_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,GetDefUnc))( this, status );
+}
+AstRegion *astGetUnc_( AstRegion *this, int def, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,GetUnc))( this, def, status );
+}
+void astSetUnc_( AstRegion *this, AstRegion *unc, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,SetUnc))( this, unc, status );
+}
+AstFrameSet *astGetRegFS_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,GetRegFS))( this, status );
+}
+void astSetRegFS_( AstRegion *this, AstFrame *frm, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Region,SetRegFS))( this, frm, status );
+}
+AstPointSet *astRegBaseMesh_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegBaseMesh))( this, status );
+}
+AstRegion **astRegSplit_( AstRegion *this, int *nlist, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegSplit))( this, nlist, status );
+}
+AstPointSet *astRegBaseGrid_( AstRegion *this, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,RegBaseGrid))( this, status );
+}
+AstPointSet *astBndBaseMesh_( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,BndBaseMesh))( this, lbnd, ubnd, status );
+}
+AstPointSet *astBndMesh_( AstRegion *this, double *lbnd, double *ubnd, int *status ){
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Region,BndMesh))( this, lbnd, ubnd, status );
+}
+
+#define MAKE_MASK_(X,Xtype) \
+int astMask##X##_( AstRegion *this, AstMapping *map, int inside, int ndim, \
+                   const int lbnd[], const int ubnd[], Xtype in[], \
+                   Xtype val, int *status ) { \
+   if ( !astOK ) return 0; \
+   return (**astMEMBER(this,Region,Mask##X))( this, map, inside, ndim, lbnd, \
+                                              ubnd, in, val, status ); \
+}
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+MAKE_MASK_(LD,long double)
+#endif
+MAKE_MASK_(D,double)
+MAKE_MASK_(F,float)
+MAKE_MASK_(L,long int)
+MAKE_MASK_(UL,unsigned long int)
+MAKE_MASK_(I,int)
+MAKE_MASK_(UI,unsigned int)
+MAKE_MASK_(S,short int)
+MAKE_MASK_(US,unsigned short int)
+MAKE_MASK_(B,signed char)
+MAKE_MASK_(UB,unsigned char)
+#undef MAKE_MASK_
+
+/* Special public interface functions. */
+/* =================================== */
+/* These provide the public interface to certain special functions
+   whose public interface cannot be handled using macros (such as
+   astINVOKE) alone. In general, they are named after the
+   corresponding protected version of the function, but with "Id"
+   appended to the name. */
+
+/* Public 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. */
+
+/* Special interface function implementations. */
+/* ------------------------------------------- */
+
+
+AstRegion *astMapRegionId_( AstRegion *this, AstMapping *map, AstFrame *frame, int *status ) {
+/*
+*++
+*  Name:
+c     astMapRegion
+f     AST_MAPREGION
+
+*  Purpose:
+*     Transform a Region into a new Frame using a given Mapping.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "region.h"
+c     AstRegion *astMapRegion( AstRegion *this, AstMapping *map,
+c                              AstFrame *frame )
+f     RESULT = AST_MAPREGION( THIS, MAP, FRAME, STATUS )
+
+*  Class Membership:
+*     Region method.
+
+*  Description:
+*     This function returns a pointer to a new Region which corresponds to
+*     supplied Region described by some other specified coordinate system. A
+*     Mapping is supplied which transforms positions between the old and new
+*     coordinate systems. The new Region may not be of the same class as
+*     the original region.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the Region.
+c     map
+f     MAP = INTEGER (Given)
+*        Pointer to a Mapping which transforms positions from the
+*        coordinate system represented by the supplied Region to the
+*        coordinate system specified by
+c        "frame".
+f        FRAME.
+*        The supplied Mapping should define both forward and inverse
+*        transformations, and these transformations should form a genuine
+*        inverse pair. That is, transforming a position using the forward
+*        transformation and then using the inverse transformation should
+*        produce the original input position. Some Mapping classes (such
+*        as PermMap, MathMap, SphMap) can result in Mappings for which this
+*        is not true.
+c     frame
+f     FRAME = INTEGER (Given)
+*        Pointer to a Frame describing the coordinate system in which
+*        the new Region is required.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astMapRegion()
+f     AST_MAPREGION = INTEGER
+*        A pointer to a new Region. This Region will represent the area
+*        within the coordinate system specified by
+c        "frame"
+f        FRAME
+*        which corresponds to the supplied Region.
+
+*  Notes:
+*     - The uncertainty associated with the supplied Region is modified
+*     using the supplied Mapping.
+*     - 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:
+*     - The only difference between this public interface and the protected
+*     astMapRegion interface is that this implementation additionally
+*     simplifies the returned Region. The protected implementation does
+*     not do this since doing so can lead to infinite recursion because
+*     it is sometimes necessary for Simplify to call astMapRegion.
+
+*/
+
+/* Local Variables: */
+   AstRegion *new;                /* Pointer to new Region */
+   AstRegion *result;             /* Pointer value to return */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Invoke the protected astMapRegion function. */
+   new = astMapRegion( this, map, frame );
+
+/* Simplify the resulting Region. */
+   result = astSimplify( new );
+
+/* Free resources. */
+   new = astAnnul( new );
+
+/* If not OK, annul the returned pointer. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+}
+
+
+
+
+
+
+
+
+
+
+
+