upgrade ast 8.7.1

1 files changed, 8587 insertions, 0 deletions

diff --git a/ast/plot3d.c b/ast/plot3d.c
new file mode 100644
index 0000000..1bed16c
--- /dev/null
+++ b/ast/plot3d.c
@@ -0,0 +1,8587 @@
+/*
+*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 int (* 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 int 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 int GetObjSize( AstObject *this_object, int *status ) {
+/*
+*  Name:
+*     GetObjSize
+
+*  Purpose:
+*     Return the in-memory size of an Object.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "plot3d.h"
+*     int 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 */
+   int 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
+
+
+
+
+
+
+
+