//
// 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;
}
}
