diff options
author | William Joye <wjoye@cfa.harvard.edu> | 2019-05-10 19:05:35 (GMT) |
---|---|---|
committer | William Joye <wjoye@cfa.harvard.edu> | 2019-05-10 19:05:35 (GMT) |
commit | 51cd8ee68a63edc414c0fe3344ba0589ac5849dd (patch) | |
tree | 662741d231423544a0c4d8bec55d7c457a18c17e /ast/xphmap.c | |
parent | beb90b7d3f526440250bba67e5ab07bb7eb7bbc3 (diff) | |
download | blt-51cd8ee68a63edc414c0fe3344ba0589ac5849dd.zip blt-51cd8ee68a63edc414c0fe3344ba0589ac5849dd.tar.gz blt-51cd8ee68a63edc414c0fe3344ba0589ac5849dd.tar.bz2 |
upgrade ast 8.7.1
Diffstat (limited to 'ast/xphmap.c')
-rw-r--r-- | ast/xphmap.c | 1702 |
1 files changed, 1702 insertions, 0 deletions
diff --git a/ast/xphmap.c b/ast/xphmap.c new file mode 100644 index 0000000..b8bf030 --- /dev/null +++ b/ast/xphmap.c @@ -0,0 +1,1702 @@ +/* +*class+ +* Name: +* XphMap + +* Purpose: +* Transform between different HEALPix projections. + +* Constructor Function: +* astXphMap + +* Description: +* The XphMap class implements a Mapping between grid coordinates +* within different types of HEALPix projection: The available types +* are : +* +* - "HPX0": An HPX projection centred on RA=0h. +* - "HPX12": An HPX projection centred on RA=12h. +* - "XPHN": An XPH ("Butterfly") projection centred on the +* north pole. +* - "XPHS": An XPH ("Butterfly") projection centred on the +* south pole. +* +* The HPX projection is described in "Mapping on the HEALPix grid" +* by Calabretta and Roukema, A&A, 2005. The XPH projection is +* described in "Representing the 'butterfly' projection in FITS - +* projection code XPH" by Calabretta and Lowe, PASA, 2018. +* +* The forward transformation of an XphMap transforms from grid +* coordinates within the nominated projection type into grid +* coordinates within an HPX12 projection. + +* Inheritance: +* The XphMap class inherits from the Mapping class. + +* Attributes: +* The XphMap class does not define any new attributes beyond those +* which are applicable to all Mappings. + +* Functions: +* The XphMap class does not define any new functions beyond those +* which are applicable to all Mappings. + +* Copyright: +* Copyright (C) 2018 East Asian Observatory + +* Licence: +* This program is free software: you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation, either +* version 3 of the License, or (at your option) any later +* version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General +* License along with this program. If not, see +* <http://www.gnu.org/licenses/>. + +* Authors: +* DSB: David S. Berry (EAO) + +* History: +* 18-OCT-2018 (DSB): +* Original version. +*class- +*/ + +/* Module Macros. */ +/* ============== */ +/* Set the name of the class we are implementing. This indicates to + the header files that define class interfaces that they should make + "protected" symbols available. */ +#define astCLASS XphMap + +/* Include files. */ +/* ============== */ +/* Interface definitions. */ +/* ---------------------- */ + +#include "globals.h" /* Thread-safe global data access */ +#include "error.h" /* Error reporting facilities */ +#include "memory.h" /* Memory allocation facilities */ +#include "globals.h" /* Thread-safe global data access */ +#include "object.h" /* Base Object class */ +#include "pointset.h" /* Sets of points/coordinates */ +#include "mapping.h" /* Coordinate mappings (parent class) */ +#include "channel.h" /* I/O channels */ +#include "unitmap.h" /* Unit Mappings */ +#include "matrixmap.h" /* Matrix Mappings */ +#include "xphmap.h" /* Interface definition for this class */ + +/* Error code definitions. */ +/* ----------------------- */ +#include "ast_err.h" /* AST error codes */ + +/* C header files. */ +/* --------------- */ +#include <float.h> +#include <math.h> +#include <stdarg.h> +#include <stdlib.h> +#include <stddef.h> +#include <stdio.h> +#include <string.h> + +/* Module Variables. */ +/* ================= */ + +/* Names and descriptions of each type of XphMap. These should correspond + to the values of constants AST__HPX0, AST__HPX12, AST__XPHN and AST__XPHS + in xphmap.h */ +static const char *proj_name[] = { "HPX0", "HPX12", "XPHN", "XPHS" }; +static const char *proj_comm[] = { "HPX projection centred on RA=0h", + "HPX projection centred on RA=12h", + "XPH projection centred on north pole", + "XPH projection centred on south pole" }; + +/* Address of this static variable is used as a unique identifier for + member of this class. */ +static int class_check; + +/* Pointers to parent class methods which are extended by this class. */ +static AstPointSet *(* parent_transform)( AstMapping *, AstPointSet *, int, AstPointSet *, int * ); + +/* Define macros for accessing each item of thread specific global data. */ +#ifdef THREAD_SAFE + +/* Define how to initialise thread-specific globals. */ +#define GLOBAL_inits \ + globals->Class_Init = 0; + +/* Create the function that initialises global data for this module. */ +astMAKE_INITGLOBALS(XphMap) + +/* Define macros for accessing each item of thread specific global data. */ +#define class_init astGLOBAL(XphMap,Class_Init) +#define class_vtab astGLOBAL(XphMap,Class_Vtab) +#define getattrib_buff astGLOBAL(XphMap,GetAttrib_Buff) + + + +/* If thread safety is not needed, declare and initialise globals at static + variables. */ +#else + +/* Define the class virtual function table and its initialisation flag + as static variables. */ +static AstXphMapVtab class_vtab; /* Virtual function table */ +static int class_init = 0; /* Virtual function table initialised? */ + +#endif + +/* External Interface Function Prototypes. */ +/* ======================================= */ +/* The following functions have public prototypes only (i.e. no + protected prototypes), so we must provide local prototypes for use + within this module. */ +AstXphMap *astXphMapId_( int, int, const char *, ... ); + +/* Prototypes for Private Member Functions. */ +/* ======================================== */ +static AstPointSet *Transform( AstMapping *, AstPointSet *, int, AstPointSet *, int * ); +static int Equal( AstObject *, AstObject *, int * ); +static int GetIsLinear( AstMapping *, int * ); +static int MapMerge( AstMapping *, int, int, int *, AstMapping ***, int **, int * ); +static void Dump( AstObject *, AstChannel *, int * ); + +/* Member functions. */ +/* ================= */ + +static int Equal( AstObject *this_object, AstObject *that_object, int *status ) { +/* +* Name: +* Equal + +* Purpose: +* Test if two XphMaps are equivalent. + +* Type: +* Private function. + +* Synopsis: +* #include "xphmap.h" +* int Equal( AstObject *this, AstObject *that, int *status ) + +* Class Membership: +* XphMap member function (over-rides the astEqual protected +* method inherited from the astMapping class). + +* Description: +* This function returns a boolean result (0 or 1) to indicate whether +* two XphMaps are equivalent. + +* Parameters: +* this +* Pointer to the first Object (a XphMap). +* that +* Pointer to the second Object. +* status +* Pointer to the inherited status variable. + +* Returned Value: +* One if the XphMaps are equivalent, zero otherwise. + +* Notes: +* - A value of zero will be returned if this function is invoked +* with the global status set, or if it should fail for any reason. +*/ + +/* Local Variables: */ + AstXphMap *that; + AstXphMap *this; + int result; + +/* Initialise. */ + result = 0; + +/* Check the global error status. */ + if ( !astOK ) return result; + +/* Obtain pointers to the two XphMap structures. */ + this = (AstXphMap *) this_object; + that = (AstXphMap *) that_object; + +/* Check the second object is a XphMap. We know the first is a + XphMap since we have arrived at this implementation of the virtual + function. */ + if( astIsAXphMap( that ) ) { + +/* Check the properties of the two XphMaps are equal. */ + if( astGetInvert( this ) == astGetInvert( that ) ) { + result = ( this->type == that->type ) && + ( this->order == that->order ); + } + } + +/* Return the result, */ + return result; +} + +static int GetIsLinear( AstMapping *this_mapping, int *status ){ +/* +* Name: +* GetIsLinear + +* Purpose: +* Return the value of the IsLinear attribute for a XphMap. + +* Type: +* Private function. + +* Synopsis: +* #include "mapping.h" +* void GetIsLinear( AstMapping *this, int *status ) + +* Class Membership: +* XphMap member function (over-rides the protected astGetIsLinear +* method inherited from the Mapping class). + +* Description: +* This function returns the value of the IsLinear attribute for a +* Frame, which is always one. + +* Parameters: +* this +* Pointer to the XphMap. +* status +* Pointer to the inherited status variable. +*/ + return (((AstXphMap *) this_mapping)->type == AST__HPX12 ); +} + +void astInitXphMapVtab_( AstXphMapVtab *vtab, const char *name, int *status ) { +/* +*+ +* Name: +* astInitXphMapVtab + +* Purpose: +* Initialise a virtual function table for a XphMap. + +* Type: +* Protected function. + +* Synopsis: +* #include "xphmap.h" +* void astInitXphMapVtab( AstXphMapVtab *vtab, const char *name ) + +* Class Membership: +* XphMap vtab initialiser. + +* Description: +* This function initialises the component of a virtual function +* table which is used by the XphMap class. + +* Parameters: +* vtab +* Pointer to the virtual function table. The components used by +* all ancestral classes will be initialised if they have not already +* been initialised. +* name +* Pointer to a constant null-terminated character string which contains +* the name of the class to which the virtual function table belongs (it +* is this pointer value that will subsequently be returned by the Object +* astClass function). +*- +*/ + +/* Local Variables: */ + astDECLARE_GLOBALS /* Pointer to thread-specific global data */ + AstObjectVtab *object; /* Pointer to Object component of Vtab */ + AstMappingVtab *mapping; /* Pointer to Mapping component of Vtab */ + +/* Check the local error status. */ + if ( !astOK ) return; + +/* Get a pointer to the thread specific global data structure. */ + astGET_GLOBALS(NULL); + +/* Initialize the component of the virtual function table used by the + parent class. */ + astInitMappingVtab( (AstMappingVtab *) vtab, name ); + +/* Store a unique "magic" value in the virtual function table. This + will be used (by astIsAXphMap) to determine if an object belongs + to this class. We can conveniently use the address of the (static) + class_check variable to generate this unique value. */ + vtab->id.check = &class_check; + vtab->id.parent = &(((AstMappingVtab *) vtab)->id); + +/* Initialise member function pointers. */ +/* ------------------------------------ */ +/* Store pointers to the member functions (implemented here) that provide + virtual methods for this class. */ + +/* Save the inherited pointers to methods that will be extended, and + replace them with pointers to the new member functions. */ + object = (AstObjectVtab *) vtab; + mapping = (AstMappingVtab *) vtab; + + parent_transform = mapping->Transform; + mapping->Transform = Transform; + +/* Store replacement pointers for methods which will be over-ridden by + new member functions implemented here. */ + object->Equal = Equal; + mapping->MapMerge = MapMerge; + mapping->GetIsLinear = GetIsLinear; + +/* Declare the class dump function. There is no copy constructor or + destructor. */ + astSetDump( vtab, Dump, "XphMap", "HPX variant mapping" ); + +/* If we have just initialised the vtab for the current class, indicate + that the vtab is now initialised, and store a pointer to the class + identifier in the base "object" level of the vtab. */ + if( vtab == &class_vtab ) { + class_init = 1; + astSetVtabClassIdentifier( vtab, &(vtab->id) ); + } +} + +static int MapMerge( AstMapping *this, int where, int series, int *nmap, + AstMapping ***map_list, int **invert_list, int *status ) { +/* +* Name: +* MapMerge + +* Purpose: +* Simplify a sequence of Mappings containing a XphMap. + +* Type: +* Private function. + +* Synopsis: +* #include "mapping.h" +* int MapMerge( AstMapping *this, int where, int series, int *nmap, +* AstMapping ***map_list, int **invert_list, int *status ) + +* Class Membership: +* XphMap method (over-rides the protected astMapMerge method +* inherited from the Mapping class). + +* Description: +* This function attempts to simplify a sequence of Mappings by +* merging a nominated XphMap in the sequence with its neighbours, +* so as to shorten the sequence if possible. +* +* In many cases, simplification will not be possible and the +* function will return -1 to indicate this, without further +* action. +* +* In most cases of interest, however, this function will either +* attempt to replace the nominated XphMap with one which it +* considers simpler, or to merge it with the Mappings which +* immediately precede it or follow it in the sequence (both will +* normally be considered). This is sufficient to ensure the +* eventual simplification of most Mapping sequences by repeated +* application of this function. +* +* In some cases, the function may attempt more elaborate +* simplification, involving any number of other Mappings in the +* sequence. It is not restricted in the type or scope of +* simplification it may perform, but will normally only attempt +* elaborate simplification in cases where a more straightforward +* approach is not adequate. + +* Parameters: +* this +* Pointer to the nominated XphMap which is to be merged with +* its neighbours. This should be a cloned copy of the XphMap +* pointer contained in the array element "(*map_list)[where]" +* (see below). This pointer will not be annulled, and the +* XphMap it identifies will not be modified by this function. +* where +* Index in the "*map_list" array (below) at which the pointer +* to the nominated XphMap resides. +* series +* A non-zero value indicates that the sequence of Mappings to +* be simplified will be applied in series (i.e. one after the +* other), whereas a zero value indicates that they will be +* applied in parallel (i.e. on successive sub-sets of the +* input/output coordinates). +* nmap +* Address of an int which counts the number of Mappings in the +* sequence. On entry this should be set to the initial number +* of Mappings. On exit it will be updated to record the number +* of Mappings remaining after simplification. +* map_list +* Address of a pointer to a dynamically allocated array of +* Mapping pointers (produced, for example, by the astMapList +* method) which identifies the sequence of Mappings. On entry, +* the initial sequence of Mappings to be simplified should be +* supplied. +* +* On exit, the contents of this array will be modified to +* reflect any simplification carried out. Any form of +* simplification may be performed. This may involve any of: (a) +* removing Mappings by annulling any of the pointers supplied, +* (b) replacing them with pointers to new Mappings, (c) +* inserting additional Mappings and (d) changing their order. +* +* The intention is to reduce the number of Mappings in the +* sequence, if possible, and any reduction will be reflected in +* the value of "*nmap" returned. However, simplifications which +* do not reduce the length of the sequence (but improve its +* execution time, for example) may also be performed, and the +* sequence might conceivably increase in length (but normally +* only in order to split up a Mapping into pieces that can be +* more easily merged with their neighbours on subsequent +* invocations of this function). +* +* If Mappings are removed from the sequence, any gaps that +* remain will be closed up, by moving subsequent Mapping +* pointers along in the array, so that vacated elements occur +* at the end. If the sequence increases in length, the array +* will be extended (and its pointer updated) if necessary to +* accommodate any new elements. +* +* Note that any (or all) of the Mapping pointers supplied in +* this array may be annulled by this function, but the Mappings +* to which they refer are not modified in any way (although +* they may, of course, be deleted if the annulled pointer is +* the final one). +* invert_list +* Address of a pointer to a dynamically allocated array which, +* on entry, should contain values to be assigned to the Invert +* attributes of the Mappings identified in the "*map_list" +* array before they are applied (this array might have been +* produced, for example, by the astMapList method). These +* values will be used by this function instead of the actual +* Invert attributes of the Mappings supplied, which are +* ignored. +* +* On exit, the contents of this array will be updated to +* correspond with the possibly modified contents of the +* "*map_list" array. If the Mapping sequence increases in +* length, the "*invert_list" array will be extended (and its +* pointer updated) if necessary to accommodate any new +* elements. +* status +* Pointer to the inherited status variable. + +* Returned Value: +* If simplification was possible, the function returns the index +* in the "map_list" array of the first element which was +* modified. Otherwise, it returns -1 (and makes no changes to the +* arrays supplied). + +* Notes: +* - A value of -1 will be returned if this function is invoked +* with the global error status set, or if it should fail for any +* reason. +*/ + +/* Local Variables: */ + AstMapping *new; /* Pointer to replacement Mapping */ + const char *class; /* Pointer to Mapping class string */ + int cancel; /* Do mappings cancel? */ + int imap1; /* Index of first XphMap */ + int imap2; /* Index of last XphMap */ + int imap; /* Loop counter for Mappings */ + int old_invert1; /* Original Invert flag for map1 */ + int old_invert2; /* Original Invert flag for map2 */ + int result; /* Result value to return */ + +/* Initialise the returned result. */ + result = -1; + +/* Check the global error status. */ + if ( !astOK ) return result; + +/* Note, an XphMap with a type of AST__HPX12 is not equivalent to a UnitMap + because it performs clipping of out-of-bounds input positions, even + though input positions that are within bounds are copied unchanged. */ + +/* In series. */ +/* ---------- */ +/* Handle the case where the Mappings are connected in series. */ + if ( series ) { + +/* Look for an adjacent XphMap. */ + imap1 = -1; + imap2 = -1; + + if( where > 0 ) { + class = astGetClass( ( *map_list )[ where - 1 ] ); + if ( astOK && !strcmp( class, "XphMap" ) ) { + imap1 = where - 1; + imap2 = where; + } + } + + if( imap1 == -1 && where < *nmap - 1 ) { + class = astGetClass( ( *map_list )[ where + 1 ] ); + if ( astOK && !strcmp( class, "XphMap" ) ) { + imap1 = where; + imap2 = where + 1; + } + } + +/* If one was found, check to see if the two adjacent XphMaps cancel out. */ + if( imap1 != -1 ) { + +/* Ensure they have the required Invert flags, saving the original + values first so they can be re-instated later. */ + old_invert1 = astGetInvert( ( *map_list )[ imap1 ] ); + old_invert2 = astGetInvert( ( *map_list )[ imap2 ] ); + astSetInvert( ( *map_list )[ imap1 ], ( *invert_list )[ imap1 ] ); + astSetInvert( ( *map_list )[ imap2 ], ( *invert_list )[ imap2 ] ); + +/* They cancel out if they are equal and opposite. So invert one and then + compare them for equality. */ + astInvert( ( *map_list )[ imap1 ] ); + cancel = astEqual( ( *map_list )[ imap1 ], ( *map_list )[ imap2 ] ); + astInvert( ( *map_list )[ imap1 ] ); + +/* Reinstate the original Invert flags. */ + astSetInvert( ( *map_list )[ imap1 ], old_invert1 ); + astSetInvert( ( *map_list )[ imap2 ], old_invert2 ); + +/* Replace the two XphMaps with a UnitMap if they cancel. */ + if( cancel ) { + +/* Annul the old Mapping pointers */ + ( *map_list )[ imap1 ] = astAnnul( ( *map_list )[ imap1 ] ); + ( *map_list )[ imap2 ] = astAnnul( ( *map_list )[ imap2 ] ); + +/* Create the UnitMap. */ + new = (AstMapping *) astUnitMap( 2, "", status ); + +/* Insert the pointer to the replacement Mapping and initialise its + invert flag. */ + ( *map_list )[ imap1 ] = new; + ( *invert_list )[ imap1 ] = 0; + +/* Loop to close the resulting gap by moving subsequent elements down + in the arrays. */ + for ( imap = imap2 + 1; imap < *nmap; imap++ ) { + ( *map_list )[ imap - 1 ] = ( *map_list )[ imap ]; + ( *invert_list )[ imap - 1 ] = ( *invert_list )[ imap ]; + } + +/* Clear the vacated elements at the end. */ + ( *map_list )[ *nmap - 1 ] = NULL; + ( *invert_list )[ *nmap - 1 ] = 0; + +/* Decrement the Mapping count and return the index of the first + modified element. */ + ( *nmap )--; + result = imap1; + } + } + } + +/* If an error occurred, clear the returned result. */ + if ( !astOK ) result = -1; + +/* Return the result. */ + return result; +} + +static AstPointSet *Transform( AstMapping *this, AstPointSet *in, + int forward, AstPointSet *out, int *status ) { +/* +* Name: +* Transform + +* Purpose: +* Apply a XphMap to transform a set of points. + +* Type: +* Private function. + +* Synopsis: +* #include "xphmap.h" +* AstPointSet *Transform( AstMapping *this, AstPointSet *in, +* int forward, AstPointSet *out, int *status ) + +* Class Membership: +* XphMap member function (over-rides the astTransform protected +* method inherited from the Mapping class). + +* Description: +* This function takes a XphMap and a set of points encapsulated in a +* PointSet and transforms the points so as to apply the required zoom +* factor. + +* Parameters: +* this +* Pointer to the XphMap. +* in +* Pointer to the PointSet holding the input coordinate data. +* forward +* A non-zero value indicates that the forward coordinate transformation +* should be applied, while a zero value requests the inverse +* transformation. +* out +* Pointer to a PointSet which will hold the transformed (output) +* coordinate values. A NULL value may also be given, in which case a +* new PointSet will be created by this function. +* status +* Pointer to the inherited status variable. + +* Returned Value: +* Pointer to the output (possibly new) PointSet. + +* Notes: +* - A null pointer will be returned if this function is invoked with the +* global error status set, or if it should fail for any reason. +* - The number of coordinate values per point in the input PointSet must +* match the number of coordinates for the XphMap being applied. +* - If an output PointSet is supplied, it must have space for sufficient +* number of points and coordinate values per point to accommodate the +* result. Any excess space will be ignored. +*/ + +/* Local Variables: */ + AstPointSet *result; /* Pointer to output PointSet */ + AstXphMap *map; /* Pointer to XphMap to be applied */ + double **ptr_in; /* Pointer to input coordinate data */ + double **ptr_out; /* Pointer to output coordinate data */ + double *px_in; /* Pointer to next input X value */ + double *px_out; /* Pointer to next output X value */ + double *py_in; /* Pointer to next input Y value */ + double *py_out; /* Pointer to next output Y value */ + int d; /* Difference between x and y grid indices */ + int fx; /* Facet offset along X axis */ + int fy; /* Facet offset along Y axis */ + int ix; /* Nearest integer to X value */ + int iy; /* Nearest integer to Y value */ + int n2; /* Two times nppf */ + int n3; /* Three times nppf */ + int n4; /* Four times nppf */ + int n5; /* Five times nppf */ + int n6; /* Six times nppf */ + int n7; /* Seven times nppf */ + int n9; /* Nine times nppf */ + int npoint; /* Number of points */ + int nppf; /* No. of pixels per facet */ + int point; /* Loop counter for points */ + int s; /* Sum of x and y grid indices */ + +/* Check the global error status. */ + if ( !astOK ) return NULL; + +/* Obtain a pointer to the XphMap. */ + map = (AstXphMap *) this; + +/* Apply the parent mapping using the stored pointer to the Transform member + function inherited from the parent Mapping class. This function validates + all arguments and generates an output PointSet if necessary, but does not + actually transform any coordinate values. */ + result = (*parent_transform)( this, in, forward, out, status ); + +/* We will now extend the parent astTransform method by performing the + calculations needed to generate the output coordinate values. */ + +/* Determine the numbers of points and coordinates per point from the input + PointSet and obtain pointers for accessing the input and output coordinate + values. */ + npoint = astGetNpoint( in ); + ptr_in = astGetPoints( in ); + ptr_out = astGetPoints( result ); + +/* Determine whether to apply the forward or inverse mapping, according to the + direction specified and whether the mapping has been inverted. */ + if ( astGetInvert( map ) ) forward = !forward; + +/* Get the number of pixels per facet. */ + nppf = ( 1 << map->order ); + n2 = 2*nppf; + n3 = 3*nppf; + n4 = 4*nppf; + n5 = 5*nppf; + n6 = 6*nppf; + n7 = 7*nppf; + n9 = 9*nppf; + +/* Perform coordinate arithmetic. */ +/* ------------------------------ */ + if ( astOK ) { + px_in = ptr_in[ 0 ]; + py_in = ptr_in[ 1 ]; + px_out = ptr_out[ 0 ]; + py_out = ptr_out[ 1 ]; + +/* Forward transformation - from "type" to HPX12. */ + if( forward ) { + +/* Transforming from HPX12 to HPX12 is a unit transformation, except that + we need to check for out-of-bounds input positions, which are set bad + in the output. */ + if( map->type == AST__HPX12 ){ + for ( point = 0; point < npoint; point++, + px_in++,py_in++,px_out++,py_out++ ) { + +/* Check the input values are good */ + if ( *px_in == AST__BAD || *py_in == AST__BAD ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + +/* Get the zero-based integer indices of the grid cell containing the + input position. The cell boundaries on the low RA edges are considered + to be in the cell. Those on the high RA edges are considered to be part + of the neigbouring cell. */ + } else { + ix = ceil( *px_in - 1.5 ); + iy = ceil( *py_in - 1.5 ); + +/* Get the zero-based facet (x,y) indices - offsets from the bottom left + facet. */ + fx = ix/nppf; + fy = iy/nppf; + +/* Check that the facet indices are legal. */ + if( fx >= 0 && fx < 5 && fy >= 0 && fy < 5 && + abs( fx - fy ) <= 1 ) { + +/* Get the sum of the zero-based x and y grid indices, plus one. */ + s = ix + iy + 1; + +/* The bottom left half of the bottom left facet and the top right half + of the top right facet are illegal. */ + if( s <= nppf || s > n9 ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + +/* Other positions are copied unchanged. */ + } else { + *px_out = *px_in; + *py_out = *py_in; + } + + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + } + } + +/* Transforming from HPX0 to HPX12 - swap the top right and bottom left + halves of the whole sky map. */ + } else if( map->type == AST__HPX0 ){ + for ( point = 0; point < npoint; point++, + px_in++,py_in++,px_out++,py_out++ ) { + +/* Check for bad input coordinates */ + if ( *px_in == AST__BAD || *py_in == AST__BAD ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + } else { + +/* Get the zero-based integer indices of the grid cell containing the + input position. The cell boundaries on the low RA edges are considered + to be in the cell. Those on the high RA edges are considered to be part + of the neigbouring cell. */ + ix = ceil( *px_in - 1.5 ); + iy = ceil( *py_in - 1.5 ); + +/* Get the facet indices and check they are legal. */ + fx = ix/nppf; + fy = iy/nppf; + if( fx >= 0 && fx < 5 && fy >= 0 && fy < 5 && + abs( fx - fy ) <= 1 ) { + +/* Get the sum of the zero-based x and y grid indices, plus one. */ + s = ix + iy + 1; + +/* The bottom left half of the bottom left facet and the top right half + of the top right facet are illegal. */ + if( s <= nppf || s > n9 ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + +/* Other input positions in the bottom left half of the whole-sky map get + moved to the top right by adding 2*nppf on each axis. */ + } else if( s <= n5 ) { + *px_out = *px_in + n2; + *py_out = *py_in + n2; + +/* Other input positions in the rop right half of the whole-sky map get + moved to the bottom left by subtracting 2*nppf on each axis. */ + } else { + *px_out = *px_in - n2; + *py_out = *py_in - n2; + } + + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + } + } + +/* Transforming from XPHN to HPX12 */ + } else if( map->type == AST__XPHN ){ + for ( point = 0; point < npoint; point++, + px_in++,py_in++,px_out++,py_out++ ) { + +/* Check for bad input coordinates */ + if ( *px_in == AST__BAD || *py_in == AST__BAD ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + } else { + +/* The transformation depends on the gore containing the supplied position. + A gore contains its low RA boundaries, but not its high RA boundaries. + First do gore 0. */ + if( *px_in < n2 + 0.5 && *py_in >= n2 + 0.5 ) { + +/* Get the zero-based integer indices of the grid cell containing the + input position. The cell boundaries on the low RA edges are considered + to be in the cell. Those on the high RA edges are considered to be part + of the neigbouring cell. */ + ix = floor( *px_in - 0.5 ); + iy = floor( *py_in - 0.5 ); + +/* Check that the cell containing the input position is contained with + the used part of the gore, and if so, do the appropriate transformation. */ + s = ix + iy + 1; + if( s < n5 && s >= n3 ) { + *px_out = n4 + 1.0 - *px_in; + *py_out = n6 + 1.0 - *py_in; + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + +/* Do the same for input positions within gore 3. */ + } else if( *px_in >= n2 + 0.5 && *py_in > n2 + 0.5 ) { + ix = floor( *px_in - 0.5 ); + iy = ceil( *py_in - 1.5 ); + + d = ix - iy; + if( d >= -nppf && d < nppf ) { + *px_out = *py_in - nppf; + *py_out = n5 + 1.0 - *px_in; + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + +/* Do the same for input positions within gore 2. */ + } else if( *px_in > n2 + 0.5 && *py_in <= n2 + 0.5 ) { + ix = ceil( *px_in - 1.5 ); + iy = ceil( *py_in - 1.5 ); + + s = ix + iy + 1; + if( s > n3 && s <= n5 ) { + *px_out = *px_in - n2; + *py_out = *py_in; + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + +/* Do the same for input positions within gore 1. */ + } else { + ix = ceil( *px_in - 1.5 ); + iy = floor( *py_in - 0.5 ); + + d = ix - iy; + if( d > -nppf && d <= nppf ) { + *px_out = n5 + 1.0 - *py_in; + *py_out = n3 + *px_in; + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + } + } + } + +/* Transforming from XPHS to HPX12 */ + } else if( map->type == AST__XPHS ){ + for ( point = 0; point < npoint; point++, + px_in++,py_in++,px_out++,py_out++ ) { + +/* Check for bad input coordinates */ + if ( *px_in == AST__BAD || *py_in == AST__BAD ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + } else { + +/* The transformation depends on the gore containing the supplied position. + A gore contains its low RA boundaries, but not its high RA boundaries. + First do gore 0. */ + if( *px_in < n2 + 0.5 && *py_in <= n2 + 0.5 ) { + +/* Get the zero-based integer indices of the grid cell containing the + input position. The cell boundaries on the low RA edges are considered + to be in the cell. Those on the high RA edges are considered to be part + of the neigbouring cell. */ + ix = floor( *px_in - 0.5 ); + iy = ceil( *py_in - 1.5 ); + +/* Check that the cell containing the input position is contained with + the used part of the gore, and if so, do the appropriate transformation. */ + d = ix - iy; + if( d >= -nppf && d < nppf ) { + *px_out = n2 + *py_in; + *py_out = n4 + 1.0 - *px_in; + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + +/* Do the same for input positions within gore 3. */ + } else if( *px_in >= n2 + 0.5 && *py_in < n2 + 0.5 ) { + ix = floor( *px_in - 0.5 ); + iy = floor( *py_in - 0.5 ); + + s = ix + iy + 1; + if( s >= n3 && s < n5 ) { + *px_out = n5 + 1.0 - *px_in; + *py_out = n3 + 1.0 - *py_in; + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + +/* Do the same for input positions within gore 2. */ + } else if( *px_in > n2 + 0.5 && *py_in >= n2 + 0.5 ) { + ix = ceil( *px_in - 1.5 ); + iy = floor( *py_in - 0.5 ); + + d = ix - iy; + if( d <= nppf && d > -nppf ) { + *px_out = n4 + 1 - *py_in; + *py_out = *px_in - n2; + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + +/* Do the same for input positions within gore 1. */ + } else { + ix = ceil( *px_in - 1.5 ); + iy = ceil( *py_in - 1.5 ); + + s = ix + iy + 1; + if( s <= n5 && s > n3 ) { + *px_out = n3 + *px_in; + *py_out = nppf + *py_in; + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + } + } + } + +/* Unknown projection code */ + } else if( astOK ) { + astError( AST__INTER, "astTransform(%s): Invalid projection type " + "encountered (%d) (internal programming error).", status, + astGetClass(this), map->type ); + } + +/* Inverse transformation - from HPX12 to "type". */ + } else { + +/* Transforming from HPX12 to HPX12 is a unit transformation, except that + we need to check that input positions within a split input facet are + moved to the equivalent normalised output positions. */ + if( map->type == AST__HPX12 ){ + for ( point = 0; point < npoint; point++, + px_in++,py_in++,px_out++,py_out++ ) { + +/* Check the input values are good */ + if ( *px_in == AST__BAD || *py_in == AST__BAD ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + +/* Get the zero-based integer indices of the grid cell containing the + input position. The cell boundaries on the low RA edges are considered + to be in the cell. Those on the high RA edges are considered to be part + of the neigbouring cell. */ + } else { + ix = ceil( *px_in - 1.5 ); + iy = ceil( *py_in - 1.5 ); + +/* Get the zero-based facet (x,y) indices - offsets from the bottom left + facet in Calabretta & Roukema 2005 Fig 3. */ + fx = ix/nppf; + fy = iy/nppf; + +/* Check that the facet indices are legal. */ + if( fx >= 0 && fx < 5 && fy >= 0 && fy < 5 && + abs( fx - fy ) <= 1 ) { + +/* Get the sum of the zero-based x and y grid indices, plus one. */ + s = ix + iy + 1; + +/* The bottom left half of the bottom left facet and the top right half + of the top right facet are illegal. */ + if( s <= nppf || s > n9 ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + +/* Other positions are copied unchanged. */ + } else { + *px_out = *px_in; + *py_out = *py_in; + } + + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + } + } + +/* Transforming from HPX12 to HPX0 - swap the top right and bottom left + halves of the whole sky map. */ + } else if( map->type == AST__HPX0 ){ + for ( point = 0; point < npoint; point++, + px_in++,py_in++,px_out++,py_out++ ) { + + if ( *px_in == AST__BAD || *py_in == AST__BAD ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + + } else { + +/* Get the zero-based integer indices of the grid cell containing the + input position. The cell boundaries on the low RA edges are considered + to be in the cell. Those on the high RA edges are considered to be part + of the neigbouring cell. */ + ix = ceil( *px_in - 1.5 ); + iy = ceil( *py_in - 1.5 ); + +/* Get the facet indices and check they are legal. */ + fx = ix/nppf; + fy = iy/nppf; + if( fx >= 0 && fx < 5 && fy >= 0 && fy < 5 && + abs( fx - fy ) <= 1 ) { + +/* Get the sum of the zero-based x and y grid indices, plus one. */ + s = ix + iy + 1; + +/* The bottom left half of the bottom left facet and the top right half + of the top right facet are illegal. */ + if( s <= nppf || s > n9 ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + +/* Other input positions in the bottom left half of the whole-sky map get + moved to the top right by adding 2*nppf on each axis. */ + } else if( s <= n5 ) { + *px_out = *px_in + n2; + *py_out = *py_in + n2; + +/* Other input positions in the rop right half of the whole-sky map get + moved to the bottom left by subtracting 2*nppf on each axis. */ + } else { + *px_out = *px_in - n2; + *py_out = *py_in - n2; + } + + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + } + } + +/* Transforming from HPX12 to XPHN */ + } else if( map->type == AST__XPHN ){ + + for ( point = 0; point < npoint; point++, + px_in++,py_in++,px_out++,py_out++ ) { + + if ( *px_in == AST__BAD || *py_in == AST__BAD ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + } else { + +/* Get the zero-based integer indices of the grid cell containing the + input position. The cell boundaries on the low RA edges are considered + to be in the cell. Those on the high RA edges are considered to be part + of the neigbouring cell. */ + ix = ceil( *px_in - 1.5 ); + iy = ceil( *py_in - 1.5 ); + +/* Get the facet indices and check they are legal. */ + fx = ix/nppf; + fy = iy/nppf; + if( fx >= 0 && fx < 5 && fy >= 0 && fy < 5 && + abs( fx - fy ) <= 1 ) { + +/* Get the sum of the zero-based x and y grid indices, plus one. */ + s = ix + iy + 1; + +/* The bottom left half of the bottom left facet and the top right half + of the top right facet are illegal. */ + if( s <= nppf || s > n9 ) { + *px_out = AST__BAD; + *py_out = AST__BAD; +/* Gore 2 */ + } else if( s <= n3 ) { + *px_out = n2 + *px_in; + *py_out = *py_in; +/* Gore 3 */ + } else if( s <= n5 ) { + *px_out = n5 + 1.0 - *py_in; + *py_out = nppf + *px_in; +/* Gore 0 */ + } else if( s <= n7 ) { + *px_out = n4 + 1.0 - *px_in; + *py_out = n6 + 1.0 - *py_in; +/* Gore 1 */ + } else { + *px_out = *py_in - n3; + *py_out = n5 + 1.0 - *px_in; + } + + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + } + } + +/* Transforming from HPX12 to XPHS */ + } else if( map->type == AST__XPHS ){ + + for ( point = 0; point < npoint; point++, + px_in++,py_in++,px_out++,py_out++ ) { + + if ( *px_in == AST__BAD || *py_in == AST__BAD ) { + *px_out = AST__BAD; + *py_out = AST__BAD; + } else { + +/* Get the zero-based integer indices of the grid cell containing the + input position. The cell boundaries on the low RA edges are considered + to be in the cell. Those on the high RA edges are considered to be part + of the neigbouring cell. */ + ix = ceil( *px_in - 1.5 ); + iy = ceil( *py_in - 1.5 ); + +/* Get the facet indices and check they are legal. */ + fx = ix/nppf; + fy = iy/nppf; + if( fx >= 0 && fx < 5 && fy >= 0 && fy < 5 && + abs( fx - fy ) <= 1 ) { + +/* Get the sum of the x and y grid indices, plus one. */ + s = ix + iy + 1; + +/* The bottom left half of the bottom left facet and the top right half + of the top right facet are illegal. */ + if( s <= nppf || s > n9 ) { + *px_out = AST__BAD; + *py_out = AST__BAD; +/* Gore 2 */ + } else if( s <= n3 ) { + *px_out = n2 + *py_in; + *py_out = n4 + 1.0 - *px_in; +/* Gore 3 */ + } else if( s <= n5 ) { + *px_out = n5 + 1.0 - *px_in; + *py_out = n3 + 1.0 - *py_in; +/* Gore 0 */ + } else if( s <= n7 ) { + *px_out = n4 + 1.0 - *py_in; + *py_out = *px_in - n2; +/* Gore 1 */ + } else { + *px_out = *px_in - n3; + *py_out = *py_in - nppf; + } + + } else { + *px_out = AST__BAD; + *py_out = AST__BAD; + } + } + } + +/* Unknown projection code */ + } else if( astOK ) { + astError( AST__INTER, "astTransform(%s): Invalid projection type " + "encountered (%d) (internal programming error).", status, + astGetClass(this), map->type ); + } + } + } + +/* Return a pointer to the output PointSet. */ + return result; +} + +/* Functions which access class attributes. */ +/* ---------------------------------------- */ +/* Implement member functions to access the attributes associated with + this class using the macros defined for this purpose in the + "object.h" file. For a description of each attribute, see the class + interface (in the associated .h file). */ + +/* Copy constructor. */ +/* ----------------- */ +/* No copy constructor is needed, as a byte-by-byte copy suffices. */ + +/* Destructor. */ +/* ----------- */ +/* No destructor is needed as no memory, etc. needs freeing. */ + +/* Dump function. */ +/* -------------- */ +static void Dump( AstObject *this_object, AstChannel *channel, int *status ) { +/* +* Name: +* Dump + +* Purpose: +* Dump function for XphMap objects. + +* Type: +* Private function. + +* Synopsis: +* void Dump( AstObject *this, AstChannel *channel, int *status ) + +* Description: +* This function implements the Dump function which writes out data +* for the XphMap class to an output Channel. + +* Parameters: +* this +* Pointer to the XphMap whose data are being written. +* channel +* Pointer to the Channel to which the data are being written. +* status +* Pointer to the inherited status variable. +*/ + +/* Local Variables: */ + AstXphMap *this; /* Pointer to the XphMap structure */ + +/* Check the global error status. */ + if ( !astOK ) return; + +/* Obtain a pointer to the XphMap structure. */ + this = (AstXphMap *) this_object; + +/* Write out values representing the instance variables for the + XphMap class. Accompany these with appropriate comment strings, + possibly depending on the values being written.*/ + + astWriteInt( channel, "Order", 1, 1, this->order, "HEALPix order" ); + astWriteString( channel, "Type", 1, 1, proj_name[this->type], + proj_comm[this->type]); +} + +/* Standard class functions. */ +/* ========================= */ +/* Implement the astIsAXphMap and astCheckXphMap functions using the macros + defined for this purpose in the "object.h" header file. */ +astMAKE_ISA(XphMap,Mapping) +astMAKE_CHECK(XphMap) + +AstXphMap *astXphMap_( int order, int type, const char *options, int *status, ...) { +/* +*+ +* Name: +* astXphMap + +* Purpose: +* Create an XphMap. + +* Type: +* Public function. + +* Synopsis: +* #include "xphmap.h" +* AstXphMap *astXphMap( int order, int type, const char *options, ... ) + +* Class Membership: +* XphMap constructor. + +* Description: +* This function creates a new XphMap and optionally initialises its +* attributes. +* +* The XphMap class implements a Mapping between grid coordinates +* within different types of HEALPix projection: The available types +* are : +* +* - "HPX0": An HPX projection centred on RA=0h. +* - "HPX12": An HPX projection centred on RA=12h. +* - "XPHN": An XPH ("Butterfly") projection centred on the +* north pole. +* - "XPHS": An XPH ("Butterfly") projection centred on the +* south pole. +* +* The HPX projection is described in "Mapping on the HEALPix grid" +* by Calabretta and Roukema, A&A, 2005. The XPH projection is +* described in "Representing the 'butterfly' projection in FITS - +* projection code XPH" by Calabretta and Lowe, PASA, 2018. +* +* The forward transformation of an XphMap transforms from grid +* coordinates within the projection type specified by argument +* "type" into grid coordinates within an HPX0 projection. + +* Parameters: +* order +* The HEALPix order of the HPX transformation. +* type +* The type of projection corresponding to the inputs of the +* XphMap. This can be: +* - AST__HPX0: A basic HPX projection (centred on RA=0h) +* - AST__HPX12: An HPX projection centred on RA=12h. +* - AST__XPHN: An XPH ("Butterfly") projection centred on the +* north pole. +* - AST__XPHS: An XPH ("Butterfly") projection centred on the +* south pole. +* options +* Pointer to a null-terminated string containing an optional +* comma-separated list of attribute assignments to be used for +* initialising the new XphMap. The syntax used is identical to +* that for the astSet function and may include "printf" format +* specifiers identified by "%" symbols in the normal way. +* ... +* If the "options" string contains "%" format specifiers, then +* an optional list of additional arguments may follow it in +* order to supply values to be substituted for these +* specifiers. The rules for supplying these are identical to +* those for the astSet function (and for the C "printf" +* function). + +* Returned Value: +* astXphMap() +* A pointer to the new XphMap. + +* Notes: +* - A null Object pointer (AST__NULL) will be returned if this +* function is invoked with the AST error status set, or if it +* should fail for any reason. + +* Status Handling: +* The protected interface to this function includes an extra +* parameter at the end of the parameter list descirbed above. This +* parameter is a pointer to the integer inherited status +* variable: "int *status". + +*- +*/ + +/* Local Variables: */ + astDECLARE_GLOBALS /* Pointer to thread-specific global data */ + AstXphMap *new; /* Pointer to new XphMap */ + va_list args; /* Variable argument list */ + +/* Get a pointer to the thread specific global data structure. */ + astGET_GLOBALS(NULL); + +/* Check the global status. */ + if ( !astOK ) return NULL; + +/* Initialise the XphMap, allocating memory and initialising the + virtual function table as well if necessary. */ + new = astInitXphMap( NULL, sizeof( AstXphMap ), !class_init, &class_vtab, + "XphMap", order, type ); + +/* If successful, note that the virtual function table has been + initialised. */ + if ( astOK ) { + class_init = 1; + +/* Obtain the variable argument list and pass it along with the options string + to the astVSet method to initialise the new XphMap's attributes. */ + va_start( args, status ); + astVSet( new, options, NULL, args ); + va_end( args ); + +/* If an error occurred, clean up by deleting the new object. */ + if ( !astOK ) new = astDelete( new ); + } + +/* Return a pointer to the new XphMap. */ + return new; +} + +AstXphMap *astInitXphMap_( void *mem, size_t size, int init, + AstXphMapVtab *vtab, const char *name, + int order, int type, int *status ) { +/* +*+ +* Name: +* astInitXphMap + +* Purpose: +* Initialise a XphMap. + +* Type: +* Protected function. + +* Synopsis: +* #include "xphmap.h" +* AstXphMap *astInitXphMap( void *mem, size_t size, int init, +* AstXphMapVtab *vtab, const char *name, +* int order, int type ) + +* Class Membership: +* XphMap initialiser. + +* Description: +* This function is provided for use by class implementations to initialise +* a new XphMap object. It allocates memory (if necessary) to accommodate +* the XphMap plus any additional data associated with the derived class. +* It then initialises a XphMap structure at the start of this memory. If +* the "init" flag is set, it also initialises the contents of a virtual +* function table for a XphMap at the start of the memory passed via the +* "vtab" parameter. + +* Parameters: +* mem +* A pointer to the memory in which the XphMap is to be initialised. +* This must be of sufficient size to accommodate the XphMap data +* (sizeof(XphMap)) plus any data used by the derived class. If a value +* of NULL is given, this function will allocate the memory itself using +* the "size" parameter to determine its size. +* size +* The amount of memory used by the XphMap (plus derived class data). +* This will be used to allocate memory if a value of NULL is given for +* the "mem" parameter. This value is also stored in the XphMap +* structure, so a valid value must be supplied even if not required for +* allocating memory. +* init +* A logical flag indicating if the XphMap's virtual function table is +* to be initialised. If this value is non-zero, the virtual function +* table will be initialised by this function. +* vtab +* Pointer to the start of the virtual function table to be associated +* with the new XphMap. +* name +* Pointer to a constant null-terminated character string which contains +* the name of the class to which the new object belongs (it is this +* pointer value that will subsequently be returned by the astGetClass +* method). +* order +* The HEALPix order. +* type +* The projection type. + +* Returned Value: +* A pointer to the new XphMap. + +* Notes: +* - A null pointer will be returned if this function is invoked with the +* global error status set, or if it should fail for any reason. +*- +*/ + +/* Local Variables: */ + AstXphMap *new; /* Pointer to new XphMap */ + +/* Check the global status. */ + if ( !astOK ) return NULL; + +/* If necessary, initialise the virtual function table. */ + if ( init ) astInitXphMapVtab( vtab, name ); + +/* Initialise. */ + new = NULL; + + +/* Validate inputs */ + if( order < 0 || order > AST__MXORDHPX ) { + astError( AST__INTER, "astInitXphMap(%s): Invalid order supplied " + "(%d) (internal programming error).", status, name, order ); + } else if( type < 0 || type > AST__MXPRJHPX ) { + astError( AST__INTER, "astInitXphMap(%s): Invalid projection type " + "supplied (%d) (internal programming error).", status, + name, type ); + } + +/* Initialise a Mapping structure (the parent class) as the first component + within the XphMap structure, allocating memory if necessary. Specify that + the Mapping should be defined in both the forward and inverse directions. */ + new = (AstXphMap *) astInitMapping( mem, size, 0, (AstMappingVtab *) vtab, + name, 2, 2, 1, 1 ); + if ( astOK ) { + +/* Initialise the XphMap data. */ +/* ---------------------------- */ + new->order = order; + new->type = type; + +/* If an error occurred, clean up by deleting the new XphMap. */ + if ( !astOK ) new = astDelete( new ); + } + +/* Return a pointer to the new XphMap. */ + return new; +} + +AstXphMap *astLoadXphMap_( void *mem, size_t size, AstXphMapVtab *vtab, + const char *name, AstChannel *channel, int *status ) { +/* +*+ +* Name: +* astLoadXphMap + +* Purpose: +* Load a XphMap. + +* Type: +* Protected function. + +* Synopsis: +* #include "xphmap.h" +* AstXphMap *astLoadXphMap( void *mem, size_t size, AstXphMapVtab *vtab, +* const char *name, AstChannel *channel ) + +* Class Membership: +* XphMap loader. + +* Description: +* This function is provided to load a new XphMap using data read +* from a Channel. It first loads the data used by the parent class +* (which allocates memory if necessary) and then initialises a +* XphMap structure in this memory, using data read from the input +* Channel. +* +* If the "init" flag is set, it also initialises the contents of a +* virtual function table for a XphMap at the start of the memory +* passed via the "vtab" parameter. + + +* Parameters: +* mem +* A pointer to the memory into which the XphMap is to be +* loaded. This must be of sufficient size to accommodate the +* XphMap data (sizeof(XphMap)) plus any data used by derived +* classes. If a value of NULL is given, this function will +* allocate the memory itself using the "size" parameter to +* determine its size. +* size +* The amount of memory used by the XphMap (plus derived class +* data). This will be used to allocate memory if a value of +* NULL is given for the "mem" parameter. This value is also +* stored in the XphMap structure, so a valid value must be +* supplied even if not required for allocating memory. +* +* If the "vtab" parameter is NULL, the "size" value is ignored +* and sizeof(AstXphMap) is used instead. +* vtab +* Pointer to the start of the virtual function table to be +* associated with the new XphMap. If this is NULL, a pointer +* to the (static) virtual function table for the XphMap class +* is used instead. +* name +* Pointer to a constant null-terminated character string which +* contains the name of the class to which the new object +* belongs (it is this pointer value that will subsequently be +* returned by the astGetClass method). +* +* If the "vtab" parameter is NULL, the "name" value is ignored +* and a pointer to the string "XphMap" is used instead. + +* Returned Value: +* A pointer to the new XphMap. + +* Notes: +* - A null pointer will be returned if this function is invoked +* with the global error status set, or if it should fail for any +* reason. +*- +*/ + +/* Local Variables: */ + AstXphMap *new; /* Pointer to the new XphMap */ + const char *text; /* Text for string-valued attribute */ + astDECLARE_GLOBALS /* Pointer to thread-specific global data */ + +/* Initialise. */ + new = NULL; + +/* Check the global error status. */ + if ( !astOK ) return new; + +/* Get a pointer to the thread specific global data structure. */ + astGET_GLOBALS(channel); + +/* If a NULL virtual function table has been supplied, then this is + the first loader to be invoked for this XphMap. In this case the + XphMap belongs to this class, so supply appropriate values to be + passed to the parent class loader (and its parent, etc.). */ + if ( !vtab ) { + size = sizeof( AstXphMap ); + vtab = &class_vtab; + name = "XphMap"; + +/* If required, initialise the virtual function table for this class. */ + if ( !class_init ) { + astInitXphMapVtab( vtab, name ); + class_init = 1; + } + } + +/* Invoke the parent class loader to load data for all the ancestral + classes of the current one, returning a pointer to the resulting + partly-built XphMap. */ + new = astLoadMapping( mem, size, (AstMappingVtab *) vtab, name, + channel ); + + if ( astOK ) { + +/* Read input data. */ +/* ================ */ +/* Request the input Channel to read all the input data appropriate to + this class into the internal "values list". */ + astReadClassData( channel, "XphMap" ); + +/* Now read each individual data item from this list and use it to + initialise the appropriate instance variable(s) for this class. */ + new->order = astReadInt( channel, "order", 19 ); + text = astReadString( channel, "type", proj_name[AST__HPX12] ); + +/* COnvert the projection name into an integer projection identifier. */ + for( new->type = 0; new->type <= AST__MXPRJHPX; new->type++ ) { + if( astChrMatch( text, proj_name[new->type] ) ) break; + } + +/* Report an error if the projection name is unknown. */ + if( new->type > AST__MXPRJHPX && astOK ) { + astError( AST__OPT, "astRead(XphMap): Illegal value '%s' supplied " + "for the XphMap component 'Type'.", status, text ); + } + +/* If an error occurred, clean up by deleting the new XphMap. */ + if ( !astOK ) new = astDelete( new ); + } + +/* Return the new XphMap pointer. */ + return new; +} + +/* Virtual function interfaces. */ +/* ============================ */ +/* These provide the external interface to the virtual functions defined by + this class. Each simply checks the global error status and then locates and + executes the appropriate member function, using the function pointer stored + in the object's virtual function table (this pointer is located using the + astMEMBER macro defined in "object.h"). + + Note that the member function may not be the one defined here, as it may + have been over-ridden by a derived class. However, it should still have the + same interface. */ + + + + + |