/*----------------------------------------------------------------------
**
** Main routine for this plugin (will be called from AFNI).
**
**----------------------------------------------------------------------
*/
char * HEMISUB_main( PLUGIN_interface * plint )
{
THD_3dim_dataset * dset, * new_dset;
MCW_idcode * idc;
hemi_s hs = { 0 };
char * new_prefix;
char * ret_string = NULL;
char * tag;
if ( plint == NULL )
return "------------------------\n"
"HEMISUB_main: NULL input\n"
"------------------------\n";
PLUTO_next_option( plint );
idc = PLUTO_get_idcode( plint );
dset = PLUTO_find_dset( idc );
if( dset == NULL )
return "-------------------------------\n"
"HEMISUB_main: bad input dataset\n"
"-------------------------------";
DSET_load( dset );
PLUTO_next_option( plint );
new_prefix = PLUTO_get_string( plint );
if ( ! PLUTO_prefix_ok( new_prefix ) )
return "------------------------\n"
"HEMISUB_main: bad prefix\n"
"------------------------\n";
if ( ( new_dset = PLUTO_copy_dset( dset, new_prefix ) ) == NULL )
return "------------------------------------------\n"
"HEMISUB_main: failed to copy input dataset\n"
"------------------------------------------\n";
tag = PLUTO_get_optiontag( plint );
if ( tag && ! strcmp( tag, "Thresh Type" ) )
{
tag = PLUTO_get_string( plint );
if ( tag != NULL )
hs.thresh_type = PLUTO_string_index( tag, NUM_T_OPTS, thresh_opts );
}
if ( ret_string = process_data( new_dset, &hs ) )
return ret_string;
if ( PLUTO_add_dset( plint, new_dset, DSET_ACTION_MAKE_CURRENT ) )
{
THD_delete_3dim_dataset( new_dset, False );
return "---------------------------------------\n"
"HEMISUB_main: failed to add new dataset\n"
"---------------------------------------\n";
}
return NULL;
}
static char * CLUST_main( PLUGIN_interface * plint )
{
char * tag , * new_prefix ;
float rmm , vmul , thresh ;
MCW_idcode * idc ;
THD_3dim_dataset * dset , * new_dset ;
int ival , ityp , nbytes , nvals ;
EDIT_options edopt ;
void * new_brick , * old_brick ;
int clust_type; /* input cluster type option */ /* 19 June 1998 */
char * str; /* input string */
float pv; /* pv % voxels within rmm must be active */
int dilate; /* boolean for perform dilation of cluster voxels */
/*--------------------------------------------------------------------*/
/*----- Check inputs from AFNI to see if they are reasonable-ish -----*/
if( plint == NULL )
return "**********************\n"
"CLUST_main: NULL input\n"
"**********************" ;
tag = PLUTO_get_optiontag(plint) ;
if( tag==NULL || strcmp(tag,"Dataset") != 0 )
return "**********************************\n"
"CLUST_main: bad Dataset option tag\n"
"**********************************" ;
idc = PLUTO_get_idcode(plint) ;
dset = PLUTO_find_dset(idc) ;
if( dset == NULL )
return "*****************************\n"
"CLUST_main: bad input dataset\n"
"*****************************" ;
tag = PLUTO_get_optiontag(plint) ;
if( tag==NULL || strcmp(tag,"Params") != 0 )
return "*********************************\n"
"CLUST_main: bad Params option tag\n"
"*********************************" ;
str = PLUTO_get_string(plint); /* 19 June 1998 */
if (strcmp(str,"Keep") == 0) clust_type = ECFLAG_SAME;
else if (strcmp(str,"Mean") == 0) clust_type = ECFLAG_MEAN;
else if (strcmp(str,"Max") == 0) clust_type = ECFLAG_MAX;
else if (strcmp(str,"AMax") == 0) clust_type = ECFLAG_AMAX;
else if (strcmp(str,"SMax") == 0) clust_type = ECFLAG_SMAX;
else if (strcmp(str,"Size") == 0) clust_type = ECFLAG_SIZE;
else if (strcmp(str,"Order") == 0) clust_type = ECFLAG_ORDER;
else if (strcmp(str,"Depth") == 0) clust_type = ECFLAG_DEPTH;
else
return
"**********************************\n"
"CLUST_main: Illegal Cluster option\n"
"**********************************";
rmm = PLUTO_get_number(plint) ;
vmul = PLUTO_get_number(plint) ;
if( rmm <= 0 || vmul <= 0 )
return "****************************\n"
"CLUST_main: bad Params input\n"
"****************************" ;
/* 19 June 1998 */
tag = PLUTO_peek_optiontag(plint) ;
if( tag != NULL && strcmp(tag,"Erode/Dilate") == 0 )
{
PLUTO_next_option(plint) ;
pv = PLUTO_get_number(plint);
if ((pv > 0.0) && (rmm <= 0.0))
return
"*******************************************************\n"
"CLUST_main: Erode/Dilate requires use of Cluster option\n"
"*******************************************************";
else
pv = pv / 100.0;
str = PLUTO_get_string(plint);
if (strcmp (str, "True") == 0)
{
if (pv <= 0.0)
return
"***********************************************\n"
"CLUST_main: Dilate requires use of Erode option\n"
"***********************************************";
else
dilate = 1;
}
else
dilate = 0;
}
else
{
pv = 0.0;
dilate = 0;
}
tag = PLUTO_peek_optiontag(plint) ;
if( tag != NULL && strcmp(tag,"Threshold") == 0 ){
PLUTO_next_option(plint) ;
thresh = PLUTO_get_number(plint) ;
if( thresh < 0.0 )
return "*******************************\n"
"CLUST_main: bad Threshold input\n"
"*******************************" ;
if( thresh > 0.0 && DSET_THRESH_INDEX(dset) < 0 )
return "**********************************************\n"
"CLUST_main: Dataset has no threshold sub-brick\n"
"**********************************************" ;
} else {
thresh = 0.0 ;
}
tag = PLUTO_peek_optiontag(plint) ;
if( tag != NULL && strcmp(tag,"Output") == 0 ){
PLUTO_next_option(plint) ;
new_prefix = PLUTO_get_string(plint) ;
if( ! PLUTO_prefix_ok(new_prefix) )
return "**********************\n"
"CLUST_main: bad prefix\n"
"**********************" ;
} else {
new_prefix = NULL ;
}
/*------------------------------------------------------*/
/*---------- At this point, the inputs are OK ----------*/
/*-- maybe, make a new dataset --*/
if( new_prefix == NULL ){ /* no prefix => edit input in place */
new_dset = dset ;
DSET_load( dset ) ; /* load into memory */
} else { /* OK, make a copy first */
new_dset = PLUTO_copy_dset( dset , new_prefix ) ;
if( new_dset == NULL )
return "****************************************\n"
"CLUST_main: failed to copy input dataset\n"
"****************************************" ;
DSET_unload( dset ) ; /* unload from memory */
}
/*-- set up for dataset editing --*/
INIT_EDOPT( &edopt ) ;
edopt.edit_clust = clust_type; /* 19 June 1998 */
edopt.clust_rmm = rmm ;
edopt.clust_vmul = vmul ;
edopt.erode_pv = pv;
edopt.dilate = dilate;
if( thresh > 0.0 ) edopt.thresh = thresh ;
/*-- edit the new dataset --*/
EDIT_one_dataset( new_dset , &edopt ) ;
/*-- if we made a completely new dataset, give it to AFNI --*/
if( new_dset != dset ){
ival = PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ;
if( ival ){
THD_delete_3dim_dataset( new_dset , False ) ;
return "**********************************************\n"
"CLUST_main: failure to add new dataset to AFNI\n"
"**********************************************" ;
}
} else {
DSET_overwrite( new_dset ) ; /* otherwise, re-write to disk */
PLUTO_force_redisplay() ; /* and force a redisplay of images */
}
/*-- done successfully!!! --*/
return NULL ;
}
char * IMREG_main( PLUGIN_interface * plint )
{
MCW_idcode * idc ; /* input dataset idcode */
THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */
char * new_prefix , * str ; /* strings from user */
int base , ntime , datum , nx,ny,nz , ii,kk , npix ;
float dx,dy,dz ;
MRI_IMARR * ims_in , * ims_out ;
MRI_IMAGE * im , * imbase ;
byte ** bptr = NULL , ** bout = NULL ;
short ** sptr = NULL , ** sout = NULL ;
float ** fptr = NULL , ** fout = NULL ;
float * dxar = NULL , * dyar = NULL , * phiar = NULL ;
/*--------------------------------------------------------------------*/
/*----- Check inputs from AFNI to see if they are reasonable-ish -----*/
/*--------- go to first input line ---------*/
PLUTO_next_option(plint) ;
idc = PLUTO_get_idcode(plint) ; /* get dataset item */
old_dset = PLUTO_find_dset(idc) ; /* get ptr to dataset */
if( old_dset == NULL )
return "*************************\n"
"Cannot find Input Dataset\n"
"*************************" ;
ntime = DSET_NUM_TIMES(old_dset) ;
if( ntime < 2 )
return "*****************************\n"
"Dataset has only 1 time point\n"
"*****************************" ;
ii = DSET_NVALS_PER_TIME(old_dset) ;
if( ii > 1 )
return "************************************\n"
"Dataset has > 1 value per time point\n"
"************************************" ;
nx = old_dset->daxes->nxx ;
dx = old_dset->daxes->xxdel ;
ny = old_dset->daxes->nyy ;
dy = old_dset->daxes->yydel ;
npix = nx*ny ;
nz = old_dset->daxes->nzz ;
dz = old_dset->daxes->zzdel ;
if( nx != ny || fabs(dx) != fabs(dy) ) {
#ifdef IMREG_DEBUG
fprintf(stderr,"\nIMREG: nx=%d ny=%d nz=%d dx=%f dy=%f dz=%f\n",
nx,ny,nz,dx,dy,dz ) ;
#endif
return "***********************************\n"
"Dataset does not have square slices\n"
"***********************************" ;
}
new_prefix = PLUTO_get_string(plint) ; /* get string item (the output prefix) */
if( ! PLUTO_prefix_ok(new_prefix) ) /* check if it is OK */
return "************************\n"
"Output Prefix is illegal\n"
"************************" ;
/*--------- go to next input line ---------*/
PLUTO_next_option(plint) ;
base = PLUTO_get_number(plint) ;
if( base >= ntime )
return "********************\n"
"Base value too large\n"
"********************" ;
/*--------- see if the 3rd option line is present --------*/
str = PLUTO_get_optiontag( plint ) ;
if( str != NULL ) {
float fsig , fdxy , fdph ;
fsig = PLUTO_get_number(plint) * 0.42466090 ;
fdxy = PLUTO_get_number(plint) ;
fdph = PLUTO_get_number(plint) ;
mri_align_params( 0 , 0.0,0.0,0.0 , fsig,fdxy,fdph ) ;
/* fprintf(stderr,"Set fine params = %f %f %f\n",fsig,fdxy,fdph) ; */
}
/*------------- ready to compute new dataset -----------*/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: loading dataset\n") ;
#endif
DSET_load( old_dset ) ;
/*** 1) Copy the dataset in toto ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: Copying dataset\n") ;
#endif
new_dset = PLUTO_copy_dset( old_dset , new_prefix ) ;
if( new_dset == NULL )
return "****************************\n"
"Failed to copy input dataset\n"
"****************************" ;
/*** 2) Make an array of empty images ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: making empty images\n") ;
#endif
datum = DSET_BRICK_TYPE(new_dset,0) ;
INIT_IMARR(ims_in) ;
for( ii=0 ; ii < ntime ; ii++ ) {
im = mri_new_vol_empty( nx , ny , 1 , datum ) ;
ADDTO_IMARR(ims_in,im) ;
}
imbase = mri_new_vol_empty( nx , ny , 1 , datum ) ;
dxar = (float *) malloc( sizeof(float) * ntime ) ;
dyar = (float *) malloc( sizeof(float) * ntime ) ;
phiar = (float *) malloc( sizeof(float) * ntime ) ;
/*** 3) Get pointers to sub-bricks in old and new datasets ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: getting input brick pointers\n") ;
#endif
switch( datum ) { /* pointer type depends on input datum type */
case MRI_byte:
bptr = (byte **) malloc( sizeof(byte *) * ntime ) ;
bout = (byte **) malloc( sizeof(byte *) * ntime ) ;
for( ii=0 ; ii < ntime ; ii++ ) {
bptr[ii] = (byte *) DSET_ARRAY(old_dset,ii) ;
bout[ii] = (byte *) DSET_ARRAY(new_dset,ii) ;
}
break ;
case MRI_short:
sptr = (short **) malloc( sizeof(short *) * ntime ) ;
sout = (short **) malloc( sizeof(short *) * ntime ) ;
for( ii=0 ; ii < ntime ; ii++ ) {
sptr[ii] = (short *) DSET_ARRAY(old_dset,ii) ;
sout[ii] = (short *) DSET_ARRAY(new_dset,ii) ;
}
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: sptr[0] = %p sout[0] = %p\n",sptr[0],sout[0]) ;
#endif
break ;
case MRI_float:
fptr = (float **) malloc( sizeof(float *) * ntime ) ;
fout = (float **) malloc( sizeof(float *) * ntime ) ;
for( ii=0 ; ii < ntime ; ii++ ) {
fptr[ii] = (float *) DSET_ARRAY(old_dset,ii) ;
fout[ii] = (float *) DSET_ARRAY(new_dset,ii) ;
}
break ;
}
/*** 4) Loop over slices ***/
PLUTO_popup_meter(plint) ;
for( kk=0 ; kk < nz ; kk++ ) {
/*** 4a) Setup ims_in images to point to input slices ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: slice %d -- setup input images\n",kk) ;
#endif
for( ii=0 ; ii < ntime ; ii++ ) {
im = IMARR_SUBIMAGE(ims_in,ii) ;
switch( datum ) {
case MRI_byte:
mri_fix_data_pointer( bptr[ii] + kk*npix, im ) ;
break ;
case MRI_short:
mri_fix_data_pointer( sptr[ii] + kk*npix, im ) ;
break ;
case MRI_float:
mri_fix_data_pointer( fptr[ii] + kk*npix, im ) ;
break ;
}
}
/*** 4b) Setup im to point to base image ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: slice %d -- setup base image\n",kk) ;
#endif
switch( datum ) {
case MRI_byte:
mri_fix_data_pointer( bptr[base] + kk*npix, imbase ) ;
break ;
case MRI_short:
mri_fix_data_pointer( sptr[base] + kk*npix, imbase ) ;
break ;
case MRI_float:
mri_fix_data_pointer( fptr[base] + kk*npix, imbase ) ;
break ;
}
/*** 4c) Register this slice at all times ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: slice %d -- register\n",kk) ;
#endif
ims_out = mri_align_dfspace( imbase , NULL , ims_in ,
ALIGN_REGISTER_CODE , dxar,dyar,phiar ) ;
if( ims_out == NULL )
fprintf(stderr,"IMREG: mri_align_dfspace return NULL\n") ;
/*** 4d) Put the output back in on top of the input;
note that the output is always in MRI_float format ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: slice %d -- put output back into dataset\n",kk) ;
#endif
for( ii=0 ; ii < ntime ; ii++ ) {
switch( datum ) {
case MRI_byte:
im = mri_to_mri( MRI_byte , IMARR_SUBIMAGE(ims_out,ii) ) ;
memcpy( bout[ii] + kk*npix , MRI_BYTE_PTR(im) , sizeof(byte)*npix ) ;
mri_free(im) ;
break ;
case MRI_short:
#ifdef IMREG_DEBUG
if( ii==0 )fprintf(stderr,"IMREG: conversion to short at ii=%d\n",ii) ;
#endif
im = mri_to_mri( MRI_short , IMARR_SUBIMAGE(ims_out,ii) ) ;
#ifdef IMREG_DEBUG
if( ii==0 )fprintf(stderr,"IMREG: copying to %p from %p\n",sout[ii] + kk*npix,MRI_SHORT_PTR(im)) ;
#endif
memcpy( sout[ii] + kk*npix , MRI_SHORT_PTR(im) , sizeof(short)*npix ) ;
#ifdef IMREG_DEBUG
if( ii==0 )fprintf(stderr,"IMREG: freeing\n") ;
#endif
mri_free(im) ;
break ;
case MRI_float:
im = IMARR_SUBIMAGE(ims_out,ii) ;
memcpy( fout[ii] + kk*npix , MRI_FLOAT_PTR(im) , sizeof(float)*npix ) ;
break ;
}
}
PLUTO_set_meter(plint, (100*(kk+1))/nz ) ;
/*** 4e) Destroy the output images ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: destroying aligned output\n") ;
#endif
DESTROY_IMARR( ims_out ) ;
}
/*** 5) Destroy the empty images and other workspaces ***/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: destroy workspaces\n") ;
#endif
mri_clear_data_pointer(imbase) ;
mri_free(imbase) ;
for( ii=0 ; ii < ntime ; ii++ ) {
im = IMARR_SUBIMAGE(ims_in,ii) ;
mri_clear_data_pointer(im) ;
}
DESTROY_IMARR(ims_in) ;
FREE_WORKSPACE ;
/*------------- let AFNI know about the new dataset ------------*/
#ifdef IMREG_DEBUG
fprintf(stderr,"IMREG: send result to AFNI\n") ;
#endif
PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ;
return NULL ; /* null string returned means all was OK */
}
