1 #if !defined( FRAME_INCLUDED )   /* Include this file only once */
2 #define FRAME_INCLUDED
3 /*
4 *+
5 *  Name:
6 *     frame.h
7 
8 *  Type:
9 *     C include file.
10 
11 *  Purpose:
12 *     Define the interface to the Frame class.
13 
14 *  Invocation:
15 *     #include "frame.h"
16 
17 *  Description:
18 *     This include file defines the interface to the Frame class and
19 *     provides the type definitions, function prototypes and macros, etc.
20 *     needed to use this class.
21 *
22 *     A Frame object encapsulates information about a coordinate
23 *     system, including its axes. It may also act as a "template" to
24 *     be matched against another Frame object. This process determines
25 *     whether it is possible to perform a coordinate transformation
26 *     between the two coordinates systems they describe.
27 
28 *  Inheritance:
29 *     The Frame class inherits from the Mapping class.
30 
31 *  Attributes Over-Ridden:
32 *     Nin (integer, readonly)
33 *        The Frame class sets this value to be equal to the number of
34 *        Frame axes.
35 *     Nout (integer, readonly)
36 *        The Frame class sets this value to be equal to the number of
37 *        Frame axes.
38 
39 *  New Attributes Defined:
40 *     AlignSystem (string)
41 *        This attribute takes a value to identify the coordinate system
42 *        in which the Frame should be aligned with other Frames.
43 *     Digits [or Digits(axis)] (integer)
44 *        Specifies how many digits of precision are required by
45 *        default when a coordinate value for a Frame is formatted
46 *        (e.g. using the astFormat method). The Digits value acts as a
47 *        default only and is over-ridden if a Format string is
48 *        specified for an axis explicitly.
49 *
50 *        The default Digits value for a Frame is 7. This attribute
51 *        normally applies to all the Frame's axes, but reference may
52 *        be made to a particular axis by adding an axis subscript
53 *        (e.g. Digits(1)). If a value is set for an individual axis,
54 *        it will over-ride the Digits value for the Frame as a whole
55 *        when formatting values for that axis.
56 *     Direction(axis) (integer)
57 *        A boolean value which specifies how coordinate values for
58 *        each Frame axis should be displayed (e.g. in graphs). By
59 *        default, it has the value one, indicating that they should be
60 *        shown in the conventional sense (i.e. increasing left to
61 *        right for an abscissa and bottom to top for an ordinate). If
62 *        set to zero, this attribute indicates that the direction
63 *        should be reversed (as would often be done for an
64 *        astronomical magnitude or a right ascension axis, for
65 *        example).
66 *     Epoch (double)
67 *        This value is used to qualify coordinate systems by
68 *        giving the moment in time when the coordinates are known to
69 *        be correct. Often, this will be the date of observation.
70 *     Format(axis) (string)
71 *        Specifies the format to be used to display coordinate values
72 *        for each Frame axis (i.e. to convert them from binary to
73 *        character form). The interpretation of this string (e.g. by
74 *        derived classes) is left to the astFormat method which, in
75 *        turn will invoke the astAxisFormat for the Axis object that
76 *        describes each axis. By default, the Frame class supplies an
77 *        Axis class object for each axis and this will interpret this
78 *        parameter as a C "printf" format string which should be
79 *        capable of formatting a single coordinate value stored as a
80 *        double (e.g. "%1.7G"). If no Format string is set, the
81 *        default format is based on the value of the Digits attribute.
82 *     Label(axis) (string)
83 *        Specifies the label to be attached to each Frame axis when it
84 *        is represented in (e.g.) a graph. It is intended purely for
85 *        interpretation by human readers and not by software. The
86 *        default supplied by the Frame class is the string "Axis <n>",
87 *        where <n> is 1, 2, etc. for each successive axis.
88 *     MatchEnd (integer)
89 *        A boolean value that controls how a Frame behaves when used
90 *        as a template to match another Frame. If it is zero and a
91 *        template Frame matches a target frame which has a different
92 *        number of axes, then the axes wich occur first in the target
93 *        frame will be matched and any trailing axes in either the
94 *        target or template will be discarded (if necessary). If it is
95 *        non-zero, however, the last axes in each frame will be
96 *        matched and any un-matched leading axes will be discarded
97 *        instead. The default value supplied by the Frame class is
98 *        zero.
99 *     MaxAxes (integer)
100 *        Specifies the maximum number of axes in a target Frame that
101 *        can be matched when using the Frame as a template. Normally,
102 *        by default, this value is equal to the number of Frame axes,
103 *        so that a Frame will only match another Frame with the same
104 *        number of axes as itself. By setting a different value,
105 *        however, Frames with different numbers of axes may be matched
106 *        (the MatchEnd attribute then determines which of the
107 *        individual axes are matched).
108 *
109 *        When setting this value, the value of the MinAxes attribute
110 *        may be silently changed so that it remains consistent with
111 *        (i.e. does not exceed) the new value. The default value may
112 *        also be reduced if necessary to remain consistent with the
113 *        MinAxes value.
114 *     MinAxes (integer)
115 *        Specifies the minimum number of axes in a target Frame that
116 *        can be matched when using the Frame as a template. Normally,
117 *        by default, this value is equal to the number of Frame axes,
118 *        so that a Frame will only match another Frame with the same
119 *        number of axes as itself. By setting a different value,
120 *        however, Frames with different numbers of axes may be matched
121 *        (the MatchEnd attribute then determines which of the
122 *        individual axes are matched).
123 *
124 *        When setting this value, the value of the MaxAxes attribute
125 *        may be silently changed so that it remains consistent with
126 *        (i.e. is not less than) the new value. The default value may
127 *        also be reduced if necessary to remain consistent with the
128 *        MaxAxes value.
129 *     Domain (string)
130 *        A string which may be used to identify the physical domain to
131 *        which a Frame applies and used as an additional key when
132 *        matching a target Frame with a template. If the Domain
133 *        attribute in the template Frame is set, then only target
134 *        frames with the same Domain value will be matched. If a
135 *        Domain is not set in the template Frame, the target Frame's
136 *        Domain value will be ignored and has no effect on
137 *        matching. The default value supplied by the Frame class is an
138 *        empty string. Domain values are automatically converted to
139 *        upper case and all white space is removed before use.
140 *     Naxes (integer)
141 *        A read-only attribute that gives the number of axes in a
142 *        Frame (i.e.  the number of dimensions of the space which the
143 *        Frame describes). This value is determined when the Frame is
144 *        created.
145 *     Permute (integer)
146 *        A boolean value which specifies whether the axis order of a
147 *        target Frame may be permuted in order to obtain a match with
148 *        a template. If this value is set to zero in the template
149 *        Frame, it will only match a target if it can do so without
150 *        changing the order of its axes. The default value supplied by
151 *        the Frame class is 1 (i.e. allow axis permutations).
152 *     PreserveAxes (integer)
153 *        A boolean value which determines how the "result" Frame is
154 *        produced whan a target frame is matched by a template. If
155 *        this value is zero in the template Frame, then the result
156 *        Frame will have the same number of axes as the template. If
157 *        it is non-zero, however, the axes of the target Frame will be
158 *        preserved, so that the result Frame will have the same number
159 *        of axes as the target. The default supplied by the Frame
160 *        class is zero (i.e. target axes are not preserved).
161 *
162 *        The main use for this attribute is when the MaxAxes and/or
163 *        MinAxes attributes have been set to search for a Frame which
164 *        may have a different number of axes from the template. For
165 *        example, if a 2-dimensional template Frame matches a
166 *        3-dimensional target Frame, then by default the result is
167 *        2-dimensional and the last axis (normally) will be
168 *        discarded. However, if the template's PreserveAxes value is
169 *        non-zero, the result will instead be 3-dimensional to
170 *        correspond with the target Frame.
171 *     Symbol(axis) (string)
172 *        Specifies the symbol to be used to represent coordinate
173 *        values for each Frame axis in "short form", such as in
174 *        algebraic expressions where a full description of the axis
175 *        would be inappropriate. Examples include "RA" and "Dec" (for
176 *        Right Ascension and Declination).
177 *
178 *        The default supplied by the Frame class is the string
179 *        "<Domain><n>", where <n> is 1, 2, etc. for successive axes,
180 *        and <Domain> is the value of the Frame's Domain attribute
181 *        (with any white space replaced by underscores and truncated
182 *        if necessary so that the final string does not exceed 15
183 *        characters). If no Domain value has been set, "x" is used as
184 *        the <Domain> value in constructing this default string.
185 *     System (string)
186 *        This attribute takes a value to identify the coordinate system
187 *        used to describe positions within the domain of the Frame.
188 *     Title (string)
189 *        Specifies a string to be used as a title on (e.g.) graphs to
190 *        describe the coordinate system which the Frame
191 *        represents. Examples would be "Detector Coordinates" or
192 *        "Galactic Coordinates". This string is intended solely for
193 *        interpretation by human readers and not by software. The
194 *        default supplied by the Frame class is "<n>-D Coordinate
195 *        System", where <n> is the number of Frame axes.
196 *     Unit(axis) (string)
197 *        Describes the units used to represent coordinate values on
198 *        each Frame axis. The default supplied by the Frame class is
199 *        an empty string.
200 
201 *  Methods Over-Ridden:
202 *     Public:
203 *        astGetNin
204 *           Get the number of input coordinates for a Frame.
205 *        astGetNout
206 *           Get the number of output coordinates for a Frame.
207 *        astTransform
208 *           Use a Frame to transform a set of points.
209 
210 *     Protected:
211 *        astClearAttrib
212 *           Clear an attribute value for a Frame.
213 *        astGetAttrib
214 *           Get an attribute value for a Frame.
215 *        astReportPoints
216 *           Report the effect of transforming a set of points using a Frame.
217 *        astSetAttrib
218 *           Set an attribute value for a Frame.
219 *        astTestAttrib
220 *           Test if an attribute value has been set for a Frame.
221 
222 *  New Methods Defined:
223 *     Public:
224 *        astAngle
225 *           Calculate the angle between three points.
226 *        astAxAngle
227 *           Find the angle from an axis to a line through two points.
228 *        astAxDistance
229 *           Calculate the distance between two axis values
230 *        astAxOffset
231 *           Calculate an offset along an axis
232 *        astConvert
233 *           Determine how to convert between two coordinate systems.
234 *        astDistance
235 *           Calculate the distance between two points.
236 *        astFindFrame
237 *           Find a coordinate system with specified characteristics
238 *        astFormat
239 *           Format a coordinate value for a Frame axis.
240 *        astNorm
241 *           Normalise a set of Frame coordinates.
242 *        astOffset
243 *           Calculate an offset along a geodesic curve.
244 *        astOffset2
245 *           Calculate an offset along a geodesic curve for a 2D Frame.
246 *        astPermAxes
247 *           Permute the order of a Frame's axes.
248 *        astPickAxes
249 *           Create a new Frame by picking axes from an existing one.
250 *        astResolve
251 *           Resolve a vector into two orthogonal components.
252 *        astUnformat
253 *           Read a formatted coordinate value for a Frame axis.
254 
255 *     Protected:
256 *        astAbbrev
257 *           Abbreviate a formatted Frame axis value by skipping
258 *           leading fields.
259 *        astCheckPerm
260 *           Check that an array contains a valid permutation.
261 *        astClearDigits
262 *           Clear the Digits attribute for a Frame.
263 *        astClearDirection
264 *           Clear the Direction attribute for a Frame axis.
265 *        astClearDomain
266 *           Clear the Domain attribute for a Frame.
267 *        astClearFormat
268 *           Clear the Format attribute for a Frame axis.
269 *        astClearLabel
270 *           Clear the Label attribute for a Frame axis.
271 *        astClearMatchEnd
272 *           Clear the MatchEnd attribute for a Frame.
273 *        astClearMaxAxes
274 *           Clear the MaxAxes attribute for a Frame.
275 *        astClearMinAxes
276 *           Clear the MinAxes attribute for a Frame.
277 *        astClearPermute
278 *           Clear the Permute attribute for a Frame.
279 *        astClearPreserveAxes
280 *           Clear the PreserveAxes attribute for a Frame.
281 *        astClearSymbol
282 *           Clear the Symbol attribute for a Frame axis.
283 *        astClearSystem
284 *           Clear the value of the System attribute for a Frame.
285 *        astClearTitle
286 *           Clear the Title attribute for a Frame.
287 *        astClearUnit
288 *           Clear the Unit attribute for a Frame axis.
289 *        astConvertX
290 *           Determine how to convert between two coordinate systems.
291 *        astFields
292 *           Identify the fields within a formatted Frame axis value.
293 *        astGap
294 *           Find a "nice" gap for tabulating Frame axis values.
295 *        astGetAxis
296 *           Obtain a pointer to a specified Axis from a Frame.
297 *        astGetDigits
298 *           Get the value of the Digits attribute for a Frame.
299 *        astGetDirection
300 *           Get the value of the Direction attribute for a Frame axis.
301 *        astGetDomain
302 *           Get a pointer to the Domain attribute for a Frame.
303 *        astGetFormat
304 *           Get a pointer to the Format attribute for a Frame axis.
305 *        astGetLabel
306 *           Get a pointer to the Label attribute for a Frame axis.
307 *        astGetMatchEnd
308 *           Get the value of the MatchEnd attribute for a Frame.
309 *        astGetMaxAxes
310 *           Get the value of the MaxAxes attribute for a Frame.
311 *        astGetMinAxes
312 *           Get the value of the MinAxes attribute for a Frame.
313 *        astGetNaxes
314 *           Determine how many axes a Frame has.
315 *        astGetPerm
316 *           Access the axis permutation array for a Frame.
317 *        astGetPermute
318 *           Get the value of the Permute attribute for a Frame.
319 *        astGetPreserveAxes
320 *           Get the value of the PreserveAxes attribute for a Frame.
321 *        astGetSymbol
322 *           Get a pointer to the Symbol attribute for a Frame axis.
323 *        astGetSystem
324 *           Get the value of the System attribute for a Frame.
325 *        astGetTitle
326 *           Get a pointer to the Title attribute for a Frame.
327 *        astGetUnit
328 *           Get a pointer to the Unit attribute for a Frame axis.
329 *        astIsUnitFrame
330 *           Returns a flag indicating if a Frame is equivalent to a UnitMap.
331 *        astMatch
332 *           Determine if conversion is possible between two coordinate systems.
333 *        astOverlay
334 *           Overlay the attributes of a template Frame on to another Frame.
335 *        astPrimaryFrame
336 *           Uniquely identify a primary Frame and one of its axes.
337 *        astResolvePoints
338 *           Resolve many vectors into two orthogonal components.
339 *        astSetAxis
340 *           Set a new Axis for a Frame.
341 *        astSetDigits
342 *           Set the value of the Digits attribute for a Frame.
343 *        astSetDirection
344 *           Set the value of the Direction attribute for a Frame axis.
345 *        astSetDomain
346 *           Set the value of the Domain attribute for a Frame.
347 *        astSetFormat
348 *           Set the value of the Format attribute for a Frame axis.
349 *        astSetLabel
350 *           Set the value of the Label attribute for a Frame axis.
351 *        astSetMatchEnd
352 *           Set the value of the MatchEnd attribute for a Frame.
353 *        astSetMaxAxes
354 *           Set the value of the MaxAxes attribute for a Frame.
355 *        astSetMinAxes
356 *           Set the value of the MinAxes attribute for a Frame.
357 *        astSetPermute
358 *           Set the value of the Permute attribute for a Frame.
359 *        astSetPreserveAxes
360 *           Set the value of the PreserveAxes attribute for a Frame.
361 *        astSetSymbol
362 *           Set the value of the Symbol attribute for a Frame axis.
363 *        astSetSystem
364 *           Set the value of the System attribute for a Frame.
365 *        astSetTitle
366 *           Set the value of the Title attribute for a Frame.
367 *        astSetUnit
368 *           Set the value of the Unit attribute for a Frame axis.
369 *        astSubFrame
370 *           Select axes from a Frame and convert to the new coordinate system.
371 *        astTestDigits
372 *           Test whether a value has been set for the Digits attribute of a
373 *           Frame.
374 *        astTestDirection
375 *           Test whether a value has been set for the Direction attribute of a
376 *           Frame axis.
377 *        astTestDomain
378 *           Test whether a value has been set for the Domain attribute of a
379 *           Frame.
380 *        astTestFormat
381 *           Test whether a value has been set for the Format attribute of a
382 *           Frame axis.
383 *        astTestLabel
384 *           Test whether a value has been set for the Label attribute of a
385 *           Frame axis.
386 *        astTestMatchEnd
387 *           Test whether a value has been set for the MatchEnd attribute of a
388 *           Frame.
389 *        astTestMaxAxes
390 *           Test whether a value has been set for the MaxAxes attribute of a
391 *           Frame.
392 *        astTestMinAxes
393 *           Test whether a value has been set for the MinAxes attribute of a
394 *           Frame.
395 *        astTestPermute
396 *           Test whether a value has been set for the Permute attribute of a
397 *           Frame.
398 *        astTestPreserveAxes
399 *           Test whether a value has been set for the PreserveAxes attribute of
400 *           a Frame.
401 *        astTestSymbol
402 *           Test whether a value has been set for the Symbol attribute of a
403 *           Frame axis.
404 *        astTestSystem
405 *           Test whether a value has been set for the System attribute of a
406 *           Frame.
407 *        astTestTitle
408 *           Test whether a value has been set for the Title attribute of a
409 *           Frame.
410 *        astTestUnit
411 *           Test whether a value has been set for the Unit attribute of a Frame
412 *           axis.
413 *        astValidateAxis
414 *           Validate and permute a Frame's axis index.
415 *        astValidateAxisSelection
416 *           Check that a set of axes selected from a Frame is valid.
417 *        astValidateSystem
418 *           Validate a Frame's System attribute.
419 *        astSystemString
420 *           Return a string representation of a System code.
421 *        astSystemCode
422 *           Return a code for a string representation of a System value
423 
424 *  Other Class Functions:
425 *     Public:
426 *        astFrame
427 *           Create a Frame.
428 *        astIsAFrame
429 *           Test class membership.
430 
431 *     Protected:
432 *        astCheckFrame
433 *           Validate class membership.
434 *        astInitFrame
435 *           Initialise a Frame.
436 *        astInitFrameVtab
437 *           Initialise the virtual function table for the Frame class.
438 *        astLoadFrame
439 *           Load a Frame.
440 
441 *  Macros:
442 *     Public:
443 *        None.
444 
445 *     Protected:
446 *        AST__BADSYSTEM
447 *           A "bad" (undefined) value for the System attribute.
448 
449 *  Type Definitions:
450 *     Public:
451 *        AstFrame
452 *           Frame object type.
453 
454 *     Protected:
455 *        AstFrameVtab
456 *           Frame virtual function table type.
457 *        AstSystemType
458 *           Enumerated type used for the System attribute.
459 
460 *  Feature Test Macros:
461 *     astCLASS
462 *        If the astCLASS macro is undefined, only public symbols are
463 *        made available, otherwise protected symbols (for use in other
464 *        class implementations) are defined. This macro also affects
465 *        the reporting of error context information, which is only
466 *        provided for external calls to the AST library.
467 
468 *  Copyright:
469 *     Copyright (C) 1997-2006 Council for the Central Laboratory of the
470 *     Research Councils
471 
472 *  Licence:
473 *     This program is free software: you can redistribute it and/or
474 *     modify it under the terms of the GNU Lesser General Public
475 *     License as published by the Free Software Foundation, either
476 *     version 3 of the License, or (at your option) any later
477 *     version.
478 *
479 *     This program is distributed in the hope that it will be useful,
480 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
481 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
482 *     GNU Lesser General Public License for more details.
483 *
484 *     You should have received a copy of the GNU Lesser General
485 *     License along with this program.  If not, see
486 *     <http://www.gnu.org/licenses/>.
487 
488 *  Authors:
489 *     RFWS: R.F. Warren-Smith (Starlink)
490 *     DSB: B.S. Berry (Starlink)
491 
492 *  History:
493 *     1-MAR-1996 (RFWS):
494 *        Original version.
495 *     25-APR-1996 (RFWS):
496 *        Tidied up, etc.
497 *     11-SEP-1996 (RFWS):
498 *        Added astGap (written by DSB).
499 *     10-JUN-1997 (RFWS):
500 *        Revised astConvert and added astFindFrame.
501 *     15-FEB-1998 (RFWS):
502 *        Added astUnformat.
503 *     21-JUN-2001 (DSB):
504 *        Added astAngle and astOffset2.
505 *     29-AUG-2001 (DSB):
506 *        Added astAxDistance and astAxOffset.
507 *     4-SEP-2001 (DSB):
508 *        Added astResolve.
509 *     9-SEP-2001 (DSB):
510 *        Added astBear.
511 *     21-SEP-2001 (DSB):
512 *        Replace astBear with astAxAngle.
513 *     15-NOV-2002 (DSB):
514 *        Moved System and Epoch attributes from SkyFrame into this class.
515 *        Added AlignSystem attribute.
516 *     8-JAN-2003 (DSB):
517 *        Added protected astInitFrameVtab method.
518 *     24-JAN-2004 (DSB):
519 *        o  Added astFields.
520 *        o  Added argument "fmt" to astAbbrev.
521 *     24-JUN-2004 (DSB):
522 *        Remove unused entry "void (* SetMatchRange)( AstFrame *, int, int );"
523 *        from AstFrameVtab structure.
524 *     9-NOV-2004 (DSB):
525 *        Added protected astIsAUnitFrame method.
526 *     12-AUG-2005 (DSB):
527 *        Added ObsLat and ObsLon attributes.
528 *     14-OCT-2006 (DSB):
529 *        Added dut1 to the Frame structure.
530 *        Added Dut1 accessor methods.
531 *     17-MAY-2007 (DSB):
532 *        Added NormUnit attribute.
533 *     14-JAN-2009 (DSB):
534 *        Added astIntersect method.
535 *     18-JUN-2009 (DSB):
536 *        Added ObsAlt attribute.
537 *-
538 */
539 
540 /* Include files. */
541 /* ============== */
542 /* Interface definitions. */
543 /* ---------------------- */
544 #include "object.h"              /* Base Object class */
545 #include "axis.h"                /* Coordinate Axis class */
546 #include "mapping.h"             /* Coordinate mappings (parent class) */
547 
548 #if defined(astCLASS)            /* Protected */
549 #include "channel.h"             /* I/O channels */
550 #endif
551 
552 /* C header files. */
553 /* --------------- */
554 #include <stddef.h>
555 
556 /* Macros. */
557 /* ------- */
558 #if defined(astCLASS) || defined(astFORTRAN77)
559 #define STATUS_PTR status
560 #else
561 #define STATUS_PTR astGetStatusPtr
562 #endif
563 
564 /* Define a dummy __attribute__ macro for use on non-GNU compilers. */
565 #ifndef __GNUC__
566 #  define  __attribute__(x)  /*NOTHING*/
567 #endif
568 
569 #if defined(astCLASS)            /* Protected */
570 
571 /* A bad value for the System attribute. */
572 #define AST__BADSYSTEM -1
573 
574 /* The legal System values recognized by this class of Frame. */
575 #define AST__CART 0
576 
577 /* Flag bitmasks for use with astSetFrameFlags. */
578 # define AST__INTFLAG 1  /* FrameSet integrity is currently being restored */
579 
580 /* Define constants used to size global arrays in this module. */
581 #define AST__FRAME_LABEL_BUFF_LEN 100       /* Max length of default axis Label string */
582 #define AST__FRAME_SYMBOL_BUFF_LEN 50       /* Max length of default axis Symbol string */
583 #define AST__FRAME_TITLE_BUFF_LEN 100       /* Max length of default title string */
584 #define AST__FRAME_GETATTRIB_BUFF_LEN 50    /* Max length of string returned by GetAttrib */
585 #define AST__FRAME_ASTFMTDECIMALYR_BUFF_LEN 50    /* Max length of string returned by GetAttrib */
586 #define AST__FRAME_ASTFORMATID_MAX_STRINGS 50     /* Number of string values buffer by astFormatID*/
587 
588 #endif
589 
590 /* Type Definitions. */
591 /* ================= */
592 /* Integer type used to store the System attribute values. */
593 typedef int AstSystemType;
594 
595 /* Frame structure. */
596 /* ------------------- */
597 /* This structure contains all information that is unique to each object in
598    the class (e.g. its instance variables). */
599 typedef struct AstFrame {
600 
601 /* Attributes inherited from the parent class. */
602    AstMapping mapping;           /* Parent class structure */
603 
604 /* Attributes specific to objects in this class. */
605    AstAxis **axis;               /* Pointer to array of Axis objects */
606    char *domain;                 /* Pointer to Domain string */
607    char *title;                  /* Pointer to Title string */
608    double epoch;                 /* Epoch as Modified Julian Date */
609    double obslat;                /* Geodetic latitude of observer */
610    double obslon;                /* Geodetic longitude of observer */
611    double obsalt;                /* Height above reference spheroid (geodetic, metres) */
612    double dut1;                  /* UT1-UTC in seconds */
613    int *perm;                    /* Pointer to axis permutation array */
614    int digits;                   /* Default digits of precision */
615    int match_end;                /* Match final axes of target? */
616    int active_unit;              /* Use Unit when aligning Frames? */
617    int max_axes;                 /* Minimum no. axes matched */
618    int min_axes;                 /* Max. no. axes matched */
619    int naxes;                    /* Number of axes */
620    int permute;                  /* Permute axes in order to match? */
621    int preserve_axes;            /* Preserve target axes? */
622    AstSystemType system;         /* Code identifying coordinate system */
623    AstSystemType alignsystem;    /* Code for Alignment coordinate system */
624    int flags;                    /* Bit mask containing various protected flags */
625    struct AstFrameSet *variants; /* FrameSet defining alternative properties for the Frame */
626 } AstFrame;
627 
628 /* Cached Line structure. */
629 /* ---------------------- */
630 /* This structure contains information describing a line segment within a
631    2D Frame. It is used by other classes to store intermediate cached values
632    relating to the line in order to speed up repeated operations on the
633    line. */
634 
635 typedef struct AstLineDef {
636    AstFrame *frame;            /* Pointer to Frame in which the line is defined */
637    double length;              /* Line length */
638    int infinite;               /* Disregard the start and end of the line? */
639    double start[2];            /* Frame axis values at line start */
640    double end[2];              /* Frame axis values at line end */
641    double dir[2];              /* Unit vector defining line direction */
642    double q[2];                /* Unit vector perpendicular to line */
643 } AstLineDef;
644 
645 /* Virtual function table. */
646 /* ----------------------- */
647 /* The virtual function table makes a forward reference to the
648    AstFrameSet structure which is not defined until "frameset.h" is
649    included (below). Hence make a preliminary definition available
650    now. */
651 struct AstFrameSet;
652 
653 /* This table contains all information that is the same for all objects in the
654    class (e.g. pointers to its virtual functions). */
655 #if defined(astCLASS)            /* Protected */
656 typedef struct AstFrameVtab {
657 
658 /* Properties (e.g. methods) inherited from the parent class. */
659    AstMappingVtab mapping;       /* Parent class virtual function table */
660 
661 /* A Unique identifier to determine class membership. */
662    AstClassIdentifier id;
663 
664 /* Properties (e.g. methods) specific to this class. */
665    AstAxis *(* GetAxis)( AstFrame *, int, int * );
666    AstFrame *(* PickAxes)( AstFrame *, int, const int[], AstMapping **, int * );
667    AstLineDef *(* LineDef)( AstFrame *, const double[2], const double[2], int * );
668    AstPointSet *(* ResolvePoints)( AstFrame *, const double [], const double [], AstPointSet *, AstPointSet *, int * );
669    const char *(* Abbrev)( AstFrame *, int, const char *, const char *, const char *, int * );
670    const char *(* Format)( AstFrame *, int, double, int * );
671    const char *(* GetDomain)( AstFrame *, int * );
672    const char *(* GetFormat)( AstFrame *, int, int * );
673    const char *(* GetLabel)( AstFrame *, int, int * );
674    const char *(* GetSymbol)( AstFrame *, int, int * );
675    const char *(* GetTitle)( AstFrame *, int * );
676    const char *(* GetNormUnit)( AstFrame *, int, int * );
677    const char *(* GetUnit)( AstFrame *, int, int * );
678    const int *(* GetPerm)( AstFrame *, int * );
679    double (* Angle)( AstFrame *, const double[], const double[], const double[], int * );
680    double (* Distance)( AstFrame *, const double[], const double[], int * );
681    double (* Gap)( AstFrame *, int, double, int *, int * );
682    int (* Fields)( AstFrame *, int, const char *, const char *, int, char **, int *, double *, int * );
683    double (* AxDistance)( AstFrame *, int, double, double, int * );
684    double (* AxOffset)( AstFrame *, int, double, double, int * );
685    int (* AxIn)( AstFrame *, int, double, double, double, int, int * );
686    int (* GetDigits)( AstFrame *, int * );
687    int (* GetDirection)( AstFrame *, int, int * );
688    int (* GetMatchEnd)( AstFrame *, int * );
689    int (* GetMaxAxes)( AstFrame *, int * );
690    int (* GetMinAxes)( AstFrame *, int * );
691    int (* GetNaxes)( AstFrame *, int * );
692    int (* GetPermute)( AstFrame *, int * );
693    int (* GetPreserveAxes)( AstFrame *, int * );
694    int (* IsUnitFrame)( AstFrame *, int * );
695    int (* LineCrossing)( AstFrame *, AstLineDef *, AstLineDef *, double **, int * );
696    int (* LineContains)( AstFrame *, AstLineDef *, int, double *, int * );
697    int (* Match)( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
698    int (* SubFrame)( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
699    int (* TestDigits)( AstFrame *, int * );
700    int (* TestDirection)( AstFrame *, int, int * );
701    int (* TestDomain)( AstFrame *, int * );
702    int (* TestFormat)( AstFrame *, int, int * );
703    int (* TestLabel)( AstFrame *, int, int * );
704    int (* TestMatchEnd)( AstFrame *, int * );
705    int (* TestMaxAxes)( AstFrame *, int * );
706    int (* TestMinAxes)( AstFrame *, int * );
707    int (* TestPermute)( AstFrame *, int * );
708    int (* TestPreserveAxes)( AstFrame *, int * );
709    int (* TestSymbol)( AstFrame *, int, int * );
710    int (* TestTitle)( AstFrame *, int * );
711    int (* TestUnit)( AstFrame *, int, int * );
712    int (* Unformat)( AstFrame *, int, const char *, double *, int * );
713    int (* ValidateAxis)( AstFrame *, int, int, const char *, int * );
714    AstSystemType (* ValidateSystem)( AstFrame *, AstSystemType, const char *, int * );
715    AstSystemType (* SystemCode)( AstFrame *, const char *, int * );
716    const char *(* SystemString)( AstFrame *, AstSystemType, int * );
717    struct AstFrameSet *(* Convert)( AstFrame *, AstFrame *, const char *, int * );
718    struct AstFrameSet *(* ConvertX)( AstFrame *, AstFrame *, const char *, int * );
719    struct AstFrameSet *(* FindFrame)( AstFrame *, AstFrame *, const char *, int * );
720    void (* MatchAxes)( AstFrame *, AstFrame *, int[], int * );
721    void (* MatchAxesX)( AstFrame *, AstFrame *, int[], int * );
722    void (* CheckPerm)( AstFrame *, const int *, const char *, int * );
723    void (* ClearDigits)( AstFrame *, int * );
724    void (* ClearDirection)( AstFrame *, int, int * );
725    void (* ClearDomain)( AstFrame *, int * );
726    void (* ClearFormat)( AstFrame *, int, int * );
727    void (* ClearLabel)( AstFrame *, int, int * );
728    void (* ClearMatchEnd)( AstFrame *, int * );
729    void (* ClearMaxAxes)( AstFrame *, int * );
730    void (* ClearMinAxes)( AstFrame *, int * );
731    void (* ClearPermute)( AstFrame *, int * );
732    void (* ClearPreserveAxes)( AstFrame *, int * );
733    void (* ClearSymbol)( AstFrame *, int, int * );
734    void (* ClearTitle)( AstFrame *, int * );
735    void (* ClearUnit)( AstFrame *, int, int * );
736    void (* Intersect)( AstFrame *, const double[2], const double[2], const double[2], const double[2], double[2], int * );
737    void (* Norm)( AstFrame *, double[], int * );
738    void (* NormBox)( AstFrame *, double *, double *, AstMapping *, int * );
739    void (* Offset)( AstFrame *, const double[], const double[], double, double[], int * );
740    double (* AxAngle)( AstFrame *, const double[2], const double[2], int, int * );
741    double (* Offset2)( AstFrame *, const double[2], double, double, double[2], int * );
742    void (* Overlay)( AstFrame *, const int *, AstFrame *, int * );
743    void (* PermAxes)( AstFrame *, const int[], int * );
744    void (* PrimaryFrame)( AstFrame *, int, AstFrame **, int *, int * );
745    void (* Resolve)( AstFrame *, const double [], const double [], const double [], double [], double *, double *, int * );
746    void (* SetAxis)( AstFrame *, int, AstAxis *, int * );
747    void (* SetDigits)( AstFrame *, int, int * );
748    void (* SetDirection)( AstFrame *, int, int, int * );
749    void (* SetDomain)( AstFrame *, const char *, int * );
750    void (* SetFormat)( AstFrame *, int, const char *, int * );
751    void (* SetLabel)( AstFrame *, int, const char *, int * );
752    void (* SetMatchEnd)( AstFrame *, int, int * );
753    void (* SetMaxAxes)( AstFrame *, int, int * );
754    void (* SetMinAxes)( AstFrame *, int, int * );
755    void (* SetPermute)( AstFrame *, int, int * );
756    void (* SetPreserveAxes)( AstFrame *, int, int * );
757    void (* SetSymbol)( AstFrame *, int, const char *, int * );
758    void (* SetTitle)( AstFrame *, const char *, int * );
759    void (* SetUnit)( AstFrame *, int, const char *, int * );
760    void (* ValidateAxisSelection)( AstFrame *, int, const int *, const char *, int * );
761    void (* LineOffset)( AstFrame *, AstLineDef *, double, double, double[2], int * );
762    AstPointSet *(* FrameGrid)( AstFrame *, int, const double *, const double *, int * );
763    struct AstFrameSet *(* GetFrameVariants)( AstFrame *, int * );
764    void (* SetFrameVariants)( AstFrame *, struct AstFrameSet *, int * );
765 
766    double (* GetTop)( AstFrame *, int, int * );
767    int (* TestTop)( AstFrame *, int, int * );
768    void (* ClearTop)( AstFrame *, int, int * );
769    void (* SetTop)( AstFrame *, int, double, int * );
770 
771    double (* GetBottom)( AstFrame *, int, int * );
772    int (* TestBottom)( AstFrame *, int, int * );
773    void (* ClearBottom)( AstFrame *, int, int * );
774    void (* SetBottom)( AstFrame *, int, double, int * );
775 
776    AstSystemType (* GetSystem)( AstFrame *, int * );
777    int (* TestSystem)( AstFrame *, int * );
778    void (* ClearSystem)( AstFrame *, int * );
779    void (* SetSystem)( AstFrame *, AstSystemType, int * );
780 
781    AstSystemType (* GetAlignSystem)( AstFrame *, int * );
782    int (* TestAlignSystem)( AstFrame *, int * );
783    void (* ClearAlignSystem)( AstFrame *, int * );
784    void (* SetAlignSystem)( AstFrame *, AstSystemType, int * );
785 
786    double (* GetEpoch)( AstFrame *, int * );
787    int (* TestEpoch)( AstFrame *, int * );
788    void (* ClearEpoch)( AstFrame *, int * );
789    void (* SetEpoch)( AstFrame *, double, int * );
790 
791    int (* TestActiveUnit)( AstFrame *, int * );
792    int (* GetActiveUnit)( AstFrame *, int * );
793    void (* SetActiveUnit)( AstFrame *, int, int * );
794 
795    double (* GetObsLon)( AstFrame *, int * );
796    int (* TestObsLon)( AstFrame *, int * );
797    void (* ClearObsLon)( AstFrame *, int * );
798    void (* SetObsLon)( AstFrame *, double, int * );
799 
800    double (* GetObsLat)( AstFrame *, int * );
801    int (* TestObsLat)( AstFrame *, int * );
802    void (* ClearObsLat)( AstFrame *, int * );
803    void (* SetObsLat)( AstFrame *, double, int * );
804 
805    double (* GetObsAlt)( AstFrame *, int * );
806    int (* TestObsAlt)( AstFrame *, int * );
807    void (* ClearObsAlt)( AstFrame *, int * );
808    void (* SetObsAlt)( AstFrame *, double, int * );
809 
810    double (* GetDut1)( AstFrame *, int * );
811    int (* TestDut1)( AstFrame *, int * );
812    void (* ClearDut1)( AstFrame *, int * );
813    void (* SetDut1)( AstFrame *, double, int * );
814 
815    void (* SetFrameFlags)( AstFrame *, int, int * );
816    int (* GetFrameFlags)( AstFrame *, int * );
817 
818 } AstFrameVtab;
819 
820 #if defined(THREAD_SAFE)
821 
822 /* Define a structure holding all data items that are global within this
823    class. */
824 typedef struct AstFrameGlobals {
825    AstFrameVtab Class_Vtab;
826    int Class_Init;
827    char GetAttrib_Buff[ AST__FRAME_GETATTRIB_BUFF_LEN + 1 ];
828    char *AstFormatID_Strings[ AST__FRAME_ASTFORMATID_MAX_STRINGS ];
829    int AstFormatID_Istr;
830    int AstFormatID_Init;
831    char Label_Buff[ AST__FRAME_LABEL_BUFF_LEN + 1 ];
832    char Symbol_Buff[ AST__FRAME_SYMBOL_BUFF_LEN + 1 ];
833    char Title_Buff[ AST__FRAME_TITLE_BUFF_LEN + 1 ];
834    char AstFmtDecimalYr_Buff[ AST__FRAME_ASTFMTDECIMALYR_BUFF_LEN + 1 ];
835 } AstFrameGlobals;
836 
837 #endif
838 #endif
839 
840 /* More include files. */
841 /* =================== */
842 /* The interface to the FrameSet class must be included here (after
843    the type definitions for the Frame class) because "frameset.h"
844    itself includes this file ("frame.h"), although "frameset.h" refers
845    to the AstFrameSet structure above. This seems a little strange at
846    first, but is simply analogous to making a forward reference to a
847    structure type when recursively defining a normal C structure
848    (except that here the definitions happen to be in separate include
849    files). */
850 #include "frameset.h"
851 
852 /* Function prototypes. */
853 /* ==================== */
854 /* Prototypes for standard class functions. */
855 /* ---------------------------------------- */
856 astPROTO_CHECK(Frame)            /* Check class membership */
857 astPROTO_ISA(Frame)              /* Test class membership */
858 
859 /* Constructor. */
860 #if defined(astCLASS)            /* Protected */
861 AstFrame *astFrame_( int, const char *, int *, ...);
862 #else
863 AstFrame *astFrameId_( int, const char *, ... )__attribute__((format(printf,2,3)));
864 #endif
865 
866 #if defined(astCLASS)            /* Protected */
867 
868 /* Initialiser. */
869 AstFrame *astInitFrame_( void *, size_t, int, AstFrameVtab *, const char *,
870                          int, int * );
871 
872 /* Vtab initialiser. */
873 void astInitFrameVtab_( AstFrameVtab *, const char *, int * );
874 
875 /* Loader. */
876 AstFrame *astLoadFrame_( void *, size_t, AstFrameVtab *,
877                          const char *, AstChannel *channel, int * );
878 
879 /* Thread-safe initialiser for all global data used by this module. */
880 #if defined(THREAD_SAFE)
881 void astInitFrameGlobals_( AstFrameGlobals * );
882 #endif
883 #endif
884 
885 /* Prototypes for member functions. */
886 /* -------------------------------- */
887 AstFrameSet *astConvert_( AstFrame *, AstFrame *, const char *, int * );
888 AstFrameSet *astFindFrame_( AstFrame *, AstFrame *, const char *, int * );
889 double astAngle_( AstFrame *, const double[], const double[], const double[], int * );
890 double astAxAngle_( AstFrame *, const double[2], const double[2], int, int * );
891 double astAxDistance_( AstFrame *, int, double, double, int * );
892 double astAxOffset_( AstFrame *, int, double, double, int * );
893 double astDistance_( AstFrame *, const double[], const double[], int * );
894 double astOffset2_( AstFrame *, const double[2], double, double, double[2], int * );
895 int astGetActiveUnit_( AstFrame *, int * );
896 void astIntersect_( AstFrame *, const double[2], const double[2], const double[2], const double[2], double[2], int * );
897 void astMatchAxes_( AstFrame *, AstFrame *, int[], int * );
898 void astNorm_( AstFrame *, double[], int * );
899 void astOffset_( AstFrame *, const double[], const double[], double, double[], int * );
900 void astResolve_( AstFrame *, const double [], const double [], const double [], double [], double *, double *, int * );
901 void astSetActiveUnit_( AstFrame *, int, int * );
902 AstFrameSet *astGetFrameVariants_( AstFrame *, int * );
903 void astSetFrameVariants_( AstFrame *, AstFrameSet *, int * );
904 
905 #if defined(astCLASS)            /* Protected */
906 void astNormBox_( AstFrame *, double *, double *, AstMapping *, int * );
907 AstFrame *astPickAxes_( AstFrame *, int, const int[], AstMapping **, int * );
908 const char *astFormat_( AstFrame *, int, double, int * );
909 int astUnformat_( AstFrame *, int, const char *, double *, int * );
910 void astPermAxes_( AstFrame *, const int[], int * );
911 #else
912 AstFrame *astPickAxesId_( AstFrame *, int, const int[], AstMapping **, int * );
913 const char *astFormatId_( AstFrame *, int, double, int * );
914 int astUnformatId_( AstFrame *, int, const char *, double *, int * );
915 void astPermAxesId_( AstFrame *, const int[], int * );
916 #endif
917 
918 #if defined(astCLASS)            /* Protected */
919 int astAxIn_( AstFrame *, int, double, double, double, int, int * );
920 AstAxis * astGetAxis_( AstFrame *, int, int * );
921 AstFrameSet *astConvertX_( AstFrame *, AstFrame *, const char *, int * );
922 void astMatchAxesX_( AstFrame *, AstFrame *, int[], int * );
923 AstLineDef *astLineDef_( AstFrame *, const double[2], const double[2], int * );
924 AstPointSet *astResolvePoints_( AstFrame *, const double [], const double [], AstPointSet *, AstPointSet *, int * );
925 const char *astAbbrev_( AstFrame *, int, const char *, const char *, const char *, int * );
926 const char *astGetDomain_( AstFrame *, int * );
927 const char *astGetFormat_( AstFrame *, int, int * );
928 const char *astGetLabel_( AstFrame *, int, int * );
929 const char *astGetSymbol_( AstFrame *, int, int * );
930 const char *astGetTitle_( AstFrame *, int * );
931 const char *astGetUnit_( AstFrame *, int, int * );
932 const char *astGetNormUnit_( AstFrame *, int, int * );
933 const int *astGetPerm_( AstFrame *, int * );
934 double astGap_( AstFrame *, int, double, int *, int * );
935 int astFields_( AstFrame *, int, const char *, const char *, int, char **, int *, double *, int * );
936 int astGetDigits_( AstFrame *, int * );
937 int astGetDirection_( AstFrame *, int, int * );
938 int astGetMatchEnd_( AstFrame *, int * );
939 int astGetMaxAxes_( AstFrame *, int * );
940 int astGetMinAxes_( AstFrame *, int * );
941 int astGetNaxes_( AstFrame *, int * );
942 int astGetPermute_( AstFrame *, int * );
943 int astGetPreserveAxes_( AstFrame *, int * );
944 int astIsUnitFrame_( AstFrame *, int * );
945 int astLineCrossing_( AstFrame *, AstLineDef *, AstLineDef *, double **, int * );
946 int astLineContains_( AstFrame *, AstLineDef *, int, double *, int * );
947 int astMatch_( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
948 int astSubFrame_( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
949 int astTestDigits_( AstFrame *, int * );
950 int astTestDirection_( AstFrame *, int, int * );
951 int astTestDomain_( AstFrame *, int * );
952 int astTestFormat_( AstFrame *, int, int * );
953 int astTestLabel_( AstFrame *, int, int * );
954 int astTestMatchEnd_( AstFrame *, int * );
955 int astTestMaxAxes_( AstFrame *, int * );
956 int astTestMinAxes_( AstFrame *, int * );
957 int astTestPermute_( AstFrame *, int * );
958 int astTestPreserveAxes_( AstFrame *, int * );
959 int astTestSymbol_( AstFrame *, int, int * );
960 int astTestTitle_( AstFrame *, int * );
961 int astTestUnit_( AstFrame *, int, int * );
962 int astValidateAxis_( AstFrame *, int, int, const char *, int * );
963 AstSystemType astValidateSystem_( AstFrame *, AstSystemType, const char *, int * );
964 AstSystemType astSystemCode_( AstFrame *, const char *, int * );
965 const char *astSystemString_( AstFrame *, AstSystemType, int * );
966 void astCheckPerm_( AstFrame *, const int *, const char *, int * );
967 void astClearDigits_( AstFrame *, int * );
968 void astClearDirection_( AstFrame *, int, int * );
969 void astClearDomain_( AstFrame *, int * );
970 void astClearFormat_( AstFrame *, int, int * );
971 void astClearLabel_( AstFrame *, int, int * );
972 void astClearMatchEnd_( AstFrame *, int * );
973 void astClearMaxAxes_( AstFrame *, int * );
974 void astClearMinAxes_( AstFrame *, int * );
975 void astClearPermute_( AstFrame *, int * );
976 void astClearPreserveAxes_( AstFrame *, int * );
977 void astClearSymbol_( AstFrame *, int, int * );
978 void astClearTitle_( AstFrame *, int * );
979 void astClearUnit_( AstFrame *, int, int * );
980 void astOverlay_( AstFrame *, const int *, AstFrame *, int * );
981 void astPrimaryFrame_( AstFrame *, int, AstFrame **, int *, int * );
982 void astSetAxis_( AstFrame *, int, AstAxis *, int * );
983 void astSetDigits_( AstFrame *, int, int * );
984 void astSetDirection_( AstFrame *, int, int, int * );
985 void astSetDomain_( AstFrame *, const char *, int * );
986 void astSetFormat_( AstFrame *, int, const char *, int * );
987 void astSetLabel_( AstFrame *, int, const char *, int * );
988 void astSetMatchEnd_( AstFrame *, int, int * );
989 void astSetMaxAxes_( AstFrame *, int, int * );
990 void astSetMinAxes_( AstFrame *, int, int * );
991 void astSetPermute_( AstFrame *, int, int * );
992 void astSetPreserveAxes_( AstFrame *, int, int * );
993 void astSetSymbol_( AstFrame *, int, const char *, int * );
994 void astSetTitle_( AstFrame *, const char *, int * );
995 void astSetUnit_( AstFrame *, int, const char *, int * );
996 void astValidateAxisSelection_( AstFrame *, int, const int *, const char *, int * );
997 double astReadDateTime_( const char *, int * );
998 const char *astFmtDecimalYr_( double, int, int * );
999 void astLineOffset_( AstFrame *, AstLineDef *, double, double, double[2], int * );
1000 AstPointSet *astFrameGrid_( AstFrame *, int, const double *, const double *, int * );
1001 
1002 double astGetTop_( AstFrame *, int, int * );
1003 int astTestTop_( AstFrame *, int, int * );
1004 void astClearTop_( AstFrame *, int, int * );
1005 void astSetTop_( AstFrame *, int, double, int * );
1006 
1007 double astGetBottom_( AstFrame *, int, int * );
1008 int astTestBottom_( AstFrame *, int, int * );
1009 void astClearBottom_( AstFrame *, int, int * );
1010 void astSetBottom_( AstFrame *, int, double, int * );
1011 
1012 AstSystemType astGetSystem_( AstFrame *, int * );
1013 int astTestSystem_( AstFrame *, int * );
1014 void astClearSystem_( AstFrame *, int * );
1015 void astSetSystem_( AstFrame *, AstSystemType, int * );
1016 
1017 AstSystemType astGetAlignSystem_( AstFrame *, int * );
1018 int astTestAlignSystem_( AstFrame *, int * );
1019 void astClearAlignSystem_( AstFrame *, int * );
1020 void astSetAlignSystem_( AstFrame *, AstSystemType, int * );
1021 
1022 double astGetEpoch_( AstFrame *, int * );
1023 int astTestEpoch_( AstFrame *, int * );
1024 void astClearEpoch_( AstFrame *, int * );
1025 void astSetEpoch_( AstFrame *, double, int * );
1026 
1027 double astGetObsLon_( AstFrame *, int * );
1028 int astTestObsLon_( AstFrame *, int * );
1029 void astClearObsLon_( AstFrame *, int * );
1030 void astSetObsLon_( AstFrame *, double, int * );
1031 
1032 double astGetObsLat_( AstFrame *, int * );
1033 int astTestObsLat_( AstFrame *, int * );
1034 void astClearObsLat_( AstFrame *, int * );
1035 void astSetObsLat_( AstFrame *, double, int * );
1036 
1037 double astGetObsAlt_( AstFrame *, int * );
1038 int astTestObsAlt_( AstFrame *, int * );
1039 void astClearObsAlt_( AstFrame *, int * );
1040 void astSetObsAlt_( AstFrame *, double, int * );
1041 
1042 double astGetDut1_( AstFrame *, int * );
1043 int astTestDut1_( AstFrame *, int * );
1044 void astClearDut1_( AstFrame *, int * );
1045 void astSetDut1_( AstFrame *, double, int * );
1046 
1047 int astTestActiveUnit_( AstFrame *, int * );
1048 
1049 void astSetFrameFlags_( AstFrame *, int, int * );
1050 int astGetFrameFlags_( AstFrame *, int * );
1051 
1052 #endif
1053 
1054 /* Function interfaces. */
1055 /* ==================== */
1056 /* These macros are wrap-ups for the functions defined by this class to make
1057    them easier to invoke (e.g. to avoid type mis-matches when passing pointers
1058    to objects from derived classes). */
1059 
1060 /* Interfaces to standard class functions. */
1061 /* --------------------------------------- */
1062 /* Some of these functions provide validation, so we cannot use them to
1063    validate their own arguments. We must use a cast when passing object
1064    pointers (so that they can accept objects from derived classes). */
1065 
1066 /* Check class membership. */
1067 #define astCheckFrame(this) astINVOKE_CHECK(Frame,this,0)
1068 #define astVerifyFrame(this) astINVOKE_CHECK(Frame,this,1)
1069 
1070 /* Test class membership. */
1071 #define astIsAFrame(this) astINVOKE_ISA(Frame,this)
1072 
1073 /* Constructor. */
1074 #if defined(astCLASS)            /* Protected */
1075 #define astFrame astINVOKE(F,astFrame_)
1076 #else
1077 #define astFrame astINVOKE(F,astFrameId_)
1078 #endif
1079 
1080 #if defined(astCLASS)            /* Protected */
1081 
1082 /* Initialiser. */
1083 #define astInitFrame(mem,size,init,vtab,name,naxes) \
1084 astINVOKE(O,astInitFrame_(mem,size,init,vtab,name,naxes,STATUS_PTR))
1085 
1086 /* Vtab Initialiser. */
1087 #define astInitFrameVtab(vtab,name) astINVOKE(V,astInitFrameVtab_(vtab,name,STATUS_PTR))
1088 /* Loader. */
1089 #define astLoadFrame(mem,size,vtab,name,channel) \
1090 astINVOKE(O,astLoadFrame_(mem,size,vtab,name,astCheckChannel(channel),STATUS_PTR))
1091 #endif
1092 
1093 /* Interfaces to public member functions. */
1094 /* -------------------------------------- */
1095 /* Here we make use of astCheckFrame to validate Frame pointers before
1096    use. This provides a contextual error report if a pointer to the
1097    wrong sort of Object is supplied. */
1098 #define astConvert(from,to,domainlist) \
1099 astINVOKE(O,astConvert_(astCheckFrame(from),astCheckFrame(to),domainlist,STATUS_PTR))
1100 #define astAngle(this,a,b,c) \
1101 astINVOKE(V,astAngle_(astCheckFrame(this),a,b,c,STATUS_PTR))
1102 #define astDistance(this,point1,point2) \
1103 astINVOKE(V,astDistance_(astCheckFrame(this),point1,point2,STATUS_PTR))
1104 #define astFindFrame(target,template,domainlist) \
1105 astINVOKE(O,astFindFrame_(astCheckFrame(target),astCheckFrame(template),domainlist,STATUS_PTR))
1106 #define astMatchAxes(frm1,frm2,axes) \
1107 astINVOKE(V,astMatchAxes_(astCheckFrame(frm1),astCheckFrame(frm2),axes,STATUS_PTR))
1108 #define astNorm(this,value) \
1109 astINVOKE(V,astNorm_(astCheckFrame(this),value,STATUS_PTR))
1110 #define astAxDistance(this,axis,v1,v2) \
1111 astINVOKE(V,astAxDistance_(astCheckFrame(this),axis,v1,v2,STATUS_PTR))
1112 #define astAxOffset(this,axis,v1,dist) \
1113 astINVOKE(V,astAxOffset_(astCheckFrame(this),axis,v1,dist,STATUS_PTR))
1114 #define astOffset(this,point1,point2,offset,point3) \
1115 astINVOKE(V,astOffset_(astCheckFrame(this),point1,point2,offset,point3,STATUS_PTR))
1116 #define astAxAngle(this,a,b,axis) \
1117 astINVOKE(V,astAxAngle_(astCheckFrame(this),a,b,axis,STATUS_PTR))
1118 #define astIntersect(this,a1,a2,b1,b2,cross) \
1119 astINVOKE(V,astIntersect_(astCheckFrame(this),a1,a2,b1,b2,cross,STATUS_PTR))
1120 #define astOffset2(this,point1,angle,offset,point2) \
1121 astINVOKE(V,astOffset2_(astCheckFrame(this),point1,angle,offset,point2,STATUS_PTR))
1122 #define astResolve(this,point1,point2,point3,point4,d1,d2) \
1123 astINVOKE(V,astResolve_(astCheckFrame(this),point1,point2,point3,point4,d1,d2,STATUS_PTR))
1124 #define astGetActiveUnit(this) \
1125 astINVOKE(V,astGetActiveUnit_(astCheckFrame(this),STATUS_PTR))
1126 #define astSetActiveUnit(this,value) \
1127 astINVOKE(V,astSetActiveUnit_(astCheckFrame(this),value,STATUS_PTR))
1128 
1129 #if defined(astCLASS)            /* Protected */
1130 #define astGetFrameVariants(this) \
1131 astINVOKE(O,astGetFrameVariants_(astCheckFrame(this),STATUS_PTR))
1132 #define astSetFrameVariants(this,variants) \
1133 astINVOKE(V,astSetFrameVariants_(astCheckFrame(this),astCheckFrameSet(variants),STATUS_PTR))
1134 #define astNormBox(this,lbnd,ubnd,reg) \
1135 astINVOKE(V,astNormBox_(astCheckFrame(this),lbnd,ubnd,astCheckMapping(reg),STATUS_PTR))
1136 #define astFormat(this,axis,value) \
1137 astINVOKE(V,astFormat_(astCheckFrame(this),axis,value,STATUS_PTR))
1138 #define astPermAxes(this,perm) \
1139 astINVOKE(V,astPermAxes_(astCheckFrame(this),perm,STATUS_PTR))
1140 #define astPickAxes(this,naxes,axes,map) \
1141 astINVOKE(O,astPickAxes_(astCheckFrame(this),naxes,axes,(AstMapping **)(map),STATUS_PTR))
1142 #define astUnformat(this,axis,string,value) \
1143 astINVOKE(V,astUnformat_(astCheckFrame(this),axis,string,value,STATUS_PTR))
1144 #else
1145 #define astFormat(this,axis,value) \
1146 astINVOKE(V,astFormatId_(astCheckFrame(this),axis,value,STATUS_PTR))
1147 #define astPermAxes(this,perm) \
1148 astINVOKE(V,astPermAxesId_(astCheckFrame(this),perm,STATUS_PTR))
1149 #define astPickAxes(this,naxes,axes,map) \
1150 astINVOKE(O,astPickAxesId_(astCheckFrame(this),naxes,axes,(AstMapping **)(map),STATUS_PTR))
1151 #define astUnformat(this,axis,string,value) \
1152 astINVOKE(V,astUnformatId_(astCheckFrame(this),axis,string,value,STATUS_PTR))
1153 #endif
1154 
1155 #if defined(astCLASS)            /* Protected */
1156 #define astAxIn(this,axis,lo,hi,val,closed) \
1157 astINVOKE(V,astAxIn_(astCheckFrame(this),axis,lo,hi,val,closed,STATUS_PTR))
1158 #define astAbbrev(this,axis,fmt,str1,str2) \
1159 astINVOKE(V,astAbbrev_(astCheckFrame(this),axis,fmt,str1,str2,STATUS_PTR))
1160 #define astFields(this,axis,fmt,str,maxfld,fields,nc,val) \
1161 astINVOKE(V,astFields_(astCheckFrame(this),axis,fmt,str,maxfld,fields,nc,val,STATUS_PTR))
1162 #define astCheckPerm(this,perm,method) \
1163 astINVOKE(V,astCheckPerm_(astCheckFrame(this),perm,method,STATUS_PTR))
1164 #define astResolvePoints(this,p1,p2,in,out) \
1165 astINVOKE(O,astResolvePoints_(astCheckFrame(this),p1,p2,astCheckPointSet(in),((out)?astCheckPointSet(out):NULL),STATUS_PTR))
1166 #define astLineDef(this,p1,p2) \
1167 astINVOKE(V,astLineDef_(astCheckFrame(this),p1,p2,STATUS_PTR))
1168 #define astLineOffset(this,line,par,prp,point) \
1169 astINVOKE(V,astLineOffset_(astCheckFrame(this),line,par,prp,point,STATUS_PTR))
1170 #define astFrameGrid(this,size,lbnd,ubnd) \
1171 astINVOKE(O,astFrameGrid_(astCheckFrame(this),size,lbnd,ubnd,STATUS_PTR))
1172 #define astLineCrossing(this,l1,l2,cross) \
1173 astINVOKE(V,astLineCrossing_(astCheckFrame(this),l1,l2,cross,STATUS_PTR))
1174 #define astLineContains(this,l,def,point) \
1175 astINVOKE(V,astLineContains_(astCheckFrame(this),l,def,point,STATUS_PTR))
1176 #define astClearDigits(this) \
1177 astINVOKE(V,astClearDigits_(astCheckFrame(this),STATUS_PTR))
1178 #define astClearDirection(this,axis) \
1179 astINVOKE(V,astClearDirection_(astCheckFrame(this),axis,STATUS_PTR))
1180 #define astClearDomain(this) \
1181 astINVOKE(V,astClearDomain_(astCheckFrame(this),STATUS_PTR))
1182 #define astClearFormat(this,axis) \
1183 astINVOKE(V,astClearFormat_(astCheckFrame(this),axis,STATUS_PTR))
1184 #define astClearLabel(this,axis) \
1185 astINVOKE(V,astClearLabel_(astCheckFrame(this),axis,STATUS_PTR))
1186 #define astClearMatchEnd(this) \
1187 astINVOKE(V,astClearMatchEnd_(astCheckFrame(this),STATUS_PTR))
1188 #define astClearMaxAxes(this) \
1189 astINVOKE(V,astClearMaxAxes_(astCheckFrame(this),STATUS_PTR))
1190 #define astClearMinAxes(this) \
1191 astINVOKE(V,astClearMinAxes_(astCheckFrame(this),STATUS_PTR))
1192 #define astClearPermute(this) \
1193 astINVOKE(V,astClearPermute_(astCheckFrame(this),STATUS_PTR))
1194 #define astClearPreserveAxes(this) \
1195 astINVOKE(V,astClearPreserveAxes_(astCheckFrame(this),STATUS_PTR))
1196 #define astClearSymbol(this,axis) \
1197 astINVOKE(V,astClearSymbol_(astCheckFrame(this),axis,STATUS_PTR))
1198 #define astClearTitle(this) \
1199 astINVOKE(V,astClearTitle_(astCheckFrame(this),STATUS_PTR))
1200 #define astClearUnit(this,axis) \
1201 astINVOKE(V,astClearUnit_(astCheckFrame(this),axis,STATUS_PTR))
1202 #define astConvertX(to,from,domainlist) \
1203 astINVOKE(O,astConvertX_(astCheckFrame(to),astCheckFrame(from),domainlist,STATUS_PTR))
1204 #define astGap(this,axis,gap,ntick) \
1205 astINVOKE(V,astGap_(astCheckFrame(this),axis,gap,ntick,STATUS_PTR))
1206 #define astGetAxis(this,axis) \
1207 astINVOKE(O,astGetAxis_(astCheckFrame(this),axis,STATUS_PTR))
1208 #define astGetDigits(this) \
1209 astINVOKE(V,astGetDigits_(astCheckFrame(this),STATUS_PTR))
1210 #define astGetDirection(this,axis) \
1211 astINVOKE(V,astGetDirection_(astCheckFrame(this),axis,STATUS_PTR))
1212 #define astGetDomain(this) \
1213 astINVOKE(V,astGetDomain_(astCheckFrame(this),STATUS_PTR))
1214 #define astGetFormat(this,axis) \
1215 astINVOKE(V,astGetFormat_(astCheckFrame(this),axis,STATUS_PTR))
1216 #define astGetLabel(this,axis) \
1217 astINVOKE(V,astGetLabel_(astCheckFrame(this),axis,STATUS_PTR))
1218 #define astGetMatchEnd(this) \
1219 astINVOKE(V,astGetMatchEnd_(astCheckFrame(this),STATUS_PTR))
1220 #define astGetMaxAxes(this) \
1221 astINVOKE(V,astGetMaxAxes_(astCheckFrame(this),STATUS_PTR))
1222 #define astGetMinAxes(this) \
1223 astINVOKE(V,astGetMinAxes_(astCheckFrame(this),STATUS_PTR))
1224 #define astGetNaxes(this) \
1225 astINVOKE(V,astGetNaxes_(astCheckFrame(this),STATUS_PTR))
1226 #define astGetPerm(this) \
1227 astINVOKE(V,astGetPerm_(astCheckFrame(this),STATUS_PTR))
1228 #define astGetPermute(this) \
1229 astINVOKE(V,astGetPermute_(astCheckFrame(this),STATUS_PTR))
1230 #define astGetPreserveAxes(this) \
1231 astINVOKE(V,astGetPreserveAxes_(astCheckFrame(this),STATUS_PTR))
1232 #define astGetSymbol(this,axis) \
1233 astINVOKE(V,astGetSymbol_(astCheckFrame(this),axis,STATUS_PTR))
1234 #define astGetTitle(this) \
1235 astINVOKE(V,astGetTitle_(astCheckFrame(this),STATUS_PTR))
1236 #define astGetUnit(this,axis) \
1237 astINVOKE(V,astGetUnit_(astCheckFrame(this),axis,STATUS_PTR))
1238 #define astGetNormUnit(this,axis) \
1239 astINVOKE(V,astGetNormUnit_(astCheckFrame(this),axis,STATUS_PTR))
1240 #define astMatch(template,target,matchsub,template_axes,target_axes,map,result) \
1241 astINVOKE(V,astMatch_(astCheckFrame(template),astCheckFrame(target),matchsub,template_axes,target_axes,(AstMapping **)(map),(AstFrame **)(result),STATUS_PTR))
1242 #define astIsUnitFrame(this) \
1243 astINVOKE(V,astIsUnitFrame_(astCheckFrame(this),STATUS_PTR))
1244 #define astOverlay(template,template_axes,result) \
1245 astINVOKE(V,astOverlay_(astCheckFrame(template),template_axes,astCheckFrame(result),STATUS_PTR))
1246 #define astPrimaryFrame(this,axis1,frame,axis2) \
1247 astINVOKE(V,astPrimaryFrame_(astCheckFrame(this),axis1,(AstFrame **)(frame),axis2,STATUS_PTR))
1248 #define astSetAxis(this,axis,newaxis) \
1249 astINVOKE(V,astSetAxis_(astCheckFrame(this),axis,astCheckAxis(newaxis),STATUS_PTR))
1250 #define astSetDigits(this,digits) \
1251 astINVOKE(V,astSetDigits_(astCheckFrame(this),digits,STATUS_PTR))
1252 #define astSetDirection(this,axis,direction) \
1253 astINVOKE(V,astSetDirection_(astCheckFrame(this),axis,direction,STATUS_PTR))
1254 #define astSetDomain(this,domain) \
1255 astINVOKE(V,astSetDomain_(astCheckFrame(this),domain,STATUS_PTR))
1256 #define astSetFormat(this,axis,format) \
1257 astINVOKE(V,astSetFormat_(astCheckFrame(this),axis,format,STATUS_PTR))
1258 #define astSetLabel(this,axis,label) \
1259 astINVOKE(V,astSetLabel_(astCheckFrame(this),axis,label,STATUS_PTR))
1260 #define astSetMatchEnd(this,value) \
1261 astINVOKE(V,astSetMatchEnd_(astCheckFrame(this),value,STATUS_PTR))
1262 #define astSetMaxAxes(this,value) \
1263 astINVOKE(V,astSetMaxAxes_(astCheckFrame(this),value,STATUS_PTR))
1264 #define astSetMinAxes(this,value) \
1265 astINVOKE(V,astSetMinAxes_(astCheckFrame(this),value,STATUS_PTR))
1266 #define astSetPermute(this,value) \
1267 astINVOKE(V,astSetPermute_(astCheckFrame(this),value,STATUS_PTR))
1268 #define astSetPreserveAxes(this,value) \
1269 astINVOKE(V,astSetPreserveAxes_(astCheckFrame(this),value,STATUS_PTR))
1270 #define astSetSymbol(this,axis,symbol) \
1271 astINVOKE(V,astSetSymbol_(astCheckFrame(this),axis,symbol,STATUS_PTR))
1272 #define astSetTitle(this,title) \
1273 astINVOKE(V,astSetTitle_(astCheckFrame(this),title,STATUS_PTR))
1274 #define astSetUnit(this,axis,unit) \
1275 astINVOKE(V,astSetUnit_(astCheckFrame(this),axis,unit,STATUS_PTR))
1276 #define astSubFrame(target,template,result_naxes,target_axes,template_axes,map,result) \
1277 astINVOKE(V,astSubFrame_(astCheckFrame(target),template?astCheckFrame(template):NULL,result_naxes,target_axes,template_axes,(AstMapping **)(map),(AstFrame **)(result),STATUS_PTR))
1278 #define astTestDigits(this) \
1279 astINVOKE(V,astTestDigits_(astCheckFrame(this),STATUS_PTR))
1280 #define astTestDirection(this,axis) \
1281 astINVOKE(V,astTestDirection_(astCheckFrame(this),axis,STATUS_PTR))
1282 #define astTestDomain(this) \
1283 astINVOKE(V,astTestDomain_(astCheckFrame(this),STATUS_PTR))
1284 #define astTestFormat(this,axis) \
1285 astINVOKE(V,astTestFormat_(astCheckFrame(this),axis,STATUS_PTR))
1286 #define astTestLabel(this,axis) \
1287 astINVOKE(V,astTestLabel_(astCheckFrame(this),axis,STATUS_PTR))
1288 #define astTestMatchEnd(this) \
1289 astINVOKE(V,astTestMatchEnd_(astCheckFrame(this),STATUS_PTR))
1290 #define astTestMaxAxes(this) \
1291 astINVOKE(V,astTestMaxAxes_(astCheckFrame(this),STATUS_PTR))
1292 #define astTestMinAxes(this) \
1293 astINVOKE(V,astTestMinAxes_(astCheckFrame(this),STATUS_PTR))
1294 #define astTestPermute(this) \
1295 astINVOKE(V,astTestPermute_(astCheckFrame(this),STATUS_PTR))
1296 #define astTestPreserveAxes(this) \
1297 astINVOKE(V,astTestPreserveAxes_(astCheckFrame(this),STATUS_PTR))
1298 #define astTestSymbol(this,axis) \
1299 astINVOKE(V,astTestSymbol_(astCheckFrame(this),axis,STATUS_PTR))
1300 #define astTestTitle(this) \
1301 astINVOKE(V,astTestTitle_(astCheckFrame(this),STATUS_PTR))
1302 #define astTestUnit(this,axis) \
1303 astINVOKE(V,astTestUnit_(astCheckFrame(this),axis,STATUS_PTR))
1304 #define astValidateAxis(this,axis,fwd,method) \
1305 astINVOKE(V,astValidateAxis_(astCheckFrame(this),axis,fwd,method,STATUS_PTR))
1306 #define astValidateAxisSelection(this,naxes,axes,method) \
1307 astINVOKE(V,astValidateAxisSelection_(astCheckFrame(this),naxes,axes,method,STATUS_PTR))
1308 
1309 #define astMatchAxesX(frm2,frm1,axes) \
1310 astINVOKE(V,astMatchAxesX_(astCheckFrame(frm2),astCheckFrame(frm1),axes,STATUS_PTR))
1311 
1312 #define astFmtDecimalYr(year,digits) astFmtDecimalYr_(year,digits,STATUS_PTR)
1313 #define astReadDateTime(value) astReadDateTime_(value,STATUS_PTR)
1314 
1315 #define astValidateSystem(this,system,method) \
1316 astINVOKE(V,astValidateSystem_(astCheckFrame(this),system,method,STATUS_PTR))
1317 #define astSystemString(this,system) \
1318 astINVOKE(V,astSystemString_(astCheckFrame(this),system,STATUS_PTR))
1319 #define astSystemCode(this,system) \
1320 astINVOKE(V,astSystemCode_(astCheckFrame(this),system,STATUS_PTR))
1321 
1322 #define astClearTop(this,axis) \
1323 astINVOKE(V,astClearTop_(astCheckFrame(this),axis,STATUS_PTR))
1324 #define astGetTop(this,axis) \
1325 astINVOKE(V,astGetTop_(astCheckFrame(this),axis,STATUS_PTR))
1326 #define astSetTop(this,axis,value) \
1327 astINVOKE(V,astSetTop_(astCheckFrame(this),axis,value,STATUS_PTR))
1328 #define astTestTop(this,axis) \
1329 astINVOKE(V,astTestTop_(astCheckFrame(this),axis,STATUS_PTR))
1330 
1331 #define astClearBottom(this,axis) \
1332 astINVOKE(V,astClearBottom_(astCheckFrame(this),axis,STATUS_PTR))
1333 #define astGetBottom(this,axis) \
1334 astINVOKE(V,astGetBottom_(astCheckFrame(this),axis,STATUS_PTR))
1335 #define astSetBottom(this,axis,value) \
1336 astINVOKE(V,astSetBottom_(astCheckFrame(this),axis,value,STATUS_PTR))
1337 #define astTestBottom(this,axis) \
1338 astINVOKE(V,astTestBottom_(astCheckFrame(this),axis,STATUS_PTR))
1339 
1340 #define astClearSystem(this) \
1341 astINVOKE(V,astClearSystem_(astCheckFrame(this),STATUS_PTR))
1342 #define astGetSystem(this) \
1343 astINVOKE(V,astGetSystem_(astCheckFrame(this),STATUS_PTR))
1344 #define astSetSystem(this,value) \
1345 astINVOKE(V,astSetSystem_(astCheckFrame(this),value,STATUS_PTR))
1346 #define astTestSystem(this) \
1347 astINVOKE(V,astTestSystem_(astCheckFrame(this),STATUS_PTR))
1348 
1349 #define astClearAlignSystem(this) \
1350 astINVOKE(V,astClearAlignSystem_(astCheckFrame(this),STATUS_PTR))
1351 #define astGetAlignSystem(this) \
1352 astINVOKE(V,astGetAlignSystem_(astCheckFrame(this),STATUS_PTR))
1353 #define astSetAlignSystem(this,value) \
1354 astINVOKE(V,astSetAlignSystem_(astCheckFrame(this),value,STATUS_PTR))
1355 #define astTestAlignSystem(this) \
1356 astINVOKE(V,astTestAlignSystem_(astCheckFrame(this),STATUS_PTR))
1357 
1358 #define astClearEpoch(this) \
1359 astINVOKE(V,astClearEpoch_(astCheckFrame(this),STATUS_PTR))
1360 #define astGetEpoch(this) \
1361 astINVOKE(V,astGetEpoch_(astCheckFrame(this),STATUS_PTR))
1362 #define astSetEpoch(this,value) \
1363 astINVOKE(V,astSetEpoch_(astCheckFrame(this),value,STATUS_PTR))
1364 #define astTestEpoch(this) \
1365 astINVOKE(V,astTestEpoch_(astCheckFrame(this),STATUS_PTR))
1366 
1367 #define astGetObsLon(this) \
1368 astINVOKE(V,astGetObsLon_(astCheckFrame(this),STATUS_PTR))
1369 #define astTestObsLon(this) \
1370 astINVOKE(V,astTestObsLon_(astCheckFrame(this),STATUS_PTR))
1371 #define astClearObsLon(this) \
1372 astINVOKE(V,astClearObsLon_(astCheckFrame(this),STATUS_PTR))
1373 #define astSetObsLon(this,value) \
1374 astINVOKE(V,astSetObsLon_(astCheckFrame(this),value,STATUS_PTR))
1375 
1376 #define astGetObsLat(this) \
1377 astINVOKE(V,astGetObsLat_(astCheckFrame(this),STATUS_PTR))
1378 #define astTestObsLat(this) \
1379 astINVOKE(V,astTestObsLat_(astCheckFrame(this),STATUS_PTR))
1380 #define astClearObsLat(this) \
1381 astINVOKE(V,astClearObsLat_(astCheckFrame(this),STATUS_PTR))
1382 #define astSetObsLat(this,value) \
1383 astINVOKE(V,astSetObsLat_(astCheckFrame(this),value,STATUS_PTR))
1384 
1385 #define astGetObsAlt(this) \
1386 astINVOKE(V,astGetObsAlt_(astCheckFrame(this),STATUS_PTR))
1387 #define astTestObsAlt(this) \
1388 astINVOKE(V,astTestObsAlt_(astCheckFrame(this),STATUS_PTR))
1389 #define astClearObsAlt(this) \
1390 astINVOKE(V,astClearObsAlt_(astCheckFrame(this),STATUS_PTR))
1391 #define astSetObsAlt(this,value) \
1392 astINVOKE(V,astSetObsAlt_(astCheckFrame(this),value,STATUS_PTR))
1393 
1394 #define astClearDut1(this) \
1395 astINVOKE(V,astClearDut1_(astCheckFrame(this),STATUS_PTR))
1396 #define astGetDut1(this) \
1397 astINVOKE(V,astGetDut1_(astCheckFrame(this),STATUS_PTR))
1398 #define astSetDut1(this,value) \
1399 astINVOKE(V,astSetDut1_(astCheckFrame(this),value,STATUS_PTR))
1400 #define astTestDut1(this) \
1401 astINVOKE(V,astTestDut1_(astCheckFrame(this),STATUS_PTR))
1402 
1403 #define astTestActiveUnit(this) \
1404 astINVOKE(V,astTestActiveUnit_(astCheckFrame(this),STATUS_PTR))
1405 
1406 #define astSetFrameFlags(this,flags) \
1407 astINVOKE(V,astSetFrameFlags_(astCheckFrame(this),flags,STATUS_PTR))
1408 #define astGetFrameFlags(this) \
1409 astINVOKE(V,astGetFrameFlags_(astCheckFrame(this),STATUS_PTR))
1410 
1411 #endif
1412 #endif
1413 
1414 
1415 
1416 
1417 
1418