// // idlpgr_AllocateImage // // Allocate IDL buffer for image data and transfer image. // argv[0]: image // IDL_VPTR IDL_CDECL idlpgr_AllocateImage(int argc, IDL_VPTR argv[]) { fc2Error error; fc2Image *image; IDL_MEMINT ndims, dim[IDL_MAX_ARRAY_DIM]; IDL_VPTR idl_image; UCHAR *pd; image = (fc2Image *) IDL_ULong64Scalar(argv[0]); if (image->cols == image->stride) { ndims = 2; dim[0] = image->cols; dim[1] = image->rows; } else { ndims = 3; dim[0] = 3; dim[1] = image->cols; dim[2] = image->rows; } pd = (UCHAR *) IDL_MakeTempArray(IDL_TYP_BYTE, ndims, dim, IDL_ARR_INI_NOP, &idl_image); memcpy(pd, image->pData, image->rows*image->stride); return idl_image; }
/* err = MG_NET_RECVVAR(socket, variable) Reads an IDL variable from the socket in the form written by MG_NET_SENDVAR. The complete variable is reconstructed. See MG_NET_SENDVAR for more details. */ static IDL_VPTR IDL_CDECL mg_net_recvvar(int argc, IDL_VPTR argv[], char *argk) { IDL_LONG i, iRet; IDL_LONG swab = 0; i_var var; IDL_VPTR vpTmp; char *pbuffer; 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_EXCLUDE_EXPR(argv[1]); /* read the header */ iRet = recv_packet(net_list[i].socket, &var,sizeof(i_var)); if (iRet == -1) return (IDL_GettmpLong(-1)); if (var.token == SWAPTOKEN) { mg_byteswap(&var, sizeof(i_var), sizeof(IDL_LONG)); swab = 1; } if (var.token != TOKEN) return (IDL_GettmpLong(-1)); /* allocate the variable */ if (var.type == IDL_TYP_STRING) { vpTmp = IDL_StrToSTRING(""); IDL_StrEnsureLength(&(vpTmp->value.str), var.len); vpTmp->value.str.slen = var.len - 1; pbuffer = vpTmp->value.str.s; memset(pbuffer, 0x20, var.len-1); pbuffer[var.len] = '\0'; IDL_VarCopy(vpTmp, argv[1]); } else if (var.ndims != 0) { pbuffer = IDL_MakeTempArray(var.type, var.ndims, var.dims, IDL_BARR_INI_NOP, &vpTmp); IDL_VarCopy(vpTmp, argv[1]); } else { vpTmp = IDL_GettmpLong(0); IDL_VarCopy(vpTmp, argv[1]); IDL_StoreScalarZero(argv[1], var.type); pbuffer = &(argv[1]->value.c); } /* read the data */ iRet = recv_packet(net_list[i].socket, pbuffer, var.len); if (iRet == -1) return (IDL_GettmpLong(-1)); if (swab) { int swapsize = var.len / var.nelts; if ((var.type == IDL_TYP_COMPLEX) || (var.type == IDL_TYP_DCOMPLEX)) { swapsize /= 2; } mg_byteswap(pbuffer, var.len, swapsize); } return (IDL_GettmpLong(1)); }
// unsigned long * STDCALL mysql_fetch_lengths(MYSQL_RES *result); static IDL_VPTR IDL_mg_mysql_fetch_lengths(int argc, IDL_VPTR *argv) { MYSQL_RES *result = (MYSQL_RES *)argv[0]->value.ptrint; unsigned int num_fields = mysql_num_fields(result); unsigned long *lengths = mysql_fetch_lengths(result); IDL_ARRAY_DIM dims; IDL_VPTR vptr_lengths; unsigned long *lengths_data; int i; dims[0] = num_fields; lengths_data = (unsigned long *) IDL_MakeTempArray(IDL_TYP_ULONG64, 1, dims, IDL_ARR_INI_NOP, &vptr_lengths); for (i = 0; i < num_fields; i++) { lengths_data[i] = lengths[i]; } return vptr_lengths; }
static IDL_VPTR IDL_CDECL IDL_mg_rasterpolyline(int argc, IDL_VPTR *argv) { IDL_VPTR x, y, polylines, dims, xrange, yrange, result; int *result_data; x = argv[0]; y = argv[1]; polylines = argv[2]; dims = argv[3]; xrange = argv[4]; yrange = argv[5]; printf("dims[0] = %lld\n", x->value.arr->dim[0]); printf("dims[1] = %lld\n", x->value.arr->dim[1]); printf("dims[2] = %lld\n", x->value.arr->dim[2]); // variable to return result in result_data = (int *) IDL_MakeTempArray(IDL_TYP_LONG, x->value.arr->n_dim, x->value.arr->dim, IDL_ARR_INI_ZERO, &result); return result; }
// not part of mysql.h, but needed to access the C fields // typedef char **MYSQL_ROW; static IDL_VPTR IDL_mg_mysql_get_blobfield(int argc, IDL_VPTR *argv) { MYSQL_ROW row = (MYSQL_ROW) argv[0]->value.ptrint; IDL_ULONG field_index = IDL_ULongScalar(argv[1]); unsigned long length = IDL_ULong64Scalar(argv[2]); char *field = row[field_index]; IDL_ARRAY_DIM dims; IDL_VPTR blob; char *blob_data; int i; dims[0] = length; blob_data = (char *) IDL_MakeTempArray(IDL_TYP_BYTE, 1, dims, IDL_ARR_INI_NOP, &blob); for (i = 0; i < length; i++) { blob_data[i] = field[i]; } return blob; }
IDL_VPTR p3d_idlGetMaxVolumeBlob(int argc, IDL_VPTR argv[], char* argk) { typedef struct { IDL_KW_RESULT_FIRST_FIELD; // Must be first entry in structure IDL_LONG conn; int cn_there; } KW_RESULT; // Alphabetical order is crucial: static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN, { "CONN", IDL_TYP_LONG, 1, 0, (int*) IDL_KW_OFFSETOF(cn_there), (char*) IDL_KW_OFFSETOF(conn)}, { NULL} }; KW_RESULT kw; IDL_VPTR idl_out_rev, idl_in_rev; unsigned char *in_rev8, *out_rev8; int keywords_ct = 0; int conn2D = CONN4; int conn3D = CONN6; int err_code; // Process keywords: IDL_KWProcessByOffset(argc, argv, argk, kw_pars, NULL, 1, &kw); // Get input data in IDL format: idl_in_rev = argv[0]; IDL_ENSURE_SIMPLE(idl_in_rev); IDL_ENSURE_ARRAY(idl_in_rev); // Get the CONN input argument: if (kw.cn_there) { if (idl_in_rev->value.arr->n_dim == 2) { // Check values: if ((kw.conn != 4) && (kw.conn != 8)) _p3d_idlPrintNamedError("CONN must be a value of the set {4,8}."); // Get values: if (kw.conn == 4) conn2D = CONN4; else if (kw.conn == 8) conn2D = CONN8; } else if (idl_in_rev->value.arr->n_dim == 3) { // Check values: if ((kw.conn != 6) && (kw.conn != 18) && (kw.conn != 26)) _p3d_idlPrintNamedError("CONN must be a value of the set {6,18,26}."); // Get values: if (kw.conn == 6) conn3D = CONN6; else if (kw.conn == 18) conn3D = CONN18; else if (kw.conn == 26) conn3D = CONN26; } // else: error on input arguments with further handling. keywords_ct++; } // Call Pore3D depending on input arguments: if (idl_in_rev->value.arr->n_dim == 3) { // Extract first input (volume to filter) in C format: if (idl_in_rev->type == IDL_TYP_BYTE) { in_rev8 = (unsigned char *) idl_in_rev->value.arr->data; // Allocate memory for output: if (!(idl_in_rev->flags & IDL_V_TEMP)) out_rev8 = (unsigned char *) IDL_MakeTempArray( IDL_TYP_BYTE, idl_in_rev->value.arr->n_dim, idl_in_rev->value.arr->dim, IDL_ARR_INI_NOP, &idl_out_rev ); // Call Pore3D: err_code = p3dGetMaxVolumeBlob3D( in_rev8, out_rev8, (unsigned int) idl_in_rev->value.arr->dim[0], (unsigned int) idl_in_rev->value.arr->dim[1], (unsigned int) idl_in_rev->value.arr->dim[2], conn3D, _p3d_idlPrintInfo ); // On exception print error: if (err_code == P3D_ERROR) _p3d_idlPrintNamedError("Error on code execution."); } else { _p3d_idlPrintNamedError("Input argument IMAGE must be of type BYTE."); } } else { _p3d_idlPrintNamedError("Input argument IMAGE must be a 2D or 3D matrix."); } // Free resources: IDL_KW_FREE; // Return output in IDL Format return (idl_out_rev); }
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; }
static IDL_VPTR IDLOldCnvMapRead(int argc,IDL_VPTR *argv) { int s=0; IDL_VPTR vprm=NULL,vstvec=NULL,vgvec=NULL,vmvec=NULL,vcoef=NULL,vbnd=NULL; IDL_LONG unit=0; IDL_FILE_STAT stat; struct CnvMapData *map=NULL; struct GridData *grd=NULL; struct CnvMapIDLPrm *iprm=NULL; struct GridIDLStVec *istvec=NULL; struct GridIDLGVec *igvec=NULL; struct GridIDLGVec *imvec=NULL; struct CnvMapIDLBnd *ibnd=NULL; double *icoef=NULL; IDL_MEMINT cdim[2]; FILE *fp=NULL; IDL_ENSURE_SCALAR(argv[0]); IDL_EXCLUDE_EXPR(argv[1]); IDL_EXCLUDE_EXPR(argv[2]); IDL_EXCLUDE_EXPR(argv[4]); IDL_EXCLUDE_EXPR(argv[5]); IDL_EXCLUDE_EXPR(argv[6]); unit=IDL_LongScalar(argv[0]); s=IDL_FileEnsureStatus(IDL_MSG_RET,unit,IDL_EFS_USER); if (s==FALSE) { s=-1; return (IDL_GettmpLong(s)); } /* Get information about the file */ IDL_FileFlushUnit(unit); IDL_FileStat(unit,&stat); /* Find the file pointer */ fp=stat.fptr; if (fp==NULL) { s=-1; return (IDL_GettmpLong(s)); } map=CnvMapMake(); grd=GridMake(); s=OldCnvMapFread(fp,map,grd); if (s==-1) { CnvMapFree(map); GridFree(grd); return (IDL_GettmpLong(s)); } iprm=IDLMakeCnvMapPrm(&vprm); if (grd->stnum !=0) istvec=IDLMakeGridStVec(grd->stnum,&vstvec); if (grd->vcnum !=0) igvec=IDLMakeGridGVec(grd->vcnum,&vgvec); if (map->num_model !=0) imvec=IDLMakeGridGVec(map->num_model,&vmvec); if (map->num_bnd !=0) ibnd=IDLMakeCnvMapBnd(map->num_bnd,&vbnd); if (map->num_coef !=0) { int n=0; cdim[1]=4; cdim[0]=map->num_coef; icoef=(double *) IDL_MakeTempArray(IDL_TYP_DOUBLE,2,cdim,IDL_ARR_INI_ZERO,&vcoef); for (n=0;n<map->num_coef;n++) { icoef[n]=map->coef[4*n]; icoef[map->num_coef+n]=map->coef[4*n+1]; icoef[2*map->num_coef+n]=map->coef[4*n+2]; icoef[3*map->num_coef+n]=map->coef[4*n+3]; } } /* copy the data here */ IDLCopyCnvMapPrmToIDL(map,grd,iprm); if (istvec !=NULL) IDLCopyGridStVecToIDL(grd,grd->stnum, vstvec->value.s.arr->elt_len,istvec); if (igvec !=NULL) IDLCopyGridGVecToIDL(grd,grd->vcnum, vgvec->value.s.arr->elt_len,igvec); if (imvec !=NULL) IDLCopyCnvMapGVecToIDL(map,map->num_model, vmvec->value.s.arr->elt_len,imvec); if (ibnd !=NULL) IDLCopyCnvMapBndToIDL(map,map->num_bnd, vbnd->value.s.arr->elt_len,ibnd); CnvMapFree(map); GridFree(grd); IDL_VarCopy(vprm,argv[1]); if (vstvec !=NULL) IDL_VarCopy(vstvec,argv[2]); if (vgvec !=NULL) IDL_VarCopy(vgvec,argv[3]); if (vmvec !=NULL) IDL_VarCopy(vmvec,argv[4]); if (vcoef !=NULL) IDL_VarCopy(vcoef,argv[5]); if (vbnd !=NULL) IDL_VarCopy(vbnd,argv[6]); return (IDL_GettmpLong(s)); }
IDL_VPTR p3d_idlSquaredEuclideanDT(int argc, IDL_VPTR argv[], char* argk) { IDL_VPTR idl_out_rev, idl_in_rev; unsigned char *in_rev; unsigned int *out_rev; int err_code; // Get input data in IDL format: idl_in_rev = argv[0]; IDL_ENSURE_SIMPLE(idl_in_rev); IDL_ENSURE_ARRAY(idl_in_rev); // Get input data in IDL format: // Allocate memory for output: if (!(idl_in_rev->flags & IDL_V_TEMP)) out_rev = (unsigned int *) IDL_MakeTempArray( IDL_TYP_ULONG, idl_in_rev->value.arr->n_dim, idl_in_rev->value.arr->dim, IDL_ARR_INI_NOP, &idl_out_rev ); if (idl_in_rev->value.arr->n_dim == 3) { // Extract input in C format if (idl_in_rev->type == IDL_TYP_BYTE) in_rev = (unsigned char *) idl_in_rev->value.arr->data; else _p3d_idlPrintNamedError("Input argument IMAGE must be of type BYTE."); // Call Pore3D: err_code = p3dSquaredEuclideanDT( in_rev, out_rev, (unsigned int) idl_in_rev->value.arr->dim[0], (unsigned int) idl_in_rev->value.arr->dim[1], (unsigned int) idl_in_rev->value.arr->dim[2], _p3d_idlPrintInfo ); if (err_code == P3D_ERROR) { // Print error: _p3d_idlPrintNamedError("Error on internal code execution."); } // // Following code is not necessary 'cause number of input arguments // is checked at compile-time and not at run time (see further IDL_Load). // //else //{ // // Print error: // _p3d_idlPrintNamedError("Incorrect number of arguments."); //} } else { _p3d_idlPrintNamedError("Input argument IMAGE must be a 3D matrix."); } // Return output in IDL Format: return idl_out_rev; }
IDL_VPTR p3d_idlGaussianFilter(int argc, IDL_VPTR argv[], char* argk) { typedef struct { IDL_KW_RESULT_FIRST_FIELD; // Must be first entry in structure double sigma; int si_there; IDL_LONG nsize; int ns_there; } KW_RESULT; // Alphabetical order is crucial: static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN, { "SIGMA", IDL_TYP_DOUBLE, 1, 0, (int*) IDL_KW_OFFSETOF(si_there), (char*) IDL_KW_OFFSETOF(sigma)}, { "WIDTH", IDL_TYP_LONG, 1, 0, (int*) IDL_KW_OFFSETOF(ns_there), (char*) IDL_KW_OFFSETOF(nsize)}, { NULL} }; KW_RESULT kw; IDL_VPTR idl_out_rev, idl_in_rev; unsigned char *in_rev8, *out_rev8; unsigned short *in_rev16, *out_rev16; int keywords_ct = 0; int width = 3; // default double sigma = 1.0; // default int err_code; // Process keywords: IDL_KWProcessByOffset(argc, argv, argk, kw_pars, NULL, 1, &kw); // Get input data in IDL format: idl_in_rev = argv[0]; IDL_ENSURE_SIMPLE(idl_in_rev); IDL_ENSURE_ARRAY(idl_in_rev); // Get the WIDTH input argument: if (kw.ns_there) { // Check values: if ((kw.nsize < 3) || (kw.nsize > 51)) _p3d_idlPrintNamedError("WIDTH must be an odd value within the range [3,51]."); if ((kw.nsize % 2) == 0) _p3d_idlPrintNamedError("WIDTH must be an odd value within the range [3,51]."); // Get values: width = (int) kw.nsize; keywords_ct++; } // Get the SIGMA input argument: if (kw.si_there) { // Check values: if (kw.sigma < 0) _p3d_idlPrintNamedError("SIGMA must be greater than zero."); // Get values: sigma = (double) kw.sigma; keywords_ct++; } // Call Pore3D depending on input arguments: if (idl_in_rev->value.arr->n_dim == 3) { // Extract first input (volume to filter) in C format: if (idl_in_rev->type == IDL_TYP_BYTE) { in_rev8 = (unsigned char *) idl_in_rev->value.arr->data; // Allocate memory for output: if (!(idl_in_rev->flags & IDL_V_TEMP)) out_rev8 = (unsigned char *) IDL_MakeTempArray( IDL_TYP_BYTE, idl_in_rev->value.arr->n_dim, idl_in_rev->value.arr->dim, IDL_ARR_INI_NOP, &idl_out_rev ); // Call Pore3D: err_code = p3dGaussianFilter3D_8( in_rev8, out_rev8, (int) idl_in_rev->value.arr->dim[0], (int) idl_in_rev->value.arr->dim[1], (int) idl_in_rev->value.arr->dim[2], width, sigma, _p3d_idlPrintInfo, NULL ); // On exception print error: if ((err_code == P3D_IO_ERROR) || (err_code == P3D_ERROR)) _p3d_idlPrintNamedError("Error on code execution."); } else if (idl_in_rev->type == IDL_TYP_UINT) { in_rev16 = (unsigned short *) idl_in_rev->value.arr->data; // Allocate memory for output: if (!(idl_in_rev->flags & IDL_V_TEMP)) out_rev16 = (unsigned short *) IDL_MakeTempArray( IDL_TYP_UINT, idl_in_rev->value.arr->n_dim, idl_in_rev->value.arr->dim, IDL_ARR_INI_NOP, &idl_out_rev ); // Call Pore3D: err_code = p3dGaussianFilter3D_16( in_rev16, out_rev16, (int) idl_in_rev->value.arr->dim[0], (int) idl_in_rev->value.arr->dim[1], (int) idl_in_rev->value.arr->dim[2], width, sigma, _p3d_idlPrintInfo, NULL ); // On exception print error: if ((err_code == P3D_IO_ERROR) || (err_code == P3D_ERROR)) _p3d_idlPrintNamedError("Error on code execution."); } else { _p3d_idlPrintNamedError("Input argument IMAGE must be of type BYTE or UINT."); } } else { _p3d_idlPrintNamedError("Input argument IMAGE must be a 2D or 3D matrix."); } // Free resources: IDL_KW_FREE; // Return output in IDL Format return (idl_out_rev); }
static void copyStatsFromAtlas(ATLAS_IMAGE *ai) { IDL_VPTR row0_tmp, col0_tmp, drow_tmp, dcol_tmp; short *row0_data, *col0_data, *drow_data, *dcol_data; IDL_ARRAY_DIM dim; int i; dim[0] = NBANDS; /* row0 */ if (kw.row0_there) { row0_data = (short *) IDL_MakeTempArray(IDL_TYP_INT, 1, dim, IDL_ARR_INI_NOP, &row0_tmp); for (i=0; i<NBANDS; ++i) row0_data[i] = ai->master_mask->rmin + ai->drow[i]; /* copy into output. This just copied pointers, its fast */ IDL_VarCopy(row0_tmp, kw.row0); } /* col0 */ if (kw.col0_there) { col0_data = (short *) IDL_MakeTempArray(IDL_TYP_INT, 1, dim, IDL_ARR_INI_NOP, &col0_tmp); for (i=0; i<NBANDS; ++i) col0_data[i] = ai->master_mask->cmin + ai->dcol[i]; /* copy into output. This just copied pointers, its fast */ IDL_VarCopy(col0_tmp, kw.col0); } /* drow */ if (kw.drow_there) { drow_data = (short *) IDL_MakeTempArray(IDL_TYP_INT, 1, dim, IDL_ARR_INI_NOP, &drow_tmp); for (i=0; i<NBANDS; ++i) drow_data[i] = ai->drow[i]; /* copy into output. This just copied pointers, its fast */ IDL_VarCopy(drow_tmp, kw.drow); } /* dcol */ if (kw.dcol_there) { dcol_data = (short *) IDL_MakeTempArray(IDL_TYP_INT, 1, dim, IDL_ARR_INI_NOP, &dcol_tmp); for (i=0; i<NBANDS; ++i) dcol_data[i] = ai->dcol[i]; /* copy into output. This just copied pointers, its fast */ IDL_VarCopy(dcol_tmp, kw.dcol); } if (kw.nrow_there) { /* This frees any existing memory and sets type to INT with value zero */ IDL_StoreScalarZero(kw.nrow, IDL_TYP_INT); kw.nrow->value.i = ai->master_mask->rmax - ai->master_mask->rmin + 1; } if (kw.ncol_there) { IDL_StoreScalarZero(kw.ncol, IDL_TYP_INT); kw.ncol->value.i = ai->master_mask->cmax - ai->master_mask->cmin + 1; } }