Starlink-AST
view release on metacpan or search on metacpan
ast/src/axis.c view on Meta::CPAN
result ="<bad>";/* Otherwise, obtain a pointer to the Format string. Note a private memberfunction is used here in preference to an object method. This is because thesyntax of the Format string may be extended by derived classes and wedonotwant to obtain a string that we cannot interpret here (where we arerestricted to Cformatspecifiers capable of formatting doublevalues).Classes that extend the syntax should provide their own astAxisFormat methodand may need to store the string in a separate location. The originallocation should not be re-used as the string it contains may be needed bythe Axis astOverlay methodwhenoverlaying attributes on to another Axisobject. */}else{fmt0 = GetAxisFormat( this, status );/* Parse the Format string. This returns a collection of flags indicatingifany AST specific formatting features are specified in the Formatstring. It also returns a pointer to a new Format string which is astandard Cprintfformatspecifier. Currently the only flags are"log"which indicatesifthe value should be formatted as"10**x"usingthe graphical escape sequencesdefinedwithin the Plot class to produce
ast/src/axis.c view on Meta::CPAN
* Protected virtual function.* Synopsis:*#include "axis.h"* void astAxisOverlay( AstAxis*template, AstAxis*result)* Class Membership:* Axis method.* Description:* This function overlays attributes of one Axis (the"template") on to* another Axis, so as to over-ride selected attributes of that second* Axis. Normally only those attributes which have been specifically set* in the template will be transferred. This implements a form of* defaulting, in which an Axis acquires attributes from the template, but* retains its original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.* Parameters:* template* Pointer to the template Axis,forwhichvaluesshould have been
ast/src/axis.c view on Meta::CPAN
* Pointer to the Axis which is to receive the new attributevalues.* Returned Value:* void*-*//* Check the global error status. */if( !astOK )return;/* Define a macro to overlay a single attribute. This testsifthe attributeis set in the template Axis. If it is, its value is obtained and set in theresult Axis also. */#define OVERLAY(par) \if( astTestAxis##par( template ) ) { \astSetAxis##par( result, astGetAxis##par( template ) ); \}/* OverlayeachAxis attribute in turn. */OVERLAY(Digits);OVERLAY(Direction);OVERLAY(Label);
ast/src/cmpframe.c view on Meta::CPAN
staticint(* parent_getusedefs)( AstObject *,int* );staticint(* parent_testattrib)( AstObject *, const char *,int* );static void (* parent_clearalignsystem)( AstFrame *,int* );static void (* parent_clearattrib)( AstObject *, const char *,int* );static void (* parent_cleardtai)( AstFrame *,int* );static void (* parent_cleardut1)( AstFrame *,int* );static void (* parent_clearepoch)( AstFrame *,int* );static void (* parent_clearobsalt)( AstFrame *,int* );static void (* parent_clearobslat)( AstFrame *,int* );static void (* parent_clearobslon)( AstFrame *,int* );static void (* parent_overlay)( AstFrame *, constint*, AstFrame *,int* );static void (* parent_setactiveunit)( AstFrame *,int,int* );static void (* parent_setattrib)( AstObject *, const char *,int* );static void (* parent_setdtai)( AstFrame *, double,int* );static void (* parent_setdut1)( AstFrame *, double,int* );static void (* parent_setepoch)( AstFrame *, double,int* );static void (* parent_setframeflags)( AstFrame *,int,int* );static void (* parent_setobsalt)( AstFrame *, double,int* );static void (* parent_setobslat)( AstFrame *, double,int* );static void (* parent_setobslon)( AstFrame *, double,int* );
ast/src/cmpframe.c view on Meta::CPAN
parent_getsystem = frame->GetSystem;frame->GetSystem = GetSystem;parent_getalignsystem = frame->GetAlignSystem;frame->GetAlignSystem = GetAlignSystem;parent_clearalignsystem = frame->ClearAlignSystem;frame->ClearAlignSystem = ClearAlignSystem;parent_overlay = frame->Overlay;frame->Overlay = Overlay;parent_setactiveunit = frame->SetActiveUnit;frame->SetActiveUnit = SetActiveUnit;parent_getactiveunit = frame->GetActiveUnit;frame->GetActiveUnit = GetActiveUnit;parent_setframeflags = frame->SetFrameFlags;frame->SetFrameFlags = SetFrameFlags;
ast/src/cmpframe.c view on Meta::CPAN
* Synopsis:*#include "cmpframe.h"* void Overlay( AstFrame*template, constint*template_axes,* AstFrame*result,int*status)* Class Membership:* CmpFrame member function (over-rides the protected astOverlay* method inherited from the Frame class).* Description:* This function overlays attributes from a CmpFrame on to another Frame,* so as to over-ride selected attributes of that second Frame. Normally* only those attributes which have been specifically set in the template* will be transferred. This implements a form of defaulting, in which* a Frame acquires attributes from the template, but retains its* original attributes (as thedefault)ifnewvalueshave not previously* been explicitly set in the template.* Parameters:* template* Pointer to the template CmpFrame,forwhose current Frame
ast/src/cmpframe.c view on Meta::CPAN
/* Local Variables: */AstCmpFrame*res; /* Pointer to the result CmpFrame structure */AstCmpFrame*template; /* Pointer to the template CmpFrame structure */AstFrame*sub1; /* Template subframefor1st result subframe */AstFrame*sub2; /* Template subframefor2nd result subframe */constint*perm; /* Template axis permutation array */constint*rperm; /* Result axis permutation array */int*axes1; /* Axis associationswithtemplate frame1 */int*axes2; /* Axis associationswithtemplate frame2 */intdone; /* Have attributes been overlayed yet? */inti; /* Index of result axis */inticmp; /* Internal template axis number */intisfirst; /* Res. subframe -> 1st template subframe? */intissecond; /* Res. subframe -> 2nd template subframe? */intj; /* Index of template axis */intnc1; /* Number of axes in template frame1 */intnres1; /* Number of axes in first result subframe */intnres2; /* Number of axes in second result subframe */intnres; /* Number of axes in result Frame */
ast/src/cmpframe.c view on Meta::CPAN
/* Obtain a pointer to the CmpFrame structure. */template = (AstCmpFrame *) template_frame;/* Get the axis permutation arrayforthe template CmpFrame. */perm = astGetPerm( template );/* Get the number of axes in the first component Frame in the templateCmpFrame. */nc1 = astGetNaxes( template->frame1 );/* Indicate we have not yet overlayed any attributes. */done = 0;/* If the result Frame is a CmpFrame... */if( astIsACmpFrame( result ) ) {/* Get the number of axes in the two component Frames of the result CmpFrame. */res = (AstCmpFrame *) result;nres1 = astGetNaxes( res->frame1 );nres2 = astGetNaxes( res->frame2 );
ast/src/cmpframe.c view on Meta::CPAN
/* Get the axis permutation arrayforthe result CmpFrame. */rperm = astGetPerm( result );/* Allocate memoryfortwo new axes arrays, oneforeachresultsub-frame. */axes1 = astMalloc( sizeof(int)*(size_t)nres1 );axes2 = astMalloc( sizeof(int)*(size_t)nres2 );if( astOK ) {/* Assume that there is a 1-to-1 correspondence between axes in thesubframes of the result and template CmpFrame. That is, all the axesineachresultsub-frame are overlayed from the same templatesub-frame. */done = 1;/* Loop roundeachaxis in the first resultsub-frame. */isfirst = 0;issecond = 0;for( i = 0; i < nres1; i++ ) {/* Find the external result CmpFrame axisindex(j)forinternal axis i. */for( j = 0; j < nres; j++ ) {if( rperm[ j ] == i ) break;
ast/src/cmpframe.c view on Meta::CPAN
astOverlay( sub1, axes1, res->frame1 );astOverlay( sub2, axes2, res->frame2 );}}/* Free the axes arrays. */axes1 = astFree( axes1 );axes2 = astFree( axes2 );}/* If we have not yet overlayed any attributes... */if( !done ) {/* Get the number of axes in the result Frame. */nres = astGetNaxes( result );/* Allocate memoryfortwo new template_axes arrays. */axes1 = astMalloc( sizeof(int)*(size_t)nres );axes2 = astMalloc( sizeof(int)*(size_t)nres );if( astOK ) {
ast/src/cmpframe.c view on Meta::CPAN
/* If this template axis is in the second component Frame, store thecorresponding internal frame axisindexin"axes2"and set"axis1"to-1. */}else{axes1[ i ] = -1;axes2[ i ] = icmp - nc1;}}attributes onto the appropriate axes of the results Frame. */astOverlay( template->frame1, axes1, result );astOverlay( template->frame2, axes2, result );}/* Free the axes arrays. */axes1 = astFree( axes1 );axes2 = astFree( axes2 );}}
ast/src/cmpframe.c view on Meta::CPAN
/* Check the global error status. */if( !astOK )returnmatch;/* Initialise other variables to avoid compiler errors. */ref_naxes = 0;/* Select the requiredsub-Frames from the target. *//* ----------------------------------------------- *//* We first create twosub-Frames (that can be matched against the twotemplate component Frames) by selecting the two specified sets ofaxes from the target. This is done without overlaying any templateattributes. Annul the Mappings produced by this process, as theseare not needed. */frame1 = NULL;junk_map = NULL;(void) astSubFrame( target, NULL, naxes1, axes1, NULL,&junk_map,&frame1);if( junk_map ) junk_map = astAnnul( junk_map );frame2 = NULL;junk_map = NULL;
ast/src/cmpframe.c view on Meta::CPAN
* AstFrame **result,int*status)* Class Membership:* CmpFrame member function (over-rides the protected astSubFrame* method inherited from the Frame class).* Description:* This function selects a requestedsub-set (or super-set) of the* axes from a"target"CmpFrame and creates a new Framewith* copies of the selected axes assembled in the requested order. It* then optionally overlays the attributes of a"template"Frame on* to the result. It returns both the resulting Frame and a Mapping* that describes how to convert between the coordinate systems* described by the target and result Frames. If necessary, this* Mapping takes account of any differences in the Frames'* attributes due to the influence of the template.* Parameters:* target* Pointer to the target CmpFrame, from which axes are to be selected.* template* Pointer to the template Frame, from which new attributesfor* the result Frame are to be obtained. Optionally, this may be* NULL, in which casenooverlaying of template attributes will* be performed.* result_naxes* Number of axes to be selected from the target Frame. This* number may be greater than or less than the number of axes in* this Frame (or equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving* a list of the (zero-based) axis indices of the axes to be* selected from the target CmpFrame. The order in which these* aregivendetermines the order in which the axes appear in* the result Frame. If any of thevaluesin this array is set* to -1, the corresponding result axis will not be derived from* the target Frame, but will be assigneddefaultattributes* instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This* should contain a list of the template axes (givenas* zero-based axis indices)withwhich the axes of the result* Frame are to be associated. This array determines which axes* are usedwhenoverlaying axis-dependent attributes of the* template on to the result. If any element of this array is* set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not* used and a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned* Mapping. The forward transformation of this Mapping will* describe how to convert coordinates from the coordinate
ast/src/cmpframe.c view on Meta::CPAN
template_axes2[ n2 ] = template_axes[ result_axis ];}n2++;}}}/* Select from first component Frame only. *//* --------------------------------------- *//* If all the selected axes come from the first component Frame,usethat Frame's astSubFrame method toselectthem (and overlay thetemplate attributesifrequired). */if( astOK ) {if( n1 && !n2 ) {sub_map1 = NULL;match = astSubFrame( target->frame1, template, n1, target_axes1,template_axes1,&sub_map1, result );/* If this is successful, the"result"Frame will be ready toreturnand"sub_map1"will point at a Mapping that converts from the firstcomponent Frame to the"result"Frame. We must now modify this
ast/src/cmpframe.c view on Meta::CPAN
/* Free the permutation arrays and annul the original Mapping pointer. */inperm_pref = astFree( inperm_pref );outperm_pref = astFree( outperm_pref );sub_map1 = astAnnul( sub_map1 );}/* Select from second component Frame only. *//* ---------------------------------------- *//* If all the selected axes come from the second component Frame,usethat Frame's astSubFrame method toselectthem (and overlay thetemplate attributesifrequired). */}elseif( n2 && !n1 ) {sub_map2 = NULL;match = astSubFrame( target->frame2, template, n2, target_axes2,template_axes2,&sub_map2, result );/* If this is successful, the"result"Frame will be ready toreturnand"sub_map2"will point at a Mapping that converts from the secondcomponent Frame to the"result"Frame. We must now modify thismapping to accountforthe CmpFrame's axis permutation array
ast/src/cmpframe.c view on Meta::CPAN
/* Free the permutation arrays and annul the original Mapping pointer. */inperm_pref = astFree( inperm_pref );outperm_pref = astFree( outperm_pref );sub_map2 = astAnnul( sub_map2 );}/* Select from both component Frames. *//* ---------------------------------- */Frames' astSubFrame methods toselectthe required axes fromeachof them (and overlay the template attributesifrequired). */}else{sub_map1 = NULL;sub_map2 = NULL;sub_result1 = NULL;sub_result2 = NULL;match = astSubFrame( target->frame1, template, n1, target_axes1,template_axes1,&sub_map1,&sub_result1);if( match ) {match = astSubFrame( target->frame2, template, n2, target_axes2,template_axes2,&sub_map2,&sub_result2);
ast/src/dsbspecframe.c view on Meta::CPAN
staticintclass_check;/* Pointers to parent class methods which are extended by this class. */static const char *(* parent_getattrib)( AstObject *, const char *,int* );static const char *(* parent_getlabel)( AstFrame *,int,int* );staticint(* parent_match)( AstFrame *, AstFrame *,int,int**,int**, AstMapping **, AstFrame **,int* );staticint(* parent_subframe)( AstFrame *, AstFrame *,int, constint*, constint*, AstMapping **, AstFrame **,int* );staticint(* parent_testattrib)( AstObject *, const char *,int* );static void (* parent_clearattrib)( AstObject *, const char *,int* );static void (* parent_setattrib)( AstObject *, const char *,int* );static void (* parent_overlay)( AstFrame *, constint*, AstFrame *,int* );static const char *(* parent_getdomain)( AstFrame *,int* );/* Define macrosforaccessingeachitem of thread specific global data. */#ifdef THREAD_SAFE/* Define how to initialise thread-specific globals. */#define GLOBAL_inits \globals->Class_Init = 0; \globals->GetAttrib_Buff[ 0 ] = 0; \globals->GetLabel_Buff[ 0 ] = 0; \
ast/src/dsbspecframe.c view on Meta::CPAN
parent_setattrib = object->SetAttrib;object->SetAttrib = SetAttrib;parent_testattrib = object->TestAttrib;object->TestAttrib = TestAttrib;parent_getdomain = frame->GetDomain;frame->GetDomain = GetDomain;parent_overlay = frame->Overlay;frame->Overlay = Overlay;parent_match = frame->Match;frame->Match = Match;parent_subframe = frame->SubFrame;frame->SubFrame = SubFrame;parent_getlabel = frame->GetLabel;frame->GetLabel = GetLabel;
ast/src/dsbspecframe.c view on Meta::CPAN
parent Match method above,ifthe target axis is not a DSBSpecFrame. */if( astIsADSBSpecFrame( frame0 ) ) {/* Annul the returned objects, which are not needed, but keep the axisassociation arrays which already hold the correctvalues. */*map= astAnnul(*map);*result= astAnnul(*result);/* Use the target's"astSubFrame"method to create a new Frame (theresult Frame)witha copy of of the target axis. This process alsooverlays the template attributes on to the target Frame and returns aMapping between the target and result Frames which effects the requiredcoordinate conversion. */match = astSubFrame( target, template, 1,*target_axes,*template_axes,map, result );}/* Free resources. */frame0 = astAnnul( frame0 );}
ast/src/dsbspecframe.c view on Meta::CPAN
* Synopsis:*#include "specframe.h"* void Overlay( AstFrame*template, constint*template_axes,* AstFrame*result,int*status)* Class Membership:* DSBSpecFrame member function (over-rides the protected astOverlay method* inherited from the SpecFrame class).* Description:* This function overlays attributes of a DSBSpecFrame (the"template") on to* another Frame, so as to over-ride selected attributes of that second* Frame. Normally only those attributes which have been specifically set* in the template will be transferred. This implements a form of* defaulting, in which a Frame acquires attributes from the template, but* retains its original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.** Note thatifthe result Frame is a DSBSpecFrame and a change of spectral* coordinatesystemoccurs as a result of overlaying its System* attribute, then some of its original attributevaluesmayno* longer be appropriate (e.g. the Title, or attributes describing* its axes). In this case, these will be clearedbeforeoverlaying* any newvalues.* Parameters:* template* Pointer to the template DSBSpecFrame,forwhichvaluesshould have been* explicitly setforany attribute which is to be transferred.* template_axes* Pointer to an array ofint,withone elementforeachaxis of the*"result"Frame (see below). Foreachaxis in the result frame, the* corresponding element of this array should contain the (zero-based)
ast/src/dsbspecframe.c view on Meta::CPAN
* template DSBSpecFrame, or from a class derived from it, then attributes may* exist in the template DSBSpecFrame whichdonot exist in the result Frame.* In this case, these attributes will not be transferred.*//* Check the global error status. */if( !astOK )return;/* Invoke the parent class astOverlay method to transfer attributes inheritedfrom the parent class. */(*parent_overlay)( template, template_axes, result, status );/* Checkifthe result Frame is a DSBSpecFrame or from a class derived fromDSBSpecFrame. If not, we cannot transfer DSBSpecFrame attributes to it as it isinsufficiently specialised. In this case simply omit these attributes. */if( astIsADSBSpecFrame( result ) && astOK ) {/* Define macros that test whether an attribute is set in the template and,ifso, transfers its value to the result. */#define OVERLAY(attribute) \if( astTest##attribute( template ) ) { \
ast/src/dsbspecframe.c view on Meta::CPAN
* AstFrame **result,int*status)* Class Membership:* DSBSpecFrame member function (over-rides the protected astSubFrame* method inherited from the SpecFrame class).* Description:* This function selects a requestedsub-set (or super-set) of the axes* from a"target"DSBSpecFrame and creates a new Framewithcopies of* the selected axes assembled in the requested order. It then* optionally overlays the attributes of a"template"Frame on to the* result. It returns both the resulting Frame and a Mapping that* describes how to convert between the coordinate systems described by* the target and result Frames. If necessary, this Mapping takes* account of any differences in the Frames' attributes due to the* influence of the template.* Parameters:* target* Pointer to the target DSBSpecFrame, from which axes are to be* selected.* template* Pointer to the template Frame, from which new attributesforthe* result Frame are to be obtained. Optionally, this may be NULL, in* which casenooverlaying of template attributes will be performed.* result_naxes* Number of axes to be selected from the target Frame. This number may* be greater than or less than the number of axes in this Frame (or* equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving a list* of the (zero-based) axis indices of the axes to be selected from the* target DSBSpecFrame. The order in which these aregivendetermines* the order in which the axes appear in the result Frame. If any of the*valuesin this array is set to -1, the corresponding result axis will* not be derived from the target Frame, but will be assigneddefault* attributes instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This should* contain a list of the template axes (givenas zero-based axis indices)*withwhich the axes of the result Frame are to be associated. This* array determines which axes are usedwhenoverlaying axis-dependent* attributes of the template on to the result. If any element of this* array is set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not used and* a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned Mapping.* The forward transformation of this Mapping will describe how to* convert coordinates from the coordinatesystemdescribed by the target
ast/src/dsbspecframe.c view on Meta::CPAN
* - A NULL pointer will be returnedifthis function is invoked*withthe global error status set, orifit should failforany* reason.*//* Local Variables: */AstMapping*result; /* The returned Mapping */AstFrameSet*fs; /* FrameSet connecting tf1 and tf2 */AstSpecFrame*tf1; /* SpecFrame corresponding to this DSBSpecFrame */AstSpecFrame*tf2; /* Topocentric frequency SpecFrame */inttemplate_axis; /* The axis to overlay *//* Initialise. */result = NULL;/* Check the global error status. */if( !astOK )returnresult;/* Make a SpecFrame and then overlay the SpecFrame attributes of thisDSBSpecFrame onto the new SpecFrame. This means it inherits the currentvaluesof things like ObsLon and ObsLat. */tf1 = astSpecFrame("", status );template_axis = 0;(*parent_overlay)( (AstFrame *) this,&template_axis, (AstFrame *) tf1, status );/* Copy this new SpecFrame and set its attributes to describe topocentricfrequency in Hz. Ensure that alignment occurs in the topocentric Frame. */astSetAlignStdOfRest( tf1, AST__TPSOR);tf2 = astCopy( tf1 );astSetSystem( tf2, AST__FREQ );astSetStdOfRest( tf2, AST__TPSOR );astSetUnit( tf2, 0,"Hz");/* Find the Mapping from the spectralsystemdescribed by this SpecFrame to
ast/src/fluxframe.c view on Meta::CPAN
* Modified so that a FluxFrame can be used as a template to find a* FluxFrame contained within a CmpFrame. This involves changes in* Match and the removal of thelocalversions of SetMaxAxes and* SetMinAxes.* 3-SEP-2007 (DSB):* In SubFrame, since AlignSystem is extended by the FluxFrame class* it needs to be clearedbeforeinvoking the parent SubFrame* method in cases where the result Frame is not a FluxFrame.* 2-OCT-2007 (DSB):* In Overlay, clear AlignSystem as well as Systembeforecalling* the parent overlay method.* 29-APR-2011 (DSB):* Prevent astFindFrame from matching a subclass template against a* superclass target.*class--*//* Module Macros. *//* ============== *//* Set the name of the class we are implementing. This indicates tothe header files that define class interfaces that they should make
ast/src/fluxframe.c view on Meta::CPAN
static const char *(* parent_getdomain)( AstFrame *,int* );static const char *(* parent_getlabel)( AstFrame *,int,int* );static const char *(* parent_getsymbol)( AstFrame *,int,int* );static const char *(* parent_gettitle)( AstFrame *,int* );static const char *(* parent_getunit)( AstFrame *,int,int* );staticint(* parent_match)( AstFrame *, AstFrame *,int,int**,int**, AstMapping **, AstFrame **,int* );staticint(* parent_subframe)( AstFrame *, AstFrame *,int, constint*, constint*, AstMapping **, AstFrame **,int* );staticint(* parent_testattrib)( AstObject *, const char *,int* );static void (* parent_setunit)( AstFrame *,int, const char *,int* );static void (* parent_clearattrib)( AstObject *, const char *,int* );static void (* parent_overlay)( AstFrame *, constint*, AstFrame *,int* );static void (* parent_setattrib)( AstObject *, const char *,int* );static void (* parent_setsystem)( AstFrame *, AstSystemType,int* );static void (* parent_clearsystem)( AstFrame *,int* );static void (* parent_clearunit)( AstFrame *,int,int* );#if defined(THREAD_SAFE)staticint(* parent_managelock)( AstObject *,int,int, AstObject **,int* );#endif/* Define macrosforaccessingeachitem of thread specific global data. */
ast/src/fluxframe.c view on Meta::CPAN
parent_getunit = frame->GetUnit;frame->GetUnit = GetUnit;parent_setunit = frame->SetUnit;frame->SetUnit = SetUnit;parent_match = frame->Match;frame->Match = Match;parent_overlay = frame->Overlay;frame->Overlay = Overlay;parent_subframe = frame->SubFrame;frame->SubFrame = SubFrame;/* Store replacement pointersformethods which will be over-ridden by newmember functions implemented here. */frame->GetActiveUnit = GetActiveUnit;frame->TestActiveUnit = TestActiveUnit;frame->ValidateSystem = ValidateSystem;
ast/src/fluxframe.c view on Meta::CPAN
}/* Check at least one FluxFrame axis was found it the target. Store theaxis associataions. */if( match && astOK ) {(*template_axes)[ 0 ] = 0;(*target_axes)[ 0 ] = target_axis0;/* Use the target's"astSubFrame"method to create a new Frame (theresult Frame)withcopies of the target axes in the requiredorder. This process also overlays the template attributes on to thetarget Frame and returns a Mapping between the target and resultFrames which effects the required coordinate conversion. */match = astSubFrame( target, template, 1,*target_axes,*template_axes,map, result );}/* If an error occurred, or conversion to the result Frame'scoordinatesystemwas not possible, then free all memory, annul thereturned objects, andresetthe returned value. */if( !astOK || !match ) {
ast/src/fluxframe.c view on Meta::CPAN
* Synopsis:*#include "fluxframe.h"* void Overlay( AstFrame*template, constint*template_axes,* AstFrame*result,int*status)* Class Membership:* FluxFrame member function (over-rides the protected astOverlay method* inherited from the Frame class).* Description:* This function overlays attributes of a FluxFrame (the"template") on to* another Frame, so as to over-ride selected attributes of that second* Frame. Normally only those attributes which have been specifically set* in the template will be transferred. This implements a form of* defaulting, in which a Frame acquires attributes from the template, but* retains its original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.** Note thatifthe result Frame is a FluxFrame and a change of flux* coordinatesystemoccurs as a result of overlaying its System* attribute, then some of its original attributevaluesmayno* longer be appropriate (e.g. the Title, or attributes describing* its axes). In this case, these will be clearedbeforeoverlaying* any newvalues.* Parameters:* template* Pointer to the template FluxFrame,forwhichvaluesshould have been* explicitly setforany attribute which is to be transferred.* template_axes* Pointer to an array ofint,withone elementforeachaxis of the*"result"Frame (see below). Foreachaxis in the result frame, the* corresponding element of this array should contain the (zero-based)
ast/src/fluxframe.c view on Meta::CPAN
/* Initialise strings used in error messages. */new_class = astGetClass( template );old_class = astGetClass( result );method ="astOverlay";/* Get the old and new systems. */old_system = astGetSystem( result );new_system = astGetSystem( template );/* If the result Frame is a FluxFrame, we must test to seeifoverlaying itsSystem attribute will change the type of coordinatesystemit describes.Determine the value of this attributeforthe result and templateFluxFrames. */resetSystem = 0;fluxframe = astIsAFluxFrame( result );if( fluxframe ) {/* If the coordinatesystemwill change, any value already setforthe resultFluxFrame's Title willnolonger be appropriate, so clear it. */if( ( new_system != old_system ) && astTestSystem( template ) ) {
ast/src/fluxframe.c view on Meta::CPAN
new_alignsystem = astGetAlignSystem( template );astClearAlignSystem( template );resetSystem = 1;}}/* Invoke the parent class astOverlay method to transfer attributes inheritedfrom the parent class. */(*parent_overlay)( template, template_axes, result, status );/* Reset the System and AlignSystemvaluesifnecessary */if( resetSystem ) {astSetSystem( template, new_system );astSetAlignSystem( template, new_alignsystem );}/* Checkifthe result Frame is a FluxFrame or from a class derived fromFluxFrame. If not, we cannot transfer FluxFrame attributes to it as it isinsufficiently specialised. In this case simply omit these attributes. */
ast/src/fluxframe.c view on Meta::CPAN
* AstFrame **result,int*status)* Class Membership:* FluxFrame member function (over-rides the protected astSubFrame* method inherited from the Frame class).* Description:* This function selects a requestedsub-set (or super-set) of the axes* from a"target"FluxFrame and creates a new Framewithcopies of* the selected axes assembled in the requested order. It then* optionally overlays the attributes of a"template"Frame on to the* result. It returns both the resulting Frame and a Mapping that* describes how to convert between the coordinate systems described by* the target and result Frames. If necessary, this Mapping takes* account of any differences in the Frames' attributes due to the* influence of the template.* Parameters:* target* Pointer to the target FluxFrame, from which axes are to be* selected.* template* Pointer to the template Frame, from which new attributesforthe* result Frame are to be obtained. Optionally, this may be NULL, in* which casenooverlaying of template attributes will be performed.* result_naxes* Number of axes to be selected from the target Frame. This number may* be greater than or less than the number of axes in this Frame (or* equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving a list* of the (zero-based) axis indices of the axes to be selected from the* target FluxFrame. The order in which these aregivendetermines* the order in which the axes appear in the result Frame. If any of the*valuesin this array is set to -1, the corresponding result axis will* not be derived from the target Frame, but will be assigneddefault* attributes instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This should* contain a list of the template axes (givenas zero-based axis indices)*withwhich the axes of the result Frame are to be associated. This* array determines which axes are usedwhenoverlaying axis-dependent* attributes of the template on to the result. If any element of this* array is set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not used and* a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned Mapping.* The forward transformation of this Mapping will describe how to* convert coordinates from the coordinatesystemdescribed by the target
ast/src/fluxframe.c view on Meta::CPAN
a FluxFrame. */if( ( result_naxes == 1 ) && ( target_axes[ 0 ] == 0 ) ) {/* Form the result from a copy of the target. */*result= astCopy( target );/* Initialise a flag to indicate that MakeFluxMapping should not reporterrorsifnoMapping can be created. */report = 0;/* If required, overlay the template attributes on to the result FluxFrame.Also get thesystemin which to align the two FluxFrames. These are thevaluesfrom the template (ifthere is a template). */if( template ) {astOverlay( template, template_axes,*result);if( astIsAFluxFrame( template ) ) {align_sys = astGetAlignSystem( template );/* Since we now know that both the template and target are FluxFrames, itshould usually be possible to convert betwen them. If conversion is*not* possible then the user will probably be interested in knowing the
ast/src/fluxframe.c view on Meta::CPAN
SET_AXIS(Symbol)SET_AXIS(Unit)/* Clear attributes which have an extended range ofvaluesallowed bythis class. */astClearSystem( temp );astClearAlignSystem( temp );/* Invoke the astSubFrame method inherited from the Frame class toproduce the result Frame by selecting the required set of axes andoverlaying the template Frame's attributes. */match = (*parent_subframe)( (AstFrame *) temp, template,result_naxes, target_axes, template_axes,map, result, status );/* Delete the temporary copy of the target FluxFrame. */temp = astDelete( temp );}/* If an error occurred ornomatch was found, annul the returnedobjects andresetthe returned result. */
ast/src/frame.c view on Meta::CPAN
( (*template_axes)[ result_axis ] >= template_naxes ) ) {(*template_axes)[ result_axis ] = -1;}if( ( (*target_axes)[ result_axis ] < 0 ) ||( (*target_axes)[ result_axis ] >= target_naxes ) ) {(*target_axes)[ result_axis ] = -1;}}/* Use the target's astSubFrame method toselectthe required axes from it,overlaying the template's attributes on to the resulting Frame. This processalso generates the required Mapping between the target and result Frames. */match = astSubFrame( target, template,result_naxes,*target_axes,*template_axes,map, result );}}/* If an error occurred, free any allocated memory andresetthe result. */if( !astOK || !match ) {*template_axes= astFree(*template_axes);
ast/src/frame.c view on Meta::CPAN
* Synopsis:*#include "frame.h"* void astOverlay( AstFrame*template, constint*template_axes,* AstFrame*result)* Class Membership:* Frame method.* Description:* This function overlays attributes of one Frame (the"template") on to* another Frame, so as to over-ride selected attributes of that second* Frame. Normally only those attributes which have been specifically set* in the template will be transferred. This implements a form of* defaulting, in which a Frame acquires attributes from the template, but* retains its original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.* Parameters:* template* Pointer to the template Frame,forwhichvaluesshould have been
ast/src/frame.c view on Meta::CPAN
OVERLAY(Domain);OVERLAY(Epoch);OVERLAY(Title);OVERLAY(ObsLat)OVERLAY(ObsLon)OVERLAY(ObsAlt)/* Transfer the ActiveUnit flag. */astSetActiveUnit( result, astGetActiveUnit( template ) );/* Only overlay the System and AlignSystem attributeifthevaluesarevalidforthe result class. */if( astTestSystem( template ) ) {sys = astGetSystem( template );if( astValidateSystem( result, sys,"astOverlay") ) {astSetSystem( result, sys );}}if( astTestAlignSystem( template ) ) {sys = astGetAlignSystem( template );
ast/src/frame.c view on Meta::CPAN
if( astOK ) {/* Loop through all the axes in the result Frame and determine to whichtemplate axiseachone corresponds. Check that the resulting axisindexisvalid. If not, then the axis will not receive new attributes. */for( result_axis = 0; result_axis < result_naxes; result_axis++ ) {template_axis = template_axes ? template_axes[ result_axis ] : result_axis;if( ( template_axis >= 0 ) && ( template_axis < template_naxes ) ) {astAxisOverlay method of the template Axis to overlay attributes on tothe result Axis. Annul the Axis pointers afterwards. */template_ax = astGetAxis( template, template_axis );result_ax = astGetAxis( result, result_axis );astAxisOverlay( template_ax, result_ax );template_ax = astAnnul( template_ax );result_ax = astAnnul( result_ax );/* Quit loopingifan error occurs. */if( !astOK ) break;}
ast/src/frame.c view on Meta::CPAN
*intresult_naxes, constint*target_axes,* constint*template_axes, AstMapping **map,* AstFrame **result)* Class Membership:* Frame method.* Description:* This function selects a requestedsub-set (or super-set) of the axes from* a"target"Frame and creates a new Framewithcopies of the selected* axes assembled in the requested order. It then optionally overlays the* attributes of a"template"Frame on to the result. It returns both the* resulting Frame and a Mapping that describes how to convert between the* coordinate systems described by the target and result Frames. If* necessary, this Mapping takes account of any differences in the Frames'* attributes due to the influence of the template.* Parameters:* target* Pointer to the target Frame, from which axes are to be selected.* template* Pointer to the template Frame, from which new attributesforthe* result Frame are to be obtained. Optionally, this may be NULL, in* which casenooverlaying of template attributes will be performed.* result_naxes* Number of axes to be selected from the target Frame. This number may* be greater than or less than the number of axes in this Frame (or* equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving a list* of the (zero-based) axis indices of the axes to be selected from the* target Frame. The order in which these aregivendetermines the order* in which the axes appear in the result Frame. If any of thevaluesin* this array is set to -1, the corresponding result axis will not be* derived from the target Frame, but will be assigneddefaultattributes* instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This should* contain a list of the template axes (givenas zero-based axis indices)*withwhich the axes of the result Frame are to be associated. This* array determines which axes are usedwhenoverlaying axis-dependent* attributes of the template on to the result. If any element of this* array is set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not used and* a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned Mapping.* The forward transformation of this Mapping will describe how to* convert coordinates from the coordinatesystemdescribed by the target
ast/src/frame.c view on Meta::CPAN
/* So far, we have only modified pointers in the temporary Frame to refer tothe target Frame's Axis objects. Since we will next modify these objects'attributes, we must make a deep copy of the entire temporary Frame so thatwedonot modify the target's axes. This copy now becomesourresult Frame.Annul the temporary one. */if( astOK ) {*result= astCopy( tempframe );tempframe = astAnnul( tempframe );/* Invoke the target"astOverlay"method to overlay any remainingattributes from the target Frame which are not associatedwithindividual axes (e.g. the Frame's Title and Domain). */astOverlay( target, target_axes,*result);/* If a template Frame was supplied, also invoke its astOverlay method tooverlay its attributes on the result Frame. (Note that in this particularcase thishasnoeffect other than transferring attributes. In general,however, i.e. in derived classes, this process is vital to determining themapping below, whose main purpose is to convert between the target andresult Frames. These will have different attributes as a result of theinfluence that the templatehashere.) */if( template ) astOverlay( template, template_axes,*result);/* We willnextgenerate the Mapping that relates the target and resultFrames. If appropriate this should be a unit Mapping (UnitMap), so testifthe number of axes in both Frames is equal. */
ast/src/frameset.c view on Meta::CPAN
* Synopsis:*#include "frameset.h"* void Overlay( AstFrame*template, constint*template_axes,* AstFrame*result,int*status)* Class Membership:* FrameSet member function (over-rides the protected astOverlay* method inherited from the Frame class).* Description:* This function overlays attributes from the current Frame of a* FrameSet on to another Frame, so as to over-ride selected* attributes of that second Frame. Normally only those attributes* which have been specifically set in the template will be* transferred. This implements a form of defaulting, in which a* Frame acquires attributes from the template, but retains its* original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.* Parameters:* template
ast/src/frameset.c view on Meta::CPAN
AstFrame*fr; /* Pointer to current Frame */AstFrameSet*template; /* Pointer to the FrameSet structure *//* Check the global error status. */if( !astOK )return;/* Obtain a pointer to the FrameSet structure. */template = (AstFrameSet *) template_frame;/* Obtain a pointer to the current Frame and invoke its astOverlaymethod to overlay its attributes. Annul the Frame pointerafterwards. */fr = astGetFrame( template, AST__CURRENT );astOverlay( fr, template_axes, result );fr = astAnnul( fr );}static void PermAxes( AstFrame*this_frame, constintperm[],int*status) {/** Name:* PermAxes
ast/src/frameset.c view on Meta::CPAN
* AstMapping **map, AstFrame **result,int*status)* Class Membership:* FrameSet member function (over-rides the protected astSubFrame* method inherited from the Frame class).* Description:* This function selects a requestedsub-set (or super-set) of the* axes from the current Frame of a"target"FrameSet and creates a* new Framewithcopies of the selected axes assembled in the* requested order. It then optionally overlays the attributes of a*"template"Frame on to the result. It returns both the resulting* Frame and a Mapping that describes how to convert between the* coordinate systems described by the current Frame of the target* FrameSet and the result Frame. If necessary, this Mapping takes* account of any differences in the Frames' attributes due to the* influence of the template.* Parameters:* target* Pointer to the target FrameSet, from whose current Frame the* axes are to be selected.* template* Pointer to the template Frame, from which new attributesfor* the result Frame are to be obtained. Optionally, this may be* NULL, in which casenooverlaying of template attributes will* be performed.* result_naxes* Number of axes to be selected from the target FrameSet. This* number may be greater than or less than the number of axes in* the FrameSet's current Frame (or equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving* a list of the (zero-based) axis indices of the axes to be* selected from the current Frame of the target FrameSet. The* order in which these aregivendetermines the order in which* the axes appear in the result Frame. If any of thevaluesin* this array is set to -1, the corresponding result axis will* not be derived from the target FrameSet, but will be assigned*defaultattributes instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This* should contain a list of the template axes (givenas* zero-based axis indices)withwhich the axes of the result* Frame are to be associated. This array determines which axes* are usedwhenoverlaying axis-dependent attributes of the* template on to the result. If any element of this array is* set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not* used and a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned* Mapping. The forward transformation of this Mapping will* describe how to convert coordinates from the coordinate
ast/src/region.c view on Meta::CPAN
* Synopsis:*#include "region.h"* void Overlay( AstFrame*template, constint*template_axes,* AstFrame*result,int*status)* Class Membership:* Region member function (over-rides the protected astOverlay* method inherited from the Frame class).* Description:* This function overlays attributes from the current Frame of a* Region on to another Frame, so as to over-ride selected* attributes of that second Frame. Normally only those attributes* which have been specifically set in the template will be* transferred. This implements a form of defaulting, in which a* Frame acquires attributes from the template, but retains its* original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.* Parameters:* template
ast/src/region.c view on Meta::CPAN
* Pointer to the inherited status variable.*//* Local Variables: */AstFrame*fr; /* Pointer to current Frame *//* Check the global error status. */if( !astOK )return;/* Obtain a pointer to the current Frame in the Region and invoke itsastOverlay method to overlay its attributes. Annul the Frame pointerafterwards. */fr = astGetFrame( ((AstRegion *) template_frame)->frameset, AST__CURRENT );astOverlay( fr, template_axes, result );fr = astAnnul( fr );}static void PermAxes( AstFrame*this_frame, constintperm[],int*status) {/** Name:* PermAxes
ast/src/region.c view on Meta::CPAN
* AstMapping **map, AstFrame **result,int*status)* Class Membership:* Region member function (over-rides the protected astSubFrame* method inherited from the Frame class).* Description:* This function selects a requestedsub-set (or super-set) of the* axes from the current Frame of a"target"Region and creates a* new Framewithcopies of the selected axes assembled in the* requested order. It then optionally overlays the attributes of a*"template"Frame on to the result. It returns both the resulting* Frame and a Mapping that describes how to convert between the* coordinate systems described by the current Frame of the target* Region and the result Frame. If necessary, this Mapping takes* account of any differences in the Frames' attributes due to the* influence of the template.* Parameters:* target* Pointer to the target Region, from whose current Frame the* axes are to be selected.* template* Pointer to the template Frame, from which new attributesfor* the result Frame are to be obtained. Optionally, this may be* NULL, in which casenooverlaying of template attributes will* be performed.* result_naxes* Number of axes to be selected from the target Region. This* number may be greater than or less than the number of axes in* the Region's current Frame (or equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving* a list of the (zero-based) axis indices of the axes to be* selected from the current Frame of the target Region. The* order in which these aregivendetermines the order in which* the axes appear in the result Frame. If any of thevaluesin* this array is set to -1, the corresponding result axis will* not be derived from the target Region, but will be assigned*defaultattributes instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This* should contain a list of the template axes (givenas* zero-based axis indices)withwhich the axes of the result* Frame are to be associated. This array determines which axes* are usedwhenoverlaying axis-dependent attributes of the* template on to the result. If any element of this array is* set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not* used and a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned* Mapping. The forward transformation of this Mapping will* describe how to convert coordinates from the coordinate
ast/src/skyaxis.c view on Meta::CPAN
staticintclass_check;/* Pointers to parent class methods which are extended by this class. */static size_t (* parent_getobjsize)( AstObject *,int* );static const char *(* parent_getattrib)( AstObject *, const char *,int* );static const char *(* parent_getaxislabel)( AstAxis *,int* );static const char *(* parent_getaxissymbol)( AstAxis *,int* );static const char *(* parent_getaxisunit)( AstAxis *,int* );staticint(* parent_testattrib)( AstObject *, const char *,int* );staticint(*parent_getaxisdirection)( AstAxis*this,int* );static void (* parent_axisoverlay)( AstAxis *, AstAxis *,int* );static void (* parent_clearattrib)( AstObject *, const char *,int* );static void (* parent_setattrib)( AstObject *, const char *,int* );static double (*parent_getaxisbottom)( AstAxis*this,int* );static double (*parent_getaxistop)( AstAxis*this,int* );static const char *(* parent_axisformat)( AstAxis *, double,int* );static double (*parent_axisgap)( AstAxis *, double,int*,int* );staticint(*parent_axisunformat)( AstAxis *, const char *, double *,int* );staticint(*parent_axisfields)( AstAxis *, const char *, const char *,int, char **,int*, double *,int* );/* Factorsforconverting between hours, degrees and radians. */
ast/src/skyaxis.c view on Meta::CPAN
* Synopsis:*#include "skyaxis.h"* void AxisOverlay( AstAxis*template, AstAxis*result,int*status)* Class Membership:* SkyAxis member function (over-rides the astAxisOverlay method inherited* from the Axis class).* Description:* This function overlays attributes of a SkyAxis (the"template") on to* another Axis, so as to over-ride selected attributes of that second* Axis. Normally only those attributes which have been specifically set* in the template will be transferred. This implements a form of* defaulting, in which an Axis acquires attributes from the template, but* retains its original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.* Parameters:* template* Pointer to the template SkyAxis,forwhichvaluesshould have been
ast/src/skyaxis.c view on Meta::CPAN
/* Local Variables: */AstSkyAxis*template; /* Pointer to the SkyAxis structure *//* Check the global error status. */if( !astOK )return;/* Obtain a pointer to the template SkyAxis structure. */template = (AstSkyAxis *) template_axis;/* Invoke the parent astAstOverlay method to overlay inherited attributes. */(*parent_axisoverlay)( template_axis, result, status );/* Testifthe"result"Axis is a SkyAxis (ifnot, it cannot acquire anyfurther attributes, so there is nothing more todo). */if( astIsASkyAxis( result ) && astOK ) {/* Overlay the Format attributeifit is set in the template. Note that wederived classes may extend the syntax of this string and we should notoverlay a string whose syntax cannot be interpreted by the result Axis. */if( TestAxisFormat( template_axis, status ) ) {SetAxisFormat( result, GetAxisFormat( template_axis, status ), status );}/* Overlay the AsTime attribute in the same way, but thistimeusing methodsto access it. */if( astTestAxisAsTime( template ) ) {astSetAxisAsTime( result, astGetAxisAsTime( template ) );}/* Also overlay the IsLatitude attribute. */if( astTestAxisIsLatitude( template ) ) {astSetAxisIsLatitude( result, astGetAxisIsLatitude( template ) );}/* Also overlay the CentreZero attribute. */if( astTestAxisCentreZero( template ) ) {astSetAxisCentreZero( result, astGetAxisCentreZero( template ) );}}}static void ClearAttrib( AstObject*this_object, const char*attrib,int*status) {/** Name:* ClearAttrib
ast/src/skyaxis.c view on Meta::CPAN
parent_clearattrib = object->ClearAttrib;object->ClearAttrib = ClearAttrib;parent_getattrib = object->GetAttrib;object->GetAttrib = GetAttrib;parent_setattrib = object->SetAttrib;object->SetAttrib = SetAttrib;parent_testattrib = object->TestAttrib;object->TestAttrib = TestAttrib;parent_axisoverlay = axis->AxisOverlay;axis->AxisOverlay = AxisOverlay;parent_getaxisdirection = axis->GetAxisDirection;axis->GetAxisDirection = GetAxisDirection;parent_getaxislabel = axis->GetAxisLabel;axis->GetAxisLabel = GetAxisLabel;parent_getaxissymbol = axis->GetAxisSymbol;axis->GetAxisSymbol = GetAxisSymbol;parent_getaxisunit = axis->GetAxisUnit;axis->GetAxisUnit = GetAxisUnit;
ast/src/skyframe.c view on Meta::CPAN
* - Modify the azel conversions to include correctionfordiurnal* aberration.* - Override astClearObsLat and astSetObsLat by implementations which*resetthe magnitude of the diurnal aberration vector.* 3-SEP-2007 (DSB):* In SubFrame, since AlignSystem is extended by the SkyFrame class* it needs to be clearedbeforeinvoking the parent SubFrame* method in cases where the result Frame is not a SkyFrame.* 2-OCT-2007 (DSB):* In Overlay, clear AlignSystem as well as Systembeforecalling* the parent overlay method.* 10-OCT-2007 (DSB):* In MakeSkyMapping, correct the usage of variables"system"and*"align_sys"whenaligning in AZEL.* 18-OCT-2007 (DSB):* Compare target and template AlignSystemvaluesin Match, rather* than comparing target and result AlignSystemvaluesin MakeSkyMapping* (since result is basically a copy of target).* 27-NOV-2007 (DSB):* - Modify SetSystem to ensure that SkyRef and SkyRefP position are* always transformed as absolutevalues, rather than as offset
ast/src/skyframe.c view on Meta::CPAN
staticint(* parent_testformat)( AstFrame *,int,int* );staticint(* parent_unformat)( AstFrame *,int, const char *, double *,int* );static void (* parent_clearattrib)( AstObject *, const char *,int* );static void (* parent_cleardtai)( AstFrame *,int* );static void (* parent_cleardut1)( AstFrame *,int* );static void (* parent_clearformat)( AstFrame *,int,int* );static void (* parent_clearobsalt)( AstFrame *,int* );static void (* parent_clearobslat)( AstFrame *,int* );static void (* parent_clearobslon)( AstFrame *,int* );static void (* parent_clearsystem)( AstFrame *,int* );static void (* parent_overlay)( AstFrame *, constint*, AstFrame *,int* );static void (* parent_setattrib)( AstObject *, const char *,int* );static void (* parent_setdtai)( AstFrame *, double,int* );static void (* parent_setdut1)( AstFrame *, double,int* );static void (* parent_setformat)( AstFrame *,int, const char *,int* );static void (* parent_setobsalt)( AstFrame *, double,int* );static void (* parent_setobslat)( AstFrame *, double,int* );static void (* parent_setobslon)( AstFrame *, double,int* );static void (* parent_setsystem)( AstFrame *, AstSystemType,int* );/* Factorsforconverting between hours, degrees and radians. */
ast/src/skyframe.c view on Meta::CPAN
parent_getlabel = frame->GetLabel;frame->GetLabel = GetLabel;parent_getsymbol = frame->GetSymbol;frame->GetSymbol = GetSymbol;parent_gettitle = frame->GetTitle;frame->GetTitle = GetTitle;parent_getunit = frame->GetUnit;frame->GetUnit = GetUnit;parent_match = frame->Match;frame->Match = Match;parent_overlay = frame->Overlay;frame->Overlay = Overlay;parent_subframe = frame->SubFrame;frame->SubFrame = SubFrame;parent_unformat = frame->Unformat;frame->Unformat = Unformat;parent_setdtai = frame->SetDtai;frame->SetDtai = SetDtai;parent_setdut1 = frame->SetDut1;frame->SetDut1 = SetDut1;
ast/src/skyframe.c view on Meta::CPAN
instead. */}else{(*template_axes)[ 0 ] = 0;(*template_axes)[ 1 ] = 1;(*target_axes)[ 0 ] = swap ? target_axis1 : target_axis0;(*target_axes)[ 1 ] = swap ? target_axis0 : target_axis1;}/* Use the target's"astSubFrame"method to create a new Frame (theresult Frame)withcopies of the target axes in the requiredorder. This process also overlays the template attributes on to thetarget Frame and returns a Mapping between the target and resultFrames which effects the required coordinate conversion. */match = astSubFrame( target, template, 2,*target_axes,*template_axes,map, result );}/* If an error occurred, or conversion to the result Frame'scoordinatesystemwas not possible, then free all memory, annul thereturned objects, andresetthe returned value. */if( !astOK || !match ) {
ast/src/skyframe.c view on Meta::CPAN
* Synopsis:*#include "skyframe.h"* void Overlay( AstFrame*template, constint*template_axes,* AstFrame*result,int*status)* Class Membership:* SkyFrame member function (over-rides the protected astOverlay method* inherited from the Frame class).* Description:* This function overlays attributes of a SkyFrame (the"template") on to* another Frame, so as to over-ride selected attributes of that second* Frame. Normally only those attributes which have been specifically set* in the template will be transferred. This implements a form of* defaulting, in which a Frame acquires attributes from the template, but* retains its original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.** Note thatifthe result Frame is a SkyFrame and a change of sky* coordinatesystemoccurs as a result of overlaying its System* attribute, then some of its original attributevaluesmayno* longer be appropriate (e.g. the Title, or attributes describing* its axes). In this case, these will be clearedbeforeoverlaying* any newvalues.* Parameters:* template* Pointer to the template SkyFrame,forwhichvaluesshould have been* explicitly setforany attribute which is to be transferred.* template_axes* Pointer to an array ofint,withone elementforeachaxis of the*"result"Frame (see below). Foreachaxis in the result frame, the* corresponding element of this array should contain the (zero-based)
ast/src/skyframe.c view on Meta::CPAN
inttax1; /* Template axisforresult axis 1 *//* Check the global error status. */if( !astOK )return;/* Indicate that wedonot need toresetthe System attribute of thetemplate. */reset_system = 0;new_system = AST__UNKNOWN;/* If the result Frame is a SkyFrame, we must test to seeifoverlaying itsSystem attribute will change the type of sky coordinatesystemitdescribes. Determine the value of this attributeforthe result and templateSkyFrames. We also need todothisifeither SkyRef attribute wouldchange. */skyframe = astIsASkyFrame( result );if( skyframe ) {old_system = astGetSystem( result );new_system = astGetSystem( template );skyref_changed = ( astGetSkyRef( result, 0 ) !=astGetSkyRef( template, 0 ) ) ||
ast/src/skyframe.c view on Meta::CPAN
new_system = astGetSystem( template );astClearSystem( template );new_alignsystem = astGetAlignSystem( template );astClearAlignSystem( template );reset_system = 1;}}/* Invoke the parent class astOverlay method to transfer attributes inheritedfrom the parent class. */(*parent_overlay)( template, template_axes, result, status );/* Reset the System and AlignSystemvaluesifnecessary */if( reset_system ) {astSetSystem( template, new_system );astSetAlignSystem( template, new_alignsystem );}/* Checkifthe result Frame is a SkyFrame or from a class derived fromSkyFrame. If not, we cannot transfer SkyFrame attributes to it as it isinsufficiently specialised. In this case simply omit these attributes. */
ast/src/skyframe.c view on Meta::CPAN
/* Validate the axisindex. */(void) astValidateAxis( this, axis, 1,"astSetAsTime");/* Obtain a pointer to the Axis object. */ax = astGetAxis( this, axis );/* Checkifthe Axis object is a SkyAxis. If not, we will replace itwithone. */if( !astIsASkyAxis( ax ) ) {/* Create a new SkyAxis and overlay the attributes of the original Axis. */new_ax = astSkyAxis("", status );astAxisOverlay( ax, new_ax );pointer. Retain a pointer to the new SkyAxis. */astSetAxis( this, axis, new_ax );ax = astAnnul( ax );ax = (AstAxis *) new_ax;}
ast/src/skyframe.c view on Meta::CPAN
* constint*template_axes, AstMapping **map,* AstFrame **result,int*status)* Class Membership:* SkyFrame member function (over-rides the protected astSubFrame method* inherited from the Frame class).* Description:* This function selects a requestedsub-set (or super-set) of the axes from* a"target"SkyFrame and creates a new Framewithcopies of the selected* axes assembled in the requested order. It then optionally overlays the* attributes of a"template"Frame on to the result. It returns both the* resulting Frame and a Mapping that describes how to convert between the* coordinate systems described by the target and result Frames. If* necessary, this Mapping takes account of any differences in the Frames'* attributes due to the influence of the template.* Parameters:* target* Pointer to the target SkyFrame, from which axes are to be selected.* template* Pointer to the template Frame, from which new attributesforthe* result Frame are to be obtained. Optionally, this may be NULL, in* which casenooverlaying of template attributes will be performed.* result_naxes* Number of axes to be selected from the target Frame. This number may* be greater than or less than the number of axes in this Frame (or* equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving a list* of the (zero-based) axis indices of the axes to be selected from the* target SkyFrame. The order in which these aregivendetermines the* order in which the axes appear in the result Frame. If any of the*valuesin this array is set to -1, the corresponding result axis will* not be derived from the target Frame, but will be assigneddefault* attributes instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This should* contain a list of the template axes (givenas zero-based axis indices)*withwhich the axes of the result Frame are to be associated. This* array determines which axes are usedwhenoverlaying axis-dependent* attributes of the template on to the result. If any element of this* array is set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not used and* a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned Mapping.* The forward transformation of this Mapping will describe how to* convert coordinates from the coordinatesystemdescribed by the target
ast/src/skyframe.c view on Meta::CPAN
astClearUseDefs( target );set_usedefs = 1;}}/* Form the result from a copy of the target and then permute its axesinto the order required. */*result= astCopy( target );astPermAxes(*result, target_axes );/* If required, overlay the template attributes on to the result SkyFrame.Also get thesystemin which to align the two SkyFrames. This is thevalue of the AlignSystem attribute from the template (ifthere is atemplate). */if( template ) {astOverlay( template, template_axes,*result);align_sys = astGetAlignSystem( template );}else{align_sys = astGetAlignSystem( target );}
ast/src/skyframe.c view on Meta::CPAN
ax = astAnnul( ax );}/* Clear attributes which have an extended range ofvaluesallowed bythis class. */astClearSystem( temp );astClearAlignSystem( temp );/* Invoke the astSubFrame method inherited from the Frame class toproduce the result Frame by selecting the required set of axes andoverlaying the template Frame's attributes. */match = (*parent_subframe)( (AstFrame *) temp, template,result_naxes, target_axes, template_axes,map, result, status );/* Delete the temporary copy of the target SkyFrame. */temp = astDelete( temp );}/* Ensure the returned Frame does not have active units. */astSetActiveUnit(*result, 0 );
ast/src/specfluxframe.c view on Meta::CPAN
instead. */}else{(*template_axes)[ 0 ] = 0;(*template_axes)[ 1 ] = 1;(*target_axes)[ 0 ] = swap;(*target_axes)[ 1 ] = !swap;}/* Use the target's"astSubFrame"method to create a new Frame (theresult Frame)withcopies of the target axes in the requiredorder. This process also overlays the template attributes on to thetarget Frame and returns a Mapping between the target and resultFrames which effects the required coordinate conversion. */match = astSubFrame( target, template, 2,*target_axes,*template_axes,map, result );/* If an error occurred, or conversion to the result Frame'scoordinatesystemwas not possible, then free all memory, annul thereturned objects, andresetthe returned value. */if( !astOK || !match ) {*template_axes= astFree(*template_axes);
ast/src/specfluxframe.c view on Meta::CPAN
* AstFrame **result,int*status)* Class Membership:* SpecFluxFrame member function (over-rides the protected astSubFrame* method inherited from the Frame class).* Description:* This function selects a requestedsub-set (or super-set) of the* axes from a"target"SpecFluxFrame and creates a new Framewith* copies of the selected axes assembled in the requested order. It* then optionally overlays the attributes of a"template"Frame on* to the result. It returns both the resulting Frame and a Mapping* that describes how to convert between the coordinate systems* described by the target and result Frames. If necessary, this* Mapping takes account of any differences in the Frames'* attributes due to the influence of the template.* Parameters:* target* Pointer to the target SpecFluxFrame, from which axes are to be selected.* template* Pointer to the template Frame, from which new attributesfor* the result Frame are to be obtained. Optionally, this may be* NULL, in which casenooverlaying of template attributes will* be performed.* result_naxes* Number of axes to be selected from the target Frame. This* number may be greater than or less than the number of axes in* this Frame (or equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving* a list of the (zero-based) axis indices of the axes to be* selected from the target SpecFluxFrame. The order in which these* aregivendetermines the order in which the axes appear in* the result Frame. If any of thevaluesin this array is set* to -1, the corresponding result axis will not be derived from* the target Frame, but will be assigneddefaultattributes* instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This* should contain a list of the template axes (givenas* zero-based axis indices)withwhich the axes of the result* Frame are to be associated. This array determines which axes* are usedwhenoverlaying axis-dependent attributes of the* template on to the result. If any element of this array is* set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not* used and a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned* Mapping. The forward transformation of this Mapping will* describe how to convert coordinates from the coordinate
ast/src/specframe.c view on Meta::CPAN
* SetMinAxes.* 8-AUG-2007 (DSB):* Changed Overlay to avoid the possibility of making permanent* changes to the supplied template Frame.* 3-SEP-2007 (DSB):* In SubFrame, since AlignSystem is extended by the SpecFrame class* it needs to be clearedbeforeinvoking the parent SubFrame* method in cases where the result Frame is not a SkyFrame.* 2-OCT-2007 (DSB):* In Overlay, clear AlignSystem as well as Systembeforecalling* the parent overlay method.* 4-SEP-2009 (DSB):* In MakeSpecMapping, in order to produce alignment that is not* affected by the epoch or reference position, make the alignment* frame adapt to the epoch and reference position of the target* and result Frames.* 14-SEP-2009 (DSB):* In MakeSpecMapping, extend the 4-SEP-2009 fix to cover other* attributes that define the available rest frames (e.g.* SourceVRF, SourceVel, ObsLat, ObsLon, ObsAlt).* 16-SEP-2009 (DSB):
ast/src/specframe.c view on Meta::CPAN
static const char *(* parent_getdomain)( AstFrame *,int* );static const char *(* parent_getlabel)( AstFrame *,int,int* );static const char *(* parent_getsymbol)( AstFrame *,int,int* );static const char *(* parent_gettitle)( AstFrame *,int* );static const char *(* parent_getunit)( AstFrame *,int,int* );staticint(* parent_match)( AstFrame *, AstFrame *,int,int**,int**, AstMapping **, AstFrame **,int* );staticint(* parent_subframe)( AstFrame *, AstFrame *,int, constint*, constint*, AstMapping **, AstFrame **,int* );staticint(* parent_testattrib)( AstObject *, const char *,int* );static void (* parent_setunit)( AstFrame *,int, const char *,int* );static void (* parent_clearattrib)( AstObject *, const char *,int* );static void (* parent_overlay)( AstFrame *, constint*, AstFrame *,int* );static void (* parent_setattrib)( AstObject *, const char *,int* );static void (* parent_setsystem)( AstFrame *, AstSystemType,int* );static void (* parent_clearsystem)( AstFrame *,int* );static void (* parent_clearunit)( AstFrame *,int,int* );/* Define a variable to hold a SkyFrame which will be usedforformattingand unformatting sky positions, etc. */static AstSkyFrame*skyframe;/* Define macrosforaccessingeachitem of thread specific global data. */
ast/src/specframe.c view on Meta::CPAN
parent_getunit = frame->GetUnit;frame->GetUnit = GetUnit;parent_setunit = frame->SetUnit;frame->SetUnit = SetUnit;parent_match = frame->Match;frame->Match = Match;parent_overlay = frame->Overlay;frame->Overlay = Overlay;parent_subframe = frame->SubFrame;frame->SubFrame = SubFrame;/* Store replacement pointersformethods which will be over-ridden by newmember functions implemented here. */frame->GetActiveUnit = GetActiveUnit;frame->TestActiveUnit = TestActiveUnit;frame->ValidateSystem = ValidateSystem;
ast/src/specframe.c view on Meta::CPAN
}/* Check at least one SpecFrame axis was found it the target. Store theaxis associataions. */if( match && astOK ) {(*template_axes)[ 0 ] = 0;(*target_axes)[ 0 ] = target_axis0;/* Use the target's"astSubFrame"method to create a new Frame (theresult Frame)withcopies of the target axes in the requiredorder. This process also overlays the template attributes on to thetarget Frame and returns a Mapping between the target and resultFrames which effects the required coordinate conversion. */match = astSubFrame( target, template, 1,*target_axes,*template_axes,map, result );}/* If an error occurred, or conversion to the result Frame'scoordinatesystemwas not possible, then free all memory, annul thereturned objects, andresetthe returned value. */
ast/src/specframe.c view on Meta::CPAN
* Synopsis:*#include "specframe.h"* void Overlay( AstFrame*template, constint*template_axes,* AstFrame*result,int*status)* Class Membership:* SpecFrame member function (over-rides the protected astOverlay method* inherited from the Frame class).* Description:* This function overlays attributes of a SpecFrame (the"template") on to* another Frame, so as to over-ride selected attributes of that second* Frame. Normally only those attributes which have been specifically set* in the template will be transferred. This implements a form of* defaulting, in which a Frame acquires attributes from the template, but* retains its original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.** Note thatifthe result Frame is a SpecFrame and a change of spectral* coordinatesystemoccurs as a result of overlaying its System* attribute, then some of its original attributevaluesmayno* longer be appropriate (e.g. the Title, or attributes describing* its axes). In this case, these will be clearedbeforeoverlaying* any newvalues.* Parameters:* template* Pointer to the template SpecFrame,forwhichvaluesshould have been* explicitly setforany attribute which is to be transferred.* template_axes* Pointer to an array ofint,withone elementforeachaxis of the*"result"Frame (see below). Foreachaxis in the result frame, the* corresponding element of this array should contain the (zero-based)
ast/src/specframe.c view on Meta::CPAN
/* It may be necessary to make temporary changes to the template Framebelow. In order to ensure that we makenopermanent changes to thesupplied frame, we will,ifnecessary, take a deep copy of thesupplied Frame, storing a pointer to the copy in"templt". If it isnot necessary to make any changes to the template, we still want"templt"to hold a usable pointer, so we initialise it now to hold aclone of the supplied pointer. This pointer will be replaced by apointer to a deep copy (ifrequired) below. */templt = astClone( template );/* If the result Frame is a SpecFrame, we must test to seeifoverlaying itsSystem attribute will change the type of coordinatesystemit describes.Determine the value of this attributeforthe result and templateSpecFrames. */specframe = astIsASpecFrame( result );if( specframe ) {/* If the coordinatesystemwill change, any value already setforthe resultSpecFrame's Title willnolonger be appropriate, so clear it. But notethe coordinatesystemwill change onlyifthesystemvaluesaredifferent AND thesystemhasbeen set explicitly in the template. If
ast/src/specframe.c view on Meta::CPAN
if( astTestSystem( template ) ) {templt = astAnnul( templt );templt = astCopy( template );astClearSystem( templt );astClearAlignSystem( templt );}}/* Invoke the parent class astOverlay method to transfer attributes inheritedfrom the parent class. */(*parent_overlay)( templt, template_axes, result, status );/* Checkifthe result Frame is a SpecFrame or from a class derived fromSpecFrame. If not, we cannot transfer SpecFrame attributes to it as it isinsufficiently specialised. In this case simply omit these attributes. */if( specframe && astOK ) {/* Define macros that test whether an attribute is set in the template and,ifso, transfers its value to the result. */#define OVERLAY(attribute) \if( astTest##attribute( template ) ) { \astSet##attribute( result, astGet##attribute( template ) ); \}/* Use the macro to transfereachSpecFrame attribute in turn. Note,SourceVRF must be overlayedbeforeSourceVel. Otherwise the stored valueforSourceVel would be changed from thedefaultSourceVRF to the specifiedSourceVRFwhenSourceVRF was overlayed. */OVERLAY(AlignStdOfRest)OVERLAY(AlignSpecOffset);OVERLAY(RefDec)OVERLAY(RefRA)OVERLAY(RestFreq)OVERLAY(SourceSys)OVERLAY(SourceVRF)OVERLAY(SourceVel)OVERLAY(StdOfRest)OVERLAY(SpecOrigin)
ast/src/specframe.c view on Meta::CPAN
* AstFrame **result,int*status)* Class Membership:* SpecFrame member function (over-rides the protected astSubFrame* method inherited from the Frame class).* Description:* This function selects a requestedsub-set (or super-set) of the axes* from a"target"SpecFrame and creates a new Framewithcopies of* the selected axes assembled in the requested order. It then* optionally overlays the attributes of a"template"Frame on to the* result. It returns both the resulting Frame and a Mapping that* describes how to convert between the coordinate systems described by* the target and result Frames. If necessary, this Mapping takes* account of any differences in the Frames' attributes due to the* influence of the template.* Parameters:* target* Pointer to the target SpecFrame, from which axes are to be* selected.* template* Pointer to the template Frame, from which new attributesforthe* result Frame are to be obtained. Optionally, this may be NULL, in* which casenooverlaying of template attributes will be performed.* result_naxes* Number of axes to be selected from the target Frame. This number may* be greater than or less than the number of axes in this Frame (or* equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving a list* of the (zero-based) axis indices of the axes to be selected from the* target SpecFrame. The order in which these aregivendetermines* the order in which the axes appear in the result Frame. If any of the*valuesin this array is set to -1, the corresponding result axis will* not be derived from the target Frame, but will be assigneddefault* attributes instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This should* contain a list of the template axes (givenas zero-based axis indices)*withwhich the axes of the result Frame are to be associated. This* array determines which axes are usedwhenoverlaying axis-dependent* attributes of the template on to the result. If any element of this* array is set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not used and* a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned Mapping.* The forward transformation of this Mapping will describe how to* convert coordinates from the coordinatesystemdescribed by the target
ast/src/specframe.c view on Meta::CPAN
a SpecFrame. */if( ( result_naxes == 1 ) && ( target_axes[ 0 ] == 0 ) ) {/* Form the result from a copy of the target. */*result= astCopy( target );/* Initialise a flag to indicate that MakeSpecMapping should not reporterrorsifnoMapping can be created. */report = 0;/* If required, overlay the template attributes on to the result SpecFrame.Also get thesystemand standard of rest in which to align the twoSpecFrames. These are thevaluesfrom the template (ifthere is atemplate). */if( template ) {astOverlay( template, template_axes,*result);if( astIsASpecFrame( template ) ) {align_frm = astCopy( template );/* Since we now know that both the template and target are SpecFrames, itshould usually be possible to convert betwen them. If conversion is
ast/src/specframe.c view on Meta::CPAN
SET_AXIS(Symbol)SET_AXIS(Unit)/* Clear attributes which have an extended range ofvaluesallowed bythis class. */astClearSystem( temp );astClearAlignSystem( temp );/* Invoke the astSubFrame method inherited from the Frame class toproduce the result Frame by selecting the required set of axes andoverlaying the template Frame's attributes. */match = (*parent_subframe)( (AstFrame *) temp, template,result_naxes, target_axes, template_axes,map, result, status );/* Delete the temporary copy of the target SpecFrame. */temp = astDelete( temp );}/* If an error occurred ornomatch was found, annul the returnedobjects andresetthe returned result. */
ast/src/timeframe.c view on Meta::CPAN
* Modified so that a TimeFrame can be used as a template to find a* TimeFrame contained within a CmpFrame. This involves changes in* Match and the removal of thelocalversions of SetMaxAxes and* SetMinAxes.* 3-SEP-2007 (DSB):* In SubFrame, since AlignSystem is extended by the TimeFrame class* it needs to be clearedbeforeinvoking the parent SubFrame* method in cases where the result Frame is not a TimeFrame.* 2-OCT-2007 (DSB):* In Overlay, clear AlignSystem as well as Systembeforecalling* the parent overlay method.* 2-OCT-2007 (DSB):* Added"LT"(Local Time)timescale.* 9-DEC-2008 (DSB):* Ensure Format string pointer is used correctly.* 19-JAN-2009 (DSB):* Ensure"<bad>"is returned by astFormatifthe axis value is bad.* 31-MAR-2009 (DSB):* Extend TimeFrame"iso"Format to allow it to specify the character to* place between thetimeand date strings.* 15-APR-2009 (DSB):
ast/src/timeframe.c view on Meta::CPAN
static const char *(* parent_gettitle)( AstFrame *,int* );static const char *(* parent_getunit)( AstFrame *,int,int* );static double (* parent_getepoch)( AstFrame *,int* );staticint(* parent_fields)( AstFrame *,int, const char *, const char *,int, char **,int*, double *,int* );staticint(* parent_match)( AstFrame *, AstFrame *,int,int**,int**, AstMapping **, AstFrame **,int* );staticint(* parent_subframe)( AstFrame *, AstFrame *,int, constint*, constint*, AstMapping **, AstFrame **,int* );staticint(* parent_testattrib)( AstObject *, const char *,int* );staticint(* parent_unformat)( AstFrame *,int, const char *, double *,int* );static void (* parent_clearattrib)( AstObject *, const char *,int* );static void (* parent_clearsystem)( AstFrame *,int* );static void (* parent_overlay)( AstFrame *, constint*, AstFrame *,int* );static void (* parent_setattrib)( AstObject *, const char *,int* );static void (* parent_setsystem)( AstFrame *, AstSystemType,int* );static void (* parent_setunit)( AstFrame *,int, const char *,int* );/* Define macrosforaccessingeachitem of thread specific global data. */#ifdef THREAD_SAFE/* Define how to initialise thread-specific globals. */#define GLOBAL_inits \globals->Class_Init = 0; \
ast/src/timeframe.c view on Meta::CPAN
parent_getunit = frame->GetUnit;frame->GetUnit = GetUnit;parent_setunit = frame->SetUnit;frame->SetUnit = SetUnit;parent_match = frame->Match;frame->Match = Match;parent_overlay = frame->Overlay;frame->Overlay = Overlay;parent_subframe = frame->SubFrame;frame->SubFrame = SubFrame;parent_format = frame->Format;frame->Format = Format;parent_unformat = frame->Unformat;frame->Unformat = Unformat;
ast/src/timeframe.c view on Meta::CPAN
}/* Check at least one TimeFrame axis was found it the target. Store theaxis associataions. */if( match && astOK ) {(*template_axes)[ 0 ] = 0;(*target_axes)[ 0 ] = target_axis0;/* Use the target's"astSubFrame"method to create a new Frame (theresult Frame)withcopies of the target axes in the requiredorder. This process also overlays the template attributes on to thetarget Frame and returns a Mapping between the target and resultFrames which effects the required coordinate conversion. */match = astSubFrame( target, template, 1,*target_axes,*template_axes,map, result );}/* If an error occurred, or conversion to the result Frame's coordinatesystemwas not possible, then free all memory, annul the returnedobjects, andresetthe returned value. */if( !astOK || !match ) {
ast/src/timeframe.c view on Meta::CPAN
* Synopsis:*#include "timeframe.h"* void Overlay( AstFrame*template, constint*template_axes,* AstFrame*result,int*status)* Class Membership:* TimeFrame member function (over-rides the protected astOverlay method* inherited from the Frame class).* Description:* This function overlays attributes of a TimeFrame (the"template") on to* another Frame, so as to over-ride selected attributes of that second* Frame. Normally only those attributes which have been specifically set* in the template will be transferred. This implements a form of* defaulting, in which a Frame acquires attributes from the template, but* retains its original attributes (as thedefault)ifnewvalueshave not* previously been explicitly set in the template.** Note thatifthe result Frame is a TimeFrame and a change oftime* coordinatesystemoccurs as a result of overlaying its System* attribute, then some of its original attributevaluesmayno* longer be appropriate (e.g. the Title, or attributes describing* its axes). In this case, these will be clearedbeforeoverlaying* any newvalues.* Parameters:* template* Pointer to the template TimeFrame,forwhichvaluesshould have been* explicitly setforany attribute which is to be transferred.* template_axes* Pointer to an array ofint,withone elementforeachaxis of the*"result"Frame (see below). Foreachaxis in the result frame, the* corresponding element of this array should contain the (zero-based)
ast/src/timeframe.c view on Meta::CPAN
intresetSystem; /* Was the template System value cleared? */inttimeframe; /* Result Frame is a TimeFrame? *//* Check the global error status. */if( !astOK )return;/* Get the old and new systems. */old_system = astGetSystem( result );new_system = astGetSystem( template );/* If the result Frame is a TimeFrame, we must test to seeifoverlaying itsSystem attribute will change the type of coordinatesystemit describes.Determine the value of this attributeforthe result and templateTimeFrames. */resetSystem = 0;timeframe = astIsATimeFrame( result );if( timeframe ) {/* If the coordinatesystemwill change, any value already setforthe resultTimeFrame's Title, etc, willnolonger be appropriate, so clear it. Butnote, the coordinatesystemwill change onlyifthesystemvaluesare
ast/src/timeframe.c view on Meta::CPAN
new_alignsystem = astGetAlignSystem( template );astClearAlignSystem( template );resetSystem = 1;}}/* Invoke the parent class astOverlay method to transfer attributes inheritedfrom the parent class. */(*parent_overlay)( template, template_axes, result, status );/* Reset the System and AlignSystemvaluesifnecessary */if( resetSystem ) {astSetSystem( template, new_system );astSetAlignSystem( template, new_alignsystem );}/* Checkifthe result Frame is a TimeFrame or from a class derived fromTimeFrame. If not, we cannot transfer TimeFrame attributes to it as it isinsufficiently specialised. In this case simply omit these attributes. */if( timeframe && astOK ) {/* Define macros that test whether an attribute is set in the template and,ifso, transfers its value to the result. */#define OVERLAY(attribute) \if( astTest##attribute( template ) ) { \astSet##attribute( result, astGet##attribute( template ) ); \}/* Use the macro to transfereachTimeFrame attribute in turn. Note,SourceVRF must be overlayedbeforeSourceVel. Otherwise the stored valueforSourceVel would be changed from thedefaultSourceVRF to the specifiedSourceVRFwhenSourceVRF was overlayed. */OVERLAY(AlignTimeScale)OVERLAY(LTOffset)OVERLAY(TimeOrigin)OVERLAY(TimeScale)}/* Undefine macroslocalto this function. */#undef OVERLAY}
ast/src/timeframe.c view on Meta::CPAN
* AstFrame **result,int*status)* Class Membership:* TimeFrame member function (over-rides the protected astSubFrame* method inherited from the Frame class).* Description:* This function selects a requestedsub-set (or super-set) of the axes* from a"target"TimeFrame and creates a new Framewithcopies of* the selected axes assembled in the requested order. It then* optionally overlays the attributes of a"template"Frame on to the* result. It returns both the resulting Frame and a Mapping that* describes how to convert between the coordinate systems described by* the target and result Frames. If necessary, this Mapping takes* account of any differences in the Frames' attributes due to the* influence of the template.* Parameters:* target* Pointer to the target TimeFrame, from which axes are to be* selected.* template* Pointer to the template Frame, from which new attributesforthe* result Frame are to be obtained. Optionally, this may be NULL, in* which casenooverlaying of template attributes will be performed.* result_naxes* Number of axes to be selected from the target Frame. This number may* be greater than or less than the number of axes in this Frame (or* equal).* target_axes* Pointer to an array ofintwithresult_naxes elements, giving a list* of the (zero-based) axis indices of the axes to be selected from the* target TimeFrame. The order in which these aregivendetermines* the order in which the axes appear in the result Frame. If any of the*valuesin this array is set to -1, the corresponding result axis will* not be derived from the target Frame, but will be assigneddefault* attributes instead.* template_axes* Pointer to an array ofintwithresult_naxes elements. This should* contain a list of the template axes (givenas zero-based axis indices)*withwhich the axes of the result Frame are to be associated. This* array determines which axes are usedwhenoverlaying axis-dependent* attributes of the template on to the result. If any element of this* array is set to -1, the corresponding result axis will not receive any* template attributes.** If the template argument isgivenas NULL, this array is not used and* a NULL pointer may also be supplied here.*map* Address of a location to receive a pointer to the returned Mapping.* The forward transformation of this Mapping will describe how to* convert coordinates from the coordinatesystemdescribed by the target
ast/src/timeframe.c view on Meta::CPAN
/* Result is a TimeFrame. *//* -------------------------- *//* Checkifthe result Frame is to have one axis obtained by selectingthe single target TimeFrame axis. If so, the result will also bea TimeFrame. */if( ( result_naxes == 1 ) && ( target_axes[ 0 ] == 0 ) ) {/* Form the result from a copy of the target. */*result= astCopy( target );/* If required, overlay the template attributes on to the result TimeFrame.Also choose the Frame whichdefinedthe alignmentsystemandtimescale(via its AlignSystem and AlignTimeScale attributes) in which to align thetwo TimeFrames. This is the template (ifthere is a template). */if( template ) {astOverlay( template, template_axes,*result);if( astIsATimeFrame( template ) ) {align_frm = astClone( template );}else{align_frm = astClone( target );}
ast/src/timeframe.c view on Meta::CPAN
SET_AXIS(Symbol)SET_AXIS(Unit)/* Clear attributes which have an extended range ofvaluesallowed bythis class. */astClearSystem( temp );astClearAlignSystem( temp );/* Invoke the astSubFrame method inherited from the Frame class toproduce the result Frame by selecting the required set of axes andoverlaying the template Frame's attributes. */match = (*parent_subframe)( (AstFrame *) temp, template,result_naxes, target_axes, template_axes,map, result, status );/* Delete the temporary copy of the target TimeFrame. */temp = astDelete( temp );}/* If an error occurred ornomatch was found, annul the returnedobjects andresetthe returned result. */
( run in 1.217 second using v1.01-cache-2.11-cpan-a9ef4e587e4 )