// unsigned long STDCALL mysql_real_escape_string(MYSQL *mysql,
// char *to, const char *from,
// unsigned long length);
static IDL_VPTR IDL_mg_mysql_real_escape_string(int argc, IDL_VPTR *argv) {
unsigned long length;
IDL_ENSURE_ARRAY(argv[1])
IDL_ENSURE_ARRAY(argv[2])
length = mysql_real_escape_string((MYSQL *)argv[0]->value.ptrint,
(char *) argv[1]->value.arr->data,
(char *) argv[2]->value.arr->data,
IDL_ULong64Scalar(argv[3]));
return IDL_GettmpULong64(length);
}
//
// idlpgr_GetImage
//
// Transfer image data to preallocated IDL buffer
//
void IDL_CDECL idlpgr_GetImage(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;
}
idl_image = argv[1];
IDL_ENSURE_ARRAY(idl_image);
if (idl_image->value.arr->arr_len == image->stride*image->rows){
pd = idl_image->value.arr->data;
} else {
IDL_MessageFromBlock(msgs, M_IDLPGR_ERRORCODE, IDL_MSG_LONGJMP,
"IDL buffer is not the same size as the image.",
error);
}
memcpy(pd, image->pData, image->rows*image->stride);
}
//
// idlpgr_Connect
//
void IDL_CDECL idlpgr_Connect(int argc, IDL_VPTR argv[])
{
fc2Error error;
fc2Context context;
fc2PGRGuid guid;
IDL_MEMINT n;
IDL_ULONG *pd;
int i;
context = (fc2Context) IDL_ULong64Scalar(argv[0]);
IDL_ENSURE_ARRAY(argv[1]);
if (argv[1]->value.arr->n_elts != 4)
IDL_MessageFromBlock(msgs, M_IDLPGR_ERROR, IDL_MSG_LONGJMP,
"Provided variable is not a camera GUID.");
pd = (IDL_ULONG *) argv[1]->value.arr->data;
for (i = 0; i < 4; i++)
guid.value[i] = pd[i];
error = fc2Connect(context, &guid);
if (error)
IDL_MessageFromBlock(msgs, M_IDLPGR_ERRORCODE, IDL_MSG_LONGJMP,
"Could not connect camera to context",
error);
}
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);
}
static IDL_VPTR IDLOldCnvMapWrite(int argc,IDL_VPTR *argv) {
int s=0;
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;
FILE *fp;
IDL_ENSURE_SCALAR(argv[0]);
IDL_ENSURE_STRUCTURE(argv[1]);
IDL_ENSURE_ARRAY(argv[2]);
IDL_ENSURE_ARRAY(argv[3]);
IDL_EXCLUDE_EXPR(argv[1]);
IDL_EXCLUDE_EXPR(argv[2]);
IDL_EXCLUDE_EXPR(argv[3]);
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));
}
iprm=(struct CnvMapIDLPrm *) argv[1]->value.s.arr->data;
if (argv[2]->type==IDL_TYP_STRUCT)
istvec=(struct GridIDLStVec *) argv[2]->value.s.arr->data;
if (argv[3]->type==IDL_TYP_STRUCT)
igvec=(struct GridIDLGVec *) argv[3]->value.s.arr->data;
if (argv[4]->type==IDL_TYP_STRUCT)
imvec=(struct GridIDLGVec *) argv[4]->value.s.arr->data;
if (argv[5]->type==IDL_TYP_DOUBLE)
icoef=(double *) argv[5]->value.s.arr->data;
if (argv[6]->type==IDL_TYP_STRUCT)
ibnd=(struct CnvMapIDLBnd *) argv[6]->value.s.arr->data;
map=CnvMapMake();
grd=GridMake();
IDLCopyCnvMapPrmFromIDL(iprm,map,grd);
if (istvec !=NULL) IDLCopyGridStVecFromIDL(istvec,iprm->stnum,
argv[2]->value.s.arr->elt_len,grd);
else grd->stnum=0;
if (igvec !=NULL) IDLCopyGridGVecFromIDL(igvec,iprm->vcnum,
argv[3]->value.s.arr->elt_len,grd);
else grd->vcnum=0;
if (imvec !=NULL) IDLCopyCnvMapGVecFromIDL(imvec,
iprm->modnum,argv[4]->value.s.arr->elt_len,map);
else map->num_model=0;
if (ibnd !=NULL) IDLCopyCnvMapBndFromIDL(ibnd,
iprm->bndnum,argv[6]->value.s.arr->elt_len,map);
else map->num_bnd=0;
if (icoef !=NULL) {
int n=0;
map->coef=malloc(sizeof(double)*map->num_coef*4);
for (n=0;n<map->num_coef;n++) {
map->coef[4*n]=icoef[n];
map->coef[4*n+1]= icoef[map->num_coef+n];
map->coef[4*n+2]=icoef[2*map->num_coef+n];
map->coef[4*n+3]=icoef[3*map->num_coef+n];
}
} else map->num_coef=0;
s=OldCnvMapFwrite(fp,map,grd);
CnvMapFree(map);
GridFree(grd);
return (IDL_GettmpLong(s));
}
static IDL_VPTR IDLOldCnvMapSeek(int argc,IDL_VPTR *argv,char *argk) {
struct OldCnvMapIDLInx *ifptr;
int s=0,n;
struct RfileIndex *finx=NULL;
static IDL_VPTR vatme;
double atme=0;
int outargc=0;
IDL_VPTR outargv[8];
static IDL_KW_PAR kw_pars[]={IDL_KW_FAST_SCAN,
{"ATME",IDL_TYP_UNDEF,1,
IDL_KW_OUT | IDL_KW_ZERO,0,
IDL_CHARA(vatme)},
{NULL}};
IDL_LONG unit=0,yr=0,mo=0,dy=0,hr=0,mt=0,sc=0;
IDL_FILE_STAT stat;
FILE *fp=NULL;
IDL_KWCleanup(IDL_KW_MARK);
outargc=IDL_KWGetParams(argc,argv,argk,kw_pars,outargv,1);
IDL_ENSURE_SCALAR(outargv[0]);
IDL_ENSURE_SCALAR(outargv[1]);
IDL_ENSURE_SCALAR(outargv[2]);
IDL_ENSURE_SCALAR(outargv[3]);
IDL_ENSURE_SCALAR(outargv[4]);
IDL_ENSURE_SCALAR(outargv[5]);
IDL_ENSURE_SCALAR(outargv[6]);
if (outargc>7) IDL_ENSURE_ARRAY(outargv[7]);
unit=IDL_LongScalar(outargv[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));
}
yr=IDL_LongScalar(outargv[1]);
mo=IDL_LongScalar(outargv[2]);
dy=IDL_LongScalar(outargv[3]);
hr=IDL_LongScalar(outargv[4]);
mt=IDL_LongScalar(outargv[5]);
sc=IDL_LongScalar(outargv[6]);
/* test for existence of index */
if (outargc>7) {
/* decode index here */
finx=malloc(sizeof(struct RfileIndex));
if (finx==NULL) {
s=-1;
return (IDL_GettmpLong(s));
}
finx->num=outargv[7]->value.s.arr->n_elts;
finx->time.start=malloc(sizeof(double)*finx->num);
if (finx->time.start==NULL) {
s=-1;
free(finx);
return (IDL_GettmpLong(s));
}
finx->time.end=malloc(sizeof(double)*finx->num);
if (finx->time.end==NULL) {
s=-1;
free(finx->time.start);
free(finx);
return (IDL_GettmpLong(s));
}
finx->offset=malloc(sizeof(int)*finx->num);
if (finx->offset==NULL) {
s=-1;
free(finx->time.start);
free(finx->time.end);
free(finx);
return (IDL_GettmpLong(s));
}
for (n=0;n<finx->num;n++) {
ifptr=(struct OldCnvMapIDLInx *) (outargv[7]->value.s.arr->data+
n*outargv[7]->value.s.arr->elt_len);
finx->time.start[n]=ifptr->st_time;
finx->time.end[n]=ifptr->ed_time;
finx->offset[n]=ifptr->offset;
}
finx->st_time=finx->time.start[0];
finx->ed_time=finx->time.end[finx->num-1];
}
s=OldCnvMapFseek(fp,yr,mo,dy,hr,mt,sc,finx,&atme);
if (vatme) IDL_StoreScalar(vatme,IDL_TYP_DOUBLE,(IDL_ALLTYPES *) &atme);
if (finx !=NULL) {
free(finx->time.start);
free(finx->time.end);
free(finx->offset);
free(finx);
}
IDL_KWCleanup(IDL_KW_CLEAN);
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 IDL_VPTR IDLOldGridWrite(int argc,IDL_VPTR *argv) {
int s=0;
IDL_LONG unit=0;
IDL_FILE_STAT stat;
struct GridData *grd=NULL;
struct GridIDLPrm *iprm=NULL;
struct GridIDLStVec *istvec=NULL;
struct GridIDLGVec *igvec=NULL;
FILE *fp;
IDL_ENSURE_SCALAR(argv[0]);
IDL_ENSURE_STRUCTURE(argv[1]);
IDL_ENSURE_ARRAY(argv[2]);
IDL_ENSURE_ARRAY(argv[3]);
IDL_EXCLUDE_EXPR(argv[1]);
IDL_EXCLUDE_EXPR(argv[2]);
IDL_EXCLUDE_EXPR(argv[3]);
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));
}
iprm=(struct GridIDLPrm *) argv[1]->value.s.arr->data;
if (argv[2]->type==IDL_TYP_STRUCT)
istvec=(struct GridIDLStVec *) argv[2]->value.s.arr->data;
if (argv[3]->type==IDL_TYP_STRUCT)
igvec=(struct GridIDLGVec *) argv[3]->value.s.arr->data;
grd=GridMake();
IDLCopyGridPrmFromIDL(iprm,grd);
if (istvec !=NULL) IDLCopyGridStVecFromIDL(istvec,iprm->stnum,
argv[2]->value.s.arr->elt_len,grd);
else grd->stnum=0;
if (igvec !=NULL) IDLCopyGridGVecFromIDL(igvec,iprm->vcnum,
argv[3]->value.s.arr->elt_len,grd);
else grd->vcnum=0;
s=OldGridFwrite(fp,grd);
GridFree(grd);
return (IDL_GettmpLong(s));
}
void p3d_idlWriteRaw(int argc, IDL_VPTR argv[], char* argk) {
typedef struct {
IDL_KW_RESULT_FIRST_FIELD; // Must be first entry in structure
IDL_LONG endian;
IDL_LONG sign;
} KW_RESULT;
// Alphabetical order is crucial:
static IDL_KW_PAR kw_pars[] = {
IDL_KW_FAST_SCAN,
{ "BIG_ENDIAN", IDL_TYP_LONG, 1, IDL_KW_ZERO, 0, (char*) IDL_KW_OFFSETOF(endian)},
{ "UNSIGNED", IDL_TYP_LONG, 1, IDL_KW_ZERO, 0, (char*) IDL_KW_OFFSETOF(sign)},
{ NULL}
};
KW_RESULT kw;
IDL_VPTR idl_in_rev;
char* filename;
int err_code;
int little_endian;
int is_signed;
unsigned char* in_rev8;
unsigned short* in_rev16;
unsigned int* in_rev32;
float* in_rev32f;
// Process keywords:
IDL_KWProcessByOffset(argc, argv, argk, kw_pars, (IDL_VPTR *) 0, 1, &kw);
little_endian = (kw.endian == 0) ? P3D_TRUE : P3D_FALSE;
is_signed = (kw.sign == 0) ? P3D_TRUE : P3D_FALSE;
// Get input data in IDL format:
idl_in_rev = argv[0];
IDL_ENSURE_SIMPLE(idl_in_rev);
IDL_ENSURE_ARRAY(idl_in_rev);
if (argv[1]->type == IDL_TYP_STRING)
filename = IDL_VarGetString(argv[1]);
else
_p3d_idlPrintNamedError("Input argument FILENAME must be a string.");
// Check if user wants to write a 8-bit or 16-bit format image:
if (idl_in_rev->type == IDL_TYP_BYTE) {
// Extract input in C format
in_rev8 = (unsigned char *) idl_in_rev->value.arr->data;
// Check if user wants to write a 2D image or a 3D volume:
if (idl_in_rev->value.arr->n_dim == 2) {
// Call Pore3D:
err_code = p3dWriteRaw8(
in_rev8,
filename,
(int) (idl_in_rev->value.arr->dim[0]),
(int) (idl_in_rev->value.arr->dim[1]),
1,
_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->value.arr->n_dim == 3) {
// Call Pore3D:
err_code = p3dWriteRaw8(
in_rev8,
filename,
(int) idl_in_rev->value.arr->dim[0],
(int) idl_in_rev->value.arr->dim[1],
(int) idl_in_rev->value.arr->dim[2],
_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 a 2D or 3D matrix.");
}
} else if (idl_in_rev->type == IDL_TYP_UINT) {
// Extract input in C format
in_rev16 = (unsigned short *) idl_in_rev->value.arr->data;
// Check if user wants to write a 2D image or a 3D volume:
if (idl_in_rev->value.arr->n_dim == 2) {
// Call Pore3D:
err_code = p3dWriteRaw16(
in_rev16,
filename,
(int) idl_in_rev->value.arr->dim[0],
(int) idl_in_rev->value.arr->dim[1],
1,
little_endian,
is_signed,
_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->value.arr->n_dim == 3) {
// Call Pore3D:
err_code = p3dWriteRaw16(
in_rev16,
filename,
(int) idl_in_rev->value.arr->dim[0],
(int) idl_in_rev->value.arr->dim[1],
(int) idl_in_rev->value.arr->dim[2],
little_endian,
is_signed,
_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 a 2D or 3D matrix.");
}
} else if (idl_in_rev->type == IDL_TYP_ULONG) {
// Extract input in C format
in_rev32 = (unsigned int *) idl_in_rev->value.arr->data;
// Check if user wants to write a 2D image or a 3D volume:
if (idl_in_rev->value.arr->n_dim == 2) {
// Call Pore3D:
err_code = p3dWriteRaw32(
in_rev32,
filename,
(int) idl_in_rev->value.arr->dim[0],
(int) idl_in_rev->value.arr->dim[1],
1,
little_endian,
is_signed,
_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->value.arr->n_dim == 3) {
// Call Pore3D:
err_code = p3dWriteRaw32(
in_rev32,
filename,
(int) idl_in_rev->value.arr->dim[0],
(int) idl_in_rev->value.arr->dim[1],
(int) idl_in_rev->value.arr->dim[2],
little_endian,
is_signed,
_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 a 2D or 3D matrix.");
}
} else if (idl_in_rev->type == IDL_TYP_FLOAT) {
// Extract input in C format
in_rev32f = (float *) idl_in_rev->value.arr->data;
// Check if user wants to write a 2D image or a 3D volume:
if (idl_in_rev->value.arr->n_dim == 2) {
// Call Pore3D:
err_code = p3dWriteRaw32f(
in_rev32f,
filename,
(int) idl_in_rev->value.arr->dim[0],
(int) idl_in_rev->value.arr->dim[1],
1,
_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->value.arr->n_dim == 3) {
// Call Pore3D:
err_code = p3dWriteRaw32f(
in_rev32f,
filename,
(int) idl_in_rev->value.arr->dim[0],
(int) idl_in_rev->value.arr->dim[1],
(int) idl_in_rev->value.arr->dim[2],
_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 a 2D or 3D matrix.");
}
} else {
_p3d_idlPrintNamedError("Input argument IMAGE must be a BYTE, UINT, ULONG or FLOAT matrix.");
}
// Free keywords resources:
IDL_KW_FREE;
}
