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