path: root/ast/frame.h

#if !defined( FRAME_INCLUDED )   /* Include this file only once */
#define FRAME_INCLUDED
/*
*+
*  Name:
*     frame.h

*  Type:
*     C include file.

*  Purpose:
*     Define the interface to the Frame class.

*  Invocation:
*     #include "frame.h"

*  Description:
*     This include file defines the interface to the Frame class and
*     provides the type definitions, function prototypes and macros, etc.
*     needed to use this class.
*
*     A Frame object encapsulates information about a coordinate
*     system, including its axes. It may also act as a "template" to
*     be matched against another Frame object. This process determines
*     whether it is possible to perform a coordinate transformation
*     between the two coordinates systems they describe.

*  Inheritance:
*     The Frame class inherits from the Mapping class.

*  Attributes Over-Ridden:
*     Nin (integer, readonly)
*        The Frame class sets this value to be equal to the number of
*        Frame axes.
*     Nout (integer, readonly)
*        The Frame class sets this value to be equal to the number of
*        Frame axes.

*  New Attributes Defined:
*     AlignSystem (string)
*        This attribute takes a value to identify the coordinate system
*        in which the Frame should be aligned with other Frames.
*     Digits [or Digits(axis)] (integer)
*        Specifies how many digits of precision are required by
*        default when a coordinate value for a Frame is formatted
*        (e.g. using the astFormat method). The Digits value acts as a
*        default only and is over-ridden if a Format string is
*        specified for an axis explicitly.
*
*        The default Digits value for a Frame is 7. This attribute
*        normally applies to all the Frame's axes, but reference may
*        be made to a particular axis by adding an axis subscript
*        (e.g. Digits(1)). If a value is set for an individual axis,
*        it will over-ride the Digits value for the Frame as a whole
*        when formatting values for that axis.
*     Direction(axis) (integer)
*        A boolean value which specifies how coordinate values for
*        each Frame axis should be displayed (e.g. in graphs). By
*        default, it has the value one, indicating that they should be
*        shown in the conventional sense (i.e. increasing left to
*        right for an abscissa and bottom to top for an ordinate). If
*        set to zero, this attribute indicates that the direction
*        should be reversed (as would often be done for an
*        astronomical magnitude or a right ascension axis, for
*        example).
*     Epoch (double)
*        This value is used to qualify coordinate systems by
*        giving the moment in time when the coordinates are known to
*        be correct. Often, this will be the date of observation.
*     Format(axis) (string)
*        Specifies the format to be used to display coordinate values
*        for each Frame axis (i.e. to convert them from binary to
*        character form). The interpretation of this string (e.g. by
*        derived classes) is left to the astFormat method which, in
*        turn will invoke the astAxisFormat for the Axis object that
*        describes each axis. By default, the Frame class supplies an
*        Axis class object for each axis and this will interpret this
*        parameter as a C "printf" format string which should be
*        capable of formatting a single coordinate value stored as a
*        double (e.g. "%1.7G"). If no Format string is set, the
*        default format is based on the value of the Digits attribute.
*     Label(axis) (string)
*        Specifies the label to be attached to each Frame axis when it
*        is represented in (e.g.) a graph. It is intended purely for
*        interpretation by human readers and not by software. The
*        default supplied by the Frame class is the string "Axis <n>",
*        where <n> is 1, 2, etc. for each successive axis.
*     MatchEnd (integer)
*        A boolean value that controls how a Frame behaves when used
*        as a template to match another Frame. If it is zero and a
*        template Frame matches a target frame which has a different
*        number of axes, then the axes wich occur first in the target
*        frame will be matched and any trailing axes in either the
*        target or template will be discarded (if necessary). If it is
*        non-zero, however, the last axes in each frame will be
*        matched and any un-matched leading axes will be discarded
*        instead. The default value supplied by the Frame class is
*        zero.
*     MaxAxes (integer)
*        Specifies the maximum number of axes in a target Frame that
*        can be matched when using the Frame as a template. Normally,
*        by default, this value is equal to the number of Frame axes,
*        so that a Frame will only match another Frame with the same
*        number of axes as itself. By setting a different value,
*        however, Frames with different numbers of axes may be matched
*        (the MatchEnd attribute then determines which of the
*        individual axes are matched).
*
*        When setting this value, the value of the MinAxes attribute
*        may be silently changed so that it remains consistent with
*        (i.e. does not exceed) the new value. The default value may
*        also be reduced if necessary to remain consistent with the
*        MinAxes value.
*     MinAxes (integer)
*        Specifies the minimum number of axes in a target Frame that
*        can be matched when using the Frame as a template. Normally,
*        by default, this value is equal to the number of Frame axes,
*        so that a Frame will only match another Frame with the same
*        number of axes as itself. By setting a different value,
*        however, Frames with different numbers of axes may be matched
*        (the MatchEnd attribute then determines which of the
*        individual axes are matched).
*
*        When setting this value, the value of the MaxAxes attribute
*        may be silently changed so that it remains consistent with
*        (i.e. is not less than) the new value. The default value may
*        also be reduced if necessary to remain consistent with the
*        MaxAxes value.
*     Domain (string)
*        A string which may be used to identify the physical domain to
*        which a Frame applies and used as an additional key when
*        matching a target Frame with a template. If the Domain
*        attribute in the template Frame is set, then only target
*        frames with the same Domain value will be matched. If a
*        Domain is not set in the template Frame, the target Frame's
*        Domain value will be ignored and has no effect on
*        matching. The default value supplied by the Frame class is an
*        empty string. Domain values are automatically converted to
*        upper case and all white space is removed before use.
*     Naxes (integer)
*        A read-only attribute that gives the number of axes in a
*        Frame (i.e.  the number of dimensions of the space which the
*        Frame describes). This value is determined when the Frame is
*        created.
*     Permute (integer)
*        A boolean value which specifies whether the axis order of a
*        target Frame may be permuted in order to obtain a match with
*        a template. If this value is set to zero in the template
*        Frame, it will only match a target if it can do so without
*        changing the order of its axes. The default value supplied by
*        the Frame class is 1 (i.e. allow axis permutations).
*     PreserveAxes (integer)
*        A boolean value which determines how the "result" Frame is
*        produced whan a target frame is matched by a template. If
*        this value is zero in the template Frame, then the result
*        Frame will have the same number of axes as the template. If
*        it is non-zero, however, the axes of the target Frame will be
*        preserved, so that the result Frame will have the same number
*        of axes as the target. The default supplied by the Frame
*        class is zero (i.e. target axes are not preserved).
*
*        The main use for this attribute is when the MaxAxes and/or
*        MinAxes attributes have been set to search for a Frame which
*        may have a different number of axes from the template. For
*        example, if a 2-dimensional template Frame matches a
*        3-dimensional target Frame, then by default the result is
*        2-dimensional and the last axis (normally) will be
*        discarded. However, if the template's PreserveAxes value is
*        non-zero, the result will instead be 3-dimensional to
*        correspond with the target Frame.
*     Symbol(axis) (string)
*        Specifies the symbol to be used to represent coordinate
*        values for each Frame axis in "short form", such as in
*        algebraic expressions where a full description of the axis
*        would be inappropriate. Examples include "RA" and "Dec" (for
*        Right Ascension and Declination).
*
*        The default supplied by the Frame class is the string
*        "<Domain><n>", where <n> is 1, 2, etc. for successive axes,
*        and <Domain> is the value of the Frame's Domain attribute
*        (with any white space replaced by underscores and truncated
*        if necessary so that the final string does not exceed 15
*        characters). If no Domain value has been set, "x" is used as
*        the <Domain> value in constructing this default string.
*     System (string)
*        This attribute takes a value to identify the coordinate system
*        used to describe positions within the domain of the Frame.
*     Title (string)
*        Specifies a string to be used as a title on (e.g.) graphs to
*        describe the coordinate system which the Frame
*        represents. Examples would be "Detector Coordinates" or
*        "Galactic Coordinates". This string is intended solely for
*        interpretation by human readers and not by software. The
*        default supplied by the Frame class is "<n>-D Coordinate
*        System", where <n> is the number of Frame axes.
*     Unit(axis) (string)
*        Describes the units used to represent coordinate values on
*        each Frame axis. The default supplied by the Frame class is
*        an empty string.

*  Methods Over-Ridden:
*     Public:
*        astGetNin
*           Get the number of input coordinates for a Frame.
*        astGetNout
*           Get the number of output coordinates for a Frame.
*        astTransform
*           Use a Frame to transform a set of points.

*     Protected:
*        astClearAttrib
*           Clear an attribute value for a Frame.
*        astGetAttrib
*           Get an attribute value for a Frame.
*        astReportPoints
*           Report the effect of transforming a set of points using a Frame.
*        astSetAttrib
*           Set an attribute value for a Frame.
*        astTestAttrib
*           Test if an attribute value has been set for a Frame.

*  New Methods Defined:
*     Public:
*        astAngle
*           Calculate the angle between three points.
*        astAxAngle
*           Find the angle from an axis to a line through two points.
*        astAxDistance
*           Calculate the distance between two axis values
*        astAxOffset
*           Calculate an offset along an axis
*        astConvert
*           Determine how to convert between two coordinate systems.
*        astDistance
*           Calculate the distance between two points.
*        astFindFrame
*           Find a coordinate system with specified characteristics
*        astFormat
*           Format a coordinate value for a Frame axis.
*        astNorm
*           Normalise a set of Frame coordinates.
*        astOffset
*           Calculate an offset along a geodesic curve.
*        astOffset2
*           Calculate an offset along a geodesic curve for a 2D Frame.
*        astPermAxes
*           Permute the order of a Frame's axes.
*        astPickAxes
*           Create a new Frame by picking axes from an existing one.
*        astResolve
*           Resolve a vector into two orthogonal components.
*        astUnformat
*           Read a formatted coordinate value for a Frame axis.

*     Protected:
*        astAbbrev
*           Abbreviate a formatted Frame axis value by skipping
*           leading fields.
*        astCheckPerm
*           Check that an array contains a valid permutation.
*        astClearDigits
*           Clear the Digits attribute for a Frame.
*        astClearDirection
*           Clear the Direction attribute for a Frame axis.
*        astClearDomain
*           Clear the Domain attribute for a Frame.
*        astClearFormat
*           Clear the Format attribute for a Frame axis.
*        astClearLabel
*           Clear the Label attribute for a Frame axis.
*        astClearMatchEnd
*           Clear the MatchEnd attribute for a Frame.
*        astClearMaxAxes
*           Clear the MaxAxes attribute for a Frame.
*        astClearMinAxes
*           Clear the MinAxes attribute for a Frame.
*        astClearPermute
*           Clear the Permute attribute for a Frame.
*        astClearPreserveAxes
*           Clear the PreserveAxes attribute for a Frame.
*        astClearSymbol
*           Clear the Symbol attribute for a Frame axis.
*        astClearSystem
*           Clear the value of the System attribute for a Frame.
*        astClearTitle
*           Clear the Title attribute for a Frame.
*        astClearUnit
*           Clear the Unit attribute for a Frame axis.
*        astConvertX
*           Determine how to convert between two coordinate systems.
*        astFields
*           Identify the fields within a formatted Frame axis value.
*        astCentre
*           Find a "nice" central value for tabulating Frame axis values.
*        astGap
*           Find a "nice" gap for tabulating Frame axis values.
*        astGetAxis
*           Obtain a pointer to a specified Axis from a Frame.
*        astGetDigits
*           Get the value of the Digits attribute for a Frame.
*        astGetDirection
*           Get the value of the Direction attribute for a Frame axis.
*        astGetDomain
*           Get a pointer to the Domain attribute for a Frame.
*        astGetFormat
*           Get a pointer to the Format attribute for a Frame axis.
*        astGetLabel
*           Get a pointer to the Label attribute for a Frame axis.
*        astGetMatchEnd
*           Get the value of the MatchEnd attribute for a Frame.
*        astGetMaxAxes
*           Get the value of the MaxAxes attribute for a Frame.
*        astGetMinAxes
*           Get the value of the MinAxes attribute for a Frame.
*        astGetNaxes
*           Determine how many axes a Frame has.
*        astGetPerm
*           Access the axis permutation array for a Frame.
*        astGetPermute
*           Get the value of the Permute attribute for a Frame.
*        astGetPreserveAxes
*           Get the value of the PreserveAxes attribute for a Frame.
*        astGetSymbol
*           Get a pointer to the Symbol attribute for a Frame axis.
*        astGetSystem
*           Get the value of the System attribute for a Frame.
*        astGetTitle
*           Get a pointer to the Title attribute for a Frame.
*        astGetUnit
*           Get a pointer to the Unit attribute for a Frame axis.
*        astIsUnitFrame
*           Returns a flag indicating if a Frame is equivalent to a UnitMap.
*        astMatch
*           Determine if conversion is possible between two coordinate systems.
*        astOverlay
*           Overlay the attributes of a template Frame on to another Frame.
*        astPrimaryFrame
*           Uniquely identify a primary Frame and one of its axes.
*        astResolvePoints
*           Resolve many vectors into two orthogonal components.
*        astSetAxis
*           Set a new Axis for a Frame.
*        astSetDigits
*           Set the value of the Digits attribute for a Frame.
*        astSetDirection
*           Set the value of the Direction attribute for a Frame axis.
*        astSetDomain
*           Set the value of the Domain attribute for a Frame.
*        astSetFormat
*           Set the value of the Format attribute for a Frame axis.
*        astSetLabel
*           Set the value of the Label attribute for a Frame axis.
*        astSetMatchEnd
*           Set the value of the MatchEnd attribute for a Frame.
*        astSetMaxAxes
*           Set the value of the MaxAxes attribute for a Frame.
*        astSetMinAxes
*           Set the value of the MinAxes attribute for a Frame.
*        astSetPermute
*           Set the value of the Permute attribute for a Frame.
*        astSetPreserveAxes
*           Set the value of the PreserveAxes attribute for a Frame.
*        astSetSymbol
*           Set the value of the Symbol attribute for a Frame axis.
*        astSetSystem
*           Set the value of the System attribute for a Frame.
*        astSetTitle
*           Set the value of the Title attribute for a Frame.
*        astSetUnit
*           Set the value of the Unit attribute for a Frame axis.
*        astSubFrame
*           Select axes from a Frame and convert to the new coordinate system.
*        astTestDigits
*           Test whether a value has been set for the Digits attribute of a
*           Frame.
*        astTestDirection
*           Test whether a value has been set for the Direction attribute of a
*           Frame axis.
*        astTestDomain
*           Test whether a value has been set for the Domain attribute of a
*           Frame.
*        astTestFormat
*           Test whether a value has been set for the Format attribute of a
*           Frame axis.
*        astTestLabel
*           Test whether a value has been set for the Label attribute of a
*           Frame axis.
*        astTestMatchEnd
*           Test whether a value has been set for the MatchEnd attribute of a
*           Frame.
*        astTestMaxAxes
*           Test whether a value has been set for the MaxAxes attribute of a
*           Frame.
*        astTestMinAxes
*           Test whether a value has been set for the MinAxes attribute of a
*           Frame.
*        astTestPermute
*           Test whether a value has been set for the Permute attribute of a
*           Frame.
*        astTestPreserveAxes
*           Test whether a value has been set for the PreserveAxes attribute of
*           a Frame.
*        astTestSymbol
*           Test whether a value has been set for the Symbol attribute of a
*           Frame axis.
*        astTestSystem
*           Test whether a value has been set for the System attribute of a
*           Frame.
*        astTestTitle
*           Test whether a value has been set for the Title attribute of a
*           Frame.
*        astTestUnit
*           Test whether a value has been set for the Unit attribute of a Frame
*           axis.
*        astValidateAxis
*           Validate and permute a Frame's axis index.
*        astValidateAxisSelection
*           Check that a set of axes selected from a Frame is valid.
*        astValidateSystem
*           Validate a Frame's System attribute.
*        astSystemString
*           Return a string representation of a System code.
*        astSystemCode
*           Return a code for a string representation of a System value

*  Other Class Functions:
*     Public:
*        astFrame
*           Create a Frame.
*        astIsAFrame
*           Test class membership.

*     Protected:
*        astCheckFrame
*           Validate class membership.
*        astInitFrame
*           Initialise a Frame.
*        astInitFrameVtab
*           Initialise the virtual function table for the Frame class.
*        astLoadFrame
*           Load a Frame.

*  Macros:
*     Public:
*        None.

*     Protected:
*        AST__BADSYSTEM
*           A "bad" (undefined) value for the System attribute.

*  Type Definitions:
*     Public:
*        AstFrame
*           Frame object type.

*     Protected:
*        AstFrameVtab
*           Frame virtual function table type.
*        AstSystemType
*           Enumerated type used for the System attribute.

*  Feature Test Macros:
*     astCLASS
*        If the astCLASS macro is undefined, only public symbols are
*        made available, otherwise protected symbols (for use in other
*        class implementations) are defined. This macro also affects
*        the reporting of error context information, which is only
*        provided for external calls to the AST library.

*  Copyright:
*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
*     Research Councils

*  Licence:
*     This program is free software: you can redistribute it and/or
*     modify it under the terms of the GNU Lesser General Public
*     License as published by the Free Software Foundation, either
*     version 3 of the License, or (at your option) any later
*     version.
*
*     This program is distributed in the hope that it will be useful,
*     but WITHOUT ANY WARRANTY; without even the implied warranty of
*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*     GNU Lesser General Public License for more details.
*
*     You should have received a copy of the GNU Lesser General
*     License along with this program.  If not, see
*     <http://www.gnu.org/licenses/>.

*  Authors:
*     RFWS: R.F. Warren-Smith (Starlink)
*     DSB: B.S. Berry (Starlink)

*  History:
*     1-MAR-1996 (RFWS):
*        Original version.
*     25-APR-1996 (RFWS):
*        Tidied up, etc.
*     11-SEP-1996 (RFWS):
*        Added astGap (written by DSB).
*     10-JUN-1997 (RFWS):
*        Revised astConvert and added astFindFrame.
*     15-FEB-1998 (RFWS):
*        Added astUnformat.
*     21-JUN-2001 (DSB):
*        Added astAngle and astOffset2.
*     29-AUG-2001 (DSB):
*        Added astAxDistance and astAxOffset.
*     4-SEP-2001 (DSB):
*        Added astResolve.
*     9-SEP-2001 (DSB):
*        Added astBear.
*     21-SEP-2001 (DSB):
*        Replace astBear with astAxAngle.
*     15-NOV-2002 (DSB):
*        Moved System and Epoch attributes from SkyFrame into this class.
*        Added AlignSystem attribute.
*     8-JAN-2003 (DSB):
*        Added protected astInitFrameVtab method.
*     24-JAN-2004 (DSB):
*        o  Added astFields.
*        o  Added argument "fmt" to astAbbrev.
*     24-JUN-2004 (DSB):
*        Remove unused entry "void (* SetMatchRange)( AstFrame *, int, int );"
*        from AstFrameVtab structure.
*     9-NOV-2004 (DSB):
*        Added protected astIsAUnitFrame method.
*     12-AUG-2005 (DSB):
*        Added ObsLat and ObsLon attributes.
*     14-OCT-2006 (DSB):
*        Added dut1 to the Frame structure.
*        Added Dut1 accessor methods.
*     17-MAY-2007 (DSB):
*        Added NormUnit attribute.
*     14-JAN-2009 (DSB):
*        Added astIntersect method.
*     18-JUN-2009 (DSB):
*        Added ObsAlt attribute.
*     17-APR-2015 (DSB):
*        Added astCentre.
*     27-APR-2015 (DSB):
*        Added InternalUnit attribute.
*     26-OCT-2016 (DSB):
*        Added method astAxNorm.
*-
*/

/* Include files. */
/* ============== */
/* Interface definitions. */
/* ---------------------- */
#include "object.h"              /* Base Object class */
#include "axis.h"                /* Coordinate Axis class */
#include "mapping.h"             /* Coordinate mappings (parent class) */

#if defined(astCLASS)            /* Protected */
#include "channel.h"             /* I/O channels */
#endif

/* C header files. */
/* --------------- */
#include <stddef.h>

/* Macros. */
/* ------- */
#if defined(astCLASS) || defined(astFORTRAN77)
#define STATUS_PTR status
#else
#define STATUS_PTR astGetStatusPtr
#endif

/* Define a dummy __attribute__ macro for use on non-GNU compilers. */
#ifndef __GNUC__
#  define  __attribute__(x)  /*NOTHING*/
#endif

#if defined(astCLASS)            /* Protected */

/* A bad value for the System attribute. */
#define AST__BADSYSTEM -1

/* The legal System values recognized by this class of Frame. */
#define AST__CART 0

/* Flag bitmasks for use with astSetFrameFlags. */
# define AST__INTFLAG 1  /* FrameSet integrity is currently being restored */

/* Define constants used to size global arrays in this module. */
#define AST__FRAME_LABEL_BUFF_LEN 100       /* Max length of default axis Label string */
#define AST__FRAME_SYMBOL_BUFF_LEN 50       /* Max length of default axis Symbol string */
#define AST__FRAME_TITLE_BUFF_LEN 100       /* Max length of default title string */
#define AST__FRAME_GETATTRIB_BUFF_LEN 50    /* Max length of string returned by GetAttrib */
#define AST__FRAME_ASTFMTDECIMALYR_BUFF_LEN 50    /* Max length of string returned by GetAttrib */
#define AST__FRAME_ASTFORMATID_MAX_STRINGS 50     /* Number of string values buffer by astFormatID*/

#endif

/* Type Definitions. */
/* ================= */
/* Integer type used to store the System attribute values. */
typedef int AstSystemType;

/* Frame structure. */
/* ------------------- */
/* This structure contains all information that is unique to each object in
   the class (e.g. its instance variables). */
typedef struct AstFrame {

/* Attributes inherited from the parent class. */
   AstMapping mapping;           /* Parent class structure */

/* Attributes specific to objects in this class. */
   AstAxis **axis;               /* Pointer to array of Axis objects */
   char *domain;                 /* Pointer to Domain string */
   char *title;                  /* Pointer to Title string */
   double epoch;                 /* Epoch as Modified Julian Date */
   double obslat;                /* Geodetic latitude of observer */
   double obslon;                /* Geodetic longitude of observer */
   double obsalt;                /* Height above reference spheroid (geodetic, metres) */
   double dut1;                  /* UT1-UTC in seconds */
   int *perm;                    /* Pointer to axis permutation array */
   int digits;                   /* Default digits of precision */
   int match_end;                /* Match final axes of target? */
   int active_unit;              /* Use Unit when aligning Frames? */
   int max_axes;                 /* Minimum no. axes matched */
   int min_axes;                 /* Max. no. axes matched */
   int naxes;                    /* Number of axes */
   int permute;                  /* Permute axes in order to match? */
   int preserve_axes;            /* Preserve target axes? */
   AstSystemType system;         /* Code identifying coordinate system */
   AstSystemType alignsystem;    /* Code for Alignment coordinate system */
   int flags;                    /* Bit mask containing various protected flags */
   struct AstFrameSet *variants; /* FrameSet defining alternative properties for the Frame */
} AstFrame;

/* Cached Line structure. */
/* ---------------------- */
/* This structure contains information describing a line segment within a
   2D Frame. It is used by other classes to store intermediate cached values
   relating to the line in order to speed up repeated operations on the
   line. */

typedef struct AstLineDef {
   AstFrame *frame;            /* Pointer to Frame in which the line is defined */
   double length;              /* Line length */
   int infinite;               /* Disregard the start and end of the line? */
   double start[2];            /* Frame axis values at line start */
   double end[2];              /* Frame axis values at line end */
   double dir[2];              /* Unit vector defining line direction */
   double q[2];                /* Unit vector perpendicular to line */
} AstLineDef;

/* Virtual function table. */
/* ----------------------- */
/* The virtual function table makes a forward reference to the
   AstFrameSet structure which is not defined until "frameset.h" is
   included (below). Hence make a preliminary definition available
   now. */
struct AstFrameSet;

/* This table contains all information that is the same for all objects in the
   class (e.g. pointers to its virtual functions). */
#if defined(astCLASS)            /* Protected */
typedef struct AstFrameVtab {

/* Properties (e.g. methods) inherited from the parent class. */
   AstMappingVtab mapping;       /* Parent class virtual function table */

/* A Unique identifier to determine class membership. */
   AstClassIdentifier id;

/* Properties (e.g. methods) specific to this class. */
   AstAxis *(* GetAxis)( AstFrame *, int, int * );
   AstFrame *(* PickAxes)( AstFrame *, int, const int[], AstMapping **, int * );
   AstLineDef *(* LineDef)( AstFrame *, const double[2], const double[2], int * );
   AstPointSet *(* ResolvePoints)( AstFrame *, const double [], const double [], AstPointSet *, AstPointSet *, int * );
   const char *(* Abbrev)( AstFrame *, int, const char *, const char *, const char *, int * );
   const char *(* Format)( AstFrame *, int, double, int * );
   const char *(* GetDomain)( AstFrame *, int * );
   const char *(* GetFormat)( AstFrame *, int, int * );
   const char *(* GetLabel)( AstFrame *, int, int * );
   const char *(* GetSymbol)( AstFrame *, int, int * );
   const char *(* GetTitle)( AstFrame *, int * );
   const char *(* GetInternalUnit)( AstFrame *, int, int * );
   const char *(* GetNormUnit)( AstFrame *, int, int * );
   const char *(* GetUnit)( AstFrame *, int, int * );
   const int *(* GetPerm)( AstFrame *, int * );
   double (* Angle)( AstFrame *, const double[], const double[], const double[], int * );
   double (* Distance)( AstFrame *, const double[], const double[], int * );
   double (* Centre)( AstFrame *, int, double, double, int * );
   double (* Gap)( AstFrame *, int, double, int *, int * );
   int (* Fields)( AstFrame *, int, const char *, const char *, int, char **, int *, double *, int * );
   double (* AxDistance)( AstFrame *, int, double, double, int * );
   void (* AxNorm)( AstFrame *, int, int, int, double *, int * );
   double (* AxOffset)( AstFrame *, int, double, double, int * );
   int (* AxIn)( AstFrame *, int, double, double, double, int, int * );
   int (* GetDigits)( AstFrame *, int * );
   int (* GetDirection)( AstFrame *, int, int * );
   int (* GetMatchEnd)( AstFrame *, int * );
   int (* GetMaxAxes)( AstFrame *, int * );
   int (* GetMinAxes)( AstFrame *, int * );
   int (* GetNaxes)( AstFrame *, int * );
   int (* GetPermute)( AstFrame *, int * );
   int (* GetPreserveAxes)( AstFrame *, int * );
   int (* IsUnitFrame)( AstFrame *, int * );
   int (* LineCrossing)( AstFrame *, AstLineDef *, AstLineDef *, double **, int * );
   int (* LineContains)( AstFrame *, AstLineDef *, int, double *, int * );
   int (* Match)( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
   int (* SubFrame)( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
   int (* TestDigits)( AstFrame *, int * );
   int (* TestDirection)( AstFrame *, int, int * );
   int (* TestDomain)( AstFrame *, int * );
   int (* TestFormat)( AstFrame *, int, int * );
   int (* TestLabel)( AstFrame *, int, int * );
   int (* TestMatchEnd)( AstFrame *, int * );
   int (* TestMaxAxes)( AstFrame *, int * );
   int (* TestMinAxes)( AstFrame *, int * );
   int (* TestPermute)( AstFrame *, int * );
   int (* TestPreserveAxes)( AstFrame *, int * );
   int (* TestSymbol)( AstFrame *, int, int * );
   int (* TestTitle)( AstFrame *, int * );
   int (* TestUnit)( AstFrame *, int, int * );
   int (* Unformat)( AstFrame *, int, const char *, double *, int * );
   int (* ValidateAxis)( AstFrame *, int, int, const char *, int * );
   AstSystemType (* ValidateSystem)( AstFrame *, AstSystemType, const char *, int * );
   AstSystemType (* SystemCode)( AstFrame *, const char *, int * );
   const char *(* SystemString)( AstFrame *, AstSystemType, int * );
   struct AstFrameSet *(* Convert)( AstFrame *, AstFrame *, const char *, int * );
   struct AstFrameSet *(* ConvertX)( AstFrame *, AstFrame *, const char *, int * );
   struct AstFrameSet *(* FindFrame)( AstFrame *, AstFrame *, const char *, int * );
   void (* MatchAxes)( AstFrame *, AstFrame *, int[], int * );
   void (* MatchAxesX)( AstFrame *, AstFrame *, int[], int * );
   void (* CheckPerm)( AstFrame *, const int *, const char *, int * );
   void (* ClearDigits)( AstFrame *, int * );
   void (* ClearDirection)( AstFrame *, int, int * );
   void (* ClearDomain)( AstFrame *, int * );
   void (* ClearFormat)( AstFrame *, int, int * );
   void (* ClearLabel)( AstFrame *, int, int * );
   void (* ClearMatchEnd)( AstFrame *, int * );
   void (* ClearMaxAxes)( AstFrame *, int * );
   void (* ClearMinAxes)( AstFrame *, int * );
   void (* ClearPermute)( AstFrame *, int * );
   void (* ClearPreserveAxes)( AstFrame *, int * );
   void (* ClearSymbol)( AstFrame *, int, int * );
   void (* ClearTitle)( AstFrame *, int * );
   void (* ClearUnit)( AstFrame *, int, int * );
   void (* Intersect)( AstFrame *, const double[2], const double[2], const double[2], const double[2], double[2], int * );
   void (* Norm)( AstFrame *, double[], int * );
   void (* NormBox)( AstFrame *, double *, double *, AstMapping *, int * );
   void (* Offset)( AstFrame *, const double[], const double[], double, double[], int * );
   double (* AxAngle)( AstFrame *, const double[2], const double[2], int, int * );
   double (* Offset2)( AstFrame *, const double[2], double, double, double[2], int * );
   void (* Overlay)( AstFrame *, const int *, AstFrame *, int * );
   void (* PermAxes)( AstFrame *, const int[], int * );
   void (* PrimaryFrame)( AstFrame *, int, AstFrame **, int *, int * );
   void (* Resolve)( AstFrame *, const double [], const double [], const double [], double [], double *, double *, int * );
   void (* SetAxis)( AstFrame *, int, AstAxis *, int * );
   void (* SetDigits)( AstFrame *, int, int * );
   void (* SetDirection)( AstFrame *, int, int, int * );
   void (* SetDomain)( AstFrame *, const char *, int * );
   void (* SetFormat)( AstFrame *, int, const char *, int * );
   void (* SetLabel)( AstFrame *, int, const char *, int * );
   void (* SetMatchEnd)( AstFrame *, int, int * );
   void (* SetMaxAxes)( AstFrame *, int, int * );
   void (* SetMinAxes)( AstFrame *, int, int * );
   void (* SetPermute)( AstFrame *, int, int * );
   void (* SetPreserveAxes)( AstFrame *, int, int * );
   void (* SetSymbol)( AstFrame *, int, const char *, int * );
   void (* SetTitle)( AstFrame *, const char *, int * );
   void (* SetUnit)( AstFrame *, int, const char *, int * );
   void (* ValidateAxisSelection)( AstFrame *, int, const int *, const char *, int * );
   void (* LineOffset)( AstFrame *, AstLineDef *, double, double, double[2], int * );
   AstPointSet *(* FrameGrid)( AstFrame *, int, const double *, const double *, int * );
   struct AstFrameSet *(* GetFrameVariants)( AstFrame *, int * );
   void (* SetFrameVariants)( AstFrame *, struct AstFrameSet *, int * );

   double (* GetTop)( AstFrame *, int, int * );
   int (* TestTop)( AstFrame *, int, int * );
   void (* ClearTop)( AstFrame *, int, int * );
   void (* SetTop)( AstFrame *, int, double, int * );

   double (* GetBottom)( AstFrame *, int, int * );
   int (* TestBottom)( AstFrame *, int, int * );
   void (* ClearBottom)( AstFrame *, int, int * );
   void (* SetBottom)( AstFrame *, int, double, int * );

   AstSystemType (* GetSystem)( AstFrame *, int * );
   int (* TestSystem)( AstFrame *, int * );
   void (* ClearSystem)( AstFrame *, int * );
   void (* SetSystem)( AstFrame *, AstSystemType, int * );

   AstSystemType (* GetAlignSystem)( AstFrame *, int * );
   int (* TestAlignSystem)( AstFrame *, int * );
   void (* ClearAlignSystem)( AstFrame *, int * );
   void (* SetAlignSystem)( AstFrame *, AstSystemType, int * );

   double (* GetEpoch)( AstFrame *, int * );
   int (* TestEpoch)( AstFrame *, int * );
   void (* ClearEpoch)( AstFrame *, int * );
   void (* SetEpoch)( AstFrame *, double, int * );

   int (* TestActiveUnit)( AstFrame *, int * );
   int (* GetActiveUnit)( AstFrame *, int * );
   void (* SetActiveUnit)( AstFrame *, int, int * );

   double (* GetObsLon)( AstFrame *, int * );
   int (* TestObsLon)( AstFrame *, int * );
   void (* ClearObsLon)( AstFrame *, int * );
   void (* SetObsLon)( AstFrame *, double, int * );

   double (* GetObsLat)( AstFrame *, int * );
   int (* TestObsLat)( AstFrame *, int * );
   void (* ClearObsLat)( AstFrame *, int * );
   void (* SetObsLat)( AstFrame *, double, int * );

   double (* GetObsAlt)( AstFrame *, int * );
   int (* TestObsAlt)( AstFrame *, int * );
   void (* ClearObsAlt)( AstFrame *, int * );
   void (* SetObsAlt)( AstFrame *, double, int * );

   double (* GetDut1)( AstFrame *, int * );
   int (* TestDut1)( AstFrame *, int * );
   void (* ClearDut1)( AstFrame *, int * );
   void (* SetDut1)( AstFrame *, double, int * );

   void (* SetFrameFlags)( AstFrame *, int, int * );
   int (* GetFrameFlags)( AstFrame *, int * );

} AstFrameVtab;

#if defined(THREAD_SAFE)

/* Define a structure holding all data items that are global within this
   class. */
typedef struct AstFrameGlobals {
   AstFrameVtab Class_Vtab;
   int Class_Init;
   char GetAttrib_Buff[ AST__FRAME_GETATTRIB_BUFF_LEN + 1 ];
   char *AstFormatID_Strings[ AST__FRAME_ASTFORMATID_MAX_STRINGS ];
   int AstFormatID_Istr;
   int AstFormatID_Init;
   char Label_Buff[ AST__FRAME_LABEL_BUFF_LEN + 1 ];
   char Symbol_Buff[ AST__FRAME_SYMBOL_BUFF_LEN + 1 ];
   char Title_Buff[ AST__FRAME_TITLE_BUFF_LEN + 1 ];
   char AstFmtDecimalYr_Buff[ AST__FRAME_ASTFMTDECIMALYR_BUFF_LEN + 1 ];
} AstFrameGlobals;

#endif
#endif

/* More include files. */
/* =================== */
/* The interface to the FrameSet class must be included here (after
   the type definitions for the Frame class) because "frameset.h"
   itself includes this file ("frame.h"), although "frameset.h" refers
   to the AstFrameSet structure above. This seems a little strange at
   first, but is simply analogous to making a forward reference to a
   structure type when recursively defining a normal C structure
   (except that here the definitions happen to be in separate include
   files). */
#include "frameset.h"

/* Function prototypes. */
/* ==================== */
/* Prototypes for standard class functions. */
/* ---------------------------------------- */
astPROTO_CHECK(Frame)            /* Check class membership */
astPROTO_ISA(Frame)              /* Test class membership */

/* Constructor. */
#if defined(astCLASS)            /* Protected */
AstFrame *astFrame_( int, const char *, int *, ...);
#else
AstFrame *astFrameId_( int, const char *, ... )__attribute__((format(printf,2,3)));
#endif

#if defined(astCLASS)            /* Protected */

/* Initialiser. */
AstFrame *astInitFrame_( void *, size_t, int, AstFrameVtab *, const char *,
                         int, int * );

/* Vtab initialiser. */
void astInitFrameVtab_( AstFrameVtab *, const char *, int * );

/* Loader. */
AstFrame *astLoadFrame_( void *, size_t, AstFrameVtab *,
                         const char *, AstChannel *channel, int * );

/* Thread-safe initialiser for all global data used by this module. */
#if defined(THREAD_SAFE)
void astInitFrameGlobals_( AstFrameGlobals * );
#endif
#endif

/* Prototypes for member functions. */
/* -------------------------------- */
AstFrameSet *astConvert_( AstFrame *, AstFrame *, const char *, int * );
AstFrameSet *astFindFrame_( AstFrame *, AstFrame *, const char *, int * );
double astAngle_( AstFrame *, const double[], const double[], const double[], int * );
double astAxAngle_( AstFrame *, const double[2], const double[2], int, int * );
double astAxDistance_( AstFrame *, int, double, double, int * );
double astAxOffset_( AstFrame *, int, double, double, int * );
double astDistance_( AstFrame *, const double[], const double[], int * );
double astOffset2_( AstFrame *, const double[2], double, double, double[2], int * );
int astGetActiveUnit_( AstFrame *, int * );
void astAxNorm_( AstFrame *, int, int, int, double *, int * );
void astIntersect_( AstFrame *, const double[2], const double[2], const double[2], const double[2], double[2], int * );
void astMatchAxes_( AstFrame *, AstFrame *, int[], int * );
void astNorm_( AstFrame *, double[], int * );
void astOffset_( AstFrame *, const double[], const double[], double, double[], int * );
void astResolve_( AstFrame *, const double [], const double [], const double [], double [], double *, double *, int * );
void astSetActiveUnit_( AstFrame *, int, int * );
AstFrameSet *astGetFrameVariants_( AstFrame *, int * );
void astSetFrameVariants_( AstFrame *, AstFrameSet *, int * );

#if defined(astCLASS)            /* Protected */
void astNormBox_( AstFrame *, double *, double *, AstMapping *, int * );
AstFrame *astPickAxes_( AstFrame *, int, const int[], AstMapping **, int * );
const char *astFormat_( AstFrame *, int, double, int * );
int astUnformat_( AstFrame *, int, const char *, double *, int * );
void astPermAxes_( AstFrame *, const int[], int * );
#else
AstFrame *astPickAxesId_( AstFrame *, int, const int[], AstMapping **, int * );
const char *astFormatId_( AstFrame *, int, double, int * );
int astUnformatId_( AstFrame *, int, const char *, double *, int * );
void astPermAxesId_( AstFrame *, const int[], int * );
#endif

#if defined(astCLASS)            /* Protected */
int astAxIn_( AstFrame *, int, double, double, double, int, int * );
AstAxis * astGetAxis_( AstFrame *, int, int * );
AstFrameSet *astConvertX_( AstFrame *, AstFrame *, const char *, int * );
void astMatchAxesX_( AstFrame *, AstFrame *, int[], int * );
AstLineDef *astLineDef_( AstFrame *, const double[2], const double[2], int * );
AstPointSet *astResolvePoints_( AstFrame *, const double [], const double [], AstPointSet *, AstPointSet *, int * );
const char *astAbbrev_( AstFrame *, int, const char *, const char *, const char *, int * );
const char *astGetDomain_( AstFrame *, int * );
const char *astGetFormat_( AstFrame *, int, int * );
const char *astGetLabel_( AstFrame *, int, int * );
const char *astGetSymbol_( AstFrame *, int, int * );
const char *astGetTitle_( AstFrame *, int * );
const char *astGetUnit_( AstFrame *, int, int * );
const char *astGetInternalUnit_( AstFrame *, int, int * );
const char *astGetNormUnit_( AstFrame *, int, int * );
const int *astGetPerm_( AstFrame *, int * );
double astCentre_( AstFrame *, int, double, double, int * );
double astGap_( AstFrame *, int, double, int *, int * );
int astFields_( AstFrame *, int, const char *, const char *, int, char **, int *, double *, int * );
int astGetDigits_( AstFrame *, int * );
int astGetDirection_( AstFrame *, int, int * );
int astGetMatchEnd_( AstFrame *, int * );
int astGetMaxAxes_( AstFrame *, int * );
int astGetMinAxes_( AstFrame *, int * );
int astGetNaxes_( AstFrame *, int * );
int astGetPermute_( AstFrame *, int * );
int astGetPreserveAxes_( AstFrame *, int * );
int astIsUnitFrame_( AstFrame *, int * );
int astLineCrossing_( AstFrame *, AstLineDef *, AstLineDef *, double **, int * );
int astLineContains_( AstFrame *, AstLineDef *, int, double *, int * );
int astMatch_( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
int astSubFrame_( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
int astTestDigits_( AstFrame *, int * );
int astTestDirection_( AstFrame *, int, int * );
int astTestDomain_( AstFrame *, int * );
int astTestFormat_( AstFrame *, int, int * );
int astTestLabel_( AstFrame *, int, int * );
int astTestMatchEnd_( AstFrame *, int * );
int astTestMaxAxes_( AstFrame *, int * );
int astTestMinAxes_( AstFrame *, int * );
int astTestPermute_( AstFrame *, int * );
int astTestPreserveAxes_( AstFrame *, int * );
int astTestSymbol_( AstFrame *, int, int * );
int astTestTitle_( AstFrame *, int * );
int astTestUnit_( AstFrame *, int, int * );
int astValidateAxis_( AstFrame *, int, int, const char *, int * );
AstSystemType astValidateSystem_( AstFrame *, AstSystemType, const char *, int * );
AstSystemType astSystemCode_( AstFrame *, const char *, int * );
const char *astSystemString_( AstFrame *, AstSystemType, int * );
void astCheckPerm_( AstFrame *, const int *, const char *, int * );
void astClearDigits_( AstFrame *, int * );
void astClearDirection_( AstFrame *, int, int * );
void astClearDomain_( AstFrame *, int * );
void astClearFormat_( AstFrame *, int, int * );
void astClearLabel_( AstFrame *, int, int * );
void astClearMatchEnd_( AstFrame *, int * );
void astClearMaxAxes_( AstFrame *, int * );
void astClearMinAxes_( AstFrame *, int * );
void astClearPermute_( AstFrame *, int * );
void astClearPreserveAxes_( AstFrame *, int * );
void astClearSymbol_( AstFrame *, int, int * );
void astClearTitle_( AstFrame *, int * );
void astClearUnit_( AstFrame *, int, int * );
void astOverlay_( AstFrame *, const int *, AstFrame *, int * );
void astPrimaryFrame_( AstFrame *, int, AstFrame **, int *, int * );
void astSetAxis_( AstFrame *, int, AstAxis *, int * );
void astSetDigits_( AstFrame *, int, int * );
void astSetDirection_( AstFrame *, int, int, int * );
void astSetDomain_( AstFrame *, const char *, int * );
void astSetFormat_( AstFrame *, int, const char *, int * );
void astSetLabel_( AstFrame *, int, const char *, int * );
void astSetMatchEnd_( AstFrame *, int, int * );
void astSetMaxAxes_( AstFrame *, int, int * );
void astSetMinAxes_( AstFrame *, int, int * );
void astSetPermute_( AstFrame *, int, int * );
void astSetPreserveAxes_( AstFrame *, int, int * );
void astSetSymbol_( AstFrame *, int, const char *, int * );
void astSetTitle_( AstFrame *, const char *, int * );
void astSetUnit_( AstFrame *, int, const char *, int * );
void astValidateAxisSelection_( AstFrame *, int, const int *, const char *, int * );
double astReadDateTime_( const char *, int * );
const char *astFmtDecimalYr_( double, int, int * );
void astLineOffset_( AstFrame *, AstLineDef *, double, double, double[2], int * );
AstPointSet *astFrameGrid_( AstFrame *, int, const double *, const double *, int * );

double astGetTop_( AstFrame *, int, int * );
int astTestTop_( AstFrame *, int, int * );
void astClearTop_( AstFrame *, int, int * );
void astSetTop_( AstFrame *, int, double, int * );

double astGetBottom_( AstFrame *, int, int * );
int astTestBottom_( AstFrame *, int, int * );
void astClearBottom_( AstFrame *, int, int * );
void astSetBottom_( AstFrame *, int, double, int * );

AstSystemType astGetSystem_( AstFrame *, int * );
int astTestSystem_( AstFrame *, int * );
void astClearSystem_( AstFrame *, int * );
void astSetSystem_( AstFrame *, AstSystemType, int * );

AstSystemType astGetAlignSystem_( AstFrame *, int * );
int astTestAlignSystem_( AstFrame *, int * );
void astClearAlignSystem_( AstFrame *, int * );
void astSetAlignSystem_( AstFrame *, AstSystemType, int * );

double astGetEpoch_( AstFrame *, int * );
int astTestEpoch_( AstFrame *, int * );
void astClearEpoch_( AstFrame *, int * );
void astSetEpoch_( AstFrame *, double, int * );

double astGetObsLon_( AstFrame *, int * );
int astTestObsLon_( AstFrame *, int * );
void astClearObsLon_( AstFrame *, int * );
void astSetObsLon_( AstFrame *, double, int * );

double astGetObsLat_( AstFrame *, int * );
int astTestObsLat_( AstFrame *, int * );
void astClearObsLat_( AstFrame *, int * );
void astSetObsLat_( AstFrame *, double, int * );

double astGetObsAlt_( AstFrame *, int * );
int astTestObsAlt_( AstFrame *, int * );
void astClearObsAlt_( AstFrame *, int * );
void astSetObsAlt_( AstFrame *, double, int * );

double astGetDut1_( AstFrame *, int * );
int astTestDut1_( AstFrame *, int * );
void astClearDut1_( AstFrame *, int * );
void astSetDut1_( AstFrame *, double, int * );

int astTestActiveUnit_( AstFrame *, int * );

void astSetFrameFlags_( AstFrame *, int, int * );
int astGetFrameFlags_( AstFrame *, int * );

#endif

/* Function interfaces. */
/* ==================== */
/* These macros are wrap-ups for the functions defined by this class to make
   them easier to invoke (e.g. to avoid type mis-matches when passing pointers
   to objects from derived classes). */

/* Interfaces to standard class functions. */
/* --------------------------------------- */
/* Some of these functions provide validation, so we cannot use them to
   validate their own arguments. We must use a cast when passing object
   pointers (so that they can accept objects from derived classes). */

/* Check class membership. */
#define astCheckFrame(this) astINVOKE_CHECK(Frame,this,0)
#define astVerifyFrame(this) astINVOKE_CHECK(Frame,this,1)

/* Test class membership. */
#define astIsAFrame(this) astINVOKE_ISA(Frame,this)

/* Constructor. */
#if defined(astCLASS)            /* Protected */
#define astFrame astINVOKE(F,astFrame_)
#else
#define astFrame astINVOKE(F,astFrameId_)
#endif

#if defined(astCLASS)            /* Protected */

/* Initialiser. */
#define astInitFrame(mem,size,init,vtab,name,naxes) \
astINVOKE(O,astInitFrame_(mem,size,init,vtab,name,naxes,STATUS_PTR))

/* Vtab Initialiser. */
#define astInitFrameVtab(vtab,name) astINVOKE(V,astInitFrameVtab_(vtab,name,STATUS_PTR))
/* Loader. */
#define astLoadFrame(mem,size,vtab,name,channel) \
astINVOKE(O,astLoadFrame_(mem,size,vtab,name,astCheckChannel(channel),STATUS_PTR))
#endif

/* Interfaces to public member functions. */
/* -------------------------------------- */
/* Here we make use of astCheckFrame to validate Frame pointers before
   use. This provides a contextual error report if a pointer to the
   wrong sort of Object is supplied. */
#define astConvert(from,to,domainlist) \
astINVOKE(O,astConvert_(astCheckFrame(from),astCheckFrame(to),domainlist,STATUS_PTR))
#define astAngle(this,a,b,c) \
astINVOKE(V,astAngle_(astCheckFrame(this),a,b,c,STATUS_PTR))
#define astDistance(this,point1,point2) \
astINVOKE(V,astDistance_(astCheckFrame(this),point1,point2,STATUS_PTR))
#define astFindFrame(target,template,domainlist) \
astINVOKE(O,astFindFrame_(astCheckFrame(target),astCheckFrame(template),domainlist,STATUS_PTR))
#define astMatchAxes(frm1,frm2,axes) \
astINVOKE(V,astMatchAxes_(astCheckFrame(frm1),astCheckFrame(frm2),axes,STATUS_PTR))
#define astNorm(this,value) \
astINVOKE(V,astNorm_(astCheckFrame(this),value,STATUS_PTR))
#define astAxDistance(this,axis,v1,v2) \
astINVOKE(V,astAxDistance_(astCheckFrame(this),axis,v1,v2,STATUS_PTR))
#define astAxNorm(this,axis,oper,nval,values) \
astINVOKE(V,astAxNorm_(astCheckFrame(this),axis,oper,nval,values,STATUS_PTR))
#define astAxOffset(this,axis,v1,dist) \
astINVOKE(V,astAxOffset_(astCheckFrame(this),axis,v1,dist,STATUS_PTR))
#define astOffset(this,point1,point2,offset,point3) \
astINVOKE(V,astOffset_(astCheckFrame(this),point1,point2,offset,point3,STATUS_PTR))
#define astAxAngle(this,a,b,axis) \
astINVOKE(V,astAxAngle_(astCheckFrame(this),a,b,axis,STATUS_PTR))
#define astIntersect(this,a1,a2,b1,b2,cross) \
astINVOKE(V,astIntersect_(astCheckFrame(this),a1,a2,b1,b2,cross,STATUS_PTR))
#define astOffset2(this,point1,angle,offset,point2) \
astINVOKE(V,astOffset2_(astCheckFrame(this),point1,angle,offset,point2,STATUS_PTR))
#define astResolve(this,point1,point2,point3,point4,d1,d2) \
astINVOKE(V,astResolve_(astCheckFrame(this),point1,point2,point3,point4,d1,d2,STATUS_PTR))
#define astGetActiveUnit(this) \
astINVOKE(V,astGetActiveUnit_(astCheckFrame(this),STATUS_PTR))
#define astSetActiveUnit(this,value) \
astINVOKE(V,astSetActiveUnit_(astCheckFrame(this),value,STATUS_PTR))

#if defined(astCLASS)            /* Protected */
#define astGetFrameVariants(this) \
astINVOKE(O,astGetFrameVariants_(astCheckFrame(this),STATUS_PTR))
#define astSetFrameVariants(this,variants) \
astINVOKE(V,astSetFrameVariants_(astCheckFrame(this),astCheckFrameSet(variants),STATUS_PTR))
#define astNormBox(this,lbnd,ubnd,reg) \
astINVOKE(V,astNormBox_(astCheckFrame(this),lbnd,ubnd,astCheckMapping(reg),STATUS_PTR))
#define astFormat(this,axis,value) \
astINVOKE(V,astFormat_(astCheckFrame(this),axis,value,STATUS_PTR))
#define astPermAxes(this,perm) \
astINVOKE(V,astPermAxes_(astCheckFrame(this),perm,STATUS_PTR))
#define astPickAxes(this,naxes,axes,map) \
astINVOKE(O,astPickAxes_(astCheckFrame(this),naxes,axes,(AstMapping **)(map),STATUS_PTR))
#define astUnformat(this,axis,string,value) \
astINVOKE(V,astUnformat_(astCheckFrame(this),axis,string,value,STATUS_PTR))
#else
#define astFormat(this,axis,value) \
astINVOKE(V,astFormatId_(astCheckFrame(this),axis,value,STATUS_PTR))
#define astPermAxes(this,perm) \
astINVOKE(V,astPermAxesId_(astCheckFrame(this),perm,STATUS_PTR))
#define astPickAxes(this,naxes,axes,map) \
astINVOKE(O,astPickAxesId_(astCheckFrame(this),naxes,axes,(AstMapping **)(map),STATUS_PTR))
#define astUnformat(this,axis,string,value) \
astINVOKE(V,astUnformatId_(astCheckFrame(this),axis,string,value,STATUS_PTR))
#endif

#if defined(astCLASS)            /* Protected */
#define astAxIn(this,axis,lo,hi,val,closed) \
astINVOKE(V,astAxIn_(astCheckFrame(this),axis,lo,hi,val,closed,STATUS_PTR))
#define astAbbrev(this,axis,fmt,str1,str2) \
astINVOKE(V,astAbbrev_(astCheckFrame(this),axis,fmt,str1,str2,STATUS_PTR))
#define astFields(this,axis,fmt,str,maxfld,fields,nc,val) \
astINVOKE(V,astFields_(astCheckFrame(this),axis,fmt,str,maxfld,fields,nc,val,STATUS_PTR))
#define astCheckPerm(this,perm,method) \
astINVOKE(V,astCheckPerm_(astCheckFrame(this),perm,method,STATUS_PTR))
#define astResolvePoints(this,p1,p2,in,out) \
astINVOKE(O,astResolvePoints_(astCheckFrame(this),p1,p2,astCheckPointSet(in),((out)?astCheckPointSet(out):NULL),STATUS_PTR))
#define astLineDef(this,p1,p2) \
astINVOKE(V,astLineDef_(astCheckFrame(this),p1,p2,STATUS_PTR))
#define astLineOffset(this,line,par,prp,point) \
astINVOKE(V,astLineOffset_(astCheckFrame(this),line,par,prp,point,STATUS_PTR))
#define astFrameGrid(this,size,lbnd,ubnd) \
astINVOKE(O,astFrameGrid_(astCheckFrame(this),size,lbnd,ubnd,STATUS_PTR))
#define astLineCrossing(this,l1,l2,cross) \
astINVOKE(V,astLineCrossing_(astCheckFrame(this),l1,l2,cross,STATUS_PTR))
#define astLineContains(this,l,def,point) \
astINVOKE(V,astLineContains_(astCheckFrame(this),l,def,point,STATUS_PTR))
#define astClearDigits(this) \
astINVOKE(V,astClearDigits_(astCheckFrame(this),STATUS_PTR))
#define astClearDirection(this,axis) \
astINVOKE(V,astClearDirection_(astCheckFrame(this),axis,STATUS_PTR))
#define astClearDomain(this) \
astINVOKE(V,astClearDomain_(astCheckFrame(this),STATUS_PTR))
#define astClearFormat(this,axis) \
astINVOKE(V,astClearFormat_(astCheckFrame(this),axis,STATUS_PTR))
#define astClearLabel(this,axis) \
astINVOKE(V,astClearLabel_(astCheckFrame(this),axis,STATUS_PTR))
#define astClearMatchEnd(this) \
astINVOKE(V,astClearMatchEnd_(astCheckFrame(this),STATUS_PTR))
#define astClearMaxAxes(this) \
astINVOKE(V,astClearMaxAxes_(astCheckFrame(this),STATUS_PTR))
#define astClearMinAxes(this) \
astINVOKE(V,astClearMinAxes_(astCheckFrame(this),STATUS_PTR))
#define astClearPermute(this) \
astINVOKE(V,astClearPermute_(astCheckFrame(this),STATUS_PTR))
#define astClearPreserveAxes(this) \
astINVOKE(V,astClearPreserveAxes_(astCheckFrame(this),STATUS_PTR))
#define astClearSymbol(this,axis) \
astINVOKE(V,astClearSymbol_(astCheckFrame(this),axis,STATUS_PTR))
#define astClearTitle(this) \
astINVOKE(V,astClearTitle_(astCheckFrame(this),STATUS_PTR))
#define astClearUnit(this,axis) \
astINVOKE(V,astClearUnit_(astCheckFrame(this),axis,STATUS_PTR))
#define astConvertX(to,from,domainlist) \
astINVOKE(O,astConvertX_(astCheckFrame(to),astCheckFrame(from),domainlist,STATUS_PTR))
#define astCentre(this,axis,value,gap) \
astINVOKE(V,astCentre_(astCheckFrame(this),axis,value,gap,STATUS_PTR))
#define astGap(this,axis,gap,ntick) \
astINVOKE(V,astGap_(astCheckFrame(this),axis,gap,ntick,STATUS_PTR))
#define astGetAxis(this,axis) \
astINVOKE(O,astGetAxis_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetDigits(this) \
astINVOKE(V,astGetDigits_(astCheckFrame(this),STATUS_PTR))
#define astGetDirection(this,axis) \
astINVOKE(V,astGetDirection_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetDomain(this) \
astINVOKE(V,astGetDomain_(astCheckFrame(this),STATUS_PTR))
#define astGetFormat(this,axis) \
astINVOKE(V,astGetFormat_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetLabel(this,axis) \
astINVOKE(V,astGetLabel_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetMatchEnd(this) \
astINVOKE(V,astGetMatchEnd_(astCheckFrame(this),STATUS_PTR))
#define astGetMaxAxes(this) \
astINVOKE(V,astGetMaxAxes_(astCheckFrame(this),STATUS_PTR))
#define astGetMinAxes(this) \
astINVOKE(V,astGetMinAxes_(astCheckFrame(this),STATUS_PTR))
#define astGetNaxes(this) \
astINVOKE(V,astGetNaxes_(astCheckFrame(this),STATUS_PTR))
#define astGetPerm(this) \
astINVOKE(V,astGetPerm_(astCheckFrame(this),STATUS_PTR))
#define astGetPermute(this) \
astINVOKE(V,astGetPermute_(astCheckFrame(this),STATUS_PTR))
#define astGetPreserveAxes(this) \
astINVOKE(V,astGetPreserveAxes_(astCheckFrame(this),STATUS_PTR))
#define astGetSymbol(this,axis) \
astINVOKE(V,astGetSymbol_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetTitle(this) \
astINVOKE(V,astGetTitle_(astCheckFrame(this),STATUS_PTR))
#define astGetUnit(this,axis) \
astINVOKE(V,astGetUnit_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetNormUnit(this,axis) \
astINVOKE(V,astGetNormUnit_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetInternalUnit(this,axis) \
astINVOKE(V,astGetInternalUnit_(astCheckFrame(this),axis,STATUS_PTR))
#define astMatch(template,target,matchsub,template_axes,target_axes,map,result) \
astINVOKE(V,astMatch_(astCheckFrame(template),astCheckFrame(target),matchsub,template_axes,target_axes,(AstMapping **)(map),(AstFrame **)(result),STATUS_PTR))
#define astIsUnitFrame(this) \
astINVOKE(V,astIsUnitFrame_(astCheckFrame(this),STATUS_PTR))
#define astOverlay(template,template_axes,result) \
astINVOKE(V,astOverlay_(astCheckFrame(template),template_axes,astCheckFrame(result),STATUS_PTR))
#define astPrimaryFrame(this,axis1,frame,axis2) \
astINVOKE(V,astPrimaryFrame_(astCheckFrame(this),axis1,(AstFrame **)(frame),axis2,STATUS_PTR))
#define astSetAxis(this,axis,newaxis) \
astINVOKE(V,astSetAxis_(astCheckFrame(this),axis,astCheckAxis(newaxis),STATUS_PTR))
#define astSetDigits(this,digits) \
astINVOKE(V,astSetDigits_(astCheckFrame(this),digits,STATUS_PTR))
#define astSetDirection(this,axis,direction) \
astINVOKE(V,astSetDirection_(astCheckFrame(this),axis,direction,STATUS_PTR))
#define astSetDomain(this,domain) \
astINVOKE(V,astSetDomain_(astCheckFrame(this),domain,STATUS_PTR))
#define astSetFormat(this,axis,format) \
astINVOKE(V,astSetFormat_(astCheckFrame(this),axis,format,STATUS_PTR))
#define astSetLabel(this,axis,label) \
astINVOKE(V,astSetLabel_(astCheckFrame(this),axis,label,STATUS_PTR))
#define astSetMatchEnd(this,value) \
astINVOKE(V,astSetMatchEnd_(astCheckFrame(this),value,STATUS_PTR))
#define astSetMaxAxes(this,value) \
astINVOKE(V,astSetMaxAxes_(astCheckFrame(this),value,STATUS_PTR))
#define astSetMinAxes(this,value) \
astINVOKE(V,astSetMinAxes_(astCheckFrame(this),value,STATUS_PTR))
#define astSetPermute(this,value) \
astINVOKE(V,astSetPermute_(astCheckFrame(this),value,STATUS_PTR))
#define astSetPreserveAxes(this,value) \
astINVOKE(V,astSetPreserveAxes_(astCheckFrame(this),value,STATUS_PTR))
#define astSetSymbol(this,axis,symbol) \
astINVOKE(V,astSetSymbol_(astCheckFrame(this),axis,symbol,STATUS_PTR))
#define astSetTitle(this,title) \
astINVOKE(V,astSetTitle_(astCheckFrame(this),title,STATUS_PTR))
#define astSetUnit(this,axis,unit) \
astINVOKE(V,astSetUnit_(astCheckFrame(this),axis,unit,STATUS_PTR))
#define astSubFrame(target,template,result_naxes,target_axes,template_axes,map,result) \
astINVOKE(V,astSubFrame_(astCheckFrame(target),template?astCheckFrame(template):NULL,result_naxes,target_axes,template_axes,(AstMapping **)(map),(AstFrame **)(result),STATUS_PTR))
#define astTestDigits(this) \
astINVOKE(V,astTestDigits_(astCheckFrame(this),STATUS_PTR))
#define astTestDirection(this,axis) \
astINVOKE(V,astTestDirection_(astCheckFrame(this),axis,STATUS_PTR))
#define astTestDomain(this) \
astINVOKE(V,astTestDomain_(astCheckFrame(this),STATUS_PTR))
#define astTestFormat(this,axis) \
astINVOKE(V,astTestFormat_(astCheckFrame(this),axis,STATUS_PTR))
#define astTestLabel(this,axis) \
astINVOKE(V,astTestLabel_(astCheckFrame(this),axis,STATUS_PTR))
#define astTestMatchEnd(this) \
astINVOKE(V,astTestMatchEnd_(astCheckFrame(this),STATUS_PTR))
#define astTestMaxAxes(this) \
astINVOKE(V,astTestMaxAxes_(astCheckFrame(this),STATUS_PTR))
#define astTestMinAxes(this) \
astINVOKE(V,astTestMinAxes_(astCheckFrame(this),STATUS_PTR))
#define astTestPermute(this) \
astINVOKE(V,astTestPermute_(astCheckFrame(this),STATUS_PTR))
#define astTestPreserveAxes(this) \
astINVOKE(V,astTestPreserveAxes_(astCheckFrame(this),STATUS_PTR))
#define astTestSymbol(this,axis) \
astINVOKE(V,astTestSymbol_(astCheckFrame(this),axis,STATUS_PTR))
#define astTestTitle(this) \
astINVOKE(V,astTestTitle_(astCheckFrame(this),STATUS_PTR))
#define astTestUnit(this,axis) \
astINVOKE(V,astTestUnit_(astCheckFrame(this),axis,STATUS_PTR))
#define astValidateAxis(this,axis,fwd,method) \
astINVOKE(V,astValidateAxis_(astCheckFrame(this),axis,fwd,method,STATUS_PTR))
#define astValidateAxisSelection(this,naxes,axes,method) \
astINVOKE(V,astValidateAxisSelection_(astCheckFrame(this),naxes,axes,method,STATUS_PTR))

#define astMatchAxesX(frm2,frm1,axes) \
astINVOKE(V,astMatchAxesX_(astCheckFrame(frm2),astCheckFrame(frm1),axes,STATUS_PTR))

#define astFmtDecimalYr(year,digits) astFmtDecimalYr_(year,digits,STATUS_PTR)
#define astReadDateTime(value) astReadDateTime_(value,STATUS_PTR)

#define astValidateSystem(this,system,method) \
astINVOKE(V,astValidateSystem_(astCheckFrame(this),system,method,STATUS_PTR))
#define astSystemString(this,system) \
astINVOKE(V,astSystemString_(astCheckFrame(this),system,STATUS_PTR))
#define astSystemCode(this,system) \
astINVOKE(V,astSystemCode_(astCheckFrame(this),system,STATUS_PTR))

#define astClearTop(this,axis) \
astINVOKE(V,astClearTop_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetTop(this,axis) \
astINVOKE(V,astGetTop_(astCheckFrame(this),axis,STATUS_PTR))
#define astSetTop(this,axis,value) \
astINVOKE(V,astSetTop_(astCheckFrame(this),axis,value,STATUS_PTR))
#define astTestTop(this,axis) \
astINVOKE(V,astTestTop_(astCheckFrame(this),axis,STATUS_PTR))

#define astClearBottom(this,axis) \
astINVOKE(V,astClearBottom_(astCheckFrame(this),axis,STATUS_PTR))
#define astGetBottom(this,axis) \
astINVOKE(V,astGetBottom_(astCheckFrame(this),axis,STATUS_PTR))
#define astSetBottom(this,axis,value) \
astINVOKE(V,astSetBottom_(astCheckFrame(this),axis,value,STATUS_PTR))
#define astTestBottom(this,axis) \
astINVOKE(V,astTestBottom_(astCheckFrame(this),axis,STATUS_PTR))

#define astClearSystem(this) \
astINVOKE(V,astClearSystem_(astCheckFrame(this),STATUS_PTR))
#define astGetSystem(this) \
astINVOKE(V,astGetSystem_(astCheckFrame(this),STATUS_PTR))
#define astSetSystem(this,value) \
astINVOKE(V,astSetSystem_(astCheckFrame(this),value,STATUS_PTR))
#define astTestSystem(this) \
astINVOKE(V,astTestSystem_(astCheckFrame(this),STATUS_PTR))

#define astClearAlignSystem(this) \
astINVOKE(V,astClearAlignSystem_(astCheckFrame(this),STATUS_PTR))
#define astGetAlignSystem(this) \
astINVOKE(V,astGetAlignSystem_(astCheckFrame(this),STATUS_PTR))
#define astSetAlignSystem(this,value) \
astINVOKE(V,astSetAlignSystem_(astCheckFrame(this),value,STATUS_PTR))
#define astTestAlignSystem(this) \
astINVOKE(V,astTestAlignSystem_(astCheckFrame(this),STATUS_PTR))

#define astClearEpoch(this) \
astINVOKE(V,astClearEpoch_(astCheckFrame(this),STATUS_PTR))
#define astGetEpoch(this) \
astINVOKE(V,astGetEpoch_(astCheckFrame(this),STATUS_PTR))
#define astSetEpoch(this,value) \
astINVOKE(V,astSetEpoch_(astCheckFrame(this),value,STATUS_PTR))
#define astTestEpoch(this) \
astINVOKE(V,astTestEpoch_(astCheckFrame(this),STATUS_PTR))

#define astGetObsLon(this) \
astINVOKE(V,astGetObsLon_(astCheckFrame(this),STATUS_PTR))
#define astTestObsLon(this) \
astINVOKE(V,astTestObsLon_(astCheckFrame(this),STATUS_PTR))
#define astClearObsLon(this) \
astINVOKE(V,astClearObsLon_(astCheckFrame(this),STATUS_PTR))
#define astSetObsLon(this,value) \
astINVOKE(V,astSetObsLon_(astCheckFrame(this),value,STATUS_PTR))

#define astGetObsLat(this) \
astINVOKE(V,astGetObsLat_(astCheckFrame(this),STATUS_PTR))
#define astTestObsLat(this) \
astINVOKE(V,astTestObsLat_(astCheckFrame(this),STATUS_PTR))
#define astClearObsLat(this) \
astINVOKE(V,astClearObsLat_(astCheckFrame(this),STATUS_PTR))
#define astSetObsLat(this,value) \
astINVOKE(V,astSetObsLat_(astCheckFrame(this),value,STATUS_PTR))

#define astGetObsAlt(this) \
astINVOKE(V,astGetObsAlt_(astCheckFrame(this),STATUS_PTR))
#define astTestObsAlt(this) \
astINVOKE(V,astTestObsAlt_(astCheckFrame(this),STATUS_PTR))
#define astClearObsAlt(this) \
astINVOKE(V,astClearObsAlt_(astCheckFrame(this),STATUS_PTR))
#define astSetObsAlt(this,value) \
astINVOKE(V,astSetObsAlt_(astCheckFrame(this),value,STATUS_PTR))

#define astClearDut1(this) \
astINVOKE(V,astClearDut1_(astCheckFrame(this),STATUS_PTR))
#define astGetDut1(this) \
astINVOKE(V,astGetDut1_(astCheckFrame(this),STATUS_PTR))
#define astSetDut1(this,value) \
astINVOKE(V,astSetDut1_(astCheckFrame(this),value,STATUS_PTR))
#define astTestDut1(this) \
astINVOKE(V,astTestDut1_(astCheckFrame(this),STATUS_PTR))

#define astTestActiveUnit(this) \
astINVOKE(V,astTestActiveUnit_(astCheckFrame(this),STATUS_PTR))

#define astSetFrameFlags(this,flags) \
astINVOKE(V,astSetFrameFlags_(astCheckFrame(this),flags,STATUS_PTR))
#define astGetFrameFlags(this) \
astINVOKE(V,astGetFrameFlags_(astCheckFrame(this),STATUS_PTR))

#endif
#endif