/*
*class++
*  Name:
*     Plot3D

*  Purpose:
*     Provide facilities for 3D graphical output.

*  Constructor Function:
c     astPlot3D
f     AST_PLOT3D

*  Description:
*     A Plot3D is a specialised form of Plot that provides facilities
*     for producing 3D graphical output, including fully annotated 3D
*     coordinate grids. The base Frame in a Plot3D describes a 3-dimensional
*     "graphical" coordinate system. The axes of this coordinate system are
*     assumed to be right-handed (that is, if X appears horizontally to the
*     right and Y vertically upwards, then Z is out of the screen towards
*     the viewer), and are assumed to be equally scaled (that is, the same
*     units are used to measure positions on each of the 3 axes). The upper
*     and lower bounds of a volume within this graphical coordinate system
*     is specified when the Plot3D is created, and all subsequent graphics
*     are "drawn" in this volume.
*
*     The Plot3D class does not itself include any ability to draw on a
*     graphics device. Instead it calls upon function in an externally
*     supplied module (the "grf3d" module) to do the required drawing.
*     A module should be written that implements the functions of the
*     grf3d interface using the facilities of a specific graphics system
*     This module should then be linked into the application so that the
*     Plot3D class can use its functions (see the description of the
*     ast_link commands for details of how to do this). The grf3d interface
*     defines a few simple functions for drawing primitives such as straight
*     lines, markers and character strings. These functions all accept
*     positions in the 3D graphics coordinate system (the base Frame of the
*     Plot3D), and so the grf3d module must also manage the projection of
*     these 3D coordinates onto the 2D viewing surface, including the choice
*     of "eye"/"camera" position, direction of viewing, etc. The AST
*     library includes a sample implementation of the grf3d interface
*     based on the PGPLOT graphics system (see file grf3d_pgplot.c). This
*     implementation also serves to document the grf3d interface itself and
*     should be consulted for details before writing a new implementation.
*
*     The current Frame of a Plot3D describes a "physical" 3-dimensional
*     coordinate system, which is the coordinate system in which plotting
*     operations are specified when invoking the methods of the Plot3D
*     class. The results of each plotting operation are automatically
*     transformed into 3D graphical coordinates before being plotted
*     using the facilities of the grf3d module linked into the application.
*     Note, at least one of the three axes of the current Frame must be
*     independent of the other two current Frame axes.
*
*     You may select different physical coordinate systems in which to
*     plot (including the native graphical coordinate system itself)
*     by selecting different Frames as the current Frame of a Plot3D,
*     using its Current attribute.
*
*     Like any FrameSet, a Plot3D may also be used as a Frame. In this
*     case, it behaves like its current Frame, which describes the
*     physical coordinate system.
*
*     When used as a Mapping, a Plot3D describes the inter-relation
*     between 3D graphical coordinates (its base Frame) and 3D physical
*     coordinates (its current Frame).
*
*     Although the Plot3D class inherits from the Plot class, several of
*     the facilities of the Plot class are not available in the Plot3D
*     class, and an error will be reported if any attempt is made to use
*     them. Specifically, the Plot3D class does not support clipping
*     using the
*     astClip function.
f     AST_CLIP routine.
*     Nor does it support the specification of graphics primitive functions
*     at run-time using the
c     astGrfSet, astGrfPop, astGrfPush and astGetGrfContext functions.
f     AST_GRFSET, AST_GRFPOP, AST_GRFPUSH, and AST_GETGRFCONTEXT routines.

*  Inheritance:
*     The Plot3D class inherits from the Plot class.

*  Attributes:
*     In addition to those attributes common to all Plots, every
*     Plot3D also has the following attributes:
*
*     - Norm: Normal vector defining the 2D plane used for text and markers
*     - RootCorner: Specifies which edges of the 3D box should be annotated.
*
*     Some attributes of the Plot class refer to specific physical
*     coordinate axes (e.g. Gap, LabelUp, DrawAxes, etc). For a basic
*     Plot, the axis index must be 1 or 2, but for a Plot3D the axis index
*     can be 1, 2 or 3.
*
*     Certain Plot attributes are ignored by the Plot3D class (e.g. Edge,
*     DrawTitle, TitleGap, etc). Consult the Plot attribute documentation
*     for details. All other Plot attributes can be set for a specific
*     plane of the 3-d plot by appending one of the strings "_XY", "_XZ"
*     or "_YZ" to the end of the Plot attribute name. For instance,
*     "Grid_YZ" refers to the "Grid" attribute for the plane spanning
*     the second (Y) and third (Z) axes of the 3-d plot.


*  Functions:
c     The Plot3D class does not define any new functions beyond those
f     The Plot3D class does not define any new routines beyond those
*     which are applicable to all Plots. Note, however, that the
*     following methods inherited from the Plot class cannot be used with
*     a Plot3D and will report an error if called:
c    - astBoundingBox, astClip, astCurve, astGenCurve,
c    astGetGrfContext, astGrfPop, astGrfPush, astGrfSet, astGridLine,
c    astPolyCurve.
f    - AST_BOUNDINGBOX, AST_CLIP, AST_CURVE, AST_GENCURVE,
f    AST_GETGRFCONTEXT, AST_GRFPOP, AST_GRFPUSH, AST_GRFSET,
f    AST_GRIDLINE, AST_POLYCURVE.

*  Copyright:
*     Copyright (C) 2007 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:
*     6-JUN-2007 (DSB):
*        Original version.
*     6-SEP-2007 (DSB):
*        Re-code the astGrid function.
*     12-NOV-2007 (DSB):
*        Clear up compiler warnings.
*     4-MAY-2012 (DSB):
*        Avoid segvio in Grid if no ticks are drawn.
*     21-MAY-2012 (DSB):
*        In astLoadPlot3D, do not call SetRootCorner as it requires an
*        active graphics system to be present which may not yet have been
*        established. Also establish the grf routines to be used.
*     5-OCT-2015 (DSB):
*        Allow Plot attributes to be set for specific planes.
*class--
*/

/* Module Macros. */
/* ============== */
/* Set the name of the class we are implementing. This indicates to
   the header files that define class interfaces that they should make
   "protected" symbols available. */
#define astCLASS Plot3D

/* Integers identifying the 3 plotting surfaces */
#define XY 1
#define XZ 2
#define YZ 3

/* Integers identifying the 8 corners of the graphics cube. */
#define LLL 0
#define ULL 1
#define LUL 2
#define UUL 3
#define LLU 4
#define ULU 5
#define LUU 6
#define UUU 7

/* Identify the 4 edges of a Plot */
#define LEFT   0
#define TOP    1
#define RIGHT  2
#define BOTTOM 3

/* A macros that returns a pointer to the Plot that spans a given plane. */
#define GET_PLOT(plane) ( \
     ( plane == XY ) ? this->plotxy : ( \
     ( plane == XZ ) ? this->plotxz : ( \
     ( plane == YZ ) ? this->plotyz : NULL ) ) )


/*
*
*  Name:
*     MAKE_CLEAR3

*  Purpose:
*     Implement a method to clear a single value in a multi-valued attribute.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_CLEAR3(attr,component,assign,nval)

*  Class Membership:
*     Defined by the Plot3D class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Clear<Attribute>( AstPlot *this, int axis )
*
*     and an external interface function of the form:
*
*        void astClear<Attribute>_( AstPlot *this, int axis )
*
*     which implement a method for clearing a single value in a specified
*     multi-valued attribute for an axis of a Plot3D.

*  Parameters:
*     attr
*        The name of the attribute to be cleared, as it appears in the function
*        name (e.g. LabelAt in "astClearLabelAt").
*     component
*        The name of the class structure component that holds the attribute
*        value.
*     assign
*        An expression that evaluates to the value to assign to the component
*        to clear its value.
*     nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1).

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_CLEAR3(attr,component,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Clear##attr( AstPlot3D *this, int axis, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= nval ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astClear" #attr, astGetClass( this ), \
                axis + 1, nval ); \
\
/* Assign the "clear" value. */ \
   } else { \
      this->component[ axis ] = (assign); \
   } \
} \
\
/* External interface. */ \
/* ------------------- */ \
void astClear##attr##_( AstPlot3D *this, int axis, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Invoke the required method via the virtual function table. */ \
   (**astMEMBER(this,Plot3D,Clear##attr))( this, axis, status ); \
}


/*
*
*  Name:
*     MAKE_GET3

*  Purpose:
*     Implement a method to get a single value in a multi-valued attribute.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_GET3(attr,type,bad_value,assign,nval)

*  Class Membership:
*     Defined by the Plot3D class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static <Type> Get<Attribute>( AstPlot3D *this, int axis )
*
*     and an external interface function of the form:
*
*        <Type> astGet<Attribute>_( AstPlot3D *this, int axis )
*
*     which implement a method for getting a single value from a specified
*     multi-valued attribute for an axis of a Plot3D.

*  Parameters:
*     attr
*        The name of the attribute whose value is to be obtained, as it
*        appears in the function name (e.g. Label in "astGetLabel").
*     type
*        The C type of the attribute.
*     bad_value
*        A constant value to return if the global error status is set, or if
*        the function fails.
*     assign
*        An expression that evaluates to the value to be returned. This can
*        use the string "axis" to represent the zero-based value index.
*     nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1).

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_GET3(attr,type,bad_value,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static type Get##attr( AstPlot3D *this, int axis, int *status ) { \
   type result;                  /* Result to be returned */ \
\
/* Initialise */ \
   result = (bad_value); \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= nval ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astGet" #attr, astGetClass( this ), \
                axis + 1, nval ); \
\
/* Assign the result value. */ \
   } else { \
      result = (assign); \
   } \
\
/* Check for errors and clear the result if necessary. */ \
   if ( !astOK ) result = (bad_value); \
\
/* Return the result. */ \
   return result; \
} \
/* External interface. */ \
/* ------------------- */  \
type astGet##attr##_( AstPlot3D *this, int axis, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return (bad_value); \
\
/* Invoke the required method via the virtual function table. */ \
   return (**astMEMBER(this,Plot3D,Get##attr))( this, axis, status ); \
}

/*
*
*  Name:
*     MAKE_SET3

*  Purpose:
*     Implement a method to set a single value in a multi-valued attribute
*     for a Plot3D.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_SET3(attr,type,component,assign,nval)

*  Class Membership:
*     Defined by the Plot3D class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Set<Attribute>( AstPlot3D *this, int axis, <Type> value )
*
*     and an external interface function of the form:
*
*        void astSet<Attribute>_( AstPlot3D *this, int axis, <Type> value )
*
*     which implement a method for setting a single value in a specified
*     multi-valued attribute for a Plot3D.

*  Parameters:
*      attr
*         The name of the attribute to be set, as it appears in the function
*         name (e.g. LabelAt in "astSetLabelAt").
*      type
*         The C type of the attribute.
*      component
*         The name of the class structure component that holds the attribute
*         value.
*      assign
*         An expression that evaluates to the value to be assigned to the
*         component.
*      nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1). If a value of 0 is supplied, the
*        value of the Plot3D's Nin attribute is used instead.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*-
*/

/* Define the macro. */
#define MAKE_SET3(attr,type,component,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Set##attr( AstPlot3D *this, int axis, type value, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= nval ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astSet" #attr, astGetClass( this ), \
                axis + 1, nval ); \
\
/* Store the new value in the structure component. */ \
   } else { \
      this->component[ axis ] = (assign); \
   } \
} \
\
/* External interface. */ \
/* ------------------- */ \
void astSet##attr##_( AstPlot3D *this, int axis, type value, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Invoke the required method via the virtual function table. */ \
   (**astMEMBER(this,Plot3D,Set##attr))( this, axis, value, status ); \
}

/*
*
*  Name:
*     MAKE_TEST3

*  Purpose:
*     Implement a method to test if a single value has been set in a
*     multi-valued attribute for a class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_TEST3(attr,assign,nval)

*  Class Membership:
*     Defined by the Plot3D class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static int Test<Attribute>( AstPlot3D *this, int axis )
*
*     and an external interface function of the form:
*
*        int astTest<Attribute>_( AstPlot3D *this, int axis )
*
*     which implement a method for testing if a single value in a specified
*     multi-valued attribute has been set for a class.

*  Parameters:
*      attr
*         The name of the attribute to be tested, as it appears in the function
*         name (e.g. LabelAt in "astTestLabelAt").
*      assign
*         An expression that evaluates to 0 or 1, to be used as the returned
*         value. This can use the string "axis" to represent the zero-based
*         index of the value within the attribute.
*      nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1).

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*-
*/

/* Define the macro. */
#define MAKE_TEST3(attr,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static int Test##attr( AstPlot3D *this, int axis, int *status ) { \
   int result;                   /* Value to return */ \
\
/* Initialise */ \
   result = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= nval ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astTest" #attr, astGetClass( this ), \
                axis + 1, nval ); \
\
/* Assign the result value. */ \
   } else { \
      result = (assign); \
   } \
\
/* Check for errors and clear the result if necessary. */ \
   if ( !astOK ) result = 0; \
\
/* Return the result. */ \
   return result; \
} \
/* External interface. */ \
/* ------------------- */ \
int astTest##attr##_( AstPlot3D *this, int axis, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return 0; \
\
/* Invoke the required method via the virtual function table. */ \
   return (**astMEMBER(this,Plot3D,Test##attr))( this, axis, status ); \
}

/*
*
*  Name:
*     MAKE_CLEAR2

*  Purpose:
*     Implement a method to clear an element-specific attribute inherited
*     from the Plot class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_CLEAR2(attr)

*  Class Membership:
*     Defined by the Plot3d class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Clear<Attribute>( AstPlot *this, int element )
*
*     which implements a method for clearing one of the element-specific
*     attributes (e.g. Size, Colour, Width, etc) inherited from the
*     parent Plot class.

*  Parameters:
*     attr
*        The name of the attribute to be cleared, as it appears in the function
*        name (e.g. LabelAt in "astClearSize").

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_CLEAR2(attr) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Clear##attr( AstPlot *this_plot, int element, int *status ) { \
\
/* Local Variables: */ \
   AstPlot3D *this; \
   int axis3d; \
   int elem2d1; \
   int elem2d2; \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Clear the attribute value in the parent Plot structure. */ \
   (*parent_clear##attr)( this_plot, element, status ); \
\
/* If OK, clear the attribute in the encapsulated Plots. */ \
   if( astOK ) { \
      this = (AstPlot3D *) this_plot; \
\
/* Get the zero-based index of the 3D axis to which the supplied element \
   refers. Use an index of -1 to indicate that the element does not \
   relate to a specific axis. Also get the corresponding elements to use \
   with the two Plots that share the specified 3D axis. */ \
      axis3d = Element2D( this, element, &elem2d1, &elem2d2, status ); \
\
/* If the element is not axis-specific, clear the attribute value in all \
   three plots. */ \
      if( axis3d == -1 ) { \
         astClear##attr( this->plotxy, element ); \
         astClear##attr( this->plotxz, element ); \
         astClear##attr( this->plotyz, element ); \
\
/* Otherwise, clear the attribute in the two plots that share the \
   specified 3D axis. */ \
      } else { \
         astClear##attr( GET_PLOT(this->axis_plot1[ axis3d ]), elem2d1 ); \
         astClear##attr( GET_PLOT(this->axis_plot2[ axis3d ]), elem2d2 ); \
      } \
   } \
}

/*
*
*  Name:
*     MAKE_SET2

*  Purpose:
*     Implement a method to set an element-specific attribute inherited
*     from the Plot class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_SET2(attr,type)

*  Class Membership:
*     Defined by the Plot3d class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Set<Attribute>( AstPlot *this, int element, type value )
*
*     which implements a method for setting one of the element-specific
*     attributes (e.g. Size, Colour, Width, etc) inherited from the
*     parent Plot class.

*  Parameters:
*     attr
*        The name of the attribute to be cleared, as it appears in the function
*        name (e.g. LabelAt in "astClearSize").
*     type
*        The attribute data type.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_SET2(attr,type) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Set##attr( AstPlot *this_plot, int element, type value, int *status ) { \
\
/* Local Variables: */ \
   AstPlot3D *this; \
   int axis3d; \
   int elem2d1; \
   int elem2d2; \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Set the attribute value in the parent Plot structure. */ \
   (*parent_set##attr)( this_plot, element, value, status ); \
\
/* If OK, set the attribute in the encapsulated Plots. */ \
   if( astOK ) { \
      this = (AstPlot3D *) this_plot; \
\
/* Get the zero-based index of the 3D axis to which the supplied element \
   refers. Use an index of -1 to indicate that the element does not \
   relate to a specific axis. Also get the corresponding elements to use \
   with the two Plots that share the specified 3D axis. */ \
      axis3d = Element2D( this, element, &elem2d1, &elem2d2, status ); \
\
/* If the element is not axis-specific, clear the attribute value in all \
   three plots. */ \
      if( axis3d == -1 ) { \
         astSet##attr( this->plotxy, element, value ); \
         astSet##attr( this->plotxz, element, value ); \
         astSet##attr( this->plotyz, element, value ); \
\
/* Otherwise, clear the attribute in the two plots that share the \
   specified 3D axis. */ \
      } else { \
         astSet##attr( GET_PLOT(this->axis_plot1[ axis3d ]), elem2d1, value ); \
         astSet##attr( GET_PLOT(this->axis_plot2[ axis3d ]), elem2d2, value ); \
      } \
   } \
}


/*
*
*  Name:
*     MAKE_CLEAR1

*  Purpose:
*     Implement a method to clear an attribute inherited from the Plot class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_CLEAR1(attr)

*  Class Membership:
*     Defined by the Plot3d class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Clear<Attribute>( AstPlot *this )
*
*     which implements a method for clearing a Plot3D attribute inherited
*     from the parent Plot class. It clears the attribute in all three
*     plots encapsulated within the Plot3D.

*  Parameters:
*     attr
*        The name of the attribute to be cleared, as it appears in the function
*        name (e.g. LabelAt in "astClearLabelAt").

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_CLEAR1(attr) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Clear##attr( AstPlot *this_plot, int *status ) { \
\
/* Local Variables: */ \
   AstPlot3D *this; \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Clear the attribute value in the parent Plot structure. */ \
   (*parent_clear##attr)( this_plot, status ); \
\
/* If OK, clear the attribute in all three of the encapsulated Plots. */ \
   if( astOK ) { \
      this = (AstPlot3D *) this_plot; \
      astClear##attr( this->plotxy ); \
      astClear##attr( this->plotxz ); \
      astClear##attr( this->plotyz ); \
   } \
}

/*
*
*  Name:
*     MAKE_SET1

*  Purpose:
*     Implement a method to set an attribute inherited from the Plot class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_SET1(attr,type)

*  Class Membership:
*     Defined by the Plot3d class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Set<Attribute>( AstPlot *this, type value )
*
*     which implements a method for setting a Plot3D attribute inherited
*     from the parent Plot class. It sets the attribute in all three
*     plots encapsulated within the Plot3D.

*  Parameters:
*     attr
*        The name of the attribute to be set, as it appears in the function
*        name (e.g. LabelAt in "astSetLabelAt").
*     type
*        The C data type for the attribute value.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_SET1(attr,type) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Set##attr( AstPlot *this_plot, type value, int *status ) { \
\
/* Local Variables: */ \
   AstPlot3D *this; \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Set the attribute value in the parent Plot structure. */ \
   (*parent_set##attr)( this_plot, value, status ); \
\
/* If OK, set the attribute in all three of the encapsulated Plots. */ \
   if( astOK ) { \
      this = (AstPlot3D *) this_plot; \
      astSet##attr( this->plotxy, value ); \
      astSet##attr( this->plotxz, value ); \
      astSet##attr( this->plotyz, value ); \
   } \
}

/*
*
*  Name:
*     MAKE_CLEAR

*  Purpose:
*     Implement a method to clear an attribute inherited from the Plot class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_CLEAR(attr,whichplots)

*  Class Membership:
*     Defined by the Plot3d class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Clear<Attribute>( AstPlot *this, int axis )
*
*     which implements a method for clearing an axis specific Plot3D
*     attribute inherited from the parent Plot class.

*  Parameters:
*     attr
*        The name of the attribute to be cleared, as it appears in the function
*        name (e.g. LabelAt in "astClearLabelAt").
*     whichplots
*        A value indicating which Plots should be affected. A negative value
*        means "all threee plots", a value of zero means "just the two plots
*        that touch at the specified axis in 3D space", a positive value
*        means "just the Plot that is used to label th 3D axis."

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_CLEAR(attr,whichplots) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Clear##attr( AstPlot *this_plot, int axis, int *status ) { \
\
/* Local Variables: */ \
   AstPlot *plot; \
   AstPlot3D *this; \
   int axis2d; \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Clear the attribute value in the parent Plot structure. This will \
   validate the axis index. */ \
   (*parent_clear##attr)( this_plot, axis, status ); \
\
/* If OK, clear the attribute for the relevant axis, or axes, of the Plots  \
   encapsulated inside the Plot3D. First get a pointer to the Plot3D \
   structure. */ \
   if( astOK ) { \
      this = (AstPlot3D *) this_plot; \
\
/* If requested clear the attribute in all three Plots. */ \
      if( whichplots < 0 ) { \
         astClear##attr( this->plotxy, axis ); \
         astClear##attr( this->plotxz, axis ); \
         astClear##attr( this->plotyz, axis ); \
\
/* Each axis in 3D graphics space is described by two of the encapsulated \
   Plots, but only one of these two Plots is used to generate labels for \
   the axis. Now deal with cases where we are clearing the attribute \
   value in both of the two Plots that describe the axis. */ \
      } else if ( whichplots == 0 ) { \
         if( axis == 0 ) { \
            astClear##attr( this->plotxy, 0 ); \
            astClear##attr( this->plotxz, 0 ); \
\
         } else if( axis == 1 ) { \
            astClear##attr( this->plotxy, 1 ); \
            astClear##attr( this->plotyz, 0 ); \
\
         } else { \
            astClear##attr( this->plotxz, 1 ); \
            astClear##attr( this->plotyz, 1 ); \
         } \
\
/* Now deal with cases where we are clearing the attribute value only in  \
   the Plot that is used to label the axis. */ \
      } else { \
         plot = AxisPlot( this, axis, &axis2d, status ); \
         astClear##attr( plot, axis2d ); \
      } \
   } \
}


/*
*
*  Name:
*     MAKE_GET

*  Purpose:
*     Implement a method to get the value of an attribute inherited from the
*     Plot class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot.h"
*     MAKE_GET(attr,type,bad_value)

*  Class Membership:
*     Defined by the Plot3D class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static <Type> Get<Attribute>( AstPlot *this, int axis )
*
*     which implements a method for getting a value for an axis specific
*     attribute for a Plot3D.

*  Parameters:
*     attr
*        The name of the attribute whose value is to be obtained, as it
*        appears in the function name (e.g. Label in "astGetLabel").
*     type
*        The C type of the attribute.
*     bad_value
*        A constant value to return if the global error status is set, or if
*        the function fails.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_GET(attr,type,bad_value) \
\
/* Private member function. */ \
/* ------------------------ */ \
static type Get##attr( AstPlot *this_plot, int axis, int *status ) { \
\
/* Local Variables: */ \
   AstPlot *plot; \
   AstPlot3D *this; \
   int axis2d; \
   type result; \
\
/* Initialise */ \
   result = (bad_value); \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* See if the attribute value is set in the parent Plot structure. If so, \
   use the parent get method to get its value. */ \
   if( astTest##attr( this_plot, axis ) ) { \
      result = (*parent_get##attr)( this_plot, axis, status ); \
\
/* If the attribute value is not set in the parent Plot structure, get \
   the default value from the Plot that is used to label the 3D axis. The \
   parent test method called above will have reported an error if the axis \
   index is invalid, so check astOK here. */ \
   } else if( astOK ) { \
      this = (AstPlot3D *) this_plot; \
      plot = AxisPlot( this, axis, &axis2d, status ); \
      result = astGet##attr( plot, axis2d ); \
   } \
\
/* Return the result. */ \
   return result; \
}

/*
*
*  Name:
*     MAKE_SET

*  Purpose:
*     Implement a method to set a value for an attribute inherited from the
*     Plot class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot3d.h"
*     MAKE_SET(attr,type,whichplots)

*  Class Membership:
*     Defined by the Plot3d class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Set<Attribute>( AstPlot *this, int axis, <Type> value )
*
*     which implements a method for setting a value for an axis specific
*     attribute inherited from the parent Plot class.

*  Parameters:
*      attr
*         The name of the attribute to be set, as it appears in the function
*         name (e.g. LabelAt in "astSetLabelAt").
*      type
*         The C type of the attribute.
*     whichplots
*        A value indicating which Plots should be affected. A negative value
*        means "all threee plots", a value of zero means "just the two plots
*        that touch at the specified axis in 3D space", a positive value
*        means "just the Plot that is used to label the 3D axis."

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*-
*/

/* Define the macro. */
#define MAKE_SET(attr,type,whichplots) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Set##attr( AstPlot *this_plot, int axis, type value, int *status ) { \
\
/* Local Variables: */ \
   AstPlot3D *this; \
   AstPlot *plot; \
   int axis2d; \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Set the supplied value in the parent Plot class. This will validate \
   the axis index. */ \
   (*parent_set##attr)( this_plot, axis, value, status ); \
\
/* If this went OK, also set the value for the appropriate axis of the \
   appropriate encapsulated Plot(s). First get a pointer to the Plot3D \
   structure. */ \
   if( astOK ) { \
      this = (AstPlot3D *) this_plot; \
\
/* If requested set the attribute in all three Plots. */ \
      if( whichplots < 0 ) { \
         astSet##attr( this->plotxy, axis, value ); \
         astSet##attr( this->plotxz, axis, value ); \
         astSet##attr( this->plotyz, axis, value ); \
\
/* Each axis in 3D graphics space is described by two of the encapsulated \
   Plots, but only one of these two Plots is used to generate labels for \
   the axis. First deal with cases where we are setting the attribute \
   value in both of the two Plots that describe the axis. */ \
      } else if( whichplots == 0 ) { \
         if( axis == 0 ) { \
            astSet##attr( this->plotxy, 0, value ); \
            astSet##attr( this->plotxz, 0, value ); \
\
         } else if( axis == 1 ) { \
            astSet##attr( this->plotxy, 1, value ); \
            astSet##attr( this->plotyz, 0, value ); \
\
         } else { \
            astSet##attr( this->plotxz, 1, value ); \
            astSet##attr( this->plotyz, 1, value ); \
         } \
\
/* Now deal with cases where we are setting the attribute value only in  \
   the Plot that is used to label the axis. */ \
      } else { \
         plot = AxisPlot( this, axis, &axis2d, status ); \
         astSet##attr( plot, axis2d, value ); \
      } \
   } \
}


/* 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 "cmpframe.h"            /* Compound Frames */
#include "cmpmap.h"              /* Compound Mappings */
#include "unitmap.h"             /* Unit mappings */
#include "permmap.h"             /* Axis permutations */
#include "winmap.h"              /* Scale and shift mappings */
#include "frame.h"               /* Coordinate systems */
#include "frameset.h"            /* Inter-related coordinate systems */
#include "keymap.h"              /* Hash array */
#include "plot.h"                /* Interface definition for parent class */
#include "plot3d.h"              /* Interface definition for this class */
#include "grf3d.h"               /* The grf3D interface */
#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 <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stddef.h>
#include <math.h>
#include <limits.h>

/* Module Variables. */
/* ================= */

/* Address of this static variable is used as a unique identifier for
   member of this class. */
static int class_check;

/* Pointers to parent class methods which are used or extended by this
   class. */
static AstObject *(* parent_cast)( AstObject *, AstObject *, int * );
static void (* parent_removeframe)( AstFrameSet *, int, int * );
static size_t (* parent_getobjsize)( AstObject *, int * );
static int (* parent_equal)( AstObject *, AstObject *, int * );
static void (* parent_vset)( AstObject *, const char *, char **, va_list, int * );
static void (* parent_clear)( AstObject *, const char *, int * );
static void (* parent_clearcurrent)( AstFrameSet *, int * );
static void (* parent_setcurrent)( AstFrameSet *, int, int * );
static const char *(* parent_getattrib)( AstObject *, const char *, int * );
static int (* parent_testattrib)( AstObject *, const char *, int * );
static void (* parent_clearattrib)( AstObject *, const char *, int * );
static void (* parent_setattrib)( AstObject *, const char *, int * );

/* A FrameSet pointer that is used when calling astCast. */
static AstFrameSet *dummy_frameset = NULL;

#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(Plot3D)

/* Define macros for accessing each item of thread specific global data. */
#define class_init astGLOBAL(Plot3D,Class_Init)
#define class_vtab astGLOBAL(Plot3D,Class_Vtab)
#define getattrib_buff astGLOBAL(Plot3D,GetAttrib_Buff)

static pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
#define LOCK_MUTEX2 pthread_mutex_lock( &mutex2 );
#define UNLOCK_MUTEX2 pthread_mutex_unlock( &mutex2 );

static pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
#define LOCK_MUTEX3 pthread_mutex_lock( &mutex3 );
#define UNLOCK_MUTEX3 pthread_mutex_unlock( &mutex3 );

/* 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 AstPlot3DVtab class_vtab;   /* Virtual function table */
static int class_init = 0;       /* Virtual function table initialised? */

#define LOCK_MUTEX2
#define UNLOCK_MUTEX2

#define LOCK_MUTEX3
#define UNLOCK_MUTEX3

#endif

/* Prototypes for Private Member Functions. */
/* ======================================== */
static AstFrameSet *Fset3D( AstFrameSet *, int, int * );
static AstKeyMap *GetGrfContext( AstPlot *, int * );
static AstObject *Cast( AstObject *, AstObject *, int * );
static AstPlot *AxisPlot( AstPlot3D *, int, int *, int * );
static AstPointSet *ExtendTicks( AstPlot *, AstPointSet *, int * );
static AstPointSet *Transform( AstMapping *, AstPointSet *, int, AstPointSet *, int * );
static const char *RootCornerString( int, int * );
static int Attr3D( AstKeyMap *, int, double, double *, int, int * );
static int Border( AstPlot *, int * );
static int Element2D( AstPlot3D *, int, int *, int *, int * );
static int Equal( AstObject *, AstObject *, int * );
static size_t GetObjSize( AstObject *, int * );
static int Plot3DAttr( AstKeyMap *, int, double, double *, int );
static int Plot3DCap( AstKeyMap *, int, int );
static int Plot3DFlush( AstKeyMap * );
static int Plot3DLine( AstKeyMap *, int, const float *, const float * );
static int Plot3DMark( AstKeyMap *, int, const float *, const float *, int );
static int Plot3DQch( AstKeyMap *, float *, float * );
static int Plot3DScales( AstKeyMap *, float *, float * );
static int Plot3DText( AstKeyMap *, const char *, float, float, const char *, float, float );
static int Plot3DTxExt( AstKeyMap *, const char *, float, float, const char *, float, float, float *, float * );
static int RootCornerInt( const char *, int * );
static void BoundingBox( AstPlot *, float[2], float[2], int * );
static void ChangeRootCorner( AstPlot3D *, int, int, int * );
static void Clear( AstObject *, const char *, int * );
static void ClearCurrent( AstFrameSet *, int * );
static void Clip( AstPlot *, int, const double [], const double [], int * );
static void Copy( const AstObject *, AstObject *, int * );
static void CreatePlots( AstPlot3D *, AstFrameSet *, const float *, const double *, int * );
static void Curve( AstPlot *, const double [], const double [], int * );
static void Delete( AstObject *, int * );
static void Dump( AstObject *, AstChannel *, int * );
static void GenCurve( AstPlot *, AstMapping *, int * );
static void GrfPop( AstPlot *, int * );
static void GrfPush( AstPlot *, int * );
static void GrfSet( AstPlot *, const char *,  AstGrfFun, int * );
static void Grid( AstPlot *, int * );
static void GridLine( AstPlot *, int, const double [], double, int * );
static void Mark( AstPlot *, int, int, int, const double *, int, int * );
static void PolyCurve( AstPlot *, int, int, int, const double *, int * );
static void RemoveFrame( AstFrameSet *, int, int * );
static void Set3DGrf( AstPlot3D *, AstPlot *, int, int * );
static void SetCurrent( AstFrameSet *, int, int * );
static void SetPlotAttr( AstPlot *, int, int[ 2 ], int * );
static void SetTickValues( AstPlot *, int, int, double *, int, double *, int * );
static void SplitFrameSet( AstFrameSet *, AstFrameSet **, int[2], int[2], AstFrameSet **, int[2], int[2], AstFrameSet **, int[2], int[2], int *, int * );
static void StoreAxisInfo( AstPlot3D *, int[2], int[2], int[2], int[2], int[2], int[2], int * );
static void Text( AstPlot *, const char *, const double [], const float [2], const char *, int * );
static void UpdatePlots( AstPlot3D *, int * );
static void VSet( AstObject *, const char *, char **, va_list, 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 * );

#if defined(THREAD_SAFE)
static int ManageLock( AstObject *, int, int, AstObject **, int * );
#endif

/* Declare private member functions that access Plot3D attributes.
   --------------------------------------------------------------*/

/* Axis independent... */

#define DECLARE_PLOT3D_ACCESSORS(attr,type) \
   static type Get##attr(AstPlot3D *,int *); \
   static void Set##attr(AstPlot3D *,type,int *); \
   static void Clear##attr(AstPlot3D *,int *); \
   static int Test##attr(AstPlot3D *,int *);

DECLARE_PLOT3D_ACCESSORS(RootCorner,int)

#undef DECLARE_PLOT3D_ACCESSORS


/* Axis specific... */

#define DECLARE_PLOT3D_ACCESSORS(attr,type) \
   static type Get##attr(AstPlot3D *,int,int *); \
   static void Set##attr(AstPlot3D *,int,type,int *); \
   static void Clear##attr(AstPlot3D *,int,int *); \
   static int Test##attr(AstPlot3D *,int,int *);

DECLARE_PLOT3D_ACCESSORS(Norm,double)

#undef DECLARE_PLOT3D_ACCESSORS


/* Declare private member functions that access axis-specific attributes
   inherited from the Plot class. Also declare pointers to hold the parent
   function pointers.
   ----------------------------------------------------------------------*/

#define DECLARE_PLOT_ACCESSORS(attr,type) \
   static type Get##attr(AstPlot *,int,int *); \
   static void Set##attr(AstPlot *,int,type,int *); \
   static void Clear##attr(AstPlot *,int,int *); \
   static type (*parent_get##attr)(AstPlot *,int,int *); \
   static void (*parent_set##attr)(AstPlot *,int,type,int *); \
   static void (*parent_clear##attr)(AstPlot *,int,int *);

DECLARE_PLOT_ACCESSORS(MinTick,int)
DECLARE_PLOT_ACCESSORS(Abbrev,int)
DECLARE_PLOT_ACCESSORS(Gap,double)
DECLARE_PLOT_ACCESSORS(LogGap,double)
DECLARE_PLOT_ACCESSORS(LogPlot,int)
DECLARE_PLOT_ACCESSORS(LogTicks,int)
DECLARE_PLOT_ACCESSORS(LogLabel,int)
DECLARE_PLOT_ACCESSORS(LabelUp,int)
DECLARE_PLOT_ACCESSORS(DrawAxes,int)
DECLARE_PLOT_ACCESSORS(LabelUnits,int)
DECLARE_PLOT_ACCESSORS(MinTickLen,double)
DECLARE_PLOT_ACCESSORS(MajTickLen,double)
DECLARE_PLOT_ACCESSORS(NumLab,int)
DECLARE_PLOT_ACCESSORS(NumLabGap,double)
DECLARE_PLOT_ACCESSORS(TextLab,int)
DECLARE_PLOT_ACCESSORS(TextLabGap,double)

#undef DECLARE_PLOT_ACCESSORS


/* Declare private member functions that access element-specific attributes
   inherited from the Plot class. Also declare pointers to hold the parent
   function pointers.
   ----------------------------------------------------------------------*/

#define DECLARE_PLOT_ACCESSORS(attr,type) \
   static void Set##attr(AstPlot *,int,type,int *); \
   static void Clear##attr(AstPlot *,int,int *); \
   static void (*parent_set##attr)(AstPlot *,int,type,int *); \
   static void (*parent_clear##attr)(AstPlot *,int,int *);

DECLARE_PLOT_ACCESSORS(Style,int)
DECLARE_PLOT_ACCESSORS(Font,int)
DECLARE_PLOT_ACCESSORS(Colour,int)
DECLARE_PLOT_ACCESSORS(Width,double)
DECLARE_PLOT_ACCESSORS(Size,double)

#undef DECLARE_PLOT_ACCESSORS


/* Declare private member functions that access attributes inherited from
   the Plot class that do not need to override the Get method. This
   includes attributes that are not axis-specific or that do not have
   dynamic defaults. Also declare pointers to hold the parent function
   pointers.
   ----------------------------------------------------------------------*/
#define DECLARE_PLOT_ACCESSORS(attr,type) \
   static void Set##attr(AstPlot *,type,int *); \
   static void Clear##attr(AstPlot *,int *); \
   static void (*parent_set##attr)(AstPlot *,type,int *); \
   static void (*parent_clear##attr)(AstPlot *,int *);

DECLARE_PLOT_ACCESSORS(Ink,int)
DECLARE_PLOT_ACCESSORS(Tol,double)
DECLARE_PLOT_ACCESSORS(Invisible,int)
DECLARE_PLOT_ACCESSORS(TickAll,int)
DECLARE_PLOT_ACCESSORS(ForceExterior,int)
DECLARE_PLOT_ACCESSORS(Border,int)
DECLARE_PLOT_ACCESSORS(Clip,int)
DECLARE_PLOT_ACCESSORS(ClipOp,int)
DECLARE_PLOT_ACCESSORS(Escape,int)
DECLARE_PLOT_ACCESSORS(Grid,int)
DECLARE_PLOT_ACCESSORS(Labelling,int)

#undef DECLARE_PLOT_ACCESSORS



/* Member functions. */
/* ================= */

static int Attr3D( AstKeyMap *grfconID, int attr, double value,
                   double *old_value, int prim, int *status ){
/*
*  Name:
*     Attr3D

*  Purpose:
*     Get or set the value of a 3D grf attribute.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     Attr3D( AstKeyMap *grfconID, int attr, double value, double *old_value,
*             int prim, int *status )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function gets or sets the current value of a specified graphics
*     attribute in the parent Plot structure of a Plot3D. It forwards the
*     call to the grf3D module being used by this Plot3D. It should be
*     registered with the parent Plot using astGrfSet.

*  Parameters:
*     grfconID
*       The Plot's GrfContext KeyMap.
*     attr
*       An integer value identifying the required attribute. This should
*       be one of the symbolic values defined in grf.h.
*     value
*       A new value to store for the attribute. If this is AST__BAD
*       no value is stored.
*     old_value
*       A pointer to a double in which to return the attribute value.
*       If this is NULL, no value is returned.
*     prim
*       The sort of graphics primitive to be drawn with the new attribute.
*       Identified by one of the values defined in grf.h.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

/* Local Variables: */
   int result;

/* Check the inherited status. */
   if( !astOK ) return 0;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* Use the function in the external Grf3D module, selected at link-time
   using ast_link options. */
   result = astG3DAttr( attr, value, old_value, prim );

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

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

static AstPlot *AxisPlot( AstPlot3D *this, int axis3d, int *axis2d, int *status ){
/*
*  Name:
*     AxisPlot

*  Purpose:
*     Find the Plot used to label a 3D axis.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     AstPlot *AxisPlot( AstPlot3D *this, int axis3d, int *axis2d, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function returns a pointer to the encapsulated 2D Plot that
*     is used to label the given 3D axis. It also returns the index
*     of the labelled axis within the 2D Plot.

*  Parameters:
*     this
*        Pointer to a Plot3D.
*     axis3d
*        A zero-based axis index within the Plot3D.
*     axis2d
*        Pointer to an int in which to put the index of the labelled axis
*        within the returned 2D Plot.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Pointer to the Plot used to label the 3D axis. Do not annul this
*     pointer.

*-
*/

/* Local Variables: */
   AstPlot *plot;

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

/* Return the required information form the Plot3D structure. */
   plot = GET_PLOT( this->axis_plot1[ axis3d ] );
   if( ! plot ) {
      astError( AST__INTER, "AxisPlot(Plot3D): Illegal value %d "
                "for axis3d (internal AST programming error).", status,
                this->axis_plot1[ axis3d ] );
   }

   *axis2d = this->axis_index1[ axis3d ];

   return plot;
}

static int Border( AstPlot *this_plot, int *status ){
/*
*  Name:
*     Border

*  Purpose:
*     Draw a border around valid regions of a Plot.

*  Type:
*     Private member function.

*  Synopsis:
*     #include "plot3d.h"
*     int Border( AstPlot *this, int *status )

*  Class Membership:
*     Plot method (overrides the astBorder method inherited from the
*     Plot class)

*  Description:
*     This function draws a (line) border around regions of the
*     plotting area of a Plot which correspond to valid, unclipped
*     physical coordinates. For example, when plotting using an
*     all-sky map projection, this function could be used to draw the
*     boundary of the celestial sphere when it is projected on to the
*     plotting surface.
*
*     If the entire plotting area contains valid, unclipped physical
*     coordinates, then the boundary will just be a rectangular box
*     around the edges of the plotting area.

*  Parameters:
*     this
*        Pointer to the Plot.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Zero is returned if the plotting area is completely filled by
*     valid, unclipped physical coordinates (so that only a
*     rectangular box was drawn around the edge). Otherwise, one is
*     returned.

*  Notes:
*     - The Plot3D implementation of this method, invokes the astBorder
*     method on each of the three encapsulated Plots, and returns the
*     logical OR of the three returned flags.
*     - 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.
*     - An error results if either the current Frame or the base Frame
*     of the Plot is not 2-dimensional, or (for a Plot3D) 3-dimensional.
*     - An error also results if the transformation between the base
*     and current Frames of the Plot is not defined (i.e. the Plot's
*     TranForward attribute is zero).
*/

/* Local Variables: */
   AstPlot3D *this;
   const char *class;
   const char *method;
   float x1;
   float y1;
   float z1;
   float x[ 2 ];
   float y[ 2 ];
   float z[ 2 ];
   int flag1;
   int flag2;
   int flag3;
   int naxes;
   int ok;
   int result;
   int root_corner;

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

/* Get a pointer to the Plot3D structure. */
   this = (AstPlot3D *) this_plot;

/* Store the current method, and the class of the supplied object for use
   in error messages.*/
   method = "astBorder";
   class = astGetClass( this );

/* Check the base Frame of the Plot is 3-D. */
   naxes = astGetNin( this );
   if( naxes != 3 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 3.", status, method, class, naxes, class );
   }

/* Check the current Frame of the Plot is 3-D. */
   naxes = astGetNout( this );
   if( naxes != 3 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the current "
                "Frame of the supplied %s is invalid - this number should "
                "be 3.", status, method, class, naxes, class );
   }

/* Invoke the astBorder method on each of the three encapsulated Plots. */
   flag1 = astBorder( this->plotxy );
   flag2 = astBorder( this->plotxz );
   flag3 = astBorder( this->plotyz );

/* If no bad values were encountered in any of the Plots, draw lines
   along the remaining plot edges. */
   result = ( flag1 || flag2 || flag3 );
   if( !result ) {

/* The three remaining edges to be drawn all meet at the corner
   diagonally opposite the root corner. Get the root corner. */
      root_corner = astGetRootCorner( this );

/* The (x0,y0,z0) position is the graphics coords at the corner
   diagonally opposite the root corner. The x1, y1 and z1 values
   are the graphics x, y and z values at the ends of the three
   lines that remain to be drawn. */
      if( root_corner & 1 ) {
         x[ 0 ] = this->gbox[ 0 ];
         x1 = this->gbox[ 3 ];
      } else {
         x[ 0 ] = this->gbox[ 3 ];
         x1 = this->gbox[ 0 ];
      }

      if( root_corner & 2 ) {
         y[ 0 ] = this->gbox[ 1 ];
         y1 = this->gbox[ 4 ];
      } else {
         y[ 0 ] = this->gbox[ 4 ];
         y1 = this->gbox[ 1 ];
      }

      if( root_corner & 4 ) {
         z[ 0 ] = this->gbox[ 2 ];
         z1 = this->gbox[ 5 ];
      } else {
         z[ 0 ] = this->gbox[ 5 ];
         z1 = this->gbox[ 2 ];
      }

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
      astGrfAttrs( this, AST__BORDER_ID, 1, GRF__LINE, method, class );

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
      LOCK_MUTEX2;

/* Draw the remaining line parallel to the X axis. */
      x[ 1 ] = x1;
      y[ 1 ] = y[ 0 ];
      z[ 1 ] = z[ 0 ];
      ok = astG3DLine( 2, x, y, z );

/* Draw the remaining line parallel to the Y axis. */
      x[ 1 ] = x[ 0 ];
      y[ 1 ] = y1;
      z[ 1 ] = z[ 0 ];
      ok = ok && astG3DLine( 2, x, y, z );

/* Draw the remaining line parallel to the X axis. */
      x[ 1 ] = x[ 0 ];
      y[ 1 ] = y[ 0 ];
      z[ 1 ] = z1;
      ok = ok && astG3DLine( 2, x, y, z );

/* Allow the next thread to proceed. */
      UNLOCK_MUTEX2;

/* Re-establish the original graphical attributes. */
      astGrfAttrs( this, AST__BORDER_ID, 0, GRF__LINE, method, class );

/* Report an error if anything went wrong in the grf3d module. */
      if( !ok && astOK ) {
         astError( AST__GRFER, "%s(%s): Graphics error in astG3DLine. ", status,
                   method, class );
      }
   }

/* Return zero if an error has occurrred. */
   if( !astOK ) result = 0;

/* Return a flag indicating if any bad values were encountered in any of
   the Plots. */
   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 "plot3d.h"
*     AstObject *Cast( AstObject *this, AstObject *obj, int *status )

*  Class Membership:
*     Plot3D 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; */
   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 (Plot3D). A positive value is returned if Plot3D
   is a sub-class of "obj". A negative value is returned if "obj" is
   a sub-class of Plot3D. Zero is returned if "obj" is a Plot3D.
   AST__COUSIN is returned if "obj" is not on the same line of descent
   as Plot3D. */
   generation_gap = astClassCompare( (AstObjectVtab *) &class_vtab,
                                     astVTAB( obj ) );

/* If "obj" is a Plot3D or a sub-class of Plot3D, 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 a Plot (the parent class), we cast by returning a deep
   copy of the Plot covering the XY face. */
   } else if( generation_gap == 1 ) {
      new = astCopy( ( (AstPlot3D *) this_object)->plotxy );

/* If "obj" is a FrameSet or higher, we attempt to use the implementation
   inherited from the parent class to cast the FrameSet component into the
   class indicated by "obj". */
   } else {
      new = (*parent_cast)( this_object, obj, status );
   }

/* Return the new pointer. */
   return new;
}

static void ChangeRootCorner( AstPlot3D *this, int old, int new, int *status ){
/*
*  Name:
*     ChangeRootCorner

*  Purpose:
*     Use a new RootCorner value.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void ChangeRootCorner( AstPlot3D *this, int old, int new, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function sets the attributes of the encapsulated Plots so that
*     labels appear on the edges of the 3D graphics cube that join at the
*     specified new root corner. It also reverses the graphics axes in
*     the encapsulated Plots as required in order to ensure that the Plots
*     look "normal" when viewed from the outside of the 3D graphics cube.
*     This happens if a the Plot used to label a specific axis moves from
*     one face the the 3D graphics cube to the opposite face.

*  Parameters:
*     this
*        Pointer to a Plot3D.
*     old
*        The old RootCorner value.
*     new
*        The new RootCorner value.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - Each RootCorner value is in the range 0 to 7 and is a 3 bit
*     bit-mask. Bit 0 describes the 3D graphics X axis, bit 1 describes
*     the graphics Y axis and bit 2 describes the graphics Z axis. If a
*     bit is set it means that the corner is at the upper bound on the
*     corresponding axis. If a bit is unset it means that the corner is
*     at the lower bound on the corresponding axis.

*-
*/

/* Local Variables: */
   AstKeyMap *grfcon;
   AstPlot *plot;
   AstPlot *plots[ 24 ];
   int edges[ 24 ];
   int axes[ 24 ];
   int axis2d;
   int edge;
   int i;
   int np;
   int xeqy;
   int xeqz;

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

/* If the corner has moved on the 3D X axis (from upper X bound to lower X
   bound or vice-versa), mirror the axis of the encapsulated Plot that is
   perpendicular to the 3D X axis. This means that the Plot can be thought
   of as being viewed from the outside of the 3D graphics cube. Also,
   update the constant X axis value at which the YZ plane is drawn. */
   if( ( old & 1 ) != ( new & 1 ) ) astMirror( this->plotyz, 0 );
   grfcon = (AstKeyMap *) astGetGrfContext( this->plotyz );
   astMapPut0D( grfcon, "Gcon", this->gbox[ ( new & 1 ) ? 3 : 0 ], "Constant X value" );
   astMapPut0I( grfcon, "RootCorner", new, "Labelled corner" );
   grfcon= astAnnul( grfcon );

/* Likewise mirror the other two axes if required. */
   if( ( old & 2 ) != ( new & 2 ) ) astMirror( this->plotxz, 0 );
   grfcon = (AstKeyMap *) astGetGrfContext( this->plotxz );
   astMapPut0D( grfcon, "Gcon", this->gbox[ ( new & 2 ) ? 4 : 1 ], "Constant Y value" );
   astMapPut0I( grfcon, "RootCorner", new, "Labelled corner" );
   grfcon= astAnnul( grfcon );

   if( ( old & 4 ) != ( new & 4 ) ) astMirror( this->plotxy, 0 );
   grfcon = (AstKeyMap *) astGetGrfContext( this->plotxy );
   astMapPut0D( grfcon, "Gcon", this->gbox[ ( new & 4 ) ? 5 : 2 ], "Constant Z value" );
   astMapPut0I( grfcon, "RootCorner", new, "Labelled corner" );
   grfcon= astAnnul( grfcon );

/* Set a flag saying whether the limits are equal at the new corner for
   the X and Y axes. */
   xeqy = ( ( ( new & 1 ) > 0 ) == ( ( new & 2 ) > 0 ) );

/* Set a flag saying whether the limits are equal at the new corner for
   the X and Z axes. */
   xeqz = ( ( ( new & 1 ) > 0 ) == ( ( new & 4 ) > 0 ) );

/* Ensure all Edge attributes are clear. This means that the public
   attribute accessors routines used below will return dynamic defaults for
   the Edge attributes. */
   astClearEdge( this->plotxy, 0 );
   astClearEdge( this->plotxy, 1 );
   astClearEdge( this->plotxz, 0 );
   astClearEdge( this->plotxz, 1 );
   astClearEdge( this->plotyz, 0 );
   astClearEdge( this->plotyz, 1 );

/* So far we have recorded no edges changes. */
   np = 0;

/* We now adjust the Edge attributes in the Plot used to annotate the 3D
   X axis in order to get the X axis labels on the correct edge of the 3D
   graphics cube. Get the Plot used to produce X axis labels (this will
   be either this->plotxy or this->plotxz). */
   plot = AxisPlot( this, 0, &axis2d, status );

/* See what edge of the Plot is used to annotate the first of the two WCS
   axis described by the 2D Plot. If the Edge(1) attribute has not been
   assigned a value, then a dynamic default will be used by the Plot class.
   We want to know what this dynamic default is, so we first cleared the
   attribute above. Now we set the attribute value explicitly to the dynamic
   default returned by astGetC. Note, we use astGetC rather than astGetEdge
   because the dynamic default is not calculated when calling astGetEdge. */
   astSetC( plot, "Edge(1)", astGetC( plot, "Edge(1)" ));
   edge = astGetEdge( plot, 0 );
   astClearEdge( plot, 0 );

/* If the 3D X axis is labelled using the Plot that spans the XY plane... */
   if( plot == this->plotxy ) {

/* ... and if the new root corner is at the upper limit on the Y axis... */
      if( new & 2 ) {

/* If the first WCS axis is currently labelled on either the top or bottom
   edge, ensure it is labelled on the upper Y (top) edge. */
         if( edge == 3 || edge == 1 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = TOP;

/* Otherwise ensure that the second WCS axis is labelled on the upper Y (top)
   edge. */
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = TOP;
         }

/* If the new root corner is at the lower limit on the Y axis... */
      } else {

/* If the first WCS axis is currently labelled on either the top or bottom
   edge, ensure it is labelled on the lower Y (bottom) edge. */
         if( edge == 3 || edge == 1 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = BOTTOM;

/* Otherwise ensure that the second WCS axis is labelled on the lower Y
   (bottom) edge. */
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = BOTTOM;
         }
      }

/* If the 3D X axis is labelled using the Plot that spans the XZ plane... */
   } else {

/* ... and if the new root corner is at the upper limit on the Z axis... */
      if( new & 4 ) {

/* If the first WCS axis is currently labelled on either the top or bottom
   edge, ensure it is labelled on the upper Z (top) edge. */
         if( edge == 3 || edge == 1 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = TOP;

/* Otherwise ensure that the second WCS axis is labelled on the upper Y (top)
   edge. */
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = TOP;
         }

/* If the new root corner is at the lower limit on the Z axis... */
      } else {

/* If the first WCS axis is currently labelled on either the top or bottom
   edge, ensure it is labelled on the lower Z (bottom) edge. */
         if( edge == 3 || edge == 1 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = BOTTOM;

/* Otherwise ensure that the second WCS axis is labelled on the lower Z
   (bottom) edge. */
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = BOTTOM;
         }
      }
   }

/* We now adjust the Edge attributes in the Plot used to annotate the 3D
   Y axis in order to get the Y axis labels on the correct edge of the 3D
   graphics cube. Get the Plot used to produce Y axis labels. */
   plot = AxisPlot( this, 1, &axis2d, status );

/* See what edge of the Plot is used to annotate the first of the two WCS
   axis described by the Plot. */
   astSetC( plot, "Edge(1)", astGetC( plot, "Edge(1)" ));
   edge = astGetEdge( plot, 0 );
   astClearEdge( plot, 0 );

/* If the 3D Y axis is labelled using the Plot that spans the XY plane... */
   if( plot == this->plotxy ) {

/* ... and if the new root corner is at the same limit on the X and Z axes,
   put Y labels on the right side of the Plot.  */
      if( xeqz ) {
         if( edge == 0 || edge == 2 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = RIGHT;
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = RIGHT;
         }

/* If the new root corner is at a different limit on the X and Z axes,
   put Y labels on the left side of the Plot.  */
      } else {
         if( edge == 0 || edge == 2 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = LEFT;
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = LEFT;
         }
      }

/* If the 3D Y axis is labelled using the Plot that spans the YZ plane... */
   } else {

/* ... and if the new root corner is at the upper Z limit, put Y labels on
   the top of the Plot.  */
      if( new & 4 ) {
         if( edge == 1 || edge == 3 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = TOP;
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = TOP;
         }

/* If the new root corner is at the lower Z limit, put Y labels on the
   bottom of the Plot.  */
      } else {
         if( edge == 1 || edge == 3 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = BOTTOM;
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = BOTTOM;
         }
      }
   }

/* We now adjust the Edge attributes in the Plot used to annotate the 3D
   Z axis in order to get the Z axis labels on the correct edge of the 3D
   graphics cube. Get the Plot used to produce Z axis labels. */
   plot = AxisPlot( this, 2, &axis2d, status );

/* See what edge of the Plot is used to annotate the first of the two WCS
   axis described by the Plot. */
   astSetC( plot, "Edge(1)", astGetC( plot, "Edge(1)" ));
   edge = astGetEdge( plot, 0 );
   astClearEdge( plot, 0 );

/* If the 3D Z axis is labelled using the Plot that spans the XZ plane... */
   if( plot == this->plotxz ) {

/* ... and if the new root corner is at the same limit on the X and Y axes,
   put Z labels on the left side of the Plot.  */
      if( xeqy ) {
         if( edge == 0 || edge == 2 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = LEFT;
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = LEFT;
         }

/* If the new root corner is at a different limit on the X and Y axes,
   put Y labels on the right side of the Plot.  */
      } else {
         if( edge == 0 || edge == 2 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = RIGHT;
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = RIGHT;
         }
      }

/* If the 3D Z axis is labelled using the Plot that spans the YZ plane... */
   } else {

/* ... and if the new root corner is at the same limit on the X and Y axes,
   put Z labels on the right side of the Plot.  */
      if( xeqz ) {
         if( edge == 0 || edge == 2 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = RIGHT;
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = RIGHT;
         }

/* If the new root corner is at a different limit on the X and Y axes,
   put Y labels on the left side of the Plot.  */
      } else {
         if( edge == 0 || edge == 2 ) {
            plots[ np ] = plot;
            axes[ np ] = 0;
            edges[ np++ ] = LEFT;
         } else {
            plots[ np ] = plot;
            axes[ np ] = 1;
            edges[ np++ ] = LEFT;
         }
      }
   }

/* Apply the set of edge changes determined above. */
   for( i = 0; i < np; i++ ) {
      astSetEdge( plots[ i ], axes[ i ], edges[ i ] );
   }

/* Ensure that the 2 Plot axes that are not being used have suitable values
   for their attributes. That is, no labels are drawn, and the ticked
   edges are the one that meet at the new RootCorner. */

   if( !astTestEdge( this->plotxy, 0 ) ) {
      astSetEdge( this->plotxy, 0, ( new & 2 ) ? TOP : BOTTOM );
   }

   if( !astTestEdge( this->plotxy, 1 ) ) {
      astSetEdge( this->plotxy, 1, xeqz ? RIGHT: LEFT );
   }

   if( !astTestEdge( this->plotxz, 0 ) ) {
      astSetEdge( this->plotxz, 0, ( new & 4 ) ? TOP : BOTTOM );
   }

   if( !astTestEdge( this->plotxz, 1 ) ) {
      astSetEdge( this->plotxz, 1, xeqy ? LEFT : RIGHT );
   }

   if( !astTestEdge( this->plotyz, 0 ) ) {
      astSetEdge( this->plotyz, 0, ( new & 4 ) ? TOP : BOTTOM );
   }

   if( !astTestEdge( this->plotyz, 1 ) ) {
      astSetEdge( this->plotyz, 1, xeqy ? RIGHT : LEFT );
   }


}

static void Clear( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     Clear

*  Purpose:
*     Clear attribute values for a Plot3D.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void Clear( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the public astClear method
*     inherited from the Object class).

*  Description:
*     This function clears the values of a specified set of attributes
*     for a Plot3D. Clearing an attribute cancels any value that has
*     previously been explicitly set for it, so that the standard
*     default attribute value will subsequently be used instead. This
*     also causes the astTest function to return the value zero for
*     the attribute, indicating that no value has been set.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     attrib
*        Pointer to a null-terminated character string containing a
*        comma-separated list of the names of the attributes to be
*        cleared.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function preserves the integrity of the Plot3D (if
*     possible) by appropriately modifying the three encapsulated Plots.
*/

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

/* Invoke the parent astClear method to clear the Plot3D's attribute values. */
   (*parent_clear)( this_object, attrib, status );

/* Update the three 2D Plots stored in the Plot3D structure so that they
   reflect this modified FrameSet. */
   UpdatePlots( (AstPlot3D *) this_object, status );

}

static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     ClearAttrib

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

*  Type:
*     Private function.

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

*  Class Membership:
*     Plot3D member function (over-rides the astClearAttrib protected
*     method inherited from the Plot class).

*  Description:
*     This function clears the value of a specified attribute for a
*     Plot3D, so that the default value will subsequently be used.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     attrib
*        Pointer to a null terminated string specifying the attribute
*        name.  This should be in lower case with no surrounding white
*        space.
*/

/* Local Variables: */
   AstPlot3D *this;              /* Pointer to the Plot3D structure */
   AstPlot *plot;                /* Pointer to specific Plot */
   char attname[50];             /* Plot attribute base name */
   char patt[50];                /* Plot attribute full name */
   char spec[10];                /* Plane specification */
   int axis;                     /* Axis index */
   int len;                      /* Length of attrib string */
   int nc;                       /* Number of characters read */

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

/* Obtain a pointer to the Plot3D structure. */
   this = (AstPlot3D *) this_object;

/* Obtain the length of the "attrib" string. */
   len = strlen( attrib );

/* Check the attribute name and clear the appropriate attribute. */

/* Norm. */
/* ----------- */
   if ( !strcmp( attrib, "norm" ) ) {
      astClearNorm( this, 0 );
      astClearNorm( this, 1 );
      astClearNorm( this, 2 );

/* Norm(axis). */
/* ----------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "norm(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearNorm( this, axis - 1 );

/* RootCorner. */
/* ----------- */
   } else if ( !strcmp( attrib, "rootcorner" ) ) {
      astClearRootCorner( this );

/* ..._XY etc */
/* ---------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( attrib, "%[a-z]_%[xyz]%n", attname, spec,
                 &nc ) ) ) {

      if( !strcmp( spec, "xy" ) || !strcmp( spec, "yx" ) ) {
         plot = this->plotxy;
      } else if( !strcmp( spec, "xz" ) || !strcmp( spec, "zx" ) ) {
         plot = this->plotyz;
      } else if( !strcmp( spec, "yz" ) || !strcmp( spec, "zy" ) ) {
         plot = this->plotxz;
      } else {
         plot = NULL;
      }

      if( plot ) {
         sprintf( patt, "%s%s", attname, attrib + nc );
         astClearAttrib( plot, patt );

      } else {
         (*parent_clearattrib)( this_object, attrib, status );
      }

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      (*parent_clearattrib)( this_object, attrib, status );
   }
}

static void ClearCurrent( AstFrameSet *this_frameset, int *status ) {
/*
*  Name:
*     ClearCurrent

*  Purpose:
*     Clear the value of the Current attribute for a Plot3D.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int astClearCurrent( AstFrameSet *this )

*  Class Membership:
*     Plot3D member function (over-rides the public astClearCurrent method
*     inherited from the FrameSet class).

*  Description:
*     This function clears the value of the Current attribute for a
*     Plot3D. This attribute is an index that identifies the current
*     Frame for the Plot3D.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*/

/* Invoke the parent astClearCurrent method. */
   (*parent_clearcurrent)( this_frameset, status );

/* Update the three 2D Plots stored in the Plot3D structure so that they
   reflect this modified FrameSet. */
   UpdatePlots( (AstPlot3D *) this_frameset, status );
}

static void ClearRootCorner( AstPlot3D *this, int *status ){
/*
*+
*  Name:
*     astClearRootCorner

*  Purpose:
*     Clear the RootCorner attribute.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "plot3d.h"
*     void astClearRootCorner( AstPlot3D *this )

*  Class Membership:
*     Plot method.

*  Description:
*     This function clears the RootCorner attribute.

*  Parameters:
*     this
*        Pointer to a Plot3D.

*-
*/

/* Local Variables: */
   int old;
   int new;

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

/* Get the current rootcorner value. */
   old = astGetRootCorner( this );

/* Clear the RootCorner attribute. */
   this->rootcorner = -1;

/* Get the new (default) rootcorner value. */
   new = astGetRootCorner( this );

/* If the root corner has changed, mirror any axes of the encapsulated Plots
   that need mirroring (this is done to ensure that Plots look right when
   viewed from the outside of the graphics cube), and modify the Edge
   attributes in the encapsulated Plots to ensure the labels appear on the
   requested edges of the 3D graphics cube. . */
   if( old != new ) ChangeRootCorner( this, old, new, status );
}

static void CreatePlots( AstPlot3D *this, AstFrameSet *fset, const float *gbox,
                         const double *bbox, int *status ) {
/*
*  Name:
*     CreatePlots

*  Purpose:
*     Create three 2D plots and store in the Plot3D.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void CreatePlots( AstPlot3D *this, AstFrameSet *fset, const float *gbox,
                        const double *bbox, int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function splits the supplied FrameSet up into 3 independent 2D
*     FrameSets, each describing a 2D plane in the supplied 3D FrameSet.
*     It then uses these 2D FrameSets to create three Plots, one for each
*     plane in the graphics plotting space, and stores them in the Plot3D.
*
*     Each of the three Plots is notionally pasted onto one face of the
*     3D graphics cube (the RootCorner attribute is used to determine which
*     of the two parallel faces a particular Plot is pasted onto). The
*     Plot is pasted in such a way that, when viewed from the outside of
*     the graphics cube, the first graphics axis increases left to right
*     and the second increases bottom to top (this assumes that "up" is
*     parallel to the 3D Z axis).
*
*     Initially, the Plots are created assuming the default RootCorner
*     value ("LLL"). They will be changed later if the value of the
*     RootCorner attribute is changed.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     fset
*        Pointer to the FrameSet.
*     gbox
*        A pointer to an array of 6 values giving the graphics coordinates
*        of the bottom left and top right corners of a box on the graphics
*        output device. The first triple of values should be the graphics
*        coordinates of the bottom left corner of the box and the second
*        triple of values are the graphics coordinates of the top right corner.
*     bbox
*        A pointer to an array of 6 values giving the coordinates in the
*        supplied Frame or base Frame of the supplied FrameSet at the bottom
*        left and top right corners of the box specified by parameter gbox.
*        These should be supplied in the same order as for parameter "gbox".
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - Each returned plot has 3 Frames: Frame 1 is the base (GRAPHICS)
*     Frame; Frame 2 is spanned by 2 of the 3 axes in the base Frame of
*     the supplied FrameSet; Frame 3 is the current Frame and is spanned
*     by 2 of the 3 axes in the current Frame of the supplied FrameSet.
*     Any future changes to this function that alter this structure should
*     reflected in equivalent changes to function UpdatePlots.

*/

/* Local Variables: */
   AstFrameSet *fsetxy;
   AstFrameSet *fsetxz;
   AstFrameSet *fsetyz;
   double basebox2d[ 4 ];
   float graphbox2d[ 4 ];
   int baseplane;
   int labelxy[ 2 ];
   int labelxz[ 2 ];
   int labelyz[ 2 ];
   int wcsxy[ 2 ];
   int wcsxz[ 2 ];
   int wcsyz[ 2 ];

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

/* Split the supplied FrameSet up into 3 FrameSets, each with a 2D base
   and current Frame. Each of these FrameSets describes one plane of
   the 3D cube. One of them will be spanned by two axes picked from the
   supplied 3D FrameSet. The other two FrameSets will each include a copy
   of the remaining 3rd axis from the supplied FrameSet, plus an extra
   dummy axis. These dummy axes will never be labelled. */
   SplitFrameSet( fset, &fsetxy, labelxy, wcsxy, &fsetxz, labelxz, wcsxz,
                  &fsetyz, labelyz, wcsyz, &baseplane, status );

/* If OK, annul any existing 2D plots. */
   if( astOK ) {
      if( this->plotxy ) this->plotxy = astAnnul( this->plotxy );
      if( this->plotxz ) this->plotxz = astAnnul( this->plotxz );
      if( this->plotyz ) this->plotyz = astAnnul( this->plotyz );

/* Create three Plots; one for each 2D plane in the graphics plotting
   space. Set the attributes of these plots so that the required axes are
   labelled and other axes are left blank. The "graphbox2d" and "basebox2d"
   values used to create each Plot define the sense, as well as the extent,
   of each axis. The first pair of values in each give the lower left corner
   of the Plot and the second pair give the top right corner. We want each
   Plot to have X increasing left to right and Y increasing bottom to
   top when viewed from the outside of the cube. We assume an initial
   RootCorner value of "LLL" (that is, the Plots are pasted onto the cube
   faces that meet at the lower limit on every axis). */
      graphbox2d[ 0 ] = gbox[ 3 ];
      graphbox2d[ 1 ] = gbox[ 1 ];
      graphbox2d[ 2 ] = gbox[ 0 ];
      graphbox2d[ 3 ] = gbox[ 4 ];

      basebox2d[ 0 ] = bbox[ 3 ];
      basebox2d[ 1 ] = bbox[ 1 ];
      basebox2d[ 2 ] = bbox[ 0 ];
      basebox2d[ 3 ] = bbox[ 4 ];

      if( this->plotxy ) this->plotxy = astAnnul( this->plotxy );
      this->plotxy = astPlot( fsetxy, graphbox2d, basebox2d, "", status );
      SetPlotAttr( this->plotxy, XY, labelxy, status );

      graphbox2d[ 0 ] = gbox[ 0 ];
      graphbox2d[ 1 ] = gbox[ 2 ];
      graphbox2d[ 2 ] = gbox[ 3 ];
      graphbox2d[ 3 ] = gbox[ 5 ];

      basebox2d[ 0 ] = bbox[ 0 ];
      basebox2d[ 1 ] = bbox[ 2 ];
      basebox2d[ 2 ] = bbox[ 3 ];
      basebox2d[ 3 ] = bbox[ 5 ];

      this->plotxz = astPlot( fsetxz, graphbox2d, basebox2d, "", status );
      SetPlotAttr( this->plotxz, XZ, labelxz, status );

      graphbox2d[ 0 ] = gbox[ 4 ];
      graphbox2d[ 1 ] = gbox[ 2 ];
      graphbox2d[ 2 ] = gbox[ 1 ];
      graphbox2d[ 3 ] = gbox[ 5 ];

      basebox2d[ 0 ] = bbox[ 4 ];
      basebox2d[ 1 ] = bbox[ 2 ];
      basebox2d[ 2 ] = bbox[ 1 ];
      basebox2d[ 3 ] = bbox[ 5 ];

      this->plotyz = astPlot( fsetyz, graphbox2d, basebox2d, "", status );
      SetPlotAttr( this->plotyz, YZ, labelyz, status );

/* Store information that allows each 3D WCS axis to be associatedf with
   a pair of Plots. Also store the WCS axis within each Plot that
   corresponds to the 3D WCS axis. */
      StoreAxisInfo( this, labelxy, wcsxy, labelxz, wcsxz, labelyz, wcsyz, status );

/* Store the Plot that spans two connected 3D axes. */
      this->baseplot = baseplane;

/* Free resources */
      fsetxy = astAnnul( fsetxy );
      fsetxz = astAnnul( fsetxz );
      fsetyz = astAnnul( fsetyz );

   }
}

static int Element2D( AstPlot3D *this, int element, int *elem2d1,
                      int *elem2d2, int *status ){
/*
*  Name:
*     Element2D

*  Purpose:
*     Convert a 3D graphics element identifier to a corresponding pair of
*     2D identifiers.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Element2D( AstPlot3D *this, int element, int *elem2d1,
*                    int *elem2d2, int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function takes an integer identifier for an element of a 3D
*     annotated grid (e.g. ticks, axis 1 labels, border, etc), and returns
*     a element identifers that can be used with the encapsualted 2D Plots.

*  Parameters:
*     this
*        Pointer to the Plot2D structure.
*     element
*        The 3D element identifier to convert.
*     elem2d1
*        Pointer to an int in which to return the 2D element identifier
*        to use with the first of the two Plots that span the axis to
*        which the 3D element identifier refers. Returned holding 0 if
*        the given 3D element identifier is not axis specific.
*     elem2d2
*        Pointer to an int in which to return the 2D element identifier
*        to use with the second of the two Plots that span the axis to
*        which the 3D element identifier refers. Returned holding 0 if
*        the given 3D element identifier is not axis specific.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The zero-based index of the 3D axis to which the given element
*     identifier refers, or -1 if the element identifier is not axis
*     specific.

*/

/* Local Variables: */
   int axis3d;

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

/* Get the zero-based index of the 3D axis to which the supplied element
   refers. Use an index of -1 to indicate that the element does not
   relate to a specific axis. Also get the corresponding element to use
   with the two Plots that share the speified 3D axis. */

/* Define a macro used to set the 2d element identifiers for a given 3d
   element identifier. */

#define SET_ELEM2D(id1,id2) \
   *elem2d1 = this->axis_index1[ axis3d ] ? id2 : id1; \
   *elem2d2 = this->axis_index2[ axis3d ] ? id2 : id1;

   if( element == AST__BORDER_ID ){
      axis3d = -1;

   } else if( element == AST__CURVE_ID ){
      axis3d = -1;

   } else if( element == AST__TITLE_ID ){
      axis3d = -1;

   } else if( element == AST__MARKS_ID ){
      axis3d = -1;

   } else if( element == AST__TEXT_ID ){
      axis3d = -1;

   } else if( element == AST__AXIS1_ID ){
      axis3d = 0;
      SET_ELEM2D(AST__AXIS1_ID,AST__AXIS2_ID)

   } else if( element == AST__AXIS2_ID ){
      axis3d = 1;
      SET_ELEM2D(AST__AXIS1_ID,AST__AXIS2_ID)

   } else if( element == AST__AXIS3_ID ){
      axis3d = 2;
      SET_ELEM2D(AST__AXIS1_ID,AST__AXIS2_ID)

   } else if( element == AST__NUMLAB1_ID ){
      axis3d = 0;
      SET_ELEM2D(AST__NUMLAB1_ID,AST__NUMLAB2_ID)

   } else if( element == AST__NUMLAB2_ID ){
      axis3d = 1;
      SET_ELEM2D(AST__NUMLAB1_ID,AST__NUMLAB2_ID)

   } else if( element == AST__NUMLAB3_ID ){
      axis3d = 2;
      SET_ELEM2D(AST__NUMLAB1_ID,AST__NUMLAB2_ID)

   } else if( element == AST__TEXTLAB1_ID ){
      axis3d = 0;
      SET_ELEM2D(AST__TEXTLAB1_ID,AST__TEXTLAB2_ID)

   } else if( element == AST__TEXTLAB2_ID ){
      axis3d = 1;
      SET_ELEM2D(AST__TEXTLAB1_ID,AST__TEXTLAB2_ID)

   } else if( element == AST__TEXTLAB3_ID ){
      axis3d = 2;
      SET_ELEM2D(AST__TEXTLAB1_ID,AST__TEXTLAB2_ID)

   } else if( element == AST__TICKS1_ID ){
      axis3d = 0;
      SET_ELEM2D(AST__TICKS1_ID,AST__TICKS2_ID)

   } else if( element == AST__TICKS2_ID ){
      axis3d = 1;
      SET_ELEM2D(AST__TICKS1_ID,AST__TICKS2_ID)

   } else if( element == AST__TICKS3_ID ){
      axis3d = 2;
      SET_ELEM2D(AST__TICKS1_ID,AST__TICKS2_ID)

   } else if( element == AST__GRIDLINE1_ID ){
      axis3d = 0;
      SET_ELEM2D(AST__GRIDLINE1_ID,AST__GRIDLINE2_ID)

   } else if( element == AST__GRIDLINE2_ID ){
      axis3d = 1;
      SET_ELEM2D(AST__GRIDLINE1_ID,AST__GRIDLINE2_ID)

   } else if( element == AST__GRIDLINE3_ID ){
      axis3d = 2;
      SET_ELEM2D(AST__GRIDLINE1_ID,AST__GRIDLINE2_ID)

   } else {
      axis3d = 0;
      astError( AST__INTER, "Element2D(Plot3D): The MAKE_CLEAR2 macro "
                "does not yet support element index %d (internal "
                "AST programming error).", status, element );
   }

#undef SET_ELEM2D

   return axis3d;

}

static int Equal( AstObject *this_object, AstObject *that_object, int *status ) {
/*
*  Name:
*     Equal

*  Purpose:
*     Test if two Plot3Ds are equivalent.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Equal( AstObject *this, AstObject *that, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the astEqual protected
*     method inherited from the Plot Object class).

*  Description:
*     This function returns a boolean result (0 or 1) to indicate whether
*     two Plot3Ds are equivalent.

*  Parameters:
*     this
*        Pointer to the first Plot3D.
*     that
*        Pointer to the second Plot3D.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     One if the Plot3Ds are equivalent, zero otherwise.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global status set, or if it should fail for any reason.
*/

/* Local Variables: */
   AstPlot3D *that;         /* Pointer to the second Plot3D structure */
   AstPlot3D *this;         /* Pointer to the first Plot3D structure */
   int result;                /* Result value to return */

/* Initialise. */
   result = 0;

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

/* Invoke the Equal method inherited from the parent Plot class. This checks
   that the Plots are both of the same class (amongst other things). */
   if( (*parent_equal)( this_object, that_object, status ) ) {

/* Obtain pointers to the two Plot3D structures. */
      this = (AstPlot3D *) this_object;
      that = (AstPlot3D *) that_object;

/* Check the encapsulated Plots for equality. */
      result = ( astEqual( this->plotxz, that->plotxz ) &&
                 astEqual( this->plotyz, that->plotyz ) &&
                 astEqual( this->plotxy, that->plotxy ) );
   }

/* If an error occurred, clear the result value. */
   if ( !astOK ) result = 0;

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

static AstPointSet *ExtendTicks( AstPlot *plot, AstPointSet *ticks, int *status ){
/*
*  Name:
*     ExtendTicks

*  Purpose:
*     Add an extra tick to the start and end of a list of tick marks.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     AstPointSet *ExtendTicks( AstPlot *plot, AstPointSet *ticks, int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function takes a list of tick marks drawn using the supplied
*     Plot, and adds in an extra tick mark at the start and end of the
*     supplied list of ticks, returning the expanded list in a new
*     PointSet. The extra points are guaranteed to fall outside the area
*     enclosed within the supplied Plot.

*  Parameters:
*     plot
*        The Plot that was used to generate the list of tick marks.
*     ticks
*        A PointSet holding the 2D graphics coordinates (within the base
*        Frame of the supplied Plot) at which each tick mark starts.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a new PointSet that has 2 more entries than the
*     supplied PointSet. The first point is a new tick mark, then comes
*     all the ticks mark positions supplied in "ticks", and finally there
*     is another new tick mark.

*/

/* Local Variables: */
   AstPointSet *result;
   double **ptr_in;
   double **ptr_out;
   double *a_in;
   double *a_out;
   double *b_in;
   double *b_out;
   double *p;
   double delta;
   double hi;
   double lo;
   double range[ 2 ];
   double v;
   int axis;
   int i;
   int increasing;
   int np;

/* Check inherited status */
   if( !astOK || !ticks ) return NULL;

/* Get the number of tick marsk in the supplied PointSet and get pointers
   to the 3D Graphics values contained in the PointSet. */
   np = astGetNpoint( ticks );
   ptr_in = astGetPoints( ticks );

/* Create the returned PointSet with room for an extra pair of ticks. Get
   pointers to its data arrays */
   result = astPointSet( np + 2, 2, "", status );
   ptr_out = astGetPoints( result );

/* Check the pointers can be used safely. */
   if( astOK ) {

/* Find the index of the 2D graphics axis (0 or 1) that varies along the
   set of tick marks. We do this by finding the max and min value
   supplied for each axis, and then choosing the axis that has the highest
   range. */
      for( axis = 0; axis < 2; axis++ ) {
         hi = -DBL_MAX;
         lo = DBL_MAX;
         p = ptr_in[ axis ];

         for( i = 0; i < np; i++, p++ ) {
            v = *p;
            if( v != AST__BAD ) {
               if( v > hi ) hi = v;
               if( v < lo ) lo = v;
            }
         }

         if( lo != DBL_MAX ) {
            range[ axis ] = hi - lo;
         } else {
            astError( AST__INTER, "ExtendTicks{Plot3D): no good ticks on "
                      "axis %d (internal AST prgramming error).", status, axis );
         }
      }


/* Get the index of the axis with the largest range (the other range
   should be zero). */
      axis = ( range[ 0 ] > range[ 1 ] ) ? 0 : 1;

/* Copy the input graphics positions to the output PointSet, and add an
   extra position at the beginning and end of the output PointSet. */
      if( axis == 0 ) {
         lo = plot->xlo;
         hi = plot->xhi;
         a_in = ptr_in[ 0 ];
         b_in = ptr_in[ 1 ];
         a_out = ptr_out[ 0 ];
         b_out = ptr_out[ 1 ];

      } else {
         lo = plot->ylo;
         hi = plot->yhi;
         a_in = ptr_in[ 1 ];
         b_in = ptr_in[ 0 ];
         a_out = ptr_out[ 1 ];
         b_out = ptr_out[ 0 ];
      }

      delta = 0.2*( hi - lo );

      if( a_in[ 0 ] < a_in[ 1 ] ) {
         increasing = 1;
         *(a_out++) = lo - delta;
      } else {
         increasing = 0;
         *(a_out++) = hi + delta;
      }

      *(b_out++) = *b_in;
      for( i = 0; i < np; i++ ) {
         *(a_out++) = *(a_in++);
         *(b_out++) = *(b_in++);
      }
      *(b_out++) = b_in[ -1 ];


      if( increasing ) {
         *(a_out++) = hi + delta;
      } else {
         *(a_out++) = lo - delta;
      }
   }

/* Return the extended PointSet. */
   return result;
}

static AstFrameSet *Fset3D( AstFrameSet *fset, int ifrm, int *status ) {
/*
*  Name:
*     Fset3D

*  Purpose:
*     Create a FrameSet with no more than 3 dimensions for a given Frame.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     AstFrameSet *Fset3D( AstFrameSet *fset, int ifrm, int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function checks a specified Frame in the supplied FrameSet.
*     If the Frame has more than 3 dimensions, a new Frame is added to
*     the FrameSet containing just the first three axes of the specified
*     Frame. A PermMap is used to connect this Frame to the specified
*     Frame, which supplied bad values for any missing axes. If the
*     specified Frame is the base Frame in the supplied FrameSet, then the
*     new Frame becomes the base Frame in the returned FrameSet. Like-wise,
*     if the specified Frame is the current Frame, then the new Frame
*     will be the current Frame in the returned FrameSet.
*
*     If the specified Frame does not have more than 3 axes, then a clone
*     of the FrameSet pointer is returned, otherwise the returned pointer
*     points to a copy of the supplied FrameSet with the new 3-D Frame
*     added.

*  Parameters:
*     fset
*        Pointer to the FrameSet.
*     ifrm
*        The index of the Frame to check. This should be AST__BASE or
*        AST_CURRENT.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a FrameSet in which the Frame with index given by ifrm
*     has no more than 3 axes.
*/

/* Local Variables: */
   AstFrame *frm;
   AstFrame *newfrm;
   AstFrameSet *ret;
   AstPermMap *map;
   double zero;
   int *inperm;
   int axes[3];
   int i;
   int ic;
   int nax;

/* Check the inherited status. */
   if( !astOK ) return NULL;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   map = NULL;

/* Get a pointer to the requested Frame in the supplied FrameSet. */
   frm = astGetFrame( fset, ifrm );

/* See how many dimensions the specified Frame of the supplied FrameSet
   has. */
   nax = astGetNaxes( frm );

/* If it is more than 3-dimensionbal, create a 3D Frame by picking
   axes 1, 2 and 3 from the original Frame. */
   if( nax > 3 ) {
      axes[ 0 ] = 0;
      axes[ 1 ] = 1;
      axes[ 2 ] = 2;
      newfrm = astPickAxes( frm, 3, axes, NULL );

/* Create a PermMap to describe the mapping between the two Frames.
   Use zero as the value for unknown axes (the optional mapping which
   can be returned by astPickAxes uses AST__BAD for unknown axes). */
      inperm = (int *) astMalloc( sizeof(int)*(size_t) nax );
      if( astOK ){
         inperm[ 0 ] = 0;
         inperm[ 1 ] = 1;
         inperm[ 2 ] = 2;
         for( i = 3; i < nax; i++ ) inperm[ i ] = -1;
         zero = 0.0;
         map = astPermMap( nax, inperm, 3, axes, &zero, "", status );
         inperm = (int *) astFree( (void *) inperm );
      }

/* Get a copy of the supplied FrameSet. */
      ret = astCopy( fset );

/* Add the new Frame to the FrameSet (it becomes the current Frame). */
      ic = astGetCurrent( ret );
      astAddFrame( ret, ifrm, map, newfrm );
      newfrm = astAnnul( newfrm );

/* If the new Frame was derived from the base frame, set the new base
   Frame, and re-instate the original current Frame */
      if( ifrm == AST__BASE ){
         astSetBase( ret, astGetCurrent( ret ) );
         astSetCurrent( ret, ic );
      }

/* If the specified Frame in the supplied FrameSet is 3-dimensional, just
   return a clone of it. */
   } else {
      ret = astClone( fset );
   }

/* Annul the pointer to the original Frame. */
   frm = astAnnul( frm );

   return ret;

}

static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     GetAttrib

*  Purpose:
*     Get the value of a specified attribute for a Plot3D.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the protected astGetAttrib
*     method inherited from the FrameSet class).

*  Description:
*     This function returns a pointer to the value of a specified
*     attribute for a Plot3D, formatted as a character string.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     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 Plot3D, 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 Plot3D. 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: */
   AstPlot *plot;                /* Pointer to specific Plot */
   AstPlot3D *this;              /* Pointer to the Plot3D structure */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   char attname[50];             /* Plot attribute base name */
   char patt[50];                /* Plot attribute full name */
   char spec[10];                /* Plane specification */
   const char *result;           /* Pointer value to return */
   double dval;                  /* Floating point attribute value */
   int axis;                     /* Axis index */
   int ival;                     /* Int attribute value */
   int len;                      /* Length of attrib string */
   int nc;                       /* Number of character read */

/* 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 Plot3D structure. */
   this = (AstPlot3D *) this_object;

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

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

/* Norm(axis). */
/* ----------- */
   if ( nc = 0,
        ( 1 == astSscanf( attrib, "norm(%d)%n", &axis, &nc ) )
          && ( nc >= len ) ) {
      dval = astGetNorm( this, axis - 1 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* RootCorner. */
/* ----------- */
   } else if ( !strcmp( attrib, "rootcorner" ) ) {
      ival = astGetRootCorner( this );
      result = RootCornerString( ival, status );
      if( !result && astOK ) {
         astError( AST__INTER, "astGetAttrib(Plot3D): Illegal value %d "
                   "for RootCorner attribute (internal AST programming "
                   "error).", status, ival );
      }

/* ..._XY etc */
/* ---------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( attrib, "%[a-z]_%[xyz]%n", attname, spec,
                 &nc ) ) ) {

      if( !strcmp( spec, "xy" ) || !strcmp( spec, "yx" ) ) {
         plot = this->plotxy;
      } else if( !strcmp( spec, "xz" ) || !strcmp( spec, "zx" ) ) {
         plot = this->plotyz;
      } else if( !strcmp( spec, "yz" ) || !strcmp( spec, "zy" ) ) {
         plot = this->plotxz;
      } else {
         plot = NULL;
      }

      if( plot ) {
         sprintf( patt, "%s%s", attname, attrib + nc );
         result = astGetAttrib( plot, patt );

      } else {
         result = (*parent_getattrib)( this_object, attrib, status );
      }

/* If the attribute name was not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      result = (*parent_getattrib)( this_object, attrib, status );
   }

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

static size_t GetObjSize( AstObject *this_object, int *status ) {
/*
*  Name:
*     GetObjSize

*  Purpose:
*     Return the in-memory size of an Object.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     size_t GetObjSize( AstObject *this, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the astGetObjSize protected
*     method inherited from the parent class).

*  Description:
*     This function returns the in-memory size of the supplied Plot3D,
*     in bytes.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     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: */
   AstPlot3D *this;         /* Pointer to Plot3D structure */
   size_t result;           /* Result value to return */

/* Initialise. */
   result = 0;

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

/* Obtain a pointers to the Plot3D structure. */
   this = (AstPlot3D *) this_object;

/* Invoke the GetObjSize method inherited from the parent class, and then
   add on any components of the class structure defined by this class
   which are stored in dynamically allocated memory. */
   result = (*parent_getobjsize)( this_object, status );

   result += astGetObjSize( this->plotxy );
   result += astGetObjSize( this->plotxz );
   result += astGetObjSize( this->plotyz );

/* If an error occurred, clear the result value. */
   if ( !astOK ) result = 0;

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

static void Grid( AstPlot *this_plot, int *status ) {
/*
*  Name:
*     Grid

*  Purpose:
*     Draw a set of labelled coordinate axes.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void Grid( AstPlot *this, int *status )

*  Class Membership:
*     Plot member function (over-rides the astGrid method inherited from
*     the Plot class).

*  Description:
*     This function draws a complete annotated set of 3-dimensional
*     coordinate axes for a Plot3D with (optionally) a coordinate grid
*     superimposed.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstPlot *baseplot;
   AstPlot *plot;
   AstPlot3D *this;
   AstPointSet *majticks;
   AstPointSet *minticks;
   AstPointSet *tmp;
   AstPointSet *wcsmajticks;
   AstPointSet *wcsminticks;
   const char *edge;
   double **ptrmin;
   double **ptrmaj;
   double gcon;
   int base_wax2d;
   int itick;
   int new_gaxis;
   int new_plot;
   int new_wax2d;
   int nmaj;
   int nmin;
   int perm[ 2 ];
   int rootcorner;

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

/* Obtain a pointer to the Plot3D structure. */
   this = (AstPlot3D *) this_plot;

/* Invoke the astGrid method on the 2D base Plot. Both WCS axes in this
   Plot are inherited from the 3D FrameSet that was supplied when the Plot3D
   was constructed, and will be labelled. The other two Plots encapsulated
   in the Plot3D only inherit a single axis from the original 3D FrameSet
   (a dummy axis is used for the second WCS axis in these Plots). */
   baseplot = GET_PLOT( this->baseplot );
   astGrid( baseplot );

/* We next use astGrid to draw a grid on the 2D plane that shares the first
   base plot graphics axis. Get the identifier for this Plot and the 2D
   graphics axis index within the Plot that corresponds to the first base
   plot graphics axis. Also get the constant value on the 3rd graphics
   axis over the base plot */
   rootcorner = astGetRootCorner( this );
   if( this->baseplot == XY ) {
      new_plot = XZ;
      new_gaxis = 0;
      gcon = this->gbox[ ( rootcorner & 4 ) ? 5 : 2 ];

   } else if( this->baseplot == XZ ) {
      new_plot = XY;
      new_gaxis = 0;
      gcon = this->gbox[ ( rootcorner & 2 ) ? 4 : 1 ];

   } else {
      new_plot = XY;
      new_gaxis = 1;
      gcon = this->gbox[ ( rootcorner & 1 ) ? 3 : 0 ];
   }

/* Get a pointer to the Plot upon which astGrid is about to be invoked. */
   plot = GET_PLOT( new_plot );

/* Find which 2D WCS axis was labelled on graphics axis 0 (the bottom or
   top edge) of the base plot. */
   if( ( edge = astGetC( baseplot, "Edge(1)" ) ) ) {
      base_wax2d = ( !strcmp( edge, "bottom" ) || !strcmp( edge, "top" ) ) ? 0 : 1;
   } else {
      base_wax2d = 0;
   }

/* Get the 2D graphics coords within the base Plot at which the tick
   marks were drawn for this 2D WCS axis. Extend the PointSets holding
   the major tick values to include an extra tick above and below the
   ticks drawn by astGrid. These extra ticks are placed outside the
   bounds of the plot. This ensures that the curves on the other axis
   extend the full width of the plot. */
   tmp = astGetDrawnTicks( baseplot, base_wax2d, 1 );
   if( tmp ) {
      majticks = ExtendTicks( baseplot, tmp, status );
      nmaj = astGetNpoint( majticks );
      ptrmaj = astGetPoints( majticks );
      tmp = astAnnul( tmp );
   } else {
      majticks = NULL;
      nmaj = 0;
      ptrmaj = NULL;
   }

   minticks = astGetDrawnTicks( baseplot, base_wax2d, 0 );
   if( minticks ) {
      nmin = astGetNpoint( minticks );
      ptrmin = astGetPoints( minticks );
   } else {
      nmin = 0;
      ptrmin = NULL;
   }

/* All the tick marks will have a constant value for the 2D graphics axis
   that is not being ticked (axis 1 at the moment). Change this constant
   value to be the value appropriate to the new Plot. */
   if( ptrmaj && ptrmin ) {
      for( itick = 0; itick < nmaj; itick++ ) ptrmaj[ 1 ][ itick ] = gcon;
      for( itick = 0; itick < nmin; itick++ ) ptrmin[ 1 ][ itick ] = gcon;
   }

/* If required, permute the axes in the tick mark positions. */
   if( new_gaxis != 0 ) {
      perm[ 0 ] = 1;
      perm[ 1 ] = 0;
      if( majticks ) astPermPoints( majticks, 1, perm );
      if( minticks ) astPermPoints( minticks, 1, perm );
   }

/* Transform the tick mark positions from 2D graphics coords to 2D WCS
   coords. */
   wcsmajticks = majticks ? astTransform( plot, majticks, 1, NULL ) : NULL;
   wcsminticks = minticks ? astTransform( plot, minticks, 1, NULL ) : NULL;

/* Find the index of the 2D WCS axis that will be labelled on the bottom
   or top edge (i.e. 2D graphics axis zero) of the new Plot. */
   if( ( edge = astGetC( plot, "Edge(1)" ) ) ) {
      new_wax2d = ( !strcmp( edge, "bottom" ) || !strcmp( edge, "top" ) ) ? 0 : 1;
   } else {
      new_wax2d = 0;
   }

/* Use the other WCS axis if we are ticking the left or right edge (i.e.
   2D graphics axis one) of the new Plot. This gives us the index of the
   2D WCS axis for which tick values are to be stored in the Plot. */
   if( new_gaxis == 1 ) new_wax2d = 1 - new_wax2d;

/* Store the tick mark values to be used on this WCS axis. */
   ptrmaj = wcsmajticks ? astGetPoints( wcsmajticks ) : NULL;
   ptrmin = wcsminticks ? astGetPoints( wcsminticks ) : NULL;
   if( ptrmaj && ptrmin ) {
      astSetTickValues( plot, new_wax2d, nmaj, ptrmaj[ new_gaxis ],
                                         nmin, ptrmin[ new_gaxis ] );
   }

/* Invoke the astGrid method on this plot. */
   astGrid( plot );

/* Clear the stored tick values in the plot. */
   astSetTickValues( plot, new_wax2d, 0, NULL, 0, NULL );

/* Free resources */
   if( wcsmajticks ) wcsmajticks = astAnnul( wcsmajticks );
   if( wcsminticks ) wcsminticks = astAnnul( wcsminticks );
   if( majticks ) majticks = astAnnul( majticks );
   if( minticks ) minticks = astAnnul( minticks );

/* We next use astGrid to draw a grid on the 2D plane that shares the
   second base plot graphics axis. Get the identifier for this Plot and the
   2D graphics axis index within the Plot that corresponds to the first
   base plot graphics axis. */
   if( this->baseplot == XY ) {
      new_plot = YZ;
      new_gaxis = 0;

   } else if( this->baseplot == XZ ) {
      new_plot = YZ;
      new_gaxis = 1;

   } else {
      new_plot = XZ;
      new_gaxis = 1;
   }

/* Get a pointer to the Plot upon which astGrid is about to be invoked. */
   plot = GET_PLOT( new_plot );

/* Find which 2D WCS axis was labelled on graphics axis 1 (the left or
   right edge) of the base plot. */
   base_wax2d = 1 - base_wax2d;

/* Get the 2D graphics coords within the base Plot at which the tick
   marks were drawn for this 2D WCS axis. Extend the PointSets holding
   the major tick values to include an extra tick above and below the
   ticks drawn by astGrid. These extra ticks are placed outside the
   bounds of the plot. This ensures that the curves on the other axis
   extend the full width of the plot. */
   tmp = astGetDrawnTicks( baseplot, base_wax2d, 1 );
   if( tmp ) {
      majticks = ExtendTicks( baseplot, tmp, status );
      nmaj = astGetNpoint( majticks );
      ptrmaj = astGetPoints( majticks );
      tmp = astAnnul( tmp );
   } else {
      majticks = NULL;
      nmaj = 0;
      ptrmaj = NULL;
   }

   minticks = astGetDrawnTicks( baseplot, base_wax2d, 0 );
   if( minticks ) {
      nmin = astGetNpoint( minticks );
      ptrmin = astGetPoints( minticks );
   } else {
      nmin = 0;
      ptrmin = NULL;
   }

/* All the tick marks will have a constant value for the 2D graphics axis
   that is not being ticked (axis 0 at the moment). Change this constant
   value to be the value appropriate to the new Plot. */
   if( ptrmaj && ptrmin ) {
      for( itick = 0; itick < nmaj; itick++ ) ptrmaj[ 0 ][ itick ] = gcon;
      for( itick = 0; itick < nmin; itick++ ) ptrmin[ 0 ][ itick ] = gcon;
   }

/* If required, permute the axes in the tick mark positions. */
   if( new_gaxis != 1 ) {
      perm[ 0 ] = 1;
      perm[ 1 ] = 0;
      if( majticks ) astPermPoints( majticks, 1, perm );
      if( minticks ) astPermPoints( minticks, 1, perm );
   }

/* Transform the tick mark positions from 2D graphics coords to 2D WCS
   coords. */
   wcsmajticks = majticks ? astTransform( plot, majticks, 1, NULL ) : NULL;
   wcsminticks = minticks ? astTransform( plot, minticks, 1, NULL ) : NULL;

/* Find the index of the 2D WCS axis that will be labelled on the bottom
   or top edge (i.e. 2D graphics axis zero) of the new Plot. */
   if( ( edge = astGetC( plot, "Edge(1)" ) ) ) {
      new_wax2d = ( !strcmp( edge, "bottom" ) || !strcmp( edge, "top" ) ) ? 0 : 1;
   } else {
      new_wax2d = 0;
   }

/* Use the other WCS axis if we are ticking the left or right edge (i.e.
   2D graphics axis one) of the new Plot. This gives us the index of the
   2D WCS axis for which tick values are to be stored in the Plot. */
   if( new_gaxis == 1 ) new_wax2d = 1 - new_wax2d;

/* Store the tick mark values to be used on this WCS axis. */
   ptrmaj = wcsmajticks ? astGetPoints( wcsmajticks ) : NULL;
   ptrmin = wcsminticks ? astGetPoints( wcsminticks ) : NULL;
   if( ptrmaj && ptrmin ) {
      astSetTickValues( plot, new_wax2d, nmaj, ptrmaj[ new_gaxis ],
                                         nmin, ptrmin[ new_gaxis ] );
   }

/* Invoke the astGrid method on this plot. */
   astGrid( plot );

/* Clear the stored tick values in the plot. */
   astSetTickValues( plot, new_wax2d, 0, NULL, 0, NULL );

/* Free resources */
   if( wcsmajticks ) wcsmajticks = astAnnul( wcsmajticks );
   if( wcsminticks ) wcsminticks = astAnnul( wcsminticks );
   if( majticks ) majticks = astAnnul( majticks );
   if( minticks ) minticks = astAnnul( minticks );

}

void astInitPlot3DVtab_(  AstPlot3DVtab *vtab, const char *name, int *status ) {
/*
*+
*  Name:
*     astInitPlot3DVtab

*  Purpose:
*     Initialise a virtual function table for a Plot3D.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot3d.h"
*     void astInitPlot3DVtab( AstPlot3DVtab *vtab, const char *name )

*  Class Membership:
*     Plot3D vtab initialiser.

*  Description:
*     This function initialises the component of a virtual function
*     table which is used by the Plot3D 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 */
   AstFrame *dummy_frame;      /* The Frame to put in dummy_frameset */
   AstPlotVtab *plot;          /* Pointer to Plot component of Vtab */
   AstFrameSetVtab *fset;      /* Pointer to FrameSet 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. */
   astInitPlotVtab( (AstPlotVtab *) vtab, name );

/* Store a unique "magic" value in the virtual function table. This
   will be used (by astIsAPlot3D) 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 = &(((AstPlotVtab *) vtab)->id);

/* Initialise member function pointers. */
/* ------------------------------------ */
/* Store pointers to the member functions (implemented here) that
   provide virtual methods for this class. */

#define SET_PLOT3D_ACCESSORS(attr) \
   vtab->Set##attr = Set##attr; \
   vtab->Get##attr = Get##attr; \
   vtab->Test##attr = Test##attr; \
   vtab->Clear##attr = Clear##attr;

SET_PLOT3D_ACCESSORS(RootCorner)
SET_PLOT3D_ACCESSORS(Norm)

#undef SET_PLOT3D_ACCESSORS




/* Save the inherited pointers to methods that will be extended, and
   replace them with pointers to the new member functions. */
   object = (AstObjectVtab *) vtab;
   fset = (AstFrameSetVtab *) vtab;
   mapping = (AstMappingVtab *) vtab;
   plot = (AstPlotVtab *) vtab;

   parent_getobjsize = object->GetObjSize;
   object->GetObjSize = GetObjSize;

   parent_equal = object->Equal;
   object->Equal = Equal;

   parent_vset = object->VSet;
   object->VSet = VSet;

   parent_cast = object->Cast;
   object->Cast = Cast;

   parent_clear = object->Clear;
   object->Clear = Clear;

   parent_clearattrib = object->ClearAttrib;
   object->ClearAttrib = ClearAttrib;

   parent_getattrib = object->GetAttrib;
   object->GetAttrib = GetAttrib;

   parent_setattrib = object->SetAttrib;
   object->SetAttrib = SetAttrib;

   parent_testattrib = object->TestAttrib;
   object->TestAttrib = TestAttrib;

   parent_clearcurrent = fset->ClearCurrent;
   fset->ClearCurrent = ClearCurrent;

   parent_setcurrent = fset->SetCurrent;
   fset->SetCurrent = SetCurrent;

   parent_removeframe = fset->RemoveFrame;
   fset->RemoveFrame = RemoveFrame;

#if defined(THREAD_SAFE)
   parent_managelock = object->ManageLock;
   object->ManageLock = ManageLock;
#endif

/* Define a macro to override attribute accessors inherited from the
   parent Plot class. First do axis specific attributes. */

#define SET_PLOT_ACCESSORS(attr) \
   parent_get##attr = plot->Get##attr; \
   plot->Get##attr = Get##attr; \
   parent_set##attr = plot->Set##attr; \
   plot->Set##attr = Set##attr; \
   parent_clear##attr = plot->Clear##attr; \
   plot->Clear##attr = Clear##attr;

/* Use the above macro to override all the inherited attribute accessors. */
SET_PLOT_ACCESSORS(MinTick)
SET_PLOT_ACCESSORS(Abbrev)
SET_PLOT_ACCESSORS(Gap)
SET_PLOT_ACCESSORS(LogGap)
SET_PLOT_ACCESSORS(LogPlot)
SET_PLOT_ACCESSORS(LogTicks)
SET_PLOT_ACCESSORS(LogLabel)
SET_PLOT_ACCESSORS(LabelUp)
SET_PLOT_ACCESSORS(DrawAxes)
SET_PLOT_ACCESSORS(LabelUnits)
SET_PLOT_ACCESSORS(MinTickLen)
SET_PLOT_ACCESSORS(MajTickLen)
SET_PLOT_ACCESSORS(NumLab)
SET_PLOT_ACCESSORS(NumLabGap)
SET_PLOT_ACCESSORS(TextLab)
SET_PLOT_ACCESSORS(TextLabGap)

#undef SET_PLOT_ACCESSORS


/* Now do attributes that are not axis specific. */

#define SET_PLOT_ACCESSORS(attr) \
   parent_set##attr = plot->Set##attr; \
   plot->Set##attr = Set##attr; \
   parent_clear##attr = plot->Clear##attr; \
   plot->Clear##attr = Clear##attr;

SET_PLOT_ACCESSORS(Ink)
SET_PLOT_ACCESSORS(Tol)
SET_PLOT_ACCESSORS(Invisible)
SET_PLOT_ACCESSORS(TickAll)
SET_PLOT_ACCESSORS(ForceExterior)
SET_PLOT_ACCESSORS(Border)
SET_PLOT_ACCESSORS(Clip)
SET_PLOT_ACCESSORS(ClipOp)
SET_PLOT_ACCESSORS(Escape)
SET_PLOT_ACCESSORS(Grid)
SET_PLOT_ACCESSORS(Labelling)
SET_PLOT_ACCESSORS(Style)
SET_PLOT_ACCESSORS(Font)
SET_PLOT_ACCESSORS(Colour)
SET_PLOT_ACCESSORS(Width)
SET_PLOT_ACCESSORS(Size)

#undef SET_PLOT_ACCESSORS


/* Store replacement pointers for methods which will be over-ridden by new
   member functions implemented here. */
   plot->Grid = Grid;
   plot->Text = Text;
   plot->SetTickValues = SetTickValues;
   plot->PolyCurve = PolyCurve;
   plot->Border = Border;
   plot->BoundingBox = BoundingBox;
   plot->GetGrfContext = GetGrfContext;
   plot->GrfPop = GrfPop;
   plot->GrfPush = GrfPush;
   plot->GrfSet = GrfSet;
   plot->GridLine = GridLine;
   plot->Mark = Mark;
   plot->Curve = Curve;
   plot->GenCurve = GenCurve;
   plot->Clip = Clip;
   mapping->Transform = Transform;

/* Declare the copy constructor, destructor and class dump
   function. */
   astSetCopy( vtab, Copy );
   astSetDelete( vtab, Delete );
   astSetDump( vtab, Dump, "Plot3D", "Provide facilities for 3D graphical output" );

/* Create a FrameSet that can be used when calling astCast to indicate
   the class to which we want to cast. */
   LOCK_MUTEX3
   if( !dummy_frameset ) {
      dummy_frame = astFrame( 1, " ", status );
      dummy_frameset = astFrameSet( dummy_frame, " ", status );
      dummy_frame = astAnnul( dummy_frame );
   }
   UNLOCK_MUTEX3

/* If we have just initialised the vtab for the current class, indicate
   that the vtab is now initialised, and store a pointer to the class
   identifier in the base "object" level of the vtab. */
   if( vtab == &class_vtab ) {
      class_init = 1;
      astSetVtabClassIdentifier( vtab, &(vtab->id) );
   }
}

#if defined(THREAD_SAFE)
static int ManageLock( AstObject *this_object, int mode, int extra,
                       AstObject **fail, int *status ) {
/*
*  Name:
*     ManageLock

*  Purpose:
*     Manage the thread lock on an Object.

*  Type:
*     Private function.

*  Synopsis:
*     #include "object.h"
*     AstObject *ManageLock( AstObject *this, int mode, int extra,
*                            AstObject **fail, int *status )

*  Class Membership:
*     CmpMap 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: */
   AstPlot3D *this;       /* Pointer to Plot3D 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 Plot3D structure. */
   this = (AstPlot3D *) 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->plotxy, mode, extra, fail );
   if( !result ) result = astManageLock( this->plotxz, mode, extra, fail );
   if( !result ) result = astManageLock( this->plotyz, mode, extra, fail );

   return result;

}
#endif

static void Mark( AstPlot *this_plot, int nmark, int ncoord, int indim,
                  const double *in, int type, int *status ){
/*
*  Name:
*     Mark

*  Purpose:
*     Draw a set of markers for a Plot3D.

*  Type:
*     Private member function.

*  Synopsis:
*     #include "plot3d.h"
*     void Mark( AstPlot *this, int nmark, int ncoord, int indim,
*                const double *in, int type, int *status )

*  Class Membership:
*     Plot3d member function (overrides the astMark method inherited form
*     the parent Plot class).

*  Description:
*     This function draws a set of markers (symbols) at positions
*     specified in the physical coordinate system of a Plot3D. The
*     positions are transformed into graphical coordinates to
*     determine where the markers should appear within the plotting
*     area.
*
*     They are drawn on a 2D plane that has a normal vector given by the
*     current value of the Plot3D's "Norm" attribute.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     nmark
*        The number of markers to draw. This may be zero, in which
*        case nothing will be drawn.
*     ncoord
*        The number of coordinates being supplied for each mark
*        (i.e. the number of axes in the current Frame of the Plot, as
*        given by its Naxes attribute).
*     indim
*        The number of elements along the second dimension of the "in"
*        array (which contains the marker coordinates). This value is
*        required so that the coordinate values can be correctly
*        located if they do not entirely fill this array. The value
*        given should not be less than "nmark".
*     in
*        The address of the first element of a 2-dimensional array of
*        shape "[ncoord][indim]" giving the
*        physical coordinates of the points where markers are to be
*        drawn. These should be stored such that the value of
*        coordinate number "coord" for input mark number "mark" is
*        found in element "in[coord][mark]".
*     type
*        A value specifying the type (e.g. shape) of marker to be
*        drawn. The set of values which may be used (and the shapes
*        that will result) is determined by the underlying graphics
*        system.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - Markers are not drawn at positions which have any coordinate
*     equal to the value AST__BAD (or where the transformation into
*     graphical coordinates yields coordinates containing the value
*     AST__BAD).
*     - An error results if the base Frame of the Plot is not 3-dimensional.
*     - An error also results if the transformation between the
*     current and base Frames of the Plot is not defined (i.e. the
*     Plot's TranInverse attribute is zero).
*/

/* Local Variables: */
   AstMapping *mapping;    /* Pointer to graphics->physical mapping */
   AstPlot3D *this;        /* Pointer to the Plot3D structure */
   AstPointSet *pset1;     /* PointSet holding physical positions */
   AstPointSet *pset2;     /* PointSet holding graphics positions */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   const double **ptr1;    /* Pointer to physical positions */
   double **ptr2;          /* Pointer to graphics positions */
   double *xpd;            /* Pointer to next double precision x value */
   double *ypd;            /* Pointer to next double precision y value */
   double *zpd;            /* Pointer to next double precision z value */
   float *x;               /* Pointer to single precision x values */
   float *xpf;             /* Pointer to next single precision x value */
   float *y;               /* Pointer to single precision y values */
   float *ypf;             /* Pointer to next single precision y value */
   float *z;               /* Pointer to single precision z values */
   float *zpf;             /* Pointer to next single precision z value */
   float norm[ 3 ];        /* Single precision normal vector */
   int axis;               /* Axis index */
   int i;                  /* Loop count */
   int naxes;              /* No. of axes in the base Frame */
   int nn;                 /* Number of good marker positions */

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

/* Get a pointer to the Plot3D structure. */
   this = (AstPlot3D *) this_plot;

/* Store the current method and class for inclusion in error messages
   generated by lower level functions. */
   method = "astMark";
   class = astClass( this );

/* Check the base Frame of the Plot is 3-D. */
   naxes = astGetNin( this );
   if( naxes != 3 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 3.", status, method, class, naxes, class );
   }

/* Also validate the input array dimension argument. */
   if ( astOK && ( indim < nmark ) ) {
      astError( AST__DIMIN, "%s(%s): The input array dimension value "
                "(%d) is invalid.", status, method, class, indim );
      astError( AST__DIMIN, "This should not be less than the number of "
                "markers being drawn (%d).", status, nmark );
   }

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
   astGrfAttrs( this, AST__MARKS_ID, 1, GRF__MARK, method, class );

/* Create a PointSet to hold the supplied physical coordinates. */
   pset1 = astPointSet( nmark, ncoord, "", status );

/* Allocate memory to hold pointers to the first value on each axis. */
   ptr1 = (const double **) astMalloc( sizeof( const double * )*
                                       (size_t)( ncoord ));

/* Check the pointer can be used, then store pointers to the first value
   on each axis. */
   if( astOK ){
      for( axis = 0; axis < ncoord; axis++ ){
         ptr1[ axis ] = in + axis*indim;
      }
   }

/* Store these pointers in the PointSet. */
   astSetPoints( pset1, (double **) ptr1 );

/* Transform the supplied data from the current frame (i.e. physical
   coordinates) to the base frame (i.e. graphics coordinates) using
   the inverse Mapping defined by the Plot. */
   mapping = astGetMapping( this, AST__BASE, AST__CURRENT );
   pset2 = astTransform( mapping, pset1, 0, NULL );
   mapping = astAnnul( mapping );

/* Get pointers to the graphics coordinates. */
   ptr2 = astGetPoints( pset2 );

/* Allocate memory to hold single precision versions of the graphics
   coordinates. */
   x = (float *) astMalloc( sizeof( float )*(size_t) nmark );
   y = (float *) astMalloc( sizeof( float )*(size_t) nmark );
   z = (float *) astMalloc( sizeof( float )*(size_t) nmark );

/* Check the pointers can be used. */
   if( astOK ){

/* Store pointers to the next single and double precision x, y and z
   values. */
      xpf = x;
      ypf = y;
      zpf = z;
      xpd = ptr2[ 0 ];
      ypd = ptr2[ 1 ];
      zpd = ptr2[ 2 ];

/* Convert the double precision values to single precision, rejecting
   any bad marker positions. */
      nn = 0;
      for( i = 0; i < nmark; i++ ){
         if( *xpd != AST__BAD && *ypd != AST__BAD && *zpd != AST__BAD ){
            nn++;
            *(xpf++) = (float) *(xpd++);
            *(ypf++) = (float) *(ypd++);
            *(zpf++) = (float) *(zpd++);
         } else {
            xpd++;
            ypd++;
            zpd++;
         }
      }

/* If the nornmal vector has non-zero length, draw the remaining markers. */
      norm[ 0 ] = (float) astGetNorm( this, 0 );
      norm[ 1 ] = (float) astGetNorm( this, 1 );
      norm[ 2 ] = (float) astGetNorm( this, 2 );

      if( norm[ 0 ] != 0.0 || norm[ 1 ] != 0.0 || norm[ 2 ] != 0.0 ){

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
         LOCK_MUTEX2;

         if( !astG3DMark( nn, x, y, z, type, norm ) ) {
            astError( AST__GRFER, "%s(%s): Graphics error in astG3DMark. ", status,
                   method, class );
         }

/* Allow the next thread to proceed. */
         UNLOCK_MUTEX2;

      } else if( astOK ) {
         astError( AST__ATTIN, "%s(%s): The vector specified by the Norm "
                   "attribute has zero length.", status, method, class );
      }
   }

/* Free the memory used to store single precision graphics coordinates. */
   x = (float *) astFree( (void *) x );
   y = (float *) astFree( (void *) y );
   z = (float *) astFree( (void *) z );

/* Annul the PointSets. */
   pset1 = astAnnul( pset1 );
   pset2 = astAnnul( pset2 );

/* Free the memory holding the pointers to the first value on each axis. */
   ptr1 = (const double **) astFree( (void *) ptr1 );

/* Re-establish the original graphical attributes. */
   astGrfAttrs( this, AST__MARKS_ID, 0, GRF__MARK, method, class );

/* Return */
   return;
}

static int Plot3DAttr( AstKeyMap *grfconID, int attr, double value,
                       double *old_value, int prim ){
/*
*  Name:
*     Plot3DAttr

*  Purpose:
*     Get or set the value of a 3D grf attribute.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Plot3DAttr( AstKeyMap *grfconID, int attr, double value,
*                     double *old_value, int prim )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     get or set the current value of a specified graphics attribute. It
*     forwards the call to the grf3D module being used by this Plot3D. It
*     should be registered with each of the 2D Plots using astGrfSet.

*  Parameters:
*     grfconID
*       The Plot's GrfContext KeyMap. This is used to identify which of
*       the three Plots is calling this function.
*     attr
*       An integer value identifying the required attribute. This should
*       be one of the symbolic values defined in grf.h.
*     value
*       A new value to store for the attribute. If this is AST__BAD
*       no value is stored.
*     old_value
*       A pointer to a double in which to return the attribute value.
*       If this is NULL, no value is returned.
*     prim
*       The sort of graphics primitive to be drawn with the new attribute.
*       Identified by one of the values defined in grf.h.

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

/* Local Variables: */
   int result;
   int *status;

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

/* Check the inherited status. */
   if( !astOK ) return 0;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* Use the function in the external Grf3D module, selected at link-time
   using ast_link options. Note, attribute values are the same for each
   of the three Plot. */
   result = astG3DAttr( attr, value, old_value, prim );

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

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

static int Plot3DCap( AstKeyMap *grfconID, int cap, int value ){
/*
*  Name:
*     Plot3DCap

*  Purpose:
*     Determine if the 3D grf module has a given capability.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Plot3DCap( AstKeyMap *grfconID, int cap, int value )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     determine if a given graphics capability is available. It forwards
*     the call to the grf3D module being used by this Plot3D. It should be
*     registered with each of the 2D Plots using astGrfSet.

*  Parameters:
*     grfconID
*       The Plot's GrfContext KeyMap. This is
*       used to identify which of the three Plots is calling this function.
*     cap
*       The capability being inquired about. This will be one of the
*       following constants defined in grf.h: GRF__SCALES, GRF__MJUST,
*       GRF__ESC,
*     value
*       The use of this parameter depends on the value of "cap" as
*       described in the documentation for the astGrfSet function in the
*       Plot class.

*  Returned Value:
*     The value returned by the function depends on the value of "cap"
*     as described in the astGrfSet documentation. Zero is returned if
*     the supplied capability is not recognised.

*/

/* Local Variables: */
   int result;
   int *status;

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

/* Check the inherited status. */
   if( !astOK ) return 0;

/* The astGScales function is implemented by code within the Plot3D class
   (not within the grf3D module). The Plot3D class assumes all axes are
   equally scaled. */
   if( cap == GRF__SCALES ) {
      result = 1;

/* All grf3D modules are assumed to support "M" justification. */
   } else if( cap == GRF__MJUST ) {
      result = 1;

/* Forward all other capability requests to the grf3D module. */
   } else {

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
      LOCK_MUTEX2;

      result = astG3DCap( cap, value );

/* Allow the next thread to proceed. */
      UNLOCK_MUTEX2;
   }

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

static int Plot3DFlush( AstKeyMap *grfconID ){
/*
*  Name:
*     Plot3DFlush

*  Purpose:
*     Flush any buffered graphical output.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Plot3DFlush( AstKeyMap *grfconID )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     ensure that the display device is up-to-date by flushing any pending
*     graphics to the output device. It forwards the call to the grf3D module
*     being used by this Plot3D. It should be registered with each of the
*     2D Plots using astGrfSet.

*  Parameters:
*     grfconID
*       The Plot's GrfContext KeyMap. This is
*       used to identify which of the three Plots is calling this function.

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

/* Local Variables: */
   int result;
   int *status;

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

/* Check the inherited status. */
   if( !astOK ) return 0;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* Use the function in the external Grf3D module, selected at link-time
   using ast_link options. */
   result = astG3DFlush();

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

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

static int Plot3DLine( AstKeyMap *grfconID, int n, const float *x, const float *y ){
/*
*  Name:
*     Plot3DLine

*  Purpose:
*     Draw a polyline on a 2D surface.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Plot3DLine( AstKeyMap *grfconID, int n, const float *x,
*                     const float *y )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     draw a polyline. It forwards the call to the grf3D module being used
*     by this Plot3D. It should be registered with each of the 2D Plots
*     using astGrfSet.

*  Parameters:
*     grfconID
*       The Plot's GrfContext KeyMap. This is
*       used to identify which of the three Plots is calling this function.
*     n
*       The number of positions to be joined together.
*     x
*       A pointer to an array holding the "n" x values.
*     y
*       A pointer to an array holding the "n" y values.

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

/* Local Variables: */
   AstKeyMap *grfcon;
   double gcon;
   float *work;
   float *x3d = NULL;
   float *y3d = NULL;
   float *z3d = NULL;
   int i;
   int plane;
   int result = 0;
   int *status;

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

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

/* Get a genuine pointer from the supplied grfcon identifier. */
   grfcon = astMakePointer( grfconID );

/* Report an error if no grfcon object was supplied. */
   if( !grfcon ) {
      astError( AST__INTER, "astG3DLine(Plot3D): No grfcon Object supplied "
                "(internal AST programming error)." , status);

/* If a grfcon Object was supplied, get the graphics box array out of it. */
   } else if( !astMapGet0D( grfcon, "Gcon", &gcon ) ) {
      astError( AST__INTER, "astG3DLine(Plot3D): No \"Gcon\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* Also get the plane index out of it. */
   } else if( !astMapGet0I( grfcon, "Plane", &plane ) ) {
      astError( AST__INTER, "astG3DLine(Plot3D): No \"Plane\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);
   }

/* Allocate memory to hold the "n" values for the missing coordinate. */
   work = astMalloc( sizeof( float )*(size_t) n );
   if( work ) {

/* Set up pointers to the x, y and z arrays in the 3D graphics system.
   Fill the missing array with suitable values (the constant value of
   the third axis on the plane being drawn). */
      if( plane == XY ) {
         x3d = (float *) x;
         y3d = (float *) y;
         z3d = work;

         for( i = 0; i < n; i++ ) z3d[ i ] = gcon;

      } else if( plane == XZ ) {
         x3d = (float *) x;
         y3d = work;
         z3d = (float *) y;
         for( i = 0; i < n; i++ ) y3d[ i ] = gcon;

      } else if( plane == YZ ) {
         x3d = work;
         y3d = (float *) x;
         z3d = (float *) y;
         for( i = 0; i < n; i++ ) x3d[ i ] = gcon;

      } else {
         astError( AST__INTER, "astG3DLine(Plot3D): Illegal plane "
                   "identifier %d supplied (internal AST programming "
                   "error).", status, plane );
      }

/* If ok, draw the lines in the 3D graphics coordinate space. */
      if( x3d ) {

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
         LOCK_MUTEX2;

/* Draw the line */
         result = astG3DLine( n, x3d, y3d, z3d );

/* Allow the next thread to proceed. */
         UNLOCK_MUTEX2;
      }
   }

/* Free resources. */
   work = astFree( work );

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

static int Plot3DMark( AstKeyMap *grfconID, int n, const float *x,
                       const float *y, int type ){
/*
*  Name:
*     Plot3DMark

*  Purpose:
*     Draw a set of markers.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Plot3DMark( AstKeyMap *grfconID, int n, const float *x,
*                     const float *y, int type )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     draw a set of markers. It forwards the call to the grf3D module being
*     used by this Plot3D. It should be registered with each of the 2D Plots
*     using astGrfSet.

*  Parameters:
*     grfconID
*       The Plot's GrfContext KeyMap. This is
*       used to identify which of the three Plots is calling this function.
*     n
*       The number of markers to draw.
*     x
*       A pointer to an array holding the "n" x values.
*     y
*       A pointer to an array holding the "n" y values.
*     type
*       An integer which can be used to indicate the type of marker symbol
*       required.

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

/* Local Variables: */
   AstKeyMap *grfcon;
   double gcon;
   float *work;
   float *x3d = NULL;
   float *y3d = NULL;
   float *z3d = NULL;
   float norm[ 3 ];
   int i;
   int plane;
   int rc;
   int result = 0;
   int *status;

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

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

/* Get a genuine pointer from the supplied grfcon identifier. */
   grfcon = astMakePointer( grfconID );

/* Report an error if no grfcon object was supplied. */
   if( !grfcon ) {
      astError( AST__INTER, "astG3DMark(Plot3D): No grfcon Object supplied "
                "(internal AST programming error)." , status);

/* If a grfcon Object was supplied, get the graphics box array out of it. */
   } else if( !astMapGet0D( grfcon, "Gcon", &gcon ) ) {
      astError( AST__INTER, "astG3DMark(Plot3D): No \"Gcon\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* If a grfcon Object was supplied, get the RootCorner value out of it. */
   } else if( !astMapGet0I( grfcon, "RootCorner", &rc ) ) {
      astError( AST__INTER, "astG3DLine(Plot3D): No \"RootCornern\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* Also get the plane index out of it. */
   } else if( !astMapGet0I( grfcon, "Plane", &plane ) ) {
      astError( AST__INTER, "astG3DMark(Plot3D): No \"Plane\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);
   }

/* Allocate memory to hold the "n" values for the missing coordinate. */
   work = astMalloc( sizeof( float )*(size_t) n );
   if( work ) {

/* Set up pointers to the x, y and z arrays in the 3D graphics system.
   Fill the missing array with suitable values (the constant value of
   the third axis on the plane being drawn). Set the normal vector for
   the markers so that they are drawn in the plane described by the Plot.*/
      if( plane == XY ) {
         x3d = (float *) x;
         y3d = (float *) y;
         z3d = work;
         for( i = 0; i < n; i++ ) z3d[ i ] = gcon;
         norm[ 0 ] = 0;
         norm[ 1 ] = 0;
         norm[ 2 ] = ( rc & 4 ) ? 1 : -1;

      } else if( plane == XZ ) {
         x3d = (float *) x;
         y3d = work;
         z3d = (float *) y;
         for( i = 0; i < n; i++ ) y3d[ i ] = gcon;
         norm[ 0 ] = 0;
         norm[ 1 ] = ( rc & 2 ) ? 1 : -1;
         norm[ 2 ] = 0;

      } else if( plane == YZ ) {
         x3d = work;
         y3d = (float *) x;
         z3d = (float *) y;
         for( i = 0; i < n; i++ ) x3d[ i ] = gcon;
         norm[ 0 ] = ( rc & 1 ) ? 1 : -1;
         norm[ 1 ] = 0;
         norm[ 2 ] = 0;

      } else {
         astError( AST__INTER, "astG3DMark(Plot3D): Illegal plane "
                   "identifier %d supplied (internal AST programming "
                   "error).", status, plane );
      }

/* If ok, draw the markers in the 3D graphics coordinate space. */
      if( x3d ) {

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
         LOCK_MUTEX2;

/* Draw the markers */
         result = astG3DMark( n, x3d, y3d, z3d, type, norm );

/* Allow the next thread to proceed. */
         UNLOCK_MUTEX2;
      }
   }

/* Free resources. */
   work = astFree( work );

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

static int Plot3DQch( AstKeyMap *grfconID, float *chv, float *chh ){
/*
*  Name:
*     Plot3DQch

*  Purpose:
*     Get the current text size.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Plot3DQch( AstKeyMap *grfconID, float *chv, float *chh )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     get the current text size. It forwards the call to the grf3D module
*     being used by this Plot3D. It should be registered with each of the
*     2D Plots using astGrfSet.
*
*     The grf3D module assumes that the 3D graphics axes are equally
*     scaled and therefore the text height does not depend on the text
*     orientation. Therefore, "chv" and "chh" are returned holding the
*     same value.

*  Parameters:
*     grfconID
*       The Plot's GrfContext KeyMap. This is
*       used to identify which of the three Plots is calling this function.
*     chv
*        A pointer to the float which is to receive the height of
*        characters drawn with a vertical baseline in the 2D Plot. This
*        will be an increment in the 2D X axis.
*     chh
*       A pointer to the float which is to receive the height of
*       characters drawn with a horizontal baseline in the 2D Plot. This
*       will be an increment in the 2D Y axis.

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

/* Local Variables: */
   int result;
   float ch;
   int *status;

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

/* Check the inherited status. */
   if( !astOK ) return 0;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* Use the function in the external Grf3D module, selected at link-time
   using ast_link options. Note, text height is the same for each
   of the three Plot. */
   result = astG3DQch( &ch );

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Store the value in both the returned values. */
   *chv = ch;
   *chh = ch;

/* Return the error flag. */
   return result;
}

static int Plot3DScales( AstKeyMap *grfconID, float *alpha, float *beta ){
/*
*  Name:
*     Plot3DScales

*  Purpose:
*     Get the 2D axis scales.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*      int Plot3DScales( AstKeyMap *grfconID, float *alpha, float *beta )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     get the relative scales of the 2D axes. Since the grf3D module
*     assumes that all graphics axes are equally scaled, it just returns 1.0
*     for alpha and beta.

*  Parameters:
*     grfconID
*       The Plot's GrfContext KeyMap. This is
*       used to identify which of the three Plots is calling this function.
*     alpha
*       A pointer to the float which is to receive the scale for the X
*       axis
*     beta
*       A pointer to the float which is to receive the scale for the Y
*       axis

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

   *alpha = 1.0;
   *beta = 1.0;
   return 1;
}

static int Plot3DText( AstKeyMap *grfconID, const char *text, float x, float y,
                       const char *just, float upx, float upy ){
/*
*  Name:
*     Plot3DText

*  Purpose:
*     Draw a text string.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Plot3DText( AstKeyMap *grfconID, const char *text, float x, float y,
*                     const char *just, float upx, float upy )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     draw a text string. It forwards the call to the grf3D module being
*     used by this Plot3D. It should be registered with each of the 2D Plots
*     using astGrfSet.

*  Parameters:
*     grfconID
*        The Plot's GrfContext KeyMap. This is
*        used to identify which of the three Plots is calling this function.
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The reference x coordinate.
*     y
*        The reference y coordinate.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y.
*     upx
*        The x component of the up-vector for the text.
*     upy
*        The y component of the up-vector for the text.

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

/* Local Variables: */
   AstKeyMap *grfcon;
   double gcon;
   float norm[ 3 ];
   float ref[ 3 ];
   float up[ 3 ];
   int plane;
   int rc;
   int result = 0;
   int *status;

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

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

/* Get a genuine pointer from the supplied grfcon identifier. */
   grfcon = astMakePointer( grfconID );

/* Report an error if no grfcon object was supplied. */
   if( !grfcon ) {
      astError( AST__INTER, "astG3DText(Plot3D): No grfcon Object supplied "
                "(internal AST programming error)." , status);

/* If a grfcon Object was supplied, get the graphics box array out of it. */
   } else if( !astMapGet0D( grfcon, "Gcon", &gcon ) ) {
      astError( AST__INTER, "astG3DText(Plot3D): No \"Gcon\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* If a grfcon Object was supplied, get the RootCorner value out of it. */
   } else if( !astMapGet0I( grfcon, "RootCorner", &rc ) ) {
      astError( AST__INTER, "astG3DLine(Plot3D): No \"RootCornern\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* Also get the plane index out of it. */
   } else if( !astMapGet0I( grfcon, "Plane", &plane ) ) {
      astError( AST__INTER, "astG3DText(Plot3D): No \"Plane\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* If OK, draw the text. */
   } else {

/* Set up the reference, up and normal vectors so that the text appears
   on the required plane. */
      if( plane == XY ) {
         ref[ 0 ] = x;
         ref[ 1 ] = y;
         ref[ 2 ] = gcon;
         norm[ 0 ] = 0;
         norm[ 1 ] = 0;
         norm[ 2 ] = ( rc & 4 ) ? 1 : -1;
         up[ 0 ] = upx;
         up[ 1 ] = upy;
         up[ 2 ] = 0;

      } else if( plane == XZ ) {
         ref[ 0 ] = x;
         ref[ 1 ] = gcon;
         ref[ 2 ] = y;
         norm[ 0 ] = 0;
         norm[ 1 ] = ( rc & 2 ) ? 1 : -1;
         norm[ 2 ] = 0;
         up[ 0 ] = upx;
         up[ 1 ] = 0;
         up[ 2 ] = upy;

      } else if( plane == YZ ) {
         ref[ 0 ] = gcon;
         ref[ 1 ] = x;
         ref[ 2 ] = y;
         norm[ 0 ] = ( rc & 1 ) ? 1 : -1;
         norm[ 1 ] = 0;
         norm[ 2 ] = 0;
         up[ 0 ] = 0;
         up[ 1 ] = upx;
         up[ 2 ] = upy;

      } else {
         astError( AST__INTER, "astG3DText(Plot3D): Illegal plane "
                   "identifier %d supplied (internal AST programming "
                   "error).", status, plane );
      }

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
      LOCK_MUTEX2;

/* If ok, draw the markers in the 3D graphics coordinate space. */
      if( astOK ) result = astG3DText( text, ref, just, up, norm );

/* Allow the next thread to proceed. */
      UNLOCK_MUTEX2;
   }

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

static int Plot3DTxExt( AstKeyMap *grfconID, const char *text, float x, float y,
                        const char *just, float upx, float upy, float *xb,
                        float *yb ){
/*
*  Name:
*     Plot3DTxExt

*  Purpose:
*     Determine the plotted extent of a text string.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int Plot3DTxExt( AstKeyMap *grfconID, const char *text, float x,
*                      float y, const char *just, float upx, float upy,
*                      float *xb, float *yb )

*  Class Membership:
*     Plot3D member function.

*  Description:
*     This function is called by one of the three encapsulated 2D Plots to
*     determine the extent a string would have if plotted using Plot3DText.
*     It forwards the call to the grf3D module being used by this Plot3D. It
*     should be registered with each of the 2D Plots using astGrfSet.

*  Parameters:
*     grfconID
*        The Plot's GrfContext KeyMap. This is
*        used to identify which of the three Plots is calling this function.
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The reference x coordinate.
*     y
*        The reference y coordinate.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y.
*     upx
*        The x component of the up-vector for the text.
*     upy
*        The y component of the up-vector for the text.
*     xb
*        An array of 4 elements in which to return the x coordinate of
*        each corner of the bounding box.
*     yb
*        An array of 4 elements in which to return the y coordinate of
*        each corner of the bounding box.

*  Returned Value:
*     An integer value of 0 is returned if an error occurs, and 1 otherwise.

*/

/* Local Variables: */
   AstKeyMap *grfcon;
   double gcon;
   float *xb3d = NULL;
   float *yb3d = NULL;
   float *zb3d = NULL;
   float bl[ 3 ];
   float norm[ 3 ];
   float ref[ 3 ];
   float unused[ 4 ];
   float up[ 3 ];
   int plane;
   int rc;
   int result = 0;
   int *status;

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

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

/* Get a genuine pointer from the supplied grfcon identifier. */
   grfcon = astMakePointer( grfconID );

/* Report an error if no grfcon object was supplied. */
   if( !grfcon ) {
      astError( AST__INTER, "astG3DTxExt(Plot3D): No grfcon Object supplied "
                "(internal AST programming error)." , status);

/* If a grfcon Object was supplied, get the graphics box array out of it. */
   } else if( !astMapGet0D( grfcon, "Gcon", &gcon ) ) {
      astError( AST__INTER, "astG3DTxExt(Plot3D): No \"Gcon\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* If a grfcon Object was supplied, get the RootCorner value out of it. */
   } else if( !astMapGet0I( grfcon, "RootCorner", &rc ) ) {
      astError( AST__INTER, "astG3DLine(Plot3D): No \"RootCornern\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* Also get the plane index out of it. */
   } else if( !astMapGet0I( grfcon, "Plane", &plane ) ) {
      astError( AST__INTER, "astG3DTxExt(Plot3D): No \"Plane\" key found "
                "in the supplied grfcon Object (internal AST programming "
                "error)." , status);

/* If OK, get the extent of the text. */
   } else {

/* Set up the reference, up and normal vectors so that the text appears
   on the required plane. */
      if( plane == XY ) {
         ref[ 0 ] = x;
         ref[ 1 ] = y;
         ref[ 2 ] = gcon;
         norm[ 0 ] = 0;
         norm[ 1 ] = 0;
         norm[ 2 ] = ( rc & 4 ) ? 1 : -1;
         up[ 0 ] = upx;
         up[ 1 ] = upy;
         up[ 2 ] = 0;
         xb3d = xb;
         yb3d = yb;
         zb3d = unused;

      } else if( plane == XZ ) {
         ref[ 0 ] = x;
         ref[ 1 ] = gcon;
         ref[ 2 ] = y;
         norm[ 0 ] = 0;
         norm[ 1 ] = ( rc & 2 ) ? 1 : -1;
         norm[ 2 ] = 0;
         up[ 0 ] = upx;
         up[ 1 ] = 0;
         up[ 2 ] = upy;
         xb3d = xb;
         yb3d = unused;
         zb3d = yb;

      } else if( plane == YZ ) {
         ref[ 0 ] = gcon;
         ref[ 1 ] = x;
         ref[ 2 ] = y;
         norm[ 0 ] = ( rc & 1 ) ? 1 : -1;
         norm[ 1 ] = 0;
         norm[ 2 ] = 0;
         up[ 0 ] = 0;
         up[ 1 ] = upx;
         up[ 2 ] = upy;
         xb3d = unused;
         yb3d = xb;
         zb3d = yb;

      } else {
         astError( AST__INTER, "astG3DTxExt(Plot3D): Illegal plane "
                   "identifier %d supplied (internal AST programming "
                   "error).", status, plane );
      }

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
      LOCK_MUTEX2;

/* If ok, get the extent of the text. */
      if( astOK ) result = astG3DTxExt( text, ref, just, up, norm, xb3d, yb3d,
                                        zb3d, bl );
/* Allow the next thread to proceed. */
      UNLOCK_MUTEX2;
   }

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

static void PolyCurve( AstPlot *this, int npoint, int ncoord, int indim,
                       const double *in, int *status ){
/*
*  Name:
*     PolyCurve

*  Purpose:
*     Draw a series of connected geodesic curves.

*  Type:
*     Private member function.

*  Synopsis:
*     #include "plot3d.h"
*     void PolyCurve( AstPlot *this, int npoint, int ncoord, int indim,
*                     const double *in, int *status )

*  Class Membership:
*     Plot method (overrides the astPolyCurve method inherited form the
*     Plot class)

*  Description:
*     This function joins a series of points specified in the physical
*     coordinate system of a Plot by drawing a sequence of geodesic
*     curves.  It is equivalent to making repeated use of the astCurve
*     function (q.v.), except that astPolyCurve will generally be more
*     efficient when drawing many geodesic curves end-to-end. A
*     typical application of this might be in drawing contour lines.
*
*     As with astCurve, full account is taken of the Mapping between
*     physical and graphical coordinate systems. This includes any
*     discontinuities and clipping established using astClip.

*  Parameters:
*     this
*        Pointer to the Plot.
*     npoint
*        The number of points between which geodesic curves are to be drawn.
*     ncoord
*        The number of coordinates being supplied for each point (i.e.
*        the number of axes in the current Frame of the Plot, as given
*        by its Naxes attribute).
*     indim
*        The number of elements along the second dimension of the "in"
*        array (which contains the input coordinates). This value is
*        required so that the coordinate values can be correctly
*        located if they do not entirely fill this array. The value
*        given should not be less than "npoint".
*     in
*        The address of the first element in a 2-dimensional array of shape
*        "[ncoord][indim]" giving the
*        physical coordinates of the points which are to be joined in
*        sequence by geodesic curves. These should be stored such that
*        the value of coordinate number "coord" for point number
*        "point" is found in element "in[coord][point]".
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - No curve is drawn on either side of any point which has any
*     coordinate equal to the value AST__BAD.
*     - An error results if the base Frame of the Plot is not
*     2-dimensional.
*     - An error also results if the transformation between the
*     current and base Frames of the Plot is not defined (i.e. the
*     Plot's TranInverse attribute is zero).
*/

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

   astError( AST__INTER, "astPolyCurve(%s): The astPolyCurve "
             "method cannot be used with a %s (programming error).", status,
             astGetClass( this ), astGetClass( this ) );
}

static void RemoveFrame( AstFrameSet *this_fset, int iframe, int *status ) {
/*
*  Name:
*     RemoveFrame

*  Purpose:
*     Remove a Frame from a Plot3D.

*  Type:
*     Public virtual function.

*  Synopsis:
*     #include "plot.h"
*     void RemoveFrame( AstFrameSet *this_fset, int iframe, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the astRemoveFrame public
*     method inherited from the Plot class).

*  Description:
*     This function removes a Frame from a Plot3D. All other Frames
*     in the Plot3D have their indices re-numbered from one (if
*     necessary), but are otherwise unchanged.
*
*     If the index of the original base Frame is changed, the index value
*     stored in the Plot3D is updated. If the base Frame itself is
*     removed, an error is reported.

*  Parameters:
*     this_fset
*        Pointer to the FrameSet component of the Plot3D.
*     iframe
*        The index within the Plot3D of the Frame to be removed.
*        This value should lie in the range from 1 to the number of
*        Frames in the Plot3D (as given by its Nframe attribute).
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstPlot3D *this;          /* Pointer to Plot3D structure */
   int ifrm;                 /* Validated frame index */

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

/* Obtain a pointer to the Plot3D structure. */
   this = (AstPlot3D *) this_fset;

/* Validate the frame index. This translated AST__BASE and AST__CURRENT
   into actual Frame indices. */
   ifrm = astValidateFrameIndex( this_fset, iframe, "astRemoveFrame" );

/* Report an error if an attempt is made to delete the Frame that defines
   the mapping onto the screen (the original base Frame in the FrameSet
   supplied when the Plot3D was constructed). */
   if( ifrm == this->pix_frame ){
      astError( AST__PXFRRM, "astRemoveFrame(%s): Cannot delete Frame "
                "number %d from the supplied %s since it is the Frame "
                "that defines the mapping onto the graphics plane.", status,
                 astGetClass( this ), iframe, astGetClass( this ) );

/* Otherwise, invoke the parent astRemoveFrame method to remove the Frame. */
   } else {
      (*parent_removeframe)( this_fset, iframe, status );

/* If the index of the removed Frame is smaller than the original base Frame
   index, then decrement the original base Frame index so that the same Frame
   will be used in future. */
      if( astOK ){
         if( ifrm < this->pix_frame ) (this->pix_frame)--;
      }
   }
}

static int RootCornerInt( const char *rootcorner, int *status ){
/*
*  Name:
*     RootCornerInt

*  Purpose:
*     Convert a RootCorner string to an integer.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int RootCornerInt( const char *rootcorner, int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function converts a RootCorner string to an integer.

*  Parameters:
*     rootcorner
*        The string value to convert. Should be 3 characters long
*        and contain nothing but "U" or "L" (upper or lower case).
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The integer value that is is the protected equivalent of the
*     supplied string. A negative value is returned if an error has
*     already occurred, of the supplied string is not legal.

*/

/* Local Variables: */
   int result;

/* Initialise */
   result = -1;

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

/* Compare thr supplied value with every legal value. */
   if( astChrMatch( rootcorner, "LLL" ) ) {
      result = LLL;

   } else if( astChrMatch( rootcorner, "ULL" ) ) {
      result = ULL;

   } else if( astChrMatch( rootcorner, "LUL" ) ) {
      result = LUL;

   } else if( astChrMatch( rootcorner, "UUL" ) ) {
      result = UUL;

   } else if( astChrMatch( rootcorner, "LLU" ) ) {
      result = LLU;

   } else if( astChrMatch( rootcorner, "ULU" ) ) {
      result = ULU;

   } else if( astChrMatch( rootcorner, "LUU" ) ) {
      result = LUU;

   } else if( astChrMatch( rootcorner, "UUU" ) ) {
      result = UUU;

   }

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

static const char *RootCornerString( int rootcorner, int *status ){
/*
*  Name:
*     RootCornerString

*  Purpose:
*     Convert a RootCorner integer to a string.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     const char *RootCornerString( int rootcorner, int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function converts a RootCorner integer to a string.

*  Parameters:
*     rootcorner
*        The integer value to convert. Should be in the range 0 to 7.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a static string that is the public equivalent of the
*     supplied integer. A NULL pointer is returned if an error has
*     already occurred, of the supplied integer is not legal.

*/

/* Local Variables: */
   char *result;

/* Initialise */
   result = NULL;

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

/* Compare thr supplied value with every legal value. */
   if( rootcorner == LLL ) {
      result = "LLL";

   } else if( rootcorner == ULL ) {
      result = "ULL";

   } else if( rootcorner == LUL ) {
      result = "LUL";

   } else if( rootcorner == UUL ) {
      result = "UUL";

   } else if( rootcorner == LLU ) {
      result = "LLU";

   } else if( rootcorner == ULU ) {
      result = "ULU";

   } else if( rootcorner == LUU ) {
      result = "LUU";

   } else if( rootcorner == UUU ) {
      result = "UUU";

   }

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

static void Set3DGrf( AstPlot3D *this, AstPlot *plot, int plane, int *status ){
/*
*  Name:
*     Set3DGrf

*  Purpose:
*     Associate GRF functions with a Plot.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void Set3DGrf( AstPlot3D *this, AstPlot *plot, int plane, int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function registers grf functions defined in this class with
*     the supplied Plot, so that, whenever the Plot draws anything, the
*     plotting request is caught by this class and converted into an
*     appropriate grf3D call.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     plot
*        Pointer to the Plot.
*     plane
*        An integer identifier for the plane within 3D GRAPHICS
*        coordinates upon which the supplied Plot should draw.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstKeyMap *grfcon;

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

/* Register the plotting functions defined in this class, so that the
   plot will call these functions to do its 2D plotting. */
   astGrfSet( plot, "Attr", (AstGrfFun) Plot3DAttr );
   astGrfSet( plot, "Cap", (AstGrfFun) Plot3DCap );
   astGrfSet( plot, "Flush", (AstGrfFun) Plot3DFlush );
   astGrfSet( plot, "Line", (AstGrfFun) Plot3DLine );
   astGrfSet( plot, "Mark", (AstGrfFun) Plot3DMark );
   astGrfSet( plot, "Qch", (AstGrfFun) Plot3DQch );
   astGrfSet( plot, "Scales", (AstGrfFun) Plot3DScales );
   astGrfSet( plot, "Text", (AstGrfFun) Plot3DText );
   astGrfSet( plot, "TxExt", (AstGrfFun) Plot3DTxExt );

/* Ensure that the Plot uses the grf interface registered using
   astGrfSet. */
   astSetGrf( plot, 1 );

/* When the above functions are called, they need to know which plane
   they are drawing on. So we put this information into the GrfContext
   KeyMap stored in the Plot. This KeyMap will be passed to the above
   drawing functions when they are called from within the Plot class. */
   grfcon = astGetGrfContext( plot );
   astMapPut0I( grfcon, "Plane", plane, "The 2D plane being drawn on" );
   if( plane == XY ) {
      astMapPut0D( grfcon, "Gcon", this->gbox[2], "Constant Z value" );
   } else if( plane == XZ ) {
      astMapPut0D( grfcon, "Gcon", this->gbox[1], "Constant Y value" );
   } else {
      astMapPut0D( grfcon, "Gcon", this->gbox[0], "Constant X value" );
   }
   astMapPut0I( grfcon, "RootCorner", astGetRootCorner(this), "The labelled corner" );
   grfcon = astAnnul( grfcon );
}

static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
/*
*  Name:
*     SetAttrib

*  Purpose:
*     Set an attribute value for a Plot3D.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void SetAttrib( AstObject *this, const char *setting, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the astSetAttrib protected
*     method inherited from the Plot class).

*  Description:
*     This function assigns an attribute value for a Plot3D, 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 Plot3D.
*     setting
*        Pointer to a null terminated string specifying the new attribute
*        value.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   AstPlot *plot;                /* Pointer to specific Plot */
   AstPlot3D *this;              /* Pointer to the Plot3D structure */
   char pat[30];                 /* Regular expression pattern */
   char spec[10];                /* Plane specification */
   const char *null = "";        /* Pointer to null string */
   const char *psetting;         /* Pointer to plot-specific attrib setting */
   double dval;                  /* Floating point attribute value */
   int axis;                     /* Axis index */
   int ival;                     /* Int attribute value */
   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 Plot3D structure. */
   this = (AstPlot3D *) this_object;

/* Obtain the length of the setting string. */
   len = (int) 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. */

/* Norm(axis). */
/* ----------- */
   if ( nc = 0,
        ( 2 == astSscanf( setting, "norm(%d)= %lg %n",
                          &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetNorm( this, axis - 1, dval );

/* RootCorner. */
/* ----------- */
   } else if( nc = 0,
        ( 0 == astSscanf( setting, "rootcorner=%n%*[^\n]%n", &ival, &nc ) )
               && ( nc >= len ) ) {
      ival = RootCornerInt( setting + ival, status );
      if( astOK && ival < 0 ) {
         astError( AST__ATTIN, "astSetAttrib(Plot3D): Unusable value \"%s\" "
                   "given for attribute RootCorner.", status, setting + ival );
      } else {
         astSetRootCorner( this, ival );
      }

/* ..._XY etc */
/* ---------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( setting, "%*[a-z]_%[xyz]%n", spec, &nc ) ) ) {

      if( !strcmp( spec, "xy" ) || !strcmp( spec, "yx" ) ) {
         plot = this->plotxy;
      } else if( !strcmp( spec, "xz" ) || !strcmp( spec, "zx" ) ) {
         plot = this->plotyz;
      } else if( !strcmp( spec, "yz" ) || !strcmp( spec, "zy" ) ) {
         plot = this->plotxz;
      } else {
         plot = NULL;
      }

      if( plot ) {
         sprintf( pat, ".*(_%s).*", spec );
         psetting = astChrSub( setting, pat, &null, 1 );
         astSetAttrib( plot, psetting );
         psetting = astFree( (void *) psetting );

      } else {
         (*parent_setattrib)( this_object, setting, status );
      }

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      (*parent_setattrib)( this_object, setting, status );
   }

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

static void SetCurrent( AstFrameSet *this_frameset, int iframe, int *status ) {
/*
*  Name:
*     SetCurrent

*  Purpose:
*     Set a value for the Current attribute of a Plot3D.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int astSetCurrent( AstFrameSet *this, int iframe, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the public astSetCurrent method
*     inherited from the FrameSet class).

*  Description:
*     This function sets a value for the Current attribute of a
*     Plot3D. This attribute is an index that identifies the current
*     Frame for the Plot3D.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     iframe
*        Value to be set for the Current attribute.
*     status
*        Pointer to the inherited status variable.
*/

/* Invoke the parent astSetCurrent method. */
   (*parent_setcurrent)( this_frameset, iframe, status );

/* Update the three 2D Plots stored in the Plot3D structure so that they
   reflect this modified FrameSet. */
   UpdatePlots( (AstPlot3D *) this_frameset, status );
}

static void SetPlotAttr( AstPlot *plot, int plane, int label[ 2 ], int *status ){
/*
*  Name:
*     SetPlotAttr

*  Purpose:
*     Set the attributes ofr one of the encapsulated Plots.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void SetPlotAttr( AstPlot *plot, int plane, int label[ 2 ], int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function sets the attributes of one of the encapsulated Plots.

*  Parameters:
*     plot
*        Pointer to the Plot to modify.
*     plane
*        The 3D plane spanned by the 2D plot.
*     label
*        Array indicating if each WCS axis should be labelled or not.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int axis;

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

/* Ensure that the Plot uses the grf interface registered using
   astGrfSet. */
   astSetGrf( plot, 1 );

/* Ensure that no title is drawn. */
   astSetDrawTitle( plot, 0 );

/* For each axis, ensure that no axis labels or ticks are produced unless
   the axis is indicated as a labelled axis in the supplied array. */
   for( axis = 0; axis < 2; axis++ ) {
      if( !label[ axis ] ) {
         astSetLabelUnits( plot, axis, 0 );
         astSetNumLab( plot, axis, 0 );
         astSetTextLab( plot, axis, 0 );
      }
   }
}

static void SetRootCorner( AstPlot3D *this, int rootcorner, int *status ){
/*
*+
*  Name:
*     astSetRootCorner

*  Purpose:
*     Set a new value for the RootCorner attribute.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "plot3d.h"
*     void astSetRootCorner( AstPlot3D *this, int rootcorner )

*  Class Membership:
*     Plot method.

*  Description:
*     This function sets a new value for the RootCorner attribute.

*  Parameters:
*     this
*        Pointer to a Plot3D.
*     rootcorner
*        The new RootCorner value.

*-
*/

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

/* Report an error if the new value is out of bounds. */
   if( rootcorner < 0 || rootcorner > 7 ){
      astError( AST__ATTIN, "astSetRootCorner(Plot3D): Invalid value %d "
                "supplied for RootCorner attribute", status,rootcorner);

/* If the new corner is OK, mirror any axes of the encapsulated Plots
   that need mirroring (this is done to ensure that Plots look right when
   viewed from the outside of the graphics cube), and modify the Edge
   attributes in the encapsulated Plots to ensure the labels appear on the
   requested edges of the 3D graphics cube. . */
   } else {
      ChangeRootCorner( this, astGetRootCorner(this), rootcorner, status );

/* Store the new value. */
      this->rootcorner = rootcorner;
   }
}

static void SetTickValues( AstPlot *this, int axis, int nmajor, double *major,
                           int nminor, double *minor, int *status ){
/*
*  Name:
*     SetTickValues

*  Purpose:
*     Store the tick mark values to use for a given Plot axis.

*  Type:
*     Private member function.

*  Synopsis:
*     #include "plot3d.h"
*     void SetTickValues( AstPlot *this, int axis, int nmajor,
*                         double *major, int nminor, double *minor, int *status )

*  Class Membership:
*     Plot method (overrides the astSetTickValues method inherited form
*     the Plot class)

*  Description:
*     This function stores a set of tick mark values that should be used by
*     subsequent calls to astGrid.

*  Parameters:
*     this
*        Pointer to a Plot.
*     axis
*        The zero-based index of the axis for which tick marks values
*        have been supplied.
*     nmajor
*        The number of major tick mark values. If zero is supplied then
*        the other parameters are ignored, and subsequent calls to
*        astGrid will itself determine the tick values to be used.
*     major
*        Pointer to an array holding "nmajor" values for axis "axis" in
*        the current Frame of the suppled Plot. Major tick marks will be
*        drawn at these values.
*     nminor
*        The number of minor tick mark values.
*     minor
*        Pointer to an array holding "nminor" values for axis "axis" in
*        the current Frame of the suppled Plot. Minor tick marks will be
*        drawn at these values.
*     status
*        Pointer to the inherited status variable.
*/

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

   astError( AST__INTER, "astSetTickValues(%s): The astSetTickValues "
             "method cannot be used with a %s (programming error).", status,
             astGetClass( this ), astGetClass( this ) );
}

static void SplitFrameSet( AstFrameSet *fset,
                           AstFrameSet **fsetxy, int labelxy[2], int wcsxy[2],
                           AstFrameSet **fsetxz, int labelxz[2], int wcsxz[2],
                           AstFrameSet **fsetyz, int labelyz[2], int wcsyz[2],
                           int *baseplane, int *status ){
/*
*  Name:
*     SplitFrameSet

*  Purpose:
*     Split a 3D FrameSet into three 2D FrameSets.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void SplitFrameSet( AstFrameSet *fset,
*                         AstFrameSet **fsetxy, int labelxy[2], int wcsxy[2],
*                         AstFrameSet **fsetxz, int labelxz[2], int wcsxz[2],
*                         AstFrameSet **fsetyz, int labelyz[2], int wcsyz[2],
*                         int *baseplane, int *status )

*  Class Membership:
*     Plot3D member function

*  Description:
*     This function returns 3 FrameSets, each of which has 2-dimensional
*     base and current Frames. Each of the 2D base Frames span a single
*     plane in the 3D base Frame of the supplied FrameSet. Likewise, each
*     of the 2D current Frames span a single plane in the 3D current Frame
*     of the supplied FrameSet. An error is reported if there is no
*     one-to-one association between the three planes in the supplied
*     current Frame and the 3 planes in the supplied base Frame.

*  Parameters:
*     fset
*        Pointer to a FrameSet that has a 3D base Frame and a 3D current
*        Frame.
*     fsetxy
*        Pointer to a location at which to return a pointer to a new FrameSet
*        that has a 2D base Frame and a 2D current. The base Frame spans
*        axes 1 and 2 of the 3D base Frame in "fset".
*     labelxy
*        Returned holding flags indicating if the two axes of the current
*        Frame in *fsetxy should be labelled or not.
*     wcsxy
*        Returned holding the zero based axis index within the current Frame
*        of the supplied FrameSet that corresponds to each of the two
*        current Frame axes in the "fsetxy" FrameSet.
*     fsetxz
*        Pointer to a location at which to return a pointer to a new FrameSet
*        that has a 2D base Frame and a 2D current. The base Frame spans
*        axes 1 and 3 of the 3D base Frame in "fset".
*     labelxz
*        Returned holding flags indicating if the two axes of the current
*        Frame in *fsetxz should be labelled or not.
*     wcsxz
*        Returned holding the zero based axis index within the current Frame
*        of the supplied FrameSet that corresponds to each of the two
*        current Frame axes in the "fsetxz" FrameSet.
*     fsetyz
*        Pointer to a location at which to return a pointer to a new FrameSet
*        that has a 2D base Frame and a 2D current. The base Frame spans
*        axes 2 and 3 of the 3D base Frame in "fset".
*     labelyz
*        Returned holding flags indicating if the two axes of the current
*        Frame in *fsetyz should be labelled or not.
*     wcsyz
*        Returned holding the zero based axis index within the current Frame
*        of the supplied FrameSet that corresponds to each of the two
*        current Frame axes in the "fsetxy" FrameSet.
*     baseplane
*        Index of the plane that is spanned by two connected 3D axes.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - Null pointers will be returned for the three new FrameSets if this
*     function is invoked with the global status set, or if it should fail
*     for any reason.
*     - Each returned FrameSet has 2 Frames: Frame 1 is the base Frame
*     and is spanned by 2 of the 3 axes in the base Frame of the supplied
*     FrameSet; Frame 2 is the current Frame and is spanned by 2 of the 3
*     axes in the current Frame of the supplied FrameSet. Any future changes
*     to this function that alter this structure should reflected in
*     equivalent changes to functions CreatePlots and UpdatePlots.
*/

/* Local Variables: */
   AstFrame *bfrm2d;
   AstFrame *bfrm;
   AstFrame *cfrm1d;
   AstFrame *cfrm2d;
   AstFrame *cfrm;
   AstFrame *dummy;
   AstFrameSet *fset1;
   AstFrameSet *fset2;
   AstFrameSet *fset3;
   AstMapping *map1d;
   AstMapping *map2d;
   AstMapping *map;
   AstMapping *smap;
   AstUnitMap *unit1d;
   int *axout;
   int *other_axout;
   int axin2[ 2 ];
   int axin[ 2 ];
   int i;
   int label1[ 2 ];
   int label2[ 2 ];
   int label3[ 2 ];
   int other_axin;
   int wcsax1[ 2 ];
   int wcsax2[ 2 ];
   int wcsax3[ 2 ];

/* Initialise. */
   *fsetxy = NULL;
   *fsetxz = NULL;
   *fsetyz = NULL;
   *baseplane = 0;

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

/* Get the simplified base -> current Mapping form the supplied FrameSet.
   Also get the base and current Frames themselves. */
   map = astGetMapping( fset, AST__BASE, AST__CURRENT );
   smap = astSimplify( map );
   map = astAnnul( map );
   cfrm = astGetFrame( fset, AST__CURRENT );
   bfrm = astGetFrame( fset, AST__BASE );

/* Create a 1D UnitMap. */
   unit1d = astUnitMap( 1, "", status );

/* First try to identify a pair of base Frame axes that map onto a pair
   of current Frame axes. This will be the case for instance if the 3D
   FrameSet describes a spectral cube in which two of the axes are spanned
   by a SkyFrame. We try all three possible pairs of axes in turn until a
   pair is found succesfully. */
   for( i = 0; i < 3  && ! *fsetxy; i++ ) {
      axin[ 0 ] = ( i < 2 ) ? 0 : 1;
      axin[ 1 ] = ( i == 0 ) ? 1 : 2;

/* Try to get a Mapping that connects the inputs given by axin to a
   distinct subset of outputs. */
      axout = astMapSplit( smap, 2, axin, &map2d );

/* If succesful, check that the 2 inputs correspond to exactly 2 outputs. */
      if( map2d ){
         if( astGetNout( map2d ) == 2 ) {

/* Get the index of the other input axis (the one not included in the pair). */
            other_axin = 3 - axin[ 0 ] - axin[ 1 ];

/* Try to get a Mapping that connects this remaining input to a distinct
   subset of outputs. */
            other_axout = astMapSplit( smap, 1, &other_axin, &map1d );

/* If succesful, check that the 1 input correspond to exactly 1 output. */
            if( map1d ){
               if( astGetNout( map1d ) == 1 ) {

/* Pick the two axes from the 3D base and current Frames that correspond to
   the paired axes found above. */
                  bfrm2d = astPickAxes( bfrm, 2, axin, NULL );
                  cfrm2d = astPickAxes( cfrm, 2, axout, NULL );

/* Pick the axis from the 3D current Frame that correspond to
   the other axis. */
                  cfrm1d = astPickAxes( cfrm, 1, other_axout, NULL );

/* Construct a FrameSet using these 2D Frames and Mapping. */
                  fset1 = astFrameSet( bfrm2d, "", status );
                  astAddFrame( fset1, AST__BASE, map2d, cfrm2d );

                  bfrm2d = astAnnul( bfrm2d );
                  cfrm2d = astAnnul( cfrm2d );
                  map2d = astAnnul( map2d );

/* Indicate that both axes in the current Frame of this FrameSet should
   be labelled. */
                  label1[ 0 ] = 1;
                  label1[ 1 ] = 1;

/* Store the index of the axis within the supplied current Frame that
   corresponds to each axis in the current Frame of the FrameSet created
   above. */
                  wcsax1[ 0 ] = axout[ 0 ];
                  wcsax1[ 1 ] = axout[ 1 ];

/* Pick the two axes from the 3D base Frame that correspond to the first of
   the paired axes, and the unpaired axis. Order them so that we get the
   2 axes in the order xy, xz or yz. Also, store the index of the axis
   within the supplied  current Frame that corresponds to each axis in
   the current Frame of the FrameSet created below. */
                  if( i < 2 ) {
                     axin2[ 0 ] = axin[ 0 ];
                     axin2[ 1 ] = other_axin;
                     wcsax2[ 0 ] = axout[ 0 ];
                     wcsax2[ 1 ] = other_axout[ 0 ];
                  } else {
                     axin2[ 0 ] = other_axin;
                     axin2[ 1 ] = axin[ 0 ];
                     wcsax2[ 0 ] = other_axout[ 0 ];
                     wcsax2[ 1 ] = axout[ 0 ];
                  }
                  bfrm2d = astPickAxes( bfrm, 2, axin2, NULL );

/* The corresponding current Frame in the new FrameSet will be a compound
   2D Frame holding the other current Frame axis and a copy of the input
   base Frame axis. Combine them so that we get the 2 axes in the order
   xy, xz or yz. */
                  dummy = astPickAxes( bfrm, 1, axin, NULL );
                  if( i < 2 ) {
                     cfrm2d = (AstFrame *) astCmpFrame( dummy, cfrm1d, "", status );
                  } else {
                     cfrm2d = (AstFrame *) astCmpFrame( cfrm1d, dummy, "", status );
                  }
                  dummy = astAnnul( dummy );

/* The Mapping that joins this 2D base Frame to the 2D current Frame uses
   the above 1D mapping for the other axis, and a UnitMap for the copied
   base Frame axis. */
                  if( i < 2 ) {
                     map2d = (AstMapping *) astCmpMap( unit1d, map1d, 0, "", status );
                  } else {
                     map2d = (AstMapping *) astCmpMap( map1d, unit1d, 0, "", status );
                  }

/* Construct a FrameSet using these 2D Frames and Mapping. */
                  fset2 = astFrameSet( bfrm2d, "", status );
                  astAddFrame( fset2, AST__BASE, map2d, cfrm2d );

                  bfrm2d = astAnnul( bfrm2d );
                  cfrm2d = astAnnul( cfrm2d );
                  map2d = astAnnul( map2d );

/* Indicate that only one of the axes in the current Frame of this FrameSet
   should be labelled. */
                  if( i < 2 ) {
                     label2[ 0 ] = 0;
                     label2[ 1 ] = 1;
                  } else {
                     label2[ 0 ] = 1;
                     label2[ 1 ] = 0;
                  }

/* Pick the two axes from the 3D base Frame that correspond to the second
   of the paired axes, and the unpaired axis. Order them so that we get the
   2 axes in the order xy, xz or yz. Also, store the index of the axis
   within the supplied  current Frame that corresponds to each axis in
   the current Frame of the FrameSet created below. */
                  if( i == 0 ) {
                     axin2[ 0 ] = axin[ 1 ];
                     axin2[ 1 ] = other_axin;
                     wcsax3[ 0 ] = axout[ 1 ];
                     wcsax3[ 1 ] = other_axout[ 0 ];
                  } else {
                     axin2[ 0 ] = other_axin;
                     axin2[ 1 ] = axin[ 1 ];
                     wcsax3[ 0 ] = other_axout[ 0 ];
                     wcsax3[ 1 ] = axout[ 1 ];
                  }
                  bfrm2d = astPickAxes( bfrm, 2, axin2, NULL );

/* The corresponding current Frame in the new FrameSet will be a compound
   2D Frame holding the other current Frame axis and a copy of the input
   base Frame axis. Combine them so that we get the 2 axes in the order
   xy, xz or yz. */
                  dummy = astPickAxes( bfrm, 1, axin + 1, NULL );
                  if( i == 0 ) {
                     cfrm2d = (AstFrame *) astCmpFrame( dummy, cfrm1d, "", status );
                  } else {
                     cfrm2d = (AstFrame *) astCmpFrame( cfrm1d, dummy, "", status );
                  }
                  dummy = astAnnul( dummy );

/* The Mapping that joins this 2D base Frame to the 2D current Frame uses
   the above 1D mapping for the other axis, and a UnitMap for the copied
   base Frame axis. */
                  if( i == 0 ) {
                     map2d = (AstMapping *) astCmpMap( unit1d, map1d, 0, "", status );
                  } else {
                     map2d = (AstMapping *) astCmpMap( map1d, unit1d, 0, "", status );
                  }

/* Construct a FrameSet using these 2D Frames and Mapping. */
                  fset3 = astFrameSet( bfrm2d, "", status );
                  astAddFrame( fset3, AST__BASE, map2d, cfrm2d );

                  bfrm2d = astAnnul( bfrm2d );
                  cfrm2d = astAnnul( cfrm2d );
                  map2d = astAnnul( map2d );

/* Indicate that neither axis in the current Frame of this FrameSet
   should be labelled. */
                  label3[ 0 ] = 0;
                  label3[ 1 ] = 0;

/* Store each FrameSet in the correct returned pointer. */
                  if( i == 0 ) {
                     *baseplane = XY;
                     *fsetxy = fset1;
                     *fsetxz = fset2;
                     *fsetyz = fset3;

                     labelxy[ 0 ] = label1[ 0 ];
                     labelxy[ 1 ] = label1[ 1 ];
                     labelxz[ 0 ] = label2[ 0 ];
                     labelxz[ 1 ] = label2[ 1 ];
                     labelyz[ 0 ] = label3[ 0 ];
                     labelyz[ 1 ] = label3[ 1 ];

                     wcsxy[ 0 ] = wcsax1[ 0 ];
                     wcsxy[ 1 ] = wcsax1[ 1 ];
                     wcsxz[ 0 ] = wcsax2[ 0 ];
                     wcsxz[ 1 ] = wcsax2[ 1 ];
                     wcsyz[ 0 ] = wcsax3[ 0 ];
                     wcsyz[ 1 ] = wcsax3[ 1 ];

                  } else if( i == 1 ) {
                     *baseplane = XZ;
                     *fsetxy = fset2;
                     *fsetxz = fset1;
                     *fsetyz = fset3;

                     labelxy[ 0 ] = label2[ 0 ];
                     labelxy[ 1 ] = label2[ 1 ];
                     labelxz[ 0 ] = label1[ 0 ];
                     labelxz[ 1 ] = label1[ 1 ];
                     labelyz[ 0 ] = label3[ 0 ];
                     labelyz[ 1 ] = label3[ 1 ];

                     wcsxy[ 0 ] = wcsax2[ 0 ];
                     wcsxy[ 1 ] = wcsax2[ 1 ];
                     wcsxz[ 0 ] = wcsax1[ 0 ];
                     wcsxz[ 1 ] = wcsax1[ 1 ];
                     wcsyz[ 0 ] = wcsax3[ 0 ];
                     wcsyz[ 1 ] = wcsax3[ 1 ];

                  } else {
                     *baseplane = YZ;
                     *fsetxy = fset2;
                     *fsetxz = fset3;
                     *fsetyz = fset1;

                     labelxy[ 0 ] = label2[ 0 ];
                     labelxy[ 1 ] = label2[ 1 ];
                     labelxz[ 0 ] = label3[ 0 ];
                     labelxz[ 1 ] = label3[ 1 ];
                     labelyz[ 0 ] = label1[ 0 ];
                     labelyz[ 1 ] = label1[ 1 ];

                     wcsxy[ 0 ] = wcsax2[ 0 ];
                     wcsxy[ 1 ] = wcsax2[ 1 ];
                     wcsxz[ 0 ] = wcsax3[ 0 ];
                     wcsxz[ 1 ] = wcsax3[ 1 ];
                     wcsyz[ 0 ] = wcsax1[ 0 ];
                     wcsyz[ 1 ] = wcsax1[ 1 ];

                  }

/*  Free resources */
                  cfrm1d = astAnnul( cfrm1d );
               }

/*  Free resources */
               map1d = astAnnul( map1d );
               other_axout = astFree( other_axout );
            }
         }

/*  Free resources */
         if( map2d ) map2d = astAnnul( map2d );
         axout = astFree( axout );

/* Leave the loop if we now have the required FrameSets, or an error has
   occurred. */
         if( *fsetxy || !astOK ) break;

      }
   }

/* Free resources */
   cfrm = astAnnul( cfrm );
   bfrm = astAnnul( bfrm );
   smap = astAnnul( smap );
   unit1d = astAnnul( unit1d );

/* Return null pointers if an error has occurred. */
   if( !astOK ) {
      *fsetxy = astAnnul( *fsetxy );
      *fsetxz = astAnnul( *fsetxz );
      *fsetyz = astAnnul( *fsetyz );

/* Report an error if the supplied FrameSet could not be split into 3
   independent 2D planes. */
   } if( ! *fsetxy ) {
      astError( AST__3DFSET, "astInitPlot3D(Plot3D): Supplied %s contains "
                             "no independent axes.", status, astGetClass( fset ) );
   }
}

static void StoreAxisInfo( AstPlot3D *this, int labelxy[2], int wcsxy[2],
                           int labelxz[2], int wcsxz[2], int labelyz[2],
                           int wcsyz[2], int *status ) {
/*
*  Name:
*     StoreAxisInfo

*  Purpose:
*     Store information connecting 3D axis with associuated 2D Plot axes.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void StoreAxisInfo( AstPlot3D *this, int labelxy[2], int wcsxy[2],
*                         int labelxz[2], int wcsxz[2], int labelyz[2],
*                         int wcsyz[2], int *status )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function stores information inside the Plot3D that allows each
*     3D axis to be associated with the 2 Plots that share the 3D axis,
*     and with the axis index within each of these two Plots.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     labelxy
*        Flags indicating if the two axes of the current Frame in the XY
*        Plot should be labelled or not.
*     wcsxy
*        The zero based axis index within the 3D current Frame that
*        corresponds to each of the two current Frame axes in the XY Plot.
*        A value of -1 should be used for 2D axes that do not correspond
*        to any 3D axis.
*     labelxz
*        Flags indicating if the two axes of the current Frame in the XZ
*        Plot should be labelled or not.
*     wcsxz
*        The zero based axis index within the 3D current Frame that
*        corresponds to each of the two current Frame axes in the XZ Plot.
*        A value of -1 should be used for 2D axes that do not correspond
*        to any 3D axis.
*     labelyz
*        Flags indicating if the two axes of the current Frame in the YZ
*        Plot should be labelled or not.
*     wcsyz
*        The zero based axis index within the 3D current Frame that
*        corresponds to each of the two current Frame axes in the YZ Plot.
*        A value of -1 should be used for 2D axes that do not correspond
*        to any 3D axis.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int axis2d;
   int axis3d;
   int gotfirst;
   int gotsecond;
   int temp;

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

/* Store information that allows each 3D WCS axis to be associated with
   a pair of Plots. Also store the WCS axis within each Plot that
   corresponds to the 3D WCS axis. Do each 3D WCS axis in turn. */
   for( axis3d = 0; axis3d < 3; axis3d++ ) {

/* Indicate we have not yet found either of the two Plots that share the
   current 3D axis. */
      gotfirst = 0;
      gotsecond = 0;

/* Check each of the 2 axes in the plot spanning the XY face of the 3D
   graphics cube. Break early if we have found both Plots for the current
   3D WCS axis. */
      for( axis2d = 0; axis2d < 2 && !gotsecond; axis2d++ ) {

/* See if this 2D axis corresponds to the required 3D axis. If so, store
   the Plot identifier and the 2D axis index. */
         if( wcsxy[ axis2d ] == axis3d ) {
            if( gotfirst ) {
               this->axis_plot2[ axis3d ] = XY;
               this->axis_index2[ axis3d ] = axis2d;
               gotsecond = 1;
            } else {
               this->axis_plot1[ axis3d ] = XY;
               this->axis_index1[ axis3d ] = axis2d;
               gotfirst = 1;
            }
         }
      }

/* Check the plot spanning the XZ face in the same way. */
      for( axis2d = 0; axis2d < 2 && !gotsecond; axis2d++ ) {
         if( wcsxz[ axis2d ] == axis3d ) {
            if( gotfirst ) {
               this->axis_plot2[ axis3d ] = XZ;
               this->axis_index2[ axis3d ] = axis2d;
               gotsecond = 1;
            } else {
               this->axis_plot1[ axis3d ] = XZ;
               this->axis_index1[ axis3d ] = axis2d;
               gotfirst = 1;
            }
         }
      }

/* Check the plot spanning the YZ face in the same way. */
      for( axis2d = 0; axis2d < 2 && !gotsecond; axis2d++ ) {
         if( wcsyz[ axis2d ] == axis3d ) {
            if( gotfirst ) {
               this->axis_plot2[ axis3d ] = YZ;
               this->axis_index2[ axis3d ] = axis2d;
               gotsecond = 1;
            } else {
               this->axis_plot1[ axis3d ] = YZ;
               this->axis_index1[ axis3d ] = axis2d;
               gotfirst = 1;
            }
         }
      }
   }

/* Ensure that the first Plot within each pair is the one that is used to
   generate labels for the 3D axis. */
   for( axis2d = 0; axis2d < 2; axis2d++ ) {
      if( labelxy[ axis2d ] ) {
         axis3d = wcsxy[ axis2d ];
         if( this->axis_plot1[ axis3d ] != XY ){
            temp = this->axis_plot1[ axis3d ];
            this->axis_plot1[ axis3d ] = this->axis_plot2[ axis3d ];
            this->axis_plot2[ axis3d ] = temp;

            temp = this->axis_index1[ axis3d ];
            this->axis_index1[ axis3d ] = this->axis_index2[ axis3d ];
            this->axis_index1[ axis3d ] = temp;
         }
      }
   }

   for( axis2d = 0; axis2d < 2; axis2d++ ) {
      if( labelxz[ axis2d ] ) {
         axis3d = wcsxz[ axis2d ];
         if( this->axis_plot1[ axis3d ] != XZ ){
            temp = this->axis_plot1[ axis3d ];
            this->axis_plot1[ axis3d ] = this->axis_plot2[ axis3d ];
            this->axis_plot2[ axis3d ] = temp;

            temp = this->axis_index1[ axis3d ];
            this->axis_index1[ axis3d ] = this->axis_index2[ axis3d ];
            this->axis_index1[ axis3d ] = temp;
         }
      }
   }

   for( axis2d = 0; axis2d < 2; axis2d++ ) {
      if( labelyz[ axis2d ] ) {
         axis3d = wcsyz[ axis2d ];
         if( this->axis_plot1[ axis3d ] != YZ ){
            temp = this->axis_plot1[ axis3d ];
            this->axis_plot1[ axis3d ] = this->axis_plot2[ axis3d ];
            this->axis_plot2[ axis3d ] = temp;

            temp = this->axis_index1[ axis3d ];
            this->axis_index1[ axis3d ] = this->axis_index2[ axis3d ];
            this->axis_index1[ axis3d ] = temp;
         }
      }
   }
}

static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     TestAttrib

*  Purpose:
*     Test if a specified attribute value is set for a Plot3D.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     int TestAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the astTestAttrib protected
*     method inherited from the Plot class).

*  Description:
*     This function returns a boolean result (0 or 1) to indicate whether
*     a value has been set for one of a Plot3D's attributes.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     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: */
   AstPlot *plot;                /* Pointer to specific Plot */
   AstPlot3D *this;              /* Pointer to the Plot3D structure */
   char attname[50];             /* Plot attribute base name */
   char patt[50];                /* Plot attribute full name */
   char spec[10];                /* Plane specification */
   int axis;                     /* Axis index */
   int len;                      /* Length of attrib string */
   int nc;                       /* Number of character read */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

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

/* Obtain a pointer to the Plot3D structure. */
   this = (AstPlot3D *) this_object;

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

/* Check the attribute name and test the appropriate attribute. */

/* Norm. */
/* ----- */
   if ( !strcmp( attrib, "norm" ) ) {
      result = astTestNorm( this, 0 ) ||
               astTestNorm( this, 1 ) ||
               astTestNorm( this, 2 );

/* Norm(axis). */
/* ----------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "norm(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestNorm( this, axis -  1 );

/* RootCorner. */
/* ----------- */
   } else if ( !strcmp( attrib, "rootcorner" ) ) {
      result = astTestRootCorner( this );


/* ..._XY etc */
/* ---------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( attrib, "%[a-z]_%[xyz]%n", attname, spec,
                 &nc ) ) ) {

      if( !strcmp( spec, "xy" ) || !strcmp( spec, "yx" ) ) {
         plot = this->plotxy;
      } else if( !strcmp( spec, "xz" ) || !strcmp( spec, "zx" ) ) {
         plot = this->plotyz;
      } else if( !strcmp( spec, "yz" ) || !strcmp( spec, "zy" ) ) {
         plot = this->plotxz;
      } else {
         plot = NULL;
      }

      if( plot ) {
         sprintf( patt, "%s%s", attname, attrib + nc );
         result = astTestAttrib( plot, patt );

      } else {
         result = (*parent_testattrib)( this_object, attrib, status );
      }

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      result = (*parent_testattrib)( this_object, attrib, status );
   }

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

static void Text( AstPlot *this_plot, const char *text, const double pos[],
                  const float up[], const char *just, int *status ){
/*
*  Name:
*     Text

*  Purpose:
*     Draw a text string for a Plot3D.

*  Type:
*     Private member function.

*  Synopsis:
*     #include "plot3d.h"
*     void Text( AstPlot *this, const char *text, const double pos[],
*                const float up[], const char *just, int *status )

*  Class Membership:
*     Plot3D method (overrides the Text method inherited form the Plot
*     class).

*  Description:
*     This function draws a string of text at a position specified in
*     the physical coordinate system of a Plot3D. The physical position
*     is transformed into graphical coordinates to determine where the
*     text should appear within the plotting area.
*
*     The text is drawn on a 2D plane that has a normal vector given by the
*     current value of the Plot3D's "Norm" attribute.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     text
*        Pointer to a null-terminated character string containing the
*        text to be drawn. Trailing white space is ignored.
*     pos
*        An array, with one element for each axis of the Plot3D, giving
*        the physical coordinates of the point where the reference
*        position of the text string is to be placed.
*     up
*        An array holding the components of a vector in the "up"
*        direction of the text (in graphical coordinates). For
*        example, to get horizontal text, the vector {0.0f,1.0f} should
*        be supplied. "Up" is taken to be the projection of the positive
*        Z axis onto the plane specified by the current value of the
*     just
*        Pointer to a null-terminated character string identifying the
*        reference point for the text being drawn. The first character in
*        this string identifies the reference position in the "up" direction
*        and may be "B" (baseline), "C" (centre), "T" (top) or "M" (bottom).
*        The second character identifies the side-to-side reference position
*        and may be "L" (left), "C" (centre) or "R" (right ). The string is
*        case-insensitive, and only the first two characters are significant.
*
*        For example, a value of "BL" means that the left end of the
*        baseline of the original (un-rotated) text is to be drawn at the
*        position given by "pos".
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstMapping *mapping;    /* Pointer to graphics->physical mapping */
   AstPlot3D *this;        /* Pointer to the Plot3D structure */
   AstPointSet *pset1;     /* PointSet holding physical positions */
   AstPointSet *pset2;     /* PointSet holding graphics positions */
   char *ltext;            /* Local copy of "text" excluding trailing spaces */
   char ljust[3];          /* Upper case copy of "just" */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   const double **ptr1;    /* Pointer to physical positions */
   double **ptr2;          /* Pointer to graphics positions */
   float norm[ 3 ];        /* Single precision normal vector */
   float ref[ 3 ];         /* Single precision ref position */
   int axis;               /* Axis index */
   int escs;               /* Original astEscapes value */
   int naxes;              /* No. of axes in the base Frame */
   int ncoord;             /* No. of axes in the current Frame */
   int ulen;               /* Length of "text" excluding trailing spaces */

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

/* Store a pointer to the Plot3D structure. */
   this = (AstPlot3D *) this_plot;

/* Store the current method and class for inclusion in error messages
   generated by lower level functions. */
   method = "astText";
   class = astClass( this );

/* Check the base Frame of the Plot is 3-D. */
   naxes = astGetNin( this );
   if( naxes != 3 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 3.", status, method, class, naxes, class );
   }

/* Ensure AST functions do not included graphical escape sequences in any
   returned text strings. This is because the Plot3D implementation of
   this method cannot currently handle graphical escape sequences. */
   escs = astEscapes( 0 );

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
   astGrfAttrs( this, AST__TEXT_ID, 1, GRF__TEXT, method, class );

/* Get the number of coordinates in the physical coordinate frame. */
   ncoord = astGetNout( this );

/* Create a PointSet to hold the supplied physical coordinates. */
   pset1 = astPointSet( 1, ncoord, "", status );

/* Allocate memory to hold pointers to the first value on each axis. */
   ptr1 = (const double **) astMalloc( sizeof( const double * )*
                                       (size_t)( ncoord ));

/* Check the pointer can be used, then store pointers to the first value
   on each axis. */
   if( astOK ){
      for( axis = 0; axis < ncoord; axis++ ){
         ptr1[ axis ] = pos + axis;
      }
   }

/* Store these pointers in the PointSet. */
   astSetPoints( pset1, (double **) ptr1 );

/* Transform the supplied data from the current frame (i.e. physical
   coordinates) to the base frame (i.e. graphics coordinates) using
   the inverse Mapping defined by the Plot. */
   mapping = astGetMapping( this, AST__BASE, AST__CURRENT );
   pset2 = astTransform( mapping, pset1, 0, NULL );
   mapping = astAnnul( mapping );

/* Get pointers to the graphics coordinates. */
   ptr2 = astGetPoints( pset2 );

/* Take a copy of the string excluding any trailing white space. */
   ulen = astChrLen( text );
   ltext = (char *) astStore( NULL, (void *) text, ulen + 1 );

/* Check the pointers can be used. */
   if( astOK ){

/* Terminate the local copy of the text string. */
      ltext[ ulen ] = 0;

/* Produce an upper-case copy of the first two characters in "just". */
      ljust[0] = (char) toupper( (int) just[0] );
      ljust[1] = (char) toupper( (int) just[1] );
      ljust[2] = 0;

/* Convert the double precision values to single precision, checking for
   bad positions. */
      if( ptr2[0][0] != AST__BAD && ptr2[1][0] != AST__BAD &&
          ptr2[2][0] != AST__BAD ){
         ref[ 0 ] = (float) ptr2[0][0];
         ref[ 1 ] = (float) ptr2[1][0];
         ref[ 2 ] = (float) ptr2[2][0];

/* If the nornmal vector has non-zero length, draw the text. */
         norm[ 0 ] = (float) astGetNorm( this, 0 );
         norm[ 1 ] = (float) astGetNorm( this, 1 );
         norm[ 2 ] = (float) astGetNorm( this, 2 );

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
         LOCK_MUTEX2;

         if( norm[ 0 ] != 0.0 || norm[ 1 ] != 0.0 || norm[ 2 ] != 0.0 ){
            if( !astG3DText( ltext, ref, ljust, (float *) up, norm ) ) {
               astError( AST__GRFER, "%s(%s): Graphics error in astG3DText. ", status,
                         method, class );
            }
         } else if( astOK ) {
            astError( AST__ATTIN, "%s(%s): The vector specified by the Norm "
                      "attribute has zero length.", status, method, class );
         }

/* Allow the next thread to proceed. */
         UNLOCK_MUTEX2;
      }

/* Free the local copy of the string. */
      ltext = (char *) astFree( (void *) ltext );

   }

/* Annul the PointSets. */
   pset1 = astAnnul( pset1 );
   pset2 = astAnnul( pset2 );

/* Free the memory holding the pointers to the first value on each axis. */
   ptr1 = (const double **) astFree( (void *) ptr1 );

/* Re-establish the original graphical attributes. */
   astGrfAttrs( this, AST__TEXT_ID, 0, GRF__TEXT, method, class );

/* Restore the original value of the flag which says whether graphical
   escape sequences should be incldued in any returned text strings. */
   astEscapes( escs );

/* Return */
   return;
}

static AstPointSet *Transform( AstMapping *this_mapping, AstPointSet *in,
                               int forward, AstPointSet *out, int *status ) {
/*
*  Name:
*     Transform

*  Purpose:
*     Use a Plot to transform a set of points.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     AstPointSet *Transform( AstMapping *this, AstPointSet *in,
*                             int forward, AstPointSet *out, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the astTransform protected
*     method inherited from the Plot class).

*  Description:
*     This function takes a Plot3D and a set of points encapsulated in a
*     PointSet and transforms the points from graphics coordinates to
*     physical coordinates (in the forward direction). No clipping or
*     normalisation is applied.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     in
*        Pointer to the PointSet holding the input coordinate data.
*     forward
*        A non-zero value indicates that the forward coordinate
*        transformation should be applied while a zero value requests the
*        inverse transformation.
*     out
*        Pointer to a PointSet which will hold the transformed (output)
*        coordinate values. A NULL value may also be given, in which case a
*        new PointSet will be created by this function.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Pointer to the output (possibly new) PointSet.

*  Notes:
*     -  A null pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*     -  The number of coordinate values per point in the input PointSet must
*     match the number of coordinates for the Plot being applied.
*     -  If an output PointSet is supplied, it must have space for sufficient
*     number of points and coordinate values per point to accommodate the
*     result. Any excess space will be ignored.
*/

/* Local Variables: */
   AstMapping *map;              /* Pointer to the mapping */
   AstPointSet *result;          /* Positions in output Frame */
   AstPlot3D *this;              /* The Plot3D */

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

/* Get a pointer to the Plot3D. */
   this = (AstPlot3D *) this_mapping;

/* Get the Mapping from the base to the current Frame. */
   map = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Do the transformation. */
   result = astTransform( map, in, forward, out );

/* Annul the mapping. */
   map = astAnnul( map );

/* If an error has occurred, annul the result. */
   if( !astOK ) result = astAnnul( result );

/* Return a pointer to the output PointSet. */
   return result;

}

static void UpdatePlots( AstPlot3D *this, int *status ) {
/*
*  Name:
*     UpdatePlots

*  Purpose:
*     Update the three 2D plots stored in the Plot3D.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot3d.h"
*     void UpdatePlots( AstPlot3D *this )

*  Class Membership:
*     Plot3D method.

*  Description:
*     This function splits the parent FrameSet up into 3 independent 2D
*     FrameSets, each describing a 2D plane in the supplied 3D FrameSet.
*     It then uses these 2D FrameSets to update the three Plots in the
*     Plot3D, by removing the existing current Frame and adding in the
*     new current Frame with the associated Mapping.

*  Parameters:
*     this
*        Pointer to the Plot3D.

*  Notes:
*     - Each of the 3 plots has 3 Frames: Frame 1 is the base (GRAPHICS)
*     Frame; Frame 2 is spanned by 2 of the 3 axes in the base Frame of
*     the supplied FrameSet; Frame 3 is the current Frame and is spanned
*     by 2 of the 3 axes in the current Frame of the supplied FrameSet.
*     Any future changes to this function that alter this structure should
*     reflected in equivalewnt changes to function CreatePlots.
*/

/* Local Variables: */
   AstFrame *frm;
   AstFrameSet *fsetxy;
   AstFrameSet *fsetxz;
   AstFrameSet *fsetyz;
   AstFrameSet *fset;
   AstMapping *map;
   int baseplane;
   int labelxy[ 2 ];
   int labelxz[ 2 ];
   int labelyz[ 2 ];
   int wcsxy[ 2 ];
   int wcsxz[ 2 ];
   int wcsyz[ 2 ];
   int rootcorner;

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

/* Return without action if the Plot3D does not contain the three 2D
   Plots. This may be the case for instance if this function is called
   before the Plot3D is fully constructed. */
   if( this->plotxy && this->plotxz && this->plotyz ){

/* We need a FrameSet that is equivalent to the one that was used to
   construct the Plot3D (i.e. a FrameSet that does not have the GRAPHICS
   Frame that was added by the Plot3D constructor). So take a copy of the
   parent FrameSet, remove the GRAPHICS Frame (Frame 1) and set the base
   Frame to be the Frame that was the base Frame when the Plot3D was
   constructed. */
      fset = (AstFrameSet *) astCast( this, dummy_frameset );
      astSetBase( fset, this->pix_frame );
      astRemoveFrame( fset, 1 );

/* Split the supplied FrameSet up into 3 FrameSets, each with a 2D base
   and current Frame. Each of these FrameSets describes one plane of
   the 3D cube. */
      SplitFrameSet( fset, &fsetxy, labelxy, wcsxy, &fsetxz, labelxz, wcsxz,
                     &fsetyz, labelyz, wcsyz, &baseplane, status );

/* First do the XY Plot. Extract the current Frame and base->current
   Mapping from the new FrameSet. It is assumed that he base Frame in the
   new FrameSet is equivalent to Frame 2 in the existing Plot. This
   assumption is based on the way the CreatePlots and SplitFrameSet
   functions work, and should be reviewed if either of these functions
   is changed. */
      frm = astGetFrame( fsetxy, 2 );
      map = astGetMapping( fsetxy, 1, 2 );

/* Add the new Frame into the existing Plot using the Mapping to connect
   it to Frame 2 in the Plot. It becomes the current Frame in the Plot. */
      astAddFrame( this->plotxy, 2, map, frm );

/* Delete the original current Frame in the Plot since it is not needed
   any more. */
      astRemoveFrame( this->plotxy, 3 );

/* Set the Plot attributes. */
      SetPlotAttr( this->plotxy, XY, labelxy, status );

/* Free resources */
      fsetxy = astAnnul( fsetxy );
      map = astAnnul( map );
      frm = astAnnul( frm );

/* Do the same for the XZ plot. */
      frm = astGetFrame( fsetxz, 2 );
      map = astGetMapping( fsetxz, 1, 2 );
      astAddFrame( this->plotxz, 2, map, frm );
      astRemoveFrame( this->plotxz, 3 );
      SetPlotAttr( this->plotxz, XZ, labelxz, status );
      fsetxz = astAnnul( fsetxz );
      map = astAnnul( map );
      frm = astAnnul( frm );

/* Do the same for the YZ plot. */
      frm = astGetFrame( fsetyz, 2 );
      map = astGetMapping( fsetyz, 1, 2 );
      astAddFrame( this->plotyz, 2, map, frm );
      astRemoveFrame( this->plotyz, 3 );
      SetPlotAttr( this->plotyz, YZ, labelyz, status );
      fsetyz = astAnnul( fsetyz );
      map = astAnnul( map );
      frm = astAnnul( frm );

/* Store information that allows each 3D WCS axis to be associatedf with
   a pair of Plots. Also store the WCS axis within each Plot that
   corresponds to the 3D WCS axis. */
      StoreAxisInfo( this, labelxy, wcsxy, labelxz, wcsxz, labelyz, wcsyz, status );

/* Set up the Edges attributes in the encapsulated Plots to produce labels
   on the required edges of the 3D graphics cube. */
      rootcorner = astGetRootCorner( this );
      ChangeRootCorner( this, rootcorner, rootcorner, status );

/* Store the plane spanned by two connected 3D axes. */
      this->baseplot = baseplane;

/* Free remaining resources */
      fset = astAnnul( fset );
   }
}

static void VSet( AstObject *this_object, const char *settings,
                  char **text, va_list args, int *status ) {
/*
*  Name:
*     VSet

*  Purpose:
*     Set values for a Plot3D's attributes.

*  Type:
*     Private function.

*  Synopsis:
*     #include "frameset.h"
*     void VSet( AstObject *this, const char *settings, char **text,
*                va_list args, int *status )

*  Class Membership:
*     Plot3D member function (over-rides the protected astVSet
*     method inherited from the Object class).

*  Description:
*     This function assigns a set of attribute values for a Plot3D,
*     the attributes and their values being specified by means of a
*     string containing a comma-separated list of the form:
*
*        "attribute1 = value1, attribute2 = value2, ... "
*
*     Here, "attribute" specifies an attribute name and the value to
*     the right of each "=" sign should be a suitable textual
*     representation of the value to be assigned to that attribute. This
*     will be interpreted according to the attribute's data type.
*
*     The string supplied may also contain "printf"-style format
*     specifiers identified by a "%" sign in the usual way. If
*     present, these will be substituted by values supplied as
*     optional arguments (as a va_list variable argument list), using
*     the normal "printf" rules, before the string is used.

*  Parameters:
*     this
*        Pointer to the Plot3D.
*     settings
*        Pointer to a null-terminated string containing a
*        comma-separated list of attribute settings.
*     text
*        Pointer to a location at which to return a pointer to dynamic
*        memory holding a copy of the expanded setting string. This memory
*        should be freed using astFree when no longer needed. If a NULL
*        pointer is supplied, no string is created.
*     args
*        The variable argument list which contains values to be
*        substituted for any "printf"-style format specifiers that
*        appear in the "settings" string.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function preserves the integrity of the Plot3D (if
*     possible) by appropriately modifying the three encapsulated Plots.
*/

/* Invoke the parent astVSet method to set the Plot3D's attribute values. */
   (*parent_vset)( this_object, settings, text, args, status );

/* Update the three 2D Plots stored in the Plot3D structure so that they
   reflect this modified FrameSet. */
   UpdatePlots( (AstPlot3D *) this_object, status );
}

/* Functions which access Plot3D class attributes. */
/* ----------------------------------------------- */

/* RootCorner. */
/* ----------- */
/*
*att++
*  Name:
*     RootCorner

*  Purpose:
*     Specifies which edges of the 3D box should be annotated.

*  Type:
*     Public attribute.

*  Synopsis:
*     String.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     which edges of the cube enclosing the 3D graphics space are used
*     for displaying numerical and descriptive axis labels. The attribute
*     value identifies one of the eight corners of the cube within
*     which graphics are being drawn (i.e. the cube specified by the
c     "graphbox" parameter when astPlot3D
f     GRAPHBOX argument when AST_PLOT3D
*     was called tp create the Plot3D). Axis labels and tick marks will
*     be placed on the three cube edges that meet at the given corner.
*
*     The attribute value should consist of three character, each of
*     which must be either "U" or "L". The first character in the string
*     specifies the position of the corner on the first graphics axis.
*     If the character is "U" then the corner is at the upper bound on the
*     first graphics axis. If it is "L", then the corner is at the lower
*     bound on the first axis. Likewise, the second and third characters
*     in the string specify the location of the corner on the second and
*     third graphics axes.
*
*     For instance, corner "LLL" is the corner that is at the lower bound
*     on all three graphics axes, and corner "ULU" is at the upper bound
*     on axes 1 and 3 but at the lower bound on axis 2.
*
*     The default value is "LLL".

*  Applicability:
*     Plot3D
*        All Plot3Ds have this attribute.

*att--
*/

/* Internally, the RootCorner is represented as an integer bit mask, with
   bit zero for the X axis, bit 1 for the Y axis and bit 2 for the Z axis.
   A bit is set if the corner is at the upper bound on the axis and unset
   if it is at the lower bound. A value of -1 indicates that the attribue
   has not been assigned a value. */
astMAKE_GET(Plot3D,RootCorner,int,0,( this->rootcorner == -1 ? 0 : this->rootcorner))
astMAKE_TEST(Plot3D,RootCorner,( this->rootcorner != -1 ))


/* Norm(axis). */
/* ----------- */
/*
*att++
*  Name:
*     Norm(axis)

*  Purpose:
*     Specifies the plane upon which a Plot3D draws text and markers.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of text and markers drawn
*     by a Plot3D. It specifies the orientation of the plane upon which
*     text and markers will be drawn by all subsequent invocations of the
c     astText and astMark functions.
f     AST_TEXT and AST_MARK functions.
*
*     When setting or getting the Norm attribute, the attribute name must
*     be qualified by an axis index in the range 1 to 3. The 3 elements of
*     the Norm attribute are together interpreted as a vector in 3D graphics
*     coordinates that is normal to the plane upon which text and marks
*     should be drawn. When testing or clearing the attribute, the axis
*     index is optional. If no index is supplied, then clearing the Norm
*     attribute will clear all three elements, and testing the Norm attribute
*     will return a non-zero value if any of the three elements are set.
*
*     The default value is 1.0 for each of the 3 elements. The length of
*     the vector is insignificant, but an error will be reported when
*     attempting to draw text or markers if the vector has zero length.

*  Applicability:
*     Plot
*        All Plot3Ds have this attribute.

*att--
*/
MAKE_CLEAR3(Norm,norm,AST__BAD,3)
MAKE_SET3(Norm,double,norm,value,3)
MAKE_TEST3(Norm,( this->norm[axis] != AST__BAD ),3)
MAKE_GET3(Norm,double,AST__BAD,(this->norm[axis]!=AST__BAD?this->norm[axis]:1.0),3)



/* Functions which access Plot class attributes. */
/* --------------------------------------------- */

/* First do axis specific attributes. */

#define MAKE_ALL(attr,type,badval,whichplots) \
   MAKE_CLEAR(attr,whichplots) \
   MAKE_SET(attr,type,whichplots) \
   MAKE_GET(attr,type,badval )

MAKE_ALL(MinTick,int,0,0)
MAKE_ALL(Abbrev,int,0,1)
MAKE_ALL(Gap,double,AST__BAD,1)
MAKE_ALL(LogGap,double,AST__BAD,1)
MAKE_ALL(LogPlot,int,0,0)
MAKE_ALL(LogTicks,int,0,0)
MAKE_ALL(LogLabel,int,0,1)
MAKE_ALL(LabelUp,int,0,1)
MAKE_ALL(DrawAxes,int,0,0)
MAKE_ALL(LabelUnits,int,0,1)
MAKE_ALL(MinTickLen,double,0.0,0)
MAKE_ALL(MajTickLen,double,0.0,0)
MAKE_ALL(NumLab,int,0,1)
MAKE_ALL(NumLabGap,double,AST__BAD,1)
MAKE_ALL(TextLab,int,0,1)
MAKE_ALL(TextLabGap,double,AST__BAD,1)

#undef MAKE_ALL


/* Now do attributes that are not axis specific. */

#define MAKE_ALL(attr,type) \
   MAKE_CLEAR1(attr) \
   MAKE_SET1(attr,type)

MAKE_ALL(Ink,int)
MAKE_ALL(Tol,double)
MAKE_ALL(Invisible,int)
MAKE_ALL(TickAll,int)
MAKE_ALL(ForceExterior,int)
MAKE_ALL(Border,int)
MAKE_ALL(Clip,int)
MAKE_ALL(ClipOp,int)
MAKE_ALL(Escape,int)
MAKE_ALL(Grid,int)
MAKE_ALL(Labelling,int)

#undef MAKE_ALL



/* First do element-specific attributes. */

#define MAKE_ALL(attr,type) \
   MAKE_CLEAR2(attr) \
   MAKE_SET2(attr,type)

MAKE_ALL(Style,int)
MAKE_ALL(Font,int)
MAKE_ALL(Colour,int)
MAKE_ALL(Width,double)
MAKE_ALL(Size,double)

#undef MAKE_ALL





/* Copy constructor. */
/* ----------------- */
static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
/*
*  Name:
*     Copy

*  Purpose:
*     Copy constructor for Plot3D objects.

*  Type:
*     Private function.

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

*  Description:
*     This function implements the copy constructor for Plot3D 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: */
   AstPlot3D *in;             /* Pointer to input Plot3D */
   AstPlot3D *out;            /* Pointer to output Plot3D */

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

/* Obtain pointers to the input and output Plot3Ds. */
   in = (AstPlot3D *) objin;
   out = (AstPlot3D *) objout;

/* Nullify the pointers stored in the output object since these will
   currently be pointing at the input data (since the output is a simple
   byte-for-byte copy of the input). Otherwise, the input data could be
   freed by accidient if the output object is deleted due to an error
   occuring in this function. */
   out->plotxy = NULL;
   out->plotxz = NULL;
   out->plotyz = NULL;

/* Copy the encapsulated Plots */
   if( in->plotxy ) out->plotxy = astCopy( in->plotxy );
   if( in->plotxz ) out->plotxz = astCopy( in->plotxz );
   if( in->plotyz ) out->plotyz = astCopy( in->plotyz );

/* If an error has occurred, free the output resources. */
   if( !astOK ) Delete( (AstObject *) out, status );

}

/* Destructor. */
/* ----------- */
static void Delete( AstObject *obj, int *status ) {
/*
*  Name:
*     Delete

*  Purpose:
*     Destructor for Plot3D objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Delete( AstObject *obj, int *status )

*  Description:
*     This function implements the destructor for Plot3D 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: */
   AstPlot3D *this;

/* Release the memory referred to in the Plot3D structure. */
   this = (AstPlot3D *) obj;
   if( this ) {
      this->plotxy = astDelete( this->plotxy );
      this->plotxz = astDelete( this->plotxz );
      this->plotyz = astDelete( this->plotyz );
   }
}

/* Dump function. */
/* -------------- */
static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
/*
*  Name:
*     Dump

*  Purpose:
*     Dump function for Plot3D 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 Plot3D class to an output Channel.

*  Parameters:
*     this
*        Pointer to the Plot3D 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 */

/* Local Variables: */
   AstPlot3D *this;
   double dval;
   char key[ KEY_LEN + 1 ];
   int axis;
   int helpful;
   int ival;
   int set;
   const char *text;

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

/* Obtain a pointer to the Plot3D structure. */
   this = (AstPlot3D *) this_object;

/* Write out values representing the instance variables for the
   Plot3D 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. */


/* Norm. */
/* ----- */
   for ( axis = 0; axis < 3; axis++ ) {
      dval = astGetNorm( this, axis );
      helpful = ( dval != -DBL_MAX );
      (void) sprintf( key, "Norm%d", axis + 1 );
      astWriteDouble( channel, key, 0, helpful, dval, "Text plane normal vector");
   }

/* RootCorner. */
/* ----------- */
   set = TestRootCorner( this, status );
   ival = set ? GetRootCorner( this, status ) : astGetRootCorner( this );
   text = RootCornerString( ival, status );
   if( text ) {
      astWriteString( channel, "RootCn", set, 1, text, "Corner where labelled axes meet" );
   } else if( astOK ) {
      astError( AST__INTER, "astDump(Plot3D): Illegal value %d found for "
                "RootCorner attribute (interbal AST programming error).", status,
                ival );
   }

/* Labelled axes */
   astWriteInt( channel, "AxPlX1", 1, 1, this->axis_plot1[0],
                "Plot used to label the 3D X axis" );
   astWriteInt( channel, "AxPlY1", 1, 1, this->axis_plot1[1],
                "Plot used to label the 3D Y axis" );
   astWriteInt( channel, "AxPlZ1", 1, 1, this->axis_plot1[2],
                "Plot used to label the 3D Z axis" );
   astWriteInt( channel, "AxInX1", 1, 1, this->axis_index1[0],
                "Plot axis index used to label the 3D X axis" );
   astWriteInt( channel, "AxInY1", 1, 1, this->axis_index1[1],
                "Plot axis index used to label the 3D Y axis" );
   astWriteInt( channel, "AxInZ1", 1, 1, this->axis_index1[2],
                "Plot axis index used to label the 3D Z axis" );

/* Unlabelled axes */
   astWriteInt( channel, "AxPlX2", 1, 1, this->axis_plot2[0],
                "Other Plot touching the 3D X axis" );
   astWriteInt( channel, "AxPlY2", 1, 1, this->axis_plot2[1],
                "Other Plot touching the 3D Y axis" );
   astWriteInt( channel, "AxPlZ2", 1, 1, this->axis_plot2[2],
                "Other Plot touching the 3D Z axis" );
   astWriteInt( channel, "AxInX2", 1, 1, this->axis_index2[0],
                "Other Plot axis index touching the 3D X axis" );
   astWriteInt( channel, "AxInY2", 1, 1, this->axis_index2[1],
                "Other Plot axis index touching the 3D Y axis" );
   astWriteInt( channel, "AxInZ2", 1, 1, this->axis_index2[2],
                "Other Plot axis index touching the 3D Z axis" );

/* The Plot that spans the two connected axes. */
   astWriteInt( channel, "BasePl", 1, 1, this->baseplot,
                "Plot spanning two connected 3D axes" );

/* XY Plot */
   astWriteObject( channel, "PlotXY", 1, 1, this->plotxy,
                   "Plot describing the XY plane" );

/* XZ Plot */
   astWriteObject( channel, "PlotXZ", 1, 1, this->plotxz,
                   "Plot describing the XZ plane" );

/* YZ Plot */
   astWriteObject( channel, "PlotYZ", 1, 1, this->plotyz,
                   "Plot describing the YZ plane" );

/* The index within the Plot3D FrameSet, of the original base Frame in
   the FrameSet supplied when the Plot3D was constructed. */
   astWriteInt( channel, "PixFrm", 1, 0, this->pix_frame,
                "Index of original base Frame" );

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

/* Standard class functions. */
/* ========================= */
/* Implement the astIsAPlot3D and astCheckPlot3D functions using the
   macros defined for this purpose in the "object.h" header file. */
astMAKE_ISA(Plot3D,Plot)
astMAKE_CHECK(Plot3D)


AstPlot3D *astPlot3D_( void *frame_void, const float *graphbox,
                       const double *basebox, const char *options, int *status, ...) {
/*
*+
*  Name:
*     astPlot3D

*  Purpose:
*     Create a Plot3D.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot3d.h"
*     AstPlot3D *astPlot3D( AstFrame *frame, const float *graphbox,
*                           const double *basebox, const char *options, ..., int *status )

*  Class Membership:
*     Plot3D constructor.

*  Description:
*     This function creates a new Plot3D and optionally initialises its
*     attributes.
*
*     The supplied Frame (or the base frame if a FrameSet was supplied) is
*     assumed to be related to the graphics world coordinate system by a
*     simple shift and scale along each axis. The mapping between graphics
*     world coordinates and this Frame is specified by supplying the
*     coordinates in both systems at the lower bounds and upper bounds corners
*     of a box on the graphics device. By default, no graphics will be
*     produced outside the supplied box, but this default behaviour can be
*     changed by setting explicit values for the various clipping attributes.

*  Parameters:
*     frame
*        A pointer to a Frame or FrameSet to be annotated. If a NULL pointer
*        is supplied, then a default 3-D Frame will be created to which labels,
*        etc, can be attached by setting the relevant Frame attributes.
*     graphbox
*        A pointer to an array of 6 values giving the graphics world
*        coordinates of the lower bounds and upper bound corners of a box on
*        the graphics output device. The first triple of values should be the
*        coordinates of the lower bounds corner of the box and the second
*        triple of values should be the coordinates of the upper bounds corner.
*     basebox
*        A pointer to an array of 6 values giving the coordinates in the
*        supplied Frame, or base frame of the supplied FrameSet, at the
*        lower bounds corner and upper bounds corners of the box specified
*        by parameter graphbox. These should be supplied in the same order as
*        for parameter "graphbox".
*     options
*        Pointer to a null terminated string containing an optional
*        comma-separated list of attribute assignments to be used for
*        initialising the new Plot3D. The syntax used is the same as for the
*        astSet method and may include "printf" format specifiers identified
*        by "%" symbols in the normal way.
*     status
*        Pointer to the inherited status variable.
*     ...
*        If the "options" string contains "%" format specifiers, then an
*        optional list of arguments may follow it in order to supply values to
*        be substituted for these specifiers. The rules for supplying these
*        are identical to those for the astSet method (and for the C "printf"
*        function).

*  Returned Value:
*     A pointer to the new Plot3D.

*  Notes:
*     -  A NULL pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*-

*  Implementation Notes:
*     - This function implements the basic Plot3D constructor which
*     is available via the protected interface to the Plot3D class.
*     A public interface is provided by the astPlot3DId_ function.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstFrame *frame;              /* Pointer to Frame structure */
   AstPlot3D *new;               /* Pointer to new Plot3D */
   va_list args;                 /* Variable argument list */

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

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

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   new = NULL;

/* Obtain and validate a pointer to any supplied Frame structure. */
   if( frame_void ){
      frame = astCheckFrame( frame_void );
   } else {
      frame = NULL;
   }

/* Check the pointer can be used. */
   if ( astOK ) {

/* Initialise the Plot3D, allocating memory and initialising the
   virtual function table as well if necessary. */
      new = astInitPlot3D( NULL, sizeof( AstPlot3D ), !class_init,
                           &class_vtab, "Plot3D", frame, graphbox,
                           basebox );

/* If successful, note that the virtual function table has been
   initialised. */
      if ( astOK ) {
         class_init = 1;

/* Obtain the variable argument list and pass it along with the
   options string to the astVSet method to initialise the new
   Plot's attributes. */
         va_start( args, status );
         astVSet( new, options, NULL, args );
         va_end( args );

/* If an error occurred, clean up by deleting the new object. */
         if ( !astOK ) new = astDelete( new );
      }
   }

/* Return a pointer to the new Plot. */
   return new;
}

AstPlot3D *astInitPlot3D_( void *mem, size_t size, int init,
                           AstPlot3DVtab *vtab, const char *name,
                           AstFrame *frame, const float *graphbox,
                           const double *basebox, int *status ) {
/*
*+
*  Name:
*     astInitPlot3D

*  Purpose:
*     Initialise a Plot3D.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot3d.h"
*     AstPlot3D *astInitPlot3D( void *mem, size_t size, int init,
*                               AstPlotVtab *vtab, const char *name,
*                               AstFrame *frame, const float *graphbox,
*                               const double *basebox )

*  Class Membership:
*     Plot3D initialiser.

*  Description:
*     This function is provided for use by class implementations to
*     initialise a new Plot3D object. It allocates memory (if
*     necessary) to accommodate the Plot3D plus any additional data
*     associated with the derived class. It then initialises a
*     Plot3D 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 Plot3D at the start of the memory passed via the
*     "vtab" parameter.

*  Parameters:
*     mem
*        A pointer to the memory in which the Plot3D is to be
*        created. This must be of sufficient size to accommodate the
* 	 Plot3D data (sizeof(Plot3D)) 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 Plot3D (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 Plot3D structure, so a valid value must be supplied
*	 even if not required for allocating memory.
*     init
*        A logical flag indicating if the Plot3D'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 Plot3D.
*     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).
*     fset
*        A pointer to the Frame or Frameset to be annotated.
*     graphbox
*        A pointer to an array of 6 values giving the graphics coordinates
*        of the bottom left and top right corners of a box on the graphics
*        output device. The first triple of values should be the graphics
*        coordinates of the bottom left corner of the box and the second
*        triple of values are the graphics coordinates of the top right corner.
*     basebox
*        A pointer to an array of 6 values giving the coordinates in the
*        supplied Frame or base Frame of the supplied FrameSet at the bottom
*        left and top right corners of the box specified by parameter graphbox.
*        These should be supplied in the same order as for parameter "graphbox".

*  Returned Value:
*     A pointer to the new Plot3D.

*  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 *baseframe = NULL;  /* Pointer to base frame */
   AstFrame *graphicsframe = NULL; /* Pointer to graphics frame */
   AstFrameSet *fset0 = NULL;   /* The n-D FrameSet to be annotated */
   AstFrameSet *fset = NULL;    /* The 2-D FrameSet to be annotated */
   AstMapping *map = NULL;      /* Mapping for converting bbox -> gbox */
   AstPlot3D *new = NULL;       /* Pointer to new Plot3D */
   char *mess = NULL;           /* Pointer to a descriptive message */
   double djunkbox[ 4 ] = { 0.0, 0.0, 1.0, 1.0 }; /* Dummy 2D basebox */
   float fjunkbox[ 4 ] = { 0.0, 0.0, 1.0, 1.0 }; /* Dummy 2D graphbox */
   int bi;                      /* Index of base frame */
   int ci;                      /* Index of current frame */
   int i;                       /* Loop count */
   int ii;                      /* Loop count */
   int naxes;                   /* No. of axes in frame */
   int nfrm;                    /* Number of Frames in frameset */

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

/* If necessary, initialise the virtual function table. */
   if ( init ) astInitPlot3DVtab( vtab, name );

/* First of all we need to ensure that we have a FrameSet and a base
   Frame on which to base the new Plot3D. If a NULL Frame pointer was
   supplied, create a default 3-D Frame, and then create a FrameSet
   containing just this default Frame. Also store a pointer to a
   message which can be used to describe the object within error
   messages. */
   if( !frame ){
      baseframe = astFrame( 3, "", status );
      fset = astFrameSet( baseframe, "", status );
      mess = "default 3-d Frame";

/* If an object was supplied, report an error if it is not a Frame or
   an object derived from a Frame (such as a FrameSet). */
   } else if( !astIsAFrame( frame ) ){
      if( astOK ){
         astError( AST__BDOBJ, "astInitPlot3D(%s): Supplied Object (class '%s') "
                   "is not a Frame.", status, name, astGetClass( frame ) );
      }

/* If the supplied object is a Plot3D or an object derived from a Plot3D
   (a Plot3D is a sort of Frame and so will pass the above test), extract a
   FrameSet from the Plot3D, and clear the Domain attribute for any existing
   Frames which have Domain GRAPHICS. */
   } else if( astIsAPlot3D( frame ) ){
      fset0 = astFrameSet( frame, "", status );
      fset = astCopy( fset0 );
      fset0 = astAnnul( fset0 );

      for( i = 0; i < astGetNframe( fset ); i++ ) {
         graphicsframe = astGetFrame( fset, i );
         if( !strcmp( astGetDomain( graphicsframe ), "GRAPHICS" ) ) {
            astClearDomain( graphicsframe );
         }
         graphicsframe = astAnnul( graphicsframe );
      }

      baseframe = astGetFrame( fset, astGetBase( fset ) );
      mess = "base Frame of the supplied Plot3D";

/* If the object is not a FrameSet, create a FrameSet holding the
   supplied Frame. If the Frame is not 3D, an extra 3D Frame is
   included in the FrameSet derived from axes 1, 2 and 3 of the supplied
   Frame. This new Frame becomes the base Frame. */
   } else if( !astIsAFrameSet( frame ) ){
      fset0 = astFrameSet( frame, "", status );
      mess = "supplied Frame";
      fset = Fset3D( fset0, AST__BASE, status );
      fset0 = astAnnul( fset0 );
      baseframe = astGetFrame( fset, astGetBase( fset ) );

/* If a FrameSet was supplied, ensure it has a 3D base Frame.
   If the supplied FrameSet is not 3D, then a new base Frame is
   inserted into it which is derived from axes 1, 2 and 3 of the
   original base Frame. */
   } else {
      fset = Fset3D( (AstFrameSet *) frame, AST__BASE, status );
      baseframe = astGetFrame( fset, astGetBase( fset ) );
      mess = "base Frame of the supplied FrameSet";
   }

/* Check that there are 3 axes in the base frame of the FrameSet. */
   naxes = astGetNaxes( baseframe );
   if ( naxes != 3 && astOK ) {
      astError( AST__NAXIN, "astInitPlot3D(%s): Number of axes (%d) in the %s "
                "is invalid - this number should be 3.", status, name, naxes, mess );
   }

/* Check that no dimension of the graphbox is bad. */
   if( astISBAD(graphbox[0]) || astISBAD(graphbox[1]) ||
       astISBAD(graphbox[2]) || astISBAD(graphbox[3]) ||
       astISBAD(graphbox[4]) || astISBAD(graphbox[5]) ) {
      astError( AST__BADBX, "astInitPlot3D(%s): The plotting volume has undefined limits "
                "in the graphics world coordinate system.", status, name );
   }

/* Check that no dimension of the graphbox is zero. */
   if( ( graphbox[ 3 ] == graphbox[ 0 ] ||
         graphbox[ 4 ] == graphbox[ 1 ] ||
         graphbox[ 5 ] == graphbox[ 2 ] ) && astOK ){
      astError( AST__BADBX, "astInitPlot3D(%s): The plotting volume has zero size "
                "in the graphics world coordinate system.", status, name );
   }

/* Check that no dimension of the basebox is bad. */
   if( astISBAD(basebox[0]) || astISBAD(basebox[1]) ||
       astISBAD(basebox[2]) || astISBAD(basebox[3]) ||
       astISBAD(basebox[4]) || astISBAD(basebox[5]) ) {
      astError( AST__BADBX, "astInitPlot3D(%s): The limits of "
                "the %s are undefined or bad.", status, name, name );
   }

/* Create a Frame which describes the graphics world coordinate system. */
   graphicsframe = astFrame( 3, "Domain=GRAPHICS,Title=Graphical Coordinates", status );

/* Initialise a 2D Plot structure (the parent class) as the first component
   within the Plot3D structure, allocating memory if necessary. We supply
   dummy arguments since we will not be using the parent Plot class to
   draw anything. We supply a NULL vtab pointer so that methods defined by
   the Plot class will be used during the construction of the Plot3D. Once
   the Plot3D is fully constructed, we will use astSetVtab to establish
   the correct vtab. */
   new = (AstPlot3D *) astInitPlot( mem, size, 0, NULL, name, NULL, fjunkbox,
                                    djunkbox );
   if ( astOK ) {

/* Initialise the Plot3D data. */
/* ----------------------------- */

/* Remove all Frames from the parent FrameSet except for the base (2D graphics)
   Frame (we leave this last Frame since an error is reported if the last
   Frame is removed from a FrameSet). We do this by repeatedly removing the
   first Frame, causing all remaining Frames to have their index reduced by 1.
   When the base Frame arrives at index 1, we skip it and start removing the
   second frame instead. */
      nfrm = astGetNframe( new );
      i = 1;
      for( ii = 0; ii < nfrm; ii++ ) {
         if( i > 1 || astGetBase( new ) != 1 ) {
            astRemoveFrame( new, i );
         } else {
            i = 2;
         }
      }

/* Add in the 3D graphics Frame, using a PermMap to connect it to the
   2D graphics Frame. */
      map = (AstMapping *) astPermMap( 2, NULL, 3, NULL, NULL, "", status );
      astAddFrame( new, 1, map, graphicsframe );
      map = astAnnul( map );

/* And remove the 2D GRAPHICS Frame, leaving just the 3D GRAPHICS Frame
   in the FrameSet, with index 1. */
      astRemoveFrame( new, 1 );

/* Get the index of the current (physical) and base (pixel) Frames in
   the supplied FrameSet. */
      bi = astGetBase( fset );
      ci = astGetCurrent( fset );

/* Temporarily set the current Frame to be the pixel frame. */
      astSetCurrent( fset, bi );

/* Get a double precision version of "graphbox", and store it in the
   Plot3D structure. */
      new->gbox[ 0 ] = (double) graphbox[ 0 ];
      new->gbox[ 1 ] = (double) graphbox[ 1 ];
      new->gbox[ 2 ] = (double) graphbox[ 2 ];
      new->gbox[ 3 ] = (double) graphbox[ 3 ];
      new->gbox[ 4 ] = (double) graphbox[ 4 ];
      new->gbox[ 5 ] = (double) graphbox[ 5 ];

/* The base Frame of the supplied FrameSet is mapped linearly onto the
   graphics frame. Create a WinMap that maps the base box (within the
   base Frame of the supplied FrameSet) onto the graphics box. */
      map = (AstMapping *) astWinMap( 3, new->gbox, new->gbox + 3, basebox,
                                      basebox + 3, "", status );

/* Add the supplied FrameSet into the Plot3D (i.e. FrameSet) created
   earlier. This leaves the graphics frame with index 1 in the
   returned  Plot3D. */
      astAddFrame( (AstFrameSet *) new, 1, map, fset );
      map = astAnnul( map );

/* Set the current Frame in the Plot to be the physical coordinate Frame
   (with index incremented by one because the graphics Frame has been added). */
      astSetCurrent( (AstFrameSet *) new, ci + 1 );

/* Note the index of the original base Frame in the Plot3D FrameSet */
      new->pix_frame = bi + 1;

/* Re-establish the original current Frame in the supplied FrameSet. */
      astSetCurrent( fset, ci );

/* Initialise the Plot pointers. */
      new->plotxy = NULL;
      new->plotxz = NULL;
      new->plotyz = NULL;

/* Initialise other attributes */
      new->rootcorner = -1;

/* Initialise the normal vector to the plane used by astText and astMark. */
      new->norm[ 0 ] = AST__BAD;
      new->norm[ 1 ] = AST__BAD;
      new->norm[ 2 ] = AST__BAD;

/* Create three 2D Plots to describe the three planes in the cube. */
      CreatePlots( new, fset, graphbox, basebox, status );

/* Ensure that attempts to use the graphics interface of the parent
   Plot structure get forwarded to the relevant 3D routines defined in
   this class. */
      astGrfSet( new, "Attr", (AstGrfFun) Attr3D );
      astSetGrf( new, 1 );

/* Change the virtual function table stored in the new Plot3D, from the Plot
   vtab (established when astINitPlot was called above), to the supplied
   vtab. */
      if( vtab ) astSetVtab( new, vtab );

/* Ensure that these Plots use the grf functions defined by this class
   (Plot3D). This means that whenever a Plot draws anything, it will use
   the appropriate grf function defined in this class to do the drawing.
   The grf functions defined in this class, convert the grf call into a
   grf3D call apprpriate the plane spanned by the Plot. */
      Set3DGrf( new, new->plotxy, XY, status );
      Set3DGrf( new, new->plotxz, XZ, status );
      Set3DGrf( new, new->plotyz, YZ, status );

/* Set up the Edges attributes in the encapsulated Plots so that labels
   appear on the requited edges. Initially, the root corner is "LLL"
   (i.e. the lower bound on every axis). */
      ChangeRootCorner( new, 0, 0, status );
   }

/* Annul the frame. */
   graphicsframe = astAnnul( graphicsframe );

/* If an error occurred, clean up by deleting the new object. */
   if ( !astOK ) new = astDelete( new );

/* Annul the pointer to the base Frame and FrameSet. */
   baseframe = astAnnul( baseframe );
   fset = astAnnul( fset );

/* Return a pointer to the new object. */
   return new;
}


AstPlot3D *astLoadPlot3D_( void *mem, size_t size, AstPlot3DVtab *vtab,
                           const char *name, AstChannel *channel, int *status ) {
/*
*+
*  Name:
*     astLoadPlot3D

*  Purpose:
*     Load a Plot3D.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot3d.h"
*     AstPlot3D *astLoadPlot3D( void *mem, size_t size,
*                               AstPlot3DVtab *vtab,
*                               const char *name, AstChannel *channel )

*  Class Membership:
*     Plot3D loader.

*  Description:
*     This function is provided to load a new Plot3D 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
*     Plot3D structure in this memory, using data read from the
*     input Channel.

*  Parameters:
*     mem
*        A pointer to the memory into which the Plot3D is to be
*        loaded.  This must be of sufficient size to accommodate the
*        Plot3D data (sizeof(Plot3D)) 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 Plot3D (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 Plot3D 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(AstPlot3D) is used instead.
*     vtab
*        Pointer to the start of the virtual function table to be
*        associated with the new Plot3D. If this is NULL, a pointer
*        to the (static) virtual function table for the Plot3D 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 "Plot3D" is used instead.

*  Returned Value:
*     A pointer to the new Plot3D.

*  Notes:
*     - A null pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Local Constants: */
#define KEY_LEN 50               /* Maximum length of a keyword */

/* Local Variables: */
   astDECLARE_GLOBALS
   AstPlot3D *new;
   char key[ KEY_LEN + 1 ];
   char *text;
   int axis;
   int i;

/* Initialise. */
   new = NULL;

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

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(channel);

/* If a NULL virtual function table has been supplied, then this is
   the first loader to be invoked for this Plot3D. In this case the
   Plot3D belongs to this class, so supply appropriate values to be
   passed to the parent class loader (and its parent, etc.). */
   if ( !vtab ) {
      size = sizeof( AstPlot3D );
      vtab = &class_vtab;
      name = "Plot3D";

/* If required, initialise the virtual function table for this class. */
      if ( !class_init ) {
         astInitPlot3DVtab( vtab, name );
         class_init = 1;
      }
   }

/* Allocate memory to hold the new Object. We allocate it now rather than
   waiting for astInitObject to allocate it so that we can pass a NULL
   vtab pointer to the Plot loader, thus causing the Plot loader to use the
   function implementations provided by the Plot class rather than those
   provided by the class being instantiated. */
   if( !mem ) mem = astMalloc( size );

/* 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 Plot3D. Pass a NULL vtab pointer so that the "new" object
   will be loaded using Plot methods rather than than Plot3D methods.
   This is important because the implementations provided by the Plot3D
   class for the Plot attribute accessors require the existence of the
   encapsulated Plots held within the Plot3D, but these have not yet been
   created. */
   new = astLoadPlot( mem, size, NULL, name, channel );
   if ( astOK ) {

/* Now modify the new object to use the supplied vtab. */
      astSetVtab( new, vtab );

/* Read input data. */
/* ================ */
/* Request the input Channel to read all the input data appropriate to
   this class into the internal "values list". */
      astReadClassData( channel, "Plot3D" );

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

/* Norm. */
/* ----- */
      for( axis = 0; axis < 3; axis++ ) {
         (void) sprintf( key, "norm%d", axis + 1 );
         new->norm[ axis ] = astReadDouble( channel, key, AST__BAD );
         if( TestNorm( new, axis, status ) ) SetNorm( new, axis, new->norm[ axis ], status );
      }

/* RootCorner. */
/* ----------- */
      text = astReadString( channel, "rootcn", " " );
      if( astOK && strcmp( text, " " ) ) {
         new->rootcorner = RootCornerInt( text, status );
         if( new->rootcorner < 0 && astOK ) {
            astError( AST__INTER, "astRead(Plot3D): Corrupt Plot3D contains "
                      "invalid RootCorner attribute value (%s).", status, text );
         }
      } else {
         new->rootcorner = -1;
      }
      text = astFree( text );

/* Labelled axes */
      new->axis_plot1[0] = astReadInt( channel, "axplx1", -1 );
      new->axis_plot1[1] = astReadInt( channel, "axply1", -1 );
      new->axis_plot1[2] = astReadInt( channel, "axplz1", -1 );

      new->axis_index1[0] = astReadInt( channel, "axinx1", -1 );
      new->axis_index1[1] = astReadInt( channel, "axiny1", -1 );
      new->axis_index1[2] = astReadInt( channel, "axinz1", -1 );

/* Unlabelled axes */
      new->axis_plot2[0] = astReadInt( channel, "axplx2", -1 );
      new->axis_plot2[1] = astReadInt( channel, "axply2", -1 );
      new->axis_plot2[2] = astReadInt( channel, "axplz2", -1 );

      new->axis_index2[0] = astReadInt( channel, "axinx2", -1 );
      new->axis_index2[1] = astReadInt( channel, "axiny2", -1 );
      new->axis_index2[2] = astReadInt( channel, "axinz2", -1 );

/* Plot that spans two connected 3D axes. */
      new->baseplot = astReadInt( channel, "basepl", -1 );

/* XY Plot */
      new->plotxy = astReadObject( channel, "plotxy", NULL );

/* XZ Plot */
      new->plotxz = astReadObject( channel, "plotxz", NULL );

/* YZ Plot */
      new->plotyz = astReadObject( channel, "plotyz", NULL );

/* The index within the Plot3D FrameSet, of the original base Frame in
   the FrameSet supplied when the Plot3D was constructed. */
      new->pix_frame = astReadInt( channel, "pixfrm", AST__NOFRAME );

/* Ensure that these Plots use the grf functions defined by this class
   (Plot3D). This means that whener a Plot draws anything, it will use
   the appropriate grf function defined in this class to do the drawing.
   The grf functions defined in this class, convert the grf call into a
   grf3D call apprpriate the plane spanned by the Plot. */
      Set3DGrf( new, new->plotxy, XY, status );
      Set3DGrf( new, new->plotxz, XZ, status );
      Set3DGrf( new, new->plotyz, YZ, status );

/* For attributes of the parent Plot class will have been loaded
   each attribute that has a set value in the parent Plot structure,
   re-set the value so that it gets copied to the copy the  to the
   encapsulated Plots. First do axis specific attributes. */

#define COPY_ATTR(attr,nval) \
   for( i = 0; i < nval; i++ ) { \
      if( astTest##attr(new,i) ) astSet##attr(new,i,astGet##attr(new,i)); \
   }

   COPY_ATTR(MinTick,3)
   COPY_ATTR(Abbrev,3)
   COPY_ATTR(Gap,3)
   COPY_ATTR(LogGap,3)
   COPY_ATTR(LogPlot,3)
   COPY_ATTR(LogTicks,3)
   COPY_ATTR(LogLabel,3)
   COPY_ATTR(LabelUp,3)
   COPY_ATTR(DrawAxes,3)
   COPY_ATTR(LabelUnits,3)
   COPY_ATTR(MinTickLen,3)
   COPY_ATTR(MajTickLen,3)
   COPY_ATTR(NumLab,3)
   COPY_ATTR(NumLabGap,3)
   COPY_ATTR(TextLab,3)
   COPY_ATTR(TextLabGap,3)

   COPY_ATTR(Style,AST__NPID)
   COPY_ATTR(Font,AST__NPID)
   COPY_ATTR(Colour,AST__NPID)
   COPY_ATTR(Width,AST__NPID)
   COPY_ATTR(Size,AST__NPID)

#undef COPY_ATTR

/* Now do attributes that are not axis specific. */

#define COPY_ATTR(attr) \
   if( astTest##attr(new) ) astSet##attr(new,astGet##attr(new));

   COPY_ATTR(Ink)
   COPY_ATTR(Tol)
   COPY_ATTR(Invisible)
   COPY_ATTR(TickAll)
   COPY_ATTR(ForceExterior)
   COPY_ATTR(Border)
   COPY_ATTR(Clip)
   COPY_ATTR(ClipOp)
   COPY_ATTR(Escape)
   COPY_ATTR(Grid)
   COPY_ATTR(Labelling)

#undef COPY_ATTR

/* If an error occurred, clean up by deleting the new Plot3D. */
      if ( !astOK ) new = astDelete( new );
   }

/* Return the new Plot3D 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 astClearRootCorner_( AstPlot3D *this, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Plot3D,ClearRootCorner))( this, status );
}

void astSetRootCorner_( AstPlot3D *this, int value, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Plot3D,SetRootCorner))( this, value, status );
}




/* 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. */
AstPlot3D *astPlot3DId_( void *frame_void, const float graphbox[6],
                         const double basebox[6], const char *, ... );

/* Special interface function implementations. */
/* ------------------------------------------- */
AstPlot3D *astPlot3DId_( void *frame_void, const float graphbox[6],
                         const double basebox[6], const char *options, ... ) {
/*
*++
*  Name:
c     astPlot3D
f     AST_PLOT3D

*  Purpose:
*     Create a Plot3D.

*  Type:
*     Public function.

*  Synopsis:
c     #include "plot3d.h"
c     AstPlot3D *astPlot3D( AstFrame *frame, const float graphbox[ 6 ],
c                           const double basebox[ 6 ], const char *options, ... )
f     RESULT = AST_PLOT3D( FRAME, GRAPHBOX, BASEBOX, OPTIONS, STATUS )

*  Class Membership:
*     Plot3D constructor.

*  Description:
*     This function creates a new Plot3D and optionally initialises
*     its attributes.
*
*     A Plot3D is a specialised form of Plot that provides facilities
*     for producing 3D graphical output.

*  Parameters:
c     frame
f     FRAME = INTEGER (Given)
*        Pointer to a Frame describing the physical coordinate system
*        in which to plot. A pointer to a FrameSet may also be given,
*        in which case its current Frame will be used to define the
*        physical coordinate system and its base Frame will be mapped
*        on to graphical coordinates (see below).
*
*        If a null Object pointer (AST__NULL) is given, a default
*        3-dimensional Frame will be used to describe the physical
*        coordinate system. Labels, etc. may then be attached to this
*        by setting the appropriate Frame attributes
*        (e.g. Label(axis)) for the Plot.
c     graphbox
f     GRAPHBOX( 6 ) = REAL (Given)
*        An array giving the position and extent of the plotting volume
*        (within the plotting space of the underlying graphics system)
*        in which graphical output is to appear. This must be
*        specified using graphical coordinates appropriate to the
*        underlying graphics system.
*
*        The first triple of values should give the coordinates of the
*        bottom left corner of the plotting volume and the second triple
*        should give the coordinates of the top right corner. The
*        coordinate on the horizontal axis should be given first in
*        each pair. Note that the order in which these points are
*        given is important because it defines up, down, left and
*        right for subsequent graphical operations.
c     basebox
f     BASEBOX( 6 ) = DOUBLE PRECISION (Given)
*        An array giving the coordinates of two points in the supplied
*        Frame (or in the base Frame if a FrameSet was supplied) which
*        correspond to the bottom left and top right corners of the
*        plotting volume, as specified above. This range of coordinates
*        will be mapped linearly on to the plotting area. The
*        coordinates should be given in the same order as above.
c     options
f     OPTIONS = CHARACTER * ( * ) (Given)
c        Pointer to a null-terminated string containing an optional
c        comma-separated list of attribute assignments to be used for
c        initialising the new Plot3D. The syntax used is identical to
c        that for the astSet function and may include "printf" format
c        specifiers identified by "%" symbols in the normal way.
c        If no initialisation is required, a zero-length string may be
c        supplied.
f        A character string containing an optional comma-separated
f        list of attribute assignments to be used for initialising the
f        new Plot3D. The syntax used is identical to that for the
f        AST_SET routine. If no initialisation is required, a blank
f        value may be supplied.
c     ...
c        If the "options" string contains "%" format specifiers, then
c        an optional list of additional arguments may follow it in
c        order to supply values to be substituted for these
c        specifiers. The rules for supplying these are identical to
c        those for the astSet function (and for the C "printf"
c        function).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astPlot3D()
f     AST_PLOT3D = INTEGER
*        A pointer to the new Plot3D.

*  Notes:
*     - The base Frame of the returned Plot3D will be a new Frame which
*     is created by this function to represent the coordinate system
*     of the underlying graphics system (graphical coordinates). It is
*     given a Frame index of 1 within the Plot3D. The choice of base
*     Frame (Base attribute) should not, in general, be changed once a
*     Plot3D has been created (although you could use this as a way of
*     moving the plotting area around on the plotting surface).
c     - If a Frame is supplied (via the "frame" pointer), then it
f     - If a Frame is supplied (via the FRAME pointer), then it
*     becomes the current Frame of the new Plot3D and is given a Frame
*     index of 2.
c     - If a FrameSet is supplied (via the "frame" pointer), then
f     - If a FrameSet is supplied (via the FRAME pointer), then
*     all the Frames within this FrameSet become part of the new Plot3D
*     (where their Frame indices are increased by 1), with the
*     FrameSet's current Frame becoming the current Frame of the Plot3D.
*     - At least one of the three axes of the current Frame must be
*     independent of the other two current Frame axes.
*     - If a null Object pointer (AST__NULL) is supplied (via the
c     "frame" pointer), then the returned Plot3D will contain two
f     FRAME pointer), then the returned Plot3D will contain two
*     Frames, both created by this function. The base Frame will
*     describe graphics coordinates (as above) and the current Frame
*     will be a basic Frame with no attributes set (this will
*     therefore give default values for such things as the Plot3D Title
*     and the Label on each axis). Physical coordinates will be mapped
*     linearly on to graphical coordinates.
*     - An error will result if the Frame supplied (or the base Frame
*     if a FrameSet was supplied) is not 3-dimensional.
*     - A null Object pointer (AST__NULL) will be returned if this
c     function is invoked with the AST error status set, or if it
f     function is invoked with STATUS set to an error value, or if it
*     should fail for any reason.
*--

*  Implementation Notes:
*     - This function implements the external (public) interface to
*     the astPlot3D constructor function. It returns an ID value
*     (instead of a true C pointer) to external users, and must be
*     provided because astPlot3D_ has a variable argument list which
*     cannot be encapsulated in a macro (where this conversion would
*     otherwise occur).
*     - Because no checking or casting of arguments is performed
*     before the function is invoked, the "frame" parameter is of type
*     (void *) and is converted from an ID value to a pointer and
*     validated within the function itself.
*     - The variable argument list also prevents this function from
*     invoking astPlot3D_ directly, so it must be a
*     re-implementation of it in all respects, except for the final
*     conversion of the result to an ID value.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstFrame *frame;              /* Pointer to Frame structure */
   AstPlot3D *new;               /* Pointer to new Plot3D */
   va_list args;                 /* Variable argument list */
   int *status;                  /* Pointer to inherited status value */

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

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

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   new = NULL;

/* Obtain a Frame pointer from any ID supplied and validate the
   pointer to ensure it identifies a valid Frame. */
   if( frame_void ){
      frame = astVerifyFrame( astMakePointer( frame_void ) );
   } else {
      frame = NULL;
   }

/* Check the pointer can be used. */
   if ( astOK ) {

/* Initialise the Plot3D, allocating memory and initialising the
   virtual function table as well if necessary. */
      new = astInitPlot3D( NULL, sizeof( AstPlot3D ), !class_init,
                           &class_vtab, "Plot3D", frame, graphbox,
                           basebox );

/* If successful, note that the virtual function table has been
   initialised. */
      if ( astOK ) {
         class_init = 1;

/* Obtain the variable argument list and pass it along with the
   options string to the astVSet method to initialise the new
   Plot3D's attributes. */
         va_start( args, options );
         astVSet( new, options, NULL, args );
         va_end( args );

/* If an error occurred, clean up by deleting the new object. */
         if ( !astOK ) new = astDelete( new );
      }
   }

/* Return an ID value for the new Plot3D. */
   return astMakeId( new );

}



/* Macros that define method to override the methods of the Plot class
   that are not currently implemented by this class. They just report an
   error if called. */

#define METHOD1(name) \
static void name(ARGLIST,int *status){ \
   if( !astOK ) return; \
   astError( AST__INTER, "ast##name(%s): The ast##name " \
             "method cannot be used with a %s (programming error).", status,  \
             astGetClass( this ), astGetClass( this ) ); \
}

#define METHOD2(name,rettype,retval) \
static rettype name(ARGLIST,int *status){ \
   if( !astOK ) return retval; \
   astError( AST__INTER, "ast##name(%s): The ast##name " \
             "method cannot be used with a %s (programming error).", status,  \
             astGetClass( this ), astGetClass( this ) ); \
   return retval; \
}


#define ARGLIST AstPlot *this
METHOD2(GetGrfContext,AstKeyMap *,NULL)
#undef ARGLIST

#define ARGLIST AstPlot *this
METHOD1(GrfPop)
#undef ARGLIST

#define ARGLIST AstPlot *this
METHOD1(GrfPush)
#undef ARGLIST

#define ARGLIST AstPlot *this, const char *name, AstGrfFun fun
METHOD1(GrfSet)
#undef ARGLIST

#define ARGLIST AstPlot *this, int axis, const double start[], double length
METHOD1(GridLine)
#undef ARGLIST

#define ARGLIST AstPlot *this, float lbnd[2], float ubnd[2]
METHOD1(BoundingBox)
#undef ARGLIST

#define ARGLIST AstPlot *this, int iframe, const double lbnd[], const double ubnd[]
METHOD1(Clip)
#undef ARGLIST

#define ARGLIST AstPlot *this, const double start[], const double finish[]
METHOD1(Curve)
#undef ARGLIST

#define ARGLIST AstPlot *this, AstMapping *map
METHOD1(GenCurve)
#undef ARGLIST








