IDL_VPTR pgsql_query(int argc, IDL_VPTR *argv, char *argk) { IDL_VPTR queryVptr; char *query; char *connect_info; IDL_VPTR resultVptr; int async = 1; int status; (void) IDL_KWProcessByOffset(argc, argv, argk, kw_pars, (IDL_VPTR *) 0, 1, &kw); if (kw.nrows_there) IDL_StoreScalarZero(kw.nrows, IDL_TYP_ULONG64); /* Check number of input parameters */ if (pgsql_query_nparams(argc) < 1) { IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "-Syntax: result=pgsql_query(query, nrows=, connect_info=, file=, /append, /nointerrupt, /verbose, status=)\nIf there are results for the query, a structure is returned. Otherwise the result is -1"); return(IDL_GettmpInt(-1)); } /* Get the input query */ queryVptr = argv[0]; query = IDL_VarGetString(queryVptr); /* The user may have input connection information */ if (kw.connect_info_there) connect_info=IDL_STRING_STR(&kw.connect_info); else connect_info=""; /* Should we query asynchronously? This would allow cancel through ^C */ if (kw.nointerrupt_there) if (kw.nointerrupt) async = 0; if (async) status = pgsql_query_send_async(query, connect_info, &resultVptr); else status = pgsql_query_send(query, connect_info, &resultVptr); setStatus(status); IDL_KW_FREE; if (status == MYPG_SUCCESS) return(resultVptr); else return(IDL_GettmpInt(-1)); }
/** * Hide a layer. * * @param[in] [1] * The name of the layer to hide. * @param[in] WINDOW @opt * The name of the window. Defaults to the active window. * @rsof * @usage print,hide_layer("raster.tif") * @endusage */ IDL_VPTR hide_layer(int argc, IDL_VPTR pArgv[], char* pArgk) { IDL_VPTR idlPtr; typedef struct { IDL_KW_RESULT_FIRST_FIELD; int windowExists; IDL_STRING windowName; } KW_RESULT; //IDL_KW_FAST_SCAN is the type of scan we are using, following it is the //name of the keyword, followed by the type, the mask(which should be 1), //flags, a boolean whether the value was populated and finally the value itself static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN, {"WINDOW", IDL_TYP_STRING, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(windowExists)), reinterpret_cast<char*>(IDL_KW_OFFSETOF(windowName))}, {NULL} }; IdlFunctions::IdlKwResource<KW_RESULT> kw(argc, pArgv, pArgk, kw_pars, 0, 1); std::string windowName; std::string layerName; if (kw->windowExists) { windowName = IDL_STRING_STR(&kw->windowName); } bool bSuccess = false; if (argc < 1) { IDL_Message(IDL_M_GENERIC, IDL_MSG_RET, "function takes a layer name as a parameter with " "'window' as an optional keyword."); return IDL_StrToSTRING("failure"); } //the layer name as a parameter layerName = IDL_VarGetString(pArgv[0]); SpatialDataView* pView = dynamic_cast<SpatialDataView*>(IdlFunctions::getViewByWindowName(windowName)); if (pView != NULL) { Layer* pLayer = IdlFunctions::getLayerByName(windowName, layerName, false); if (pLayer != NULL) { pView->hideLayer(pLayer); bSuccess = true; } } if (bSuccess) { idlPtr = IDL_StrToSTRING("success"); } else { idlPtr = IDL_StrToSTRING("failure"); } return idlPtr; }
// // idlPvAttrStringSet // // Set the value of a string attribute // // command line arguments // argv[0]: IN/FLAG debug // argv[1]: IN camera index // argv[2]: IN attribute name // argv[3]: IN attribute value int idlPvAttrStringSet (int argc, char *argv[]) { unsigned long n; unsigned long err; IDL_STRING *name; IDL_STRING *value; debug = *(IDL_INT *) argv[0]; n = *(unsigned long *) argv[1]; name = (IDL_STRING *) argv[2]; value = (IDL_STRING *) argv[3]; CHECKINDEX(n); err = PvAttrStringSet(camera[n], (const char *) IDL_STRING_STR(name), (const char *) IDL_STRING_STR(value)); return idlPvErrCode(err); }
/** * Get the current position of a layer in the layer list. * * @param[in] [1] * The name of the layer. * @param[in] WINDOW @opt * The name of the window. Defaults to the active window. * @return The 0 based position of the layer in the layer list. * @usage idx = get_layer_position("data.tif") * @endusage */ IDL_VPTR get_layer_position(int argc, IDL_VPTR pArgv[], char* pArgk) { typedef struct { IDL_KW_RESULT_FIRST_FIELD; int windowExists; IDL_STRING windowName; } KW_RESULT; //IDL_KW_FAST_SCAN is the type of scan we are using, following it is the //name of the keyword, followed by the type, the mask(which should be 1), //flags, a boolean whether the value was populated and finally the value itself static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN, {"WINDOW", IDL_TYP_STRING, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(windowExists)), reinterpret_cast<char*>(IDL_KW_OFFSETOF(windowName))}, {NULL} }; IdlFunctions::IdlKwResource<KW_RESULT> kw(argc, pArgv, pArgk, kw_pars, 0, 1); std::string windowName; std::string name; int index = -1; if (kw->windowExists) { windowName = IDL_STRING_STR(&kw->windowName); } if (argc < 1) { IDL_Message(IDL_M_GENERIC, IDL_MSG_RET, "get_layer_position takes a layer name as a parameter with a " "window as an optional keyword to specify a non current window."); } else { //layer name passed in as a parameter name = IDL_VarGetString(pArgv[0]); SpatialDataView* pView = dynamic_cast<SpatialDataView*>(IdlFunctions::getViewByWindowName(windowName)); if (pView != NULL) { Layer* pLayer = IdlFunctions::getLayerByName(windowName, name, false); if (pLayer != NULL) { index = pView->getLayerDisplayIndex(pLayer); } } } return IDL_GettmpInt(index); }
/** * Get the name of the layer in a given position in the layer list. * * @param[in] INDEX @opt * The 0 based index of the layer. Defaults to the top most layer. * @param[in] WINDOW @opt * The name of the window. Defaults to the active window. * @return The name of the layer. * @usage print,get_layer_name(2, WINDOW="Window 1") * @endusage */ IDL_VPTR get_layer_name(int argc, IDL_VPTR pArgv[], char* pArgk) { typedef struct { IDL_KW_RESULT_FIRST_FIELD; int windowExists; IDL_STRING windowName; int indexExists; IDL_LONG index; } KW_RESULT; //IDL_KW_FAST_SCAN is the type of scan we are using, following it is the //name of the keyword, followed by the type, the mask(which should be 1), //flags, a boolean whether the value was populated and finally the value itself static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN, {"INDEX", IDL_TYP_LONG, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(indexExists)), reinterpret_cast<char*>(IDL_KW_OFFSETOF(index))}, {"WINDOW", IDL_TYP_STRING, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(windowExists)), reinterpret_cast<char*>(IDL_KW_OFFSETOF(windowName))}, {NULL} }; IdlFunctions::IdlKwResource<KW_RESULT> kw(argc, pArgv, pArgk, kw_pars, 0, 1); std::string windowName; int index = -1; std::string name; if (kw->indexExists) { index = kw->index; } if (kw->windowExists) { windowName = IDL_STRING_STR(&kw->windowName); } if (argc < 0) { IDL_Message(IDL_M_GENERIC, IDL_MSG_RET, "Invalid arguments"); return IDL_StrToSTRING(""); } Layer* pLayer = IdlFunctions::getLayerByIndex(windowName, index); if (pLayer != NULL) { name = pLayer->getName(); } return IDL_StrToSTRING(const_cast<char*>(name.c_str())); }
void ridl_closenotebook(void) { char *ts = ridl_currenttimestamp(); switch(ridl_logging_format) { case 0: fprintf(notebook_fp, " <p class=\"date\">Notebook produced by rIDL %s with IDL %s on %s.</p>", RIDL_VERSION, IDL_STRING_STR(&IDL_SysvVersion.release), ts); fprintf(notebook_fp, " </body>\n"); fprintf(notebook_fp, "</html>\n"); break; case 1: if (ridl_new_codeblock) { ridl_new_codeblock = 0; } else { fprintf(notebook_fp, "\n"); } fprintf(notebook_fp, "Notebook produced by rIDL %s with IDL %s on %s.\n", RIDL_VERSION, IDL_STRING_STR(&IDL_SysvVersion.release), ts); break; } free(ts); fclose(notebook_fp); }
// // idlPvCommandRun // // Run a command. A command is an attribute that executes a function // when written. // // command line arguments // argv[0]: IN/FLAG debug // argv[1]: IN camera index // argv[2]: IN command name int idlPvCommandRun (int argc, char * argv[]) { unsigned long n; unsigned long err; IDL_STRING * name; debug = *(IDL_INT *) argv[0]; n = *(unsigned long *) argv[1]; name = (IDL_STRING *) argv[2]; CHECKINDEX(n); err = PvCommandRun(camera[n], IDL_STRING_STR(name)); return idlPvErrCode(err); }
// // idlPvAttrIsAvailable // // Determine if the attribute is available for a specified camera // // command line arguments // argv[0]: IN/FLAG debug // argv[1]: IN index of camera // argv[2]: IN name of attribute int idlPvAttrIsAvailable (int argc, char *argv[]) { unsigned long n; IDL_STRING *attribute; unsigned long err; debug = *(IDL_INT *) argv[0]; n = *(unsigned long *) argv[1]; attribute = (IDL_STRING *) argv[2]; CHECKINDEX(n); err = PvAttrIsAvailable(camera[n], IDL_STRING_STR(attribute)); return idlPvErrCode(err); }
int pgsql_write_file(PGresult *res) { int nFields; long long nTuples; int field; long long row; char *file; FILE *OFILEPTR; file = IDL_STRING_STR(&kw.file); nFields = PQnfields(res); nTuples = PQntuples(res); /* Are we creating new or appending? */ if ( (kw.append_there) && (kw.append != 0) ) OFILEPTR = fopen(file, "a"); else OFILEPTR = fopen(file, "w"); if (!OFILEPTR) { pgsql_query_error("Could not open file",file); return(MYPG_WRITE_FAILURE); } /* Loop through and write everything to file, tab-separated */ for (row=0; row<nTuples; row++) for (field=0;field<nFields;field++) { fprintf(OFILEPTR,"%s", PQgetvalue(res, row, field) ); /* If last field print a new line, else a tab*/ if (field == nFields-1) fprintf(OFILEPTR,"\n"); else fprintf(OFILEPTR,"\t"); } fclose(OFILEPTR); /* No matter what there are no results */ return(MYPG_NO_RESULT); }
// // idlPvAttrInfo // // Get data type and access mode information for an attribute // // command line arguments // argv[0]: IN/FLAG debug // argv[1]: IN camera index // argv[2]: IN attribute name // argv[3]: OUT data type // argv[4]: OUT flags int idlPvAttrInfo (int argc, char *argv[]) { unsigned long n; IDL_STRING * name; tPvAttributeInfo info; unsigned long err; debug = *(IDL_INT *) argv[0]; n = *(unsigned long *) argv[1]; name = (IDL_STRING *) argv[2]; CHECKINDEX(n); err = PvAttrInfo(camera[n], IDL_STRING_STR(name), &info); *(IDL_ULONG *) argv[3] = (IDL_ULONG) info.Datatype; *(IDL_ULONG *) argv[4] = (IDL_ULONG) info.Flags; return idlPvErrCode(err); }
/* host = MG_NET_NAME2HOST(name) Converts the ASCII host name into an unsigned long host value. If name is not specified, the local host name is used. */ static IDL_VPTR IDL_CDECL mg_net_name2host(int argc, IDL_VPTR argv[], char *argk) { struct hostent *hp; char *pName, host_name[256]; if (argc == 0) { if (gethostname(host_name, 256) == -1) { host_name[0] = '\0'; } pName = host_name; } else { IDL_ENSURE_STRING(argv[0]); IDL_ENSURE_SCALAR(argv[0]); pName = IDL_STRING_STR(&(argv[0]->value.str)); } hp = gethostbyname(pName); if (!hp) return(IDL_GettmpLong(0)); return(IDL_GettmpULong(((struct in_addr *) (hp->h_addr))->s_addr)); }
/** * Get the number of layers in a window. * * @param[in] WINDOW @opt * The name of the window. Defaults to the active window. * @return The number of layers in the window. * @usage num_layers = get_num_layers() * @endusage */ IDL_VPTR get_num_layers(int argc, IDL_VPTR pArgv[], char* pArgk) { typedef struct { IDL_KW_RESULT_FIRST_FIELD; int windowExists; IDL_STRING windowName; } KW_RESULT; //IDL_KW_FAST_SCAN is the type of scan we are using, following it is the //name of the keyword, followed by the type, the mask(which should be 1), //flags, a boolean whether the value was populated and finally the value itself static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN, {"WINDOW", IDL_TYP_STRING, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(windowExists)), reinterpret_cast<char*>(IDL_KW_OFFSETOF(windowName))}, {NULL} }; IdlFunctions::IdlKwResource<KW_RESULT> kw(argc, pArgv, pArgk, kw_pars, 0, 1); std::string windowName; int layers = 0; if (kw->windowExists) { windowName = IDL_STRING_STR(&kw->windowName); } SpatialDataView* pView = dynamic_cast<SpatialDataView*>(IdlFunctions::getViewByWindowName(windowName)); if (pView != NULL) { LayerList* pList = pView->getLayerList(); if (pList != NULL) { layers = pList->getNumLayers(); } } return IDL_GettmpInt(layers); }
// // idlPvAttrStringGet // // Get the value of a string attribute // // command line arguments // argv[0]: IN/FLAG debug // argv[1]: IN camera index // argv[2]: IN attribute name // argv[3]: OUT attribute value int idlPvAttrStringGet (int argc, char *argv[]) { unsigned long n; unsigned long err; IDL_STRING *name; IDL_STRING *value; debug = *(IDL_INT *) argv[0]; n = *(unsigned long *) argv[1]; name = (IDL_STRING *) argv[2]; value = (IDL_STRING *) argv[3]; CHECKINDEX(n); err = PvAttrStringGet(camera[n], (const char *) IDL_STRING_STR(name), buffer, STRBUFFERSIZE, (unsigned long *) NULL); IDL_StrStore(value, buffer); return idlPvErrCode(err); }
// // idlPvAttrFloat32Range // // Get the range of value of a Float32 attribute // // command line arguments // argv[0]: IN/FLAG debug // argv[1]: IN camera index // argv[2]: IN attribute name // argv[3]: OUT attribute range minumum // argv[4]: OUT attribute range maximum int idlPvAttrFloat32Range (int argc, char *argv[]) { unsigned long n; unsigned long err; IDL_STRING *name; float *vmin; float *vmax; debug = *(IDL_INT *) argv[0]; n = *(unsigned long *) argv[1]; name = (IDL_STRING *) argv[2]; vmin = (float *) argv[3]; vmax = (float *) argv[4]; CHECKINDEX(n); err = PvAttrRangeFloat32(camera[n], (const char *) IDL_STRING_STR(name), (tPvFloat32 *) vmin, (tPvFloat32 *) vmax); return idlPvErrCode(err); }
int32 OldFitIDLInxClose(int argc,char *argv[]) { int n; struct RadarIDLParm *idlprm; struct RadarParm prm; int32 irec; IDL_FILE_STAT stat; FILE *fp; int unit; int s; unit = *( (int32 *) argv[0]); /* Make sure that the "STDIO" keyword was used to * open the file in IDL. */ s=IDL_FileEnsureStatus(IDL_MSG_RET,unit,IDL_EFS_STDIO); if (s==FALSE) return -1; /* Get information about the file */ IDL_FileStat(unit,&stat); /* Find the file pointer */ fp=stat.fptr; if (fp==NULL) return -1; fflush(fp); /* get the structure pointers */ idlprm=(struct RadarIDLParm *) argv[1]; irec=*((int32 *) argv[2]); memset(&prm,0,sizeof(struct RadarParm)); /* load up the data structures */ prm.revision.major=idlprm->revision.major; prm.revision.minor=idlprm->revision.minor; prm.cp=idlprm->cp; prm.stid=idlprm->stid; prm.time.yr=idlprm->time.yr; prm.time.mo=idlprm->time.mo; prm.time.dy=idlprm->time.dy; prm.time.hr=idlprm->time.hr; prm.time.mt=idlprm->time.mt; prm.time.sc=idlprm->time.sc; prm.time.us=idlprm->time.us; prm.txpow=idlprm->txpow; prm.nave=idlprm->nave; prm.atten=idlprm->atten; prm.lagfr=idlprm->lagfr; prm.smsep=idlprm->smsep; prm.ercod=idlprm->ercod; prm.stat.agc=idlprm->stat.agc; prm.stat.lopwr=idlprm->stat.lopwr; prm.noise.search=idlprm->noise.search; prm.noise.mean=idlprm->noise.mean; prm.channel=idlprm->channel; prm.bmnum=idlprm->bmnum; prm.scan=idlprm->scan; prm.rxrise=idlprm->rxrise; prm.intt.sc=idlprm->intt.sc; prm.intt.us=idlprm->intt.us; prm.txpl=idlprm->txpl; prm.mpinc=idlprm->mpinc; prm.mppul=idlprm->mppul; prm.mplgs=idlprm->mplgs; prm.nrang=idlprm->nrang; prm.frang=idlprm->frang; prm.rsep=idlprm->rsep; prm.xcf=idlprm->xcf; prm.tfreq=idlprm->tfreq; prm.offset=idlprm->offset; prm.mxpwr=idlprm->mxpwr; prm.lvmax=idlprm->lvmax; for (n=0;n<prm.mppul;n++) prm.pulse[n]=idlprm->pulse[n]; for (n=0;n<prm.mplgs;n++) { prm.lag[n][0]=idlprm->lag[n]; prm.lag[n][1]=idlprm->lag[LAG_SIZE+n]; } if (strlen(IDL_STRING_STR(&idlprm->combf)) !=0) strncpy(prm.combf,IDL_STRING_STR(&idlprm->combf),COMBF_SIZE); s=OldFitInxFclose(fp,&prm,irec); return s; }
/* err = MG_NET_SENDVAR(socket, variable [, host] [, port]) Sends a complete IDL variable to a socket for reading by MG_NET_RECVVAR. The variable must be one of the basic types, but strings and arrays are sent with array dimensions and lengths intact. When sending data from a UDP socket, you must specify the remote host and port arguments where host is the value returned from the MG_NET_NAME2HOST function. Note: This is the easiest way to send a complete variable from one IDL to another. The receiver will byteswap the data if necessary. One should be careful not to mix calls to MG_NET_SEND/RECV and MG_NET_SENDVAR/RECVVAR as the latter send formatted information. You can use the two calls on the same socket as long as they are paired. */ static IDL_VPTR IDL_CDECL mg_net_sendvar(int argc, IDL_VPTR argv[], char *argk) { IDL_LONG i; i_var var; int host, addr_len; short port; IDL_LONG iRet; IDL_VPTR vpTmp; char *pbuffer; struct sockaddr_in sin; i = IDL_LongScalar(argv[0]); if ((i < 0) || (i >= MAX_SOCKETS)) return (IDL_GettmpLong(-1)); if (net_list[i].iState != NET_IO) return (IDL_GettmpLong(-1)); IDL_ENSURE_SIMPLE(argv[1]); vpTmp = argv[1]; if (net_list[i].iType == NET_UDP) { if (argc == 4) { host = IDL_ULongScalar(argv[2]); port = (short) IDL_LongScalar(argv[3]); } else { IDL_MessageFromBlock(msg_block, MG_NET_ERROR, IDL_MSG_RET, "This UDP socket requires the destination HOST and PORT arguments."); } } var.token = TOKEN; var.type = vpTmp->type; if ((var.type == IDL_TYP_STRUCT) || (var.type == IDL_TYP_PTR) || (var.type == IDL_TYP_OBJREF) || (var.type == IDL_TYP_UNDEF)) { IDL_MessageFromBlock(msg_block, MG_NET_BADTYPE, IDL_MSG_LONGJMP, IDL_TypeNameFunc(var.type)); } if (vpTmp->type == IDL_TYP_STRING) { if (vpTmp->flags & IDL_V_ARR) return (IDL_GettmpLong(-1)); pbuffer = IDL_STRING_STR(&(vpTmp->value.str)); var.ndims = 0; var.len = vpTmp->value.str.slen + 1; var.nelts = var.len; } else if (vpTmp->flags & IDL_V_ARR) { pbuffer = vpTmp->value.arr->data; var.ndims = vpTmp->value.arr->n_dim; var.len = vpTmp->value.arr->arr_len; var.nelts = vpTmp->value.arr->n_elts; memcpy(var.dims, vpTmp->value.arr->dim, IDL_MAX_ARRAY_DIM * sizeof(IDL_LONG)); } else { pbuffer = &(vpTmp->value.c); var.ndims = 0; var.len = IDL_TypeSizeFunc(var.type); var.nelts = 1; } /* send native, recvvar swaps if needed */ if (net_list[i].iType == NET_UDP) { sin.sin_addr.s_addr = host; sin.sin_family = AF_INET; sin.sin_port = htons(port); addr_len = sizeof(struct sockaddr_in); iRet = sendto(net_list[i].socket, (char *) &var, sizeof(i_var), 0, (struct sockaddr *) &sin, addr_len); if (iRet == -1) return(IDL_GettmpLong(iRet)); iRet = sendto(net_list[i].socket, pbuffer, var.len, 0, (struct sockaddr *) &sin, addr_len); } else { iRet = send(net_list[i].socket,(char *) &var, sizeof(i_var), 0); if (iRet == -1) return (IDL_GettmpLong(iRet)); iRet = send(net_list[i].socket, pbuffer, var.len, 0); } return(IDL_GettmpLong(1)); }
void getobjectdetails( IDL_VPTR var, void *data, char *taglist[], char hdstype[], int *numtags, int *ndims, int dims[], int *elt_len, int *status ) { UCHAR idltype; /* Type of variable */ int i; /* counter */ int *vardim; IDL_VPTR tmpvar; IDL_LONG offset; char *dimptr; char *tok; if ( *status != SAI__OK ) return; /* Type */ idltype = var->type; strcpy(hdstype, gethdstype( idltype )); if ( var->flags & IDL_V_STRUCT ) { /* Structure */ *numtags = IDL_StructNumTags( var->value.s.sdef ); *elt_len = var->value.s.arr->elt_len; if ( var->value.s.arr->n_elts == 1 ) *ndims = 0; else *ndims = (int)var->value.s.arr->n_dim; vardim = (int *)var->value.s.arr->dim; for ( i=0; i<*ndims; i++ ) dims[i] = vardim[i]; if ( !strcmp( *taglist, "HDSSTRUCTYPE" ) ) { /* Get the tag info */ offset = IDL_StructTagInfoByIndex( var->value.s.sdef, 0, IDL_MSG_LONGJMP, &tmpvar ); strcpy( hdstype, IDL_STRING_STR((IDL_STRING *)data+offset) ); } /* If it's an array structure - */ if ( dimptr=strpbrk(hdstype,"(") ) { /* terminate hdstype at the ( */ *dimptr++ = '\0'; /* and get the array dimensions */ for ( i=0; tok=strtok(i?NULL:dimptr,",)"); i++ ) { dims[i] = atoi(tok); } } *ndims = i; } else if ( var->flags & IDL_V_ARR ) { /* Primitive Array */ *numtags = 0;; *ndims = (int)var->value.arr->n_dim; vardim = (int *)var->value.s.arr->dim; for ( i=0; i<*ndims; i++ ) dims[i] = vardim[i]; } else { /* Primitive scalar */ *numtags = 0; *ndims = 0; } /* if it's IDL_STRING find the largest string size */ if ( idltype == 7 ) { strcat(hdstype,"*"); i = getidlstringsize(var,(IDL_STRING *)data); sprintf(hdstype+6,"%d",i); } return; }
/** * Get the names of all the data elements which are children of the primary raster element. * * @param[in] WINDOW @opt * The name of the window. Defaults to the active window. * @return An array of data element names or the string "failure" if an error occurred. * @usage names = get_data_element_names() * @endusage */ IDL_VPTR get_data_element_names(int argc, IDL_VPTR pArgv[], char* pArgk) { typedef struct { IDL_KW_RESULT_FIRST_FIELD; int windowExists; IDL_STRING windowName; } KW_RESULT; //IDL_KW_FAST_SCAN is the type of scan we are using, following it is the //name of the keyword, followed by the type, the mask(which should be 1), //flags, a boolean whether the value was populated and finally the value itself static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN, {"WINDOW", IDL_TYP_STRING, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(windowExists)), reinterpret_cast<char*>(IDL_KW_OFFSETOF(windowName))}, {NULL} }; IdlFunctions::IdlKwResource<KW_RESULT> kw(argc, pArgv, pArgk, kw_pars, 0, 1); std::string windowName; std::string name; bool bSuccess = false; IDL_VPTR idlPtr; unsigned int total = 0; IDL_STRING* pStrarr = NULL; if (kw->windowExists) { windowName = IDL_STRING_STR(&kw->windowName); } SpatialDataWindow* pWindow = NULL; if (windowName.empty()) { pWindow = dynamic_cast<SpatialDataWindow*>(Service<DesktopServices>()->getCurrentWorkspaceWindow()); } else { pWindow = dynamic_cast<SpatialDataWindow*>( Service<DesktopServices>()->getWindow(windowName, SPATIAL_DATA_WINDOW)); } if (pWindow != NULL) { SpatialDataView* pView = pWindow->getSpatialDataView(); if (pView != NULL) { LayerList* pList = pView->getLayerList(); if (pList != NULL) { RasterElement* pElement = pList->getPrimaryRasterElement(); if (pElement != NULL) { std::vector<std::string> names = Service<ModelServices>()->getElementNames(pElement, ""); total = names.size(); if (total > 0) { pStrarr = reinterpret_cast<IDL_STRING*>(malloc(total * sizeof(IDL_STRING))); for (unsigned int i=0; i < total; ++i) { IDL_StrStore(&(pStrarr[i]), const_cast<char*>(names[i].c_str())); } bSuccess = true; } } } } } else if (windowName == "all") { std::vector<std::string> names = Service<ModelServices>()->getElementNames("RasterElement"); total = names.size(); if (total > 0) { pStrarr = reinterpret_cast<IDL_STRING*>(malloc(total* sizeof(IDL_STRING))); for (unsigned int i=0; i < total; ++i) { IDL_StrStore(&(pStrarr[i]), const_cast<char*>(names[i].c_str())); } bSuccess = true; } } if (!bSuccess) { IDL_Message(IDL_M_GENERIC, IDL_MSG_RET, "No elements matched."); return IDL_StrToSTRING("failure"); } IDL_MEMINT dims[] = {total}; idlPtr = IDL_ImportArray(1, dims, IDL_TYP_STRING, reinterpret_cast<UCHAR*>(pStrarr), reinterpret_cast<IDL_ARRAY_FREE_CB>(free), NULL); return idlPtr; }
/** * Get the data element name of a specified layer. * * @param[in] [1] @opt * The name of the layer. Defaults to the top most layer. * @param[in] WINDOW @opt * The name of the window. Defaults to the active window. * @param[in] DATASET @opt * If \p [1] is not specified and this flag it set, get the * data set name of the top most raster layer. * @return The name of the data element. * @usage print,get_data_name(/DATASET) * @endusage */ IDL_VPTR get_data_name(int argc, IDL_VPTR pArgv[], char* pArgk) { typedef struct { IDL_KW_RESULT_FIRST_FIELD; int windowExists; IDL_STRING windowName; int datasetExists; IDL_LONG dataset; } KW_RESULT; //IDL_KW_FAST_SCAN is the type of scan we are using, following it is the //name of the keyword, followed by the type, the mask(which should be 1), //flags, a boolean whether the value was populated and finally the value itself static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN, {"DATASET", IDL_TYP_INT, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(datasetExists)), reinterpret_cast<char*>(IDL_KW_OFFSETOF(dataset))}, {"WINDOW", IDL_TYP_STRING, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(windowExists)), reinterpret_cast<char*>(IDL_KW_OFFSETOF(windowName))}, {NULL} }; IdlFunctions::IdlKwResource<KW_RESULT> kw(argc, pArgv, pArgk, kw_pars, 0, 1); std::string windowName; std::string layerName; std::string name; if (kw->windowExists) { windowName = IDL_STRING_STR(&kw->windowName); } //retrieve the layer name passed in as a parameter if (argc >= 1) { layerName = IDL_VarGetString(pArgv[0]); } //get the layer bool datasets = false; if (kw->datasetExists) { if (kw->dataset != 0) { datasets = true; } } Layer* pLayer = IdlFunctions::getLayerByName(windowName, layerName, datasets); if (pLayer != NULL) { //get the spectral element of the layer and return its name DataElement* pElement = pLayer->getDataElement(); if (pElement != NULL) { name = pElement->getName(); } } else { IDL_Message(IDL_M_GENERIC, IDL_MSG_RET, "the layer name passed into get_data_name " "was invalid."); return IDL_StrToSTRING(""); } return IDL_StrToSTRING(const_cast<char*>(name.c_str())); }
/** Registered to be called when the !prompt changes. @param[in] prompt string to change prompt to */ void ridl_changeprompt(IDL_STRING *prompt) { ridl_prompt = IDL_STRING_STR(prompt); ridl_updateprompt(); }
IDL_VPTR hds2idl( int argc, IDL_VPTR argv[] ) { /* ** Declare variables */ IDL_VPTR hds_name; /* IDL_VPTR to name of the HDS object to be read */ IDL_VPTR var; /* Variable pointer to IDL object */ IDL_VARIABLE temp; /* Temporary storage for primitive scalar variable */ IDL_StructDefPtr sdef; /* Structure definition of sub-structure */ IDL_STRING *objname; /* Pointer to object name as IDL string */ HDSLoc *objloc = NULL; /* Locator of file */ int status; /* Starlink status */ char type[DAT__SZTYP+1];/* HDS type of component */ UCHAR idltype; /* IDl type of component */ int ndims; /* Number of dimensions of object */ int dims[DAT__MXDIM]; /* Dimensions of object HDS style */ IDL_LONG idldims[DAT__MXDIM];/* Dimensions of object IDL style */ int i; /* loop index */ int fstat; /* Final status (before emsEload) */ int isstruct; /* Whether object is structure */ void *tdata; /* Pointer to data area of IDL variable or array */ char param[EMS__SZPAR+1]; /* Error message parameter name */ int parlen; /* Length of error message parameter name */ char opstr[EMS__SZMSG+1]; /* Error message */ int oplen; /* Length of error message */ IDL_LONG one[IDL_MAX_ARRAY_DIM]={1}; /* Start Error context */ status = SAI__OK; emsMark(); /* Check that the correct number of arguments were passed in */ if(argc != 1) { /* Print an error message and return */ status = SAI__ERROR; emsRep( " ", "hds2idl: Incorrect number of arguments", &status ); } else { /* Extract the arguments to comprehensible names */ hds_name = argv[0]; objname = &hds_name->value.str; /* Open the HDS object */ getcomp( IDL_STRING_STR(objname), "READ", &objloc, &status ); /* Check for structure or primitive */ datStruc( objloc, &isstruct, &status ); if (status == SAI__OK) { if ( isstruct ) { /* Create a structure */ sdef = idlstructdef( objloc, &status ); /* Create a temporary variable */ if ( status == SAI__OK ) { (void *)IDL_MakeTempStruct( sdef, 1, one, &var, TRUE ); idlstructfill( objloc, var->value.s, &status ); } } else { /* Object is primitive */ datType( objloc, type, &status ); idltype = getidltype( type ); datShape( objloc, DAT__MXDIM, dims, &ndims, &status ); if ( status == SAI__OK ) { if (ndims) { /* Get dimensions IDL style */ for (i=0;i<ndims;i++) idldims[i] = (IDL_LONG)dims[i]; /* Object is primitive array */ tdata = IDL_MakeTempArray( (int)idltype, ndims, idldims, IDL_BARR_INI_ZERO , &var ); } else { /* Object is primitive scalar */ var = &temp; var->type = idltype; var->flags = 0; tdata = &var->value; } idlprimfill( objloc, var, tdata, &status ); } } /* Annul the object (and close the file) */ datAnnul( &objloc, &status ); } } if ( status != SAI__OK ) { /* Report any error messages */ /* Adding Starlink-style !! and ! prefix */ fstat = status; while ( status != SAI__OK ) { emsEload( param, &parlen, opstr, &oplen, &status ); if ( status != SAI__OK ) IDL_Message( IDL_M_NAMED_GENERIC, IDL_MSG_INFO, opstr ); } /* Set to return undefined variable */ var = IDL_Gettmp(); /* and close error context */ emsRlse(); } /* That's it, return to the calling routine */ return var; }
int32 OldFitIDLWrite(int argc,char *argv[]) { int n; struct RadarIDLParm *idlprm; struct FitIDLData *idlfit; struct RadarParm prm; struct FitData fit; IDL_FILE_STAT stat; FILE *fp; int unit; int s; unit = *( (int32 *) argv[0]); if (unit !=-1) { /* a real file */ /* Make sure that the "STDIO" keyword was used to * open the file in IDL. */ s=IDL_FileEnsureStatus(IDL_MSG_RET,unit,IDL_EFS_STDIO); if (s==FALSE) return -1; /* Get information about the file */ IDL_FileStat(unit,&stat); /* Find the file pointer */ fp=stat.fptr; if (fp==NULL) return -1; fflush(fp); } else fp=NULL; /* dummy routine */ /* get the structure pointers */ idlprm=(struct RadarIDLParm *) argv[1]; idlfit=(struct FitIDLData *) argv[2]; memset(&prm,0,sizeof(struct RadarParm)); memset(&fit,0,sizeof(struct FitData)); /* load up the data structures */ prm.revision.major=idlprm->revision.major; prm.revision.minor=idlprm->revision.minor; prm.cp=idlprm->cp; prm.stid=idlprm->stid; prm.time.yr=idlprm->time.yr; prm.time.mo=idlprm->time.mo; prm.time.dy=idlprm->time.dy; prm.time.hr=idlprm->time.hr; prm.time.mt=idlprm->time.mt; prm.time.sc=idlprm->time.sc; prm.time.us=idlprm->time.us; prm.txpow=idlprm->txpow; prm.nave=idlprm->nave; prm.atten=idlprm->atten; prm.lagfr=idlprm->lagfr; prm.smsep=idlprm->smsep; prm.ercod=idlprm->ercod; prm.stat.agc=idlprm->stat.agc; prm.stat.lopwr=idlprm->stat.lopwr; prm.noise.search=idlprm->noise.search; prm.noise.mean=idlprm->noise.mean; prm.channel=idlprm->channel; prm.bmnum=idlprm->bmnum; prm.scan=idlprm->scan; prm.rxrise=idlprm->rxrise; prm.intt.sc=idlprm->intt.sc; prm.intt.us=idlprm->intt.us; prm.txpl=idlprm->txpl; prm.mpinc=idlprm->mpinc; prm.mppul=idlprm->mppul; prm.mplgs=idlprm->mplgs; prm.nrang=idlprm->nrang; prm.frang=idlprm->frang; prm.rsep=idlprm->rsep; prm.xcf=idlprm->xcf; prm.tfreq=idlprm->tfreq; prm.offset=idlprm->offset; prm.mxpwr=idlprm->mxpwr; prm.lvmax=idlprm->lvmax; for (n=0;n<prm.mppul;n++) prm.pulse[n]=idlprm->pulse[n]; for (n=0;n<prm.mplgs;n++) { prm.lag[n][0]=idlprm->lag[n]; prm.lag[n][1]=idlprm->lag[LAG_SIZE+n]; } if (strlen(IDL_STRING_STR(&idlprm->combf)) !=0) strncpy(prm.combf,IDL_STRING_STR(&idlprm->combf),COMBF_SIZE); fit.revision.major=idlfit->revision.major; fit.revision.minor=idlfit->revision.minor; fit.noise.skynoise=idlfit->noise.sky; fit.noise.lag0=idlfit->noise.lag0; fit.noise.vel=idlfit->noise.vel; for (n=0;n<prm.nrang;n++) { fit.rng[n].p_0=idlfit->pwr0[n]; fit.rng[n].nump=idlfit->nlag[n]; fit.rng[n].qflg=idlfit->qflg[n]; fit.rng[n].gsct=idlfit->gflg[n]; fit.rng[n].p_l=idlfit->p_l[n]; fit.rng[n].p_l_err=idlfit->p_l_e[n]; fit.rng[n].p_s=idlfit->p_s[n]; fit.rng[n].p_s_err=idlfit->p_s_e[n]; fit.rng[n].v=idlfit->v[n]; fit.rng[n].v_err=idlfit->v_e[n]; fit.rng[n].w_l=idlfit->w_l[n]; fit.rng[n].w_l_err=idlfit->w_l_e[n]; fit.rng[n].w_s=idlfit->w_s[n]; fit.rng[n].w_s_err=idlfit->w_s_e[n]; fit.rng[n].sdev_l=idlfit->sd_l[n]; fit.rng[n].sdev_s=idlfit->sd_s[n]; fit.rng[n].sdev_phi=idlfit->sd_phi[n]; if (prm.xcf !=0) { fit.elv[n].low=idlfit->elv_low[n]; fit.elv[n].normal=idlfit->elv[n]; fit.elv[n].high=idlfit->elv_high[n]; fit.xrng[n].qflg=idlfit->x_qflg[n]; fit.xrng[n].gsct=idlfit->x_gflg[n]; fit.xrng[n].p_l=idlfit->x_p_l[n]; fit.xrng[n].p_l_err=idlfit->x_p_l_e[n]; fit.xrng[n].p_s=idlfit->x_p_s[n]; fit.xrng[n].p_s_err=idlfit->x_p_s_e[n]; fit.xrng[n].v=idlfit->x_v[n]; fit.xrng[n].v_err=idlfit->x_v_e[n]; fit.xrng[n].w_l=idlfit->x_w_l[n]; fit.xrng[n].w_l_err=idlfit->x_w_l_e[n]; fit.xrng[n].w_s=idlfit->x_w_s[n]; fit.xrng[n].w_s_err=idlfit->x_w_s_e[n]; fit.xrng[n].sdev_l=idlfit->x_sd_l[n]; fit.xrng[n].sdev_s=idlfit->x_sd_s[n]; fit.xrng[n].sdev_phi=idlfit->x_sd_phi[n]; fit.xrng[n].phi0=idlfit->phi0[n]; fit.xrng[n].phi0_err=idlfit->phi0_e[n]; } } s=OldFitFwrite(fp,&prm,&fit,NULL); return s; }